diff --git a/.Rbuildignore b/.Rbuildignore
index 9d65823..fe41dc1 100644
--- a/.Rbuildignore
+++ b/.Rbuildignore
@@ -3,4 +3,5 @@
 .dir-locals.el
 .projectile
 compile_commands.json
-.cquery
\ No newline at end of file
+.cquery
+.ccls
\ No newline at end of file
diff --git a/.dir-locals.el b/.dir-locals.el
deleted file mode 100644
index a74d40a..0000000
--- a/.dir-locals.el
+++ /dev/null
@@ -1 +0,0 @@
-((nil . ((projectile-project-compilation-cmd . "~/bin/compR.sh ."))))
diff --git a/.gitignore b/.gitignore
index 17b7fc5..77a9d60 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,7 @@ GPATH
 GTAGS
 .cquery*
 GRTAGS
+/src/Makevars
+/.lintr
+*.idx
+/compile_commands.json
diff --git a/DESCRIPTION b/DESCRIPTION
index 515b60e..1e1d3e2 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,18 +1,18 @@
 Package: EigenH5
 Type: Package
 Title: Read and write R objects using HDF5
-Version: 1.2
+Version: 1.3
 Date: 2017-08-03
 Author: Nicholas Knoblauch
 Maintainer: Nicholas Knoblauch <nwknoblauch@gmail.com>
 Description: Read and write R objects using zstd+HDF5. Also contains a C++ interface for using with other packages. The C++ interface can handle the reading/writing/converting between column-major matrices (as in R/fortran) and row-major matrices (as in HDF5) 
 License: What license is it under?
 biocViews:
-Imports: Rcpp (>= 0.12.12), RcppEigen (>= 0.3.3.3.0),BH,dplyr,progress,tidyr,purrr,magrittr,zstdr,R6,fs,zstdr
-LinkingTo: Rcpp, RcppEigen,RcppProgress,testthat,Rhdf5lib,rzstdlib,BH
-SystemRequirements: C++11, HDF5 (>= 1.8.13), blosc
+Imports: Rcpp (>= 0.12.12), RcppEigen (>= 0.3.3.3.0),BH,dplyr,progress,tidyr,stringr,purrr,magrittr,fs,readr,rlang
+LinkingTo: Rcpp, RcppEigen,RcppProgress,testthat,BH,xtensor
+SystemRequirements: C++17,libhdf5,libzstd
 Suggests: testthat,
     knitr,
     rmarkdown
 VignetteBuilder: knitr
-RoxygenNote: 6.1.1
+RoxygenNote: 6.1.99.9001
diff --git a/NAMESPACE b/NAMESPACE
index a649115..8ff7f47 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -2,4 +2,5 @@ useDynLib(EigenH5,.registration=TRUE)
 importFrom(Rcpp, evalCpp)
 exportPattern("^[[:alpha:]]+")
 importFrom(magrittr,"%>%")
+importFrom(rlang,"%||%")
 importFrom(rlang,"!!")
diff --git a/R/RcppExports.R b/R/RcppExports.R
index 88d5bd2..1d2d722 100644
--- a/R/RcppExports.R
+++ b/R/RcppExports.R
@@ -33,6 +33,26 @@ get_group <- function(f, object_name) {
     .Call(`_EigenH5_get_group`, f, object_name)
 }
 
+read_matrix_rl <- function(filename, datapath, rows, cols) {
+    .Call(`_EigenH5_read_matrix_rl`, filename, datapath, rows, cols)
+}
+
+read_matrix_v <- function(filename, datapath, rows, cols) {
+    .Call(`_EigenH5_read_matrix_v`, filename, datapath, rows, cols)
+}
+
+read_vector_v <- function(filename, datapath, rows) {
+    .Call(`_EigenH5_read_vector_v`, filename, datapath, rows)
+}
+
+update_matrix_v <- function(data, filename, datapath, rows, cols) {
+    invisible(.Call(`_EigenH5_update_matrix_v`, data, filename, datapath, rows, cols))
+}
+
+update_vector_v <- function(data, filename, datapath, rows) {
+    invisible(.Call(`_EigenH5_update_vector_v`, data, filename, datapath, rows))
+}
+
 openFileHandleRead <- function(filepath) {
     .Call(`_EigenH5_openFileHandleRead`, filepath)
 }
@@ -41,6 +61,14 @@ closeFileHandle <- function(fh) {
     .Call(`_EigenH5_closeFileHandle`, fh)
 }
 
+has_blosc <- function() {
+    .Call(`_EigenH5_has_blosc`)
+}
+
+has_lzf <- function() {
+    .Call(`_EigenH5_has_lzf`)
+}
+
 start_blosc <- function() {
     invisible(.Call(`_EigenH5_start_blosc`))
 }
@@ -77,6 +105,10 @@ write_attribute_h5 <- function(data, filename, datapath) {
     .Call(`_EigenH5_write_attribute_h5`, data, filename, datapath)
 }
 
+read_R_attribute_h5 <- function(filename, datapath) {
+    .Call(`_EigenH5_read_R_attribute_h5`, filename, datapath)
+}
+
 read_attribute_h5 <- function(filename, datapath) {
     .Call(`_EigenH5_read_attribute_h5`, filename, datapath)
 }
@@ -85,6 +117,14 @@ create_dataset_h5 <- function(filename, datapath, data, options) {
     .Call(`_EigenH5_create_dataset_h5`, filename, datapath, data, options)
 }
 
+fast_str2int <- function(input, offset = 0L, na_val = NA_integer_) {
+    .Call(`_EigenH5_fast_str2int`, input, offset, na_val)
+}
+
+fast_str2ascii <- function(input, offset = 0L) {
+    .Call(`_EigenH5_fast_str2ascii`, input, offset)
+}
+
 link_objects_h5 <- function(filename_from, filename_to, datapath_from, datapath_to) {
     invisible(.Call(`_EigenH5_link_objects_h5`, filename_from, filename_to, datapath_from, datapath_to))
 }
@@ -121,6 +161,10 @@ isObject <- function(filename, dataname) {
     .Call(`_EigenH5_isObject`, filename, dataname)
 }
 
+ArrayTypeSize <- function(filename, dataname) {
+    .Call(`_EigenH5_ArrayTypeSize`, filename, dataname)
+}
+
 isDataSet <- function(filename, dataname) {
     .Call(`_EigenH5_isDataSet`, filename, dataname)
 }
@@ -137,6 +181,10 @@ typeof_h5 <- function(filename, datapath) {
     .Call(`_EigenH5_typeof_h5`, filename, datapath)
 }
 
+info_h5 <- function(filename, datapaths) {
+    .Call(`_EigenH5_info_h5`, filename, datapaths)
+}
+
 file_acc_ct <- function(filename) {
     .Call(`_EigenH5_file_acc_ct`, filename)
 }
diff --git a/R/chunk_reader_writer.R b/R/chunk_reader_writer.R
new file mode 100644
index 0000000..db0e0eb
--- /dev/null
+++ b/R/chunk_reader_writer.R
@@ -0,0 +1,71 @@
+read_matrix_h5v <- function(filename, datapath,i, j, ...){
+    has.i <- !missing(i)
+    has.j <- !missing(j)
+    if (!has.j){
+        j <- integer()
+    }
+    if (!has.i){
+        i <- integer()
+    }
+    argl <- list(...)
+    stopifnot(length(argl) == 0)
+
+    return(read_matrix_v(filename, datapath, i, j))
+
+}
+
+
+read_vector_h5v <- function(filename, datapath, i, ...){
+    has.i <- !missing(i)
+
+    if (!has.i){
+        i <- integer()
+    }
+    argl <- list(...)
+    stopifnot(length(argl) == 0)
+
+    return(read_vector_v(filename, datapath, i))
+
+}
+
+
+
+
+write_matrix_h5v <- function(data, filename, datapath, ...){
+    
+    argl <- list(...)
+    filename <- fs::path_expand(filename)
+    if(!file.exists(filename)){
+        #   argl[["dim"]] <- argl[["dim"]] %||% dim(data)
+        create_dataset_h5(filename,datapath,data,argl)
+    }
+    if(!isObject(filename,datapath)){
+        create_dataset_h5(filename = filename ,datapath = datapath, data = data, options = argl)
+    }
+    i <- argl[["i"]] %||% 1:NROW(data)
+    j <- argl[["j"]] %||% 1:NCOL(data)
+    update_matrix_v(data,filename =  filename,datapath,i,j)
+}
+
+
+
+write_vector_h5v <- function(data, filename, datapath, ...){
+    
+    argl <- list(...)
+    filename <- fs::path_expand(filename)
+    if(!file.exists(filename)){
+        #   argl[["dim"]] <- argl[["dim"]] %||% dim(data)
+        create_dataset_h5(filename,datapath,data,argl)
+    }
+    if(!isObject(filename,datapath)){
+        create_dataset_h5(filename = filename ,datapath = datapath, data = data, options = argl)
+    }
+    i <- argl[["i"]] %||% 1:NROW(data)
+    #j <- argl[["j"]] %||% 1:ncol(data)
+    update_vector_v(data,filename =  filename,datapath,i)
+}
+
+
+
+
+
diff --git a/R/read_write.R b/R/read_write.R
index c23bb9e..f9cc2c5 100644
--- a/R/read_write.R
+++ b/R/read_write.R
@@ -1,29 +1,32 @@
-read_df_h5 <- function(filename,datapath,...){
+read_df_h5 <- function(filename, datapath = "/", ...){
     filename <- fs::path_expand(filename)
-  stopifnot(file.exists(filename))
-  dsets <- ls_h5(filename,groupname = datapath)
-  argl <- list(...)
-  if(!hasArg(subcols)){
-    argl[["subcols"]] <- dsets
-    # subcols <- dsets
-  }
-  dsets <- dsets[dsets %in% argl[["subcols"]]]
-  if(datapath=="/"){
-    groupname <- ""
-  }
-  dsp <- normalizePath(paste(datapath,dsets,sep="/"), mustWork = F)
-  names(dsp) <- basename(dsp)
-  return(purrr::map_dfc(dsp,~read_vector_h5(filename, datapath = .x, ...), ...=...))
+    stopifnot(file.exists(filename))
+    dsets <- ls_h5(filename, groupname = datapath)
+    argl <- list(...)
+    if(!hasArg(subcols)){
+        argl[["subcols"]] <- dsets
+                                        # subcols <- dsets
+    }
+    dsets <- dsets[dsets %in% argl[["subcols"]]]
+    dsp <- fix_paths(datapath, dsets)
+    names(dsp) <- basename(dsp)
+    if(!hasArg(subset)){
+        return(purrr::map_dfc(dsp,~read_vector_h5v(filename = filename,datapath =  .x)))
+    }else{
+        return(purrr::map_dfc(dsp,~read_vector_h5v(filename = filename,datapath = .x,i=as.integer(argl[["subset"]]))))
+    }
 }
 
 
 
 write_df_h5 <- function(df, filename, datapath="/", ...){
     argl <- list(...)
-    filename <- fs::path_expand(filename)
+ if(datapath=="/"){
+        datapath <- ""
+    }
   purrr::iwalk(df, ~purrr::invoke(write_vector_h5,
                                   filename = filename,
-                                  datapath = normalizePath(paste(datapath, .y, sep="/"),mustWork = F),
+                                  datapath = fix_paths(datapath, .y),
                                   data=.x,
                                   argl))
 }
@@ -57,16 +60,20 @@ write_vector_h5 <- function(data, filename, datapath, ...){
   app_v <- TRUE
   filename <- fs::path_expand(filename)
   if(!file.exists(filename)){
+    if(isTRUE(argl[["append"]]) && is.null(argl[["max_dims"]])){
+      argl[["max_dims"]] <- NA_integer_
+    }
     create_dataset_h5(filename, datapath, data, argl)
     app_v <- FALSE
   }
   if(!isObject(filename, datapath)){
+    if(isTRUE(argl[["append"]]) && is.null(argl[["max_dims"]])){
+      argl[["max_dims"]] <- NA_integer_
+    }
     create_dataset_h5(filename, datapath, data, argl)
   }else{
-    if(hasArg(append)){
-      if(app_v & argl[["append"]]){
-        ret <- append_vector_h5(data = data,filename = filename, datapath = datapath,  ... = argl)
-      }
+    if(app_v && isTRUE(argl[["append"]])){
+      ret <- append_vector_h5(data = data,filename = filename, datapath = datapath,  ... = argl)
     }
   }
   if(!ret){
diff --git a/R/utils.R b/R/utils.R
index d4f6f03..1f578c4 100644
--- a/R/utils.R
+++ b/R/utils.R
@@ -1,13 +1,68 @@
-.onLoad <- function(libname, pkgname){
+.onLoad <- function(libname, pkgname) {
+    pkgconfig::set_config("EigenH5::use_blosc" = has_blosc())
+    pkgconfig::set_config("EigenH5::use_lzf" = has_lzf())
     start_blosc()
-    # start_singleton()
+
+}
+
+fix_paths <- function(...) {
+    ret <- stringr::str_replace(normalizePath(paste(..., sep = "/"), mustWork = FALSE), "//", "/")
+    if (length(ret) == 0) {
+        ret <- "/"
+    }
+    return(ret)
 }
 
 
-ls_h5 <- function(filename,groupname="/",full_names=FALSE){
+
+
+#' Convert RLE-encoded vector to offset+size dataframe
+#'
+#' @param x either a vector of class `rle`, or a vector that can be converte to one via (`rle(x)`)
+#' @param na_replace value to replace NA (rle doesn't play well with NA)
+#'
+#' @return tibble with columns `value`,`offset` and `datasize`
+#' @export
+#'
+#' @examples
+#' x <- rev(rep(6:10, 1:5))
+#' x_na <- c(NA,NA,NA,rev(rep(6:10, 1:5)))
+#' x_n3 <- c(-3,-3,-3,rev(rep(6:10, 1:5)))
+#' print(rle2offset(rle(x)))
+#' stopifnot(
+#'   identical(rle2offset(rle(x)),rle2offset(x)),
+#'   identical(rle2offset(x_na,na_replace=-3),rle2offset(x_n3)))
+rle2offset <- function(x,na_replace = -1L){
+  if (!inherits(x,"rle")){
+    x[is.na(x)] <- na_replace
+    x <- rle(x)
+  }
+  x$values[x$values==na_replace] <- NA_integer_
+  tibble::tibble(value=x$values,
+                 offset=c(0,cumsum(x$lengths)[-length(x$lengths)]),
+                 datasize=x$lengths)
+}
+
+
+ls_h5 <- function(filename,groupname="/",full_names=FALSE,details=FALSE){
+  if(!details){
     fs::path_norm(ls_h5_exp(filename = fs::path_expand(filename),
                             groupname = groupname,
                             full_names = full_names))
+  }else{
+    full_n <- ls_h5_exp(filename = fs::path_expand(filename),
+                            groupname = groupname,
+                            full_names = TRUE)
+    id_type=purrr::map_chr(full_n,~typeof_h5(filename,.x))
+    id_dim=purrr::map(full_n,~dim_h5(filename,.x))
+    if(all(lengths(id_dim)==length(id_dim[[1]]))){
+      id_dim <- purrr::flatten_int(id_dim)
+    }
+    if(!full_names){
+      full_n <- fs::path_rel(full_n,start=groupname)
+    }
+    tibble::tibble(name=full_n,dims=id_dim,type=id_type)
+  }
 }
 
 construct_data_path <- function(...){
@@ -33,20 +88,14 @@ isObject_h5 <- function(filename,datapath){
   return(ret)
 }
 
-## gen_matslice_chunk_l <- function(input_rows,chunksize=10000,...){
-##     output_l <- BBmisc::chunk(input_rows,chunk.size=chunksize)  %>% purrr::map(~tibble::data_frame(input_rows=.x)afunction(x){
-##       stopifnot(all(x==seq(x[1],x[length(x)])))
-##       return(data_frame(row_offsets=x[1]-1,row_chunksizes=length(x)))
-##       }) %>% dplyr::mutate(...)
-##     return(input_df)
-## }
+
 
 
 gen_matslice_df <- function(filename,group_prefix,dataname){
   sub_grps <- ls_h5(filename,group_prefix)
   retdf <- dplyr::data_frame(filenames=filename,
                     groupnames=paste0(group_prefix,"/",sub_grps),
-                    datanames=dataname) %>% arrange(as.integer(sub_grps))
+                    datanames=dataname) %>% dplyr::arrange(as.integer(sub_grps))
   return(retdf)
 }
 
@@ -106,7 +155,7 @@ write_l_h5 <- function(data,filename,datapath,...){
   if(datapath=="/"){
     datapath <- ""
   }
-  purrr::iwalk(datal,~write_h5(filename,normalizePath(paste(datapath,.y,sep="/"),mustWork = F),data = .x))
+  purrr::iwalk(datal,~write_h5(filename,fix_paths(datapath,.y),data = .x))
 }
 
 
@@ -211,3 +260,59 @@ create_mat_l <- function(dff){
 }
 
 
+
+
+#' Convert to HDF5 with a custom callback
+#'
+#' @param input_file
+#' @param output_file
+#' @param h5_args ... args for write_df_h5 unpacked and passed to `callback_fun`
+#' @param callback_fun function with signature matching function(df,filename,datapath,...) (defaults to `write_df_h5`)
+#' @param ...
+#'
+#' @return
+#' @export
+#'
+#' @examples
+#'
+#' temp_h5 <- fs::file_temp(ext="h5")
+#' delim2h5(readr::readr_example("mtcars.csv"),temp_h5,delim="/")
+#' new_data  <- read_df_h5(temp_h5)
+
+delim2h5 <- function(input_file, output_file, h5_args = list(datapath = "/"), callback_fun = write_df_h5, id_col = NULL, ...){
+    h5_args[["append"]] <- TRUE
+    callback_args <- formalArgs(callback_fun)
+    stopifnot(all.equal(callback_args, formalArgs(write_df_h5)))
+
+    h5_args[["append"]] <- TRUE
+    if (is.null(id_col) ||  isFALSE(id_col)) {
+
+        wf <- function(x, pos)
+            rlang::exec(callback_fun, df = x, filename = output_file, !!!h5_args)
+
+    }else {
+        if (is.character(id_col)) {
+
+            stopifnot(length(id_col) == 1)
+            wf <- function(x, pos) {
+                pos_seq <- seq(from = pos, length.out = nrow(x))
+                rlang::exec(callback_fun,
+                            df = dplyr::mutate(x, {{id_col}} := pos_seq),
+                            filename = output_file, !!!h5_args)
+                }
+
+        }else {
+            stopifnot(isTRUE(id_col))
+            wf <- function(x, pos) {
+                pos_seq <- seq(from = pos, length.out = nrow(x))
+                rlang::exec(callback_fun,
+                            df = dplyr::mutate(x, id_col = pos_seq),
+                            filename = output_file, !!!h5_args)
+                }
+
+        }
+    }
+
+
+  readr::read_delim_chunked(file = input_file, callback = readr::SideEffectChunkCallback$new(wf), ...)
+}
diff --git a/configure b/configure
new file mode 100755
index 0000000..be19a61
--- /dev/null
+++ b/configure
@@ -0,0 +1,5700 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69 for EigenH5 0.1.0.
+#
+# Report bugs to <nwknoblauch@gmail.com>.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org and
+$0: nwknoblauch@gmail.com about your system, including any
+$0: error possibly output before this message. Then install
+$0: a modern shell, or manually run the script under such a
+$0: shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='EigenH5'
+PACKAGE_TARNAME='eigenh5'
+PACKAGE_VERSION='0.1.0'
+PACKAGE_STRING='EigenH5 0.1.0'
+PACKAGE_BUGREPORT='nwknoblauch@gmail.com'
+PACKAGE_URL=''
+
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='LTLIBOBJS
+LIBOBJS
+HDF5R_CFLAGS
+DEFINE_H5FREE_MEMORY
+HDF5_VERSION_USE
+HDF5_FLIBS
+HDF5_FFLAGS
+HDF5_FC
+HDF5_LIBS
+HDF5_LDFLAGS
+HDF5_CPPFLAGS
+HDF5_CFLAGS
+HDF5_CC
+HDF5_REVISION_VERSION
+HDF5_VERSION
+H5FC
+EGREP
+CPP
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+H5CC
+HDF5_MINOR_VERSION
+HDF5_MAJOR_VERSION
+HDF5R_CPPFLAGS
+HDF5R_LIBS
+SED
+AWK
+GREP
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+with_hdf5
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CPP'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures EigenH5 0.1.0 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/eigenh5]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of EigenH5 0.1.0:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-hdf5=yes/no/PATH location of h5cc or h5pcc for HDF5 configuration
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <nwknoblauch@gmail.com>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+EigenH5 configure 0.1.0
+generated by GNU Autoconf 2.69
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_c_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if eval \${$3+:} false; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+( $as_echo "## ------------------------------------ ##
+## Report this to nwknoblauch@gmail.com ##
+## ------------------------------------ ##"
+     ) | sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_mongrel
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by EigenH5 $as_me 0.1.0, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+# ===========================================================================
+#        http://www.gnu.org/software/autoconf-archive/ax_lib_hdf5.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_LIB_HDF5([serial/parallel])
+#
+# DESCRIPTION
+#
+#   This macro provides tests of the availability of HDF5 library.
+#
+#   The optional macro argument should be either 'serial' or 'parallel'. The
+#   former only looks for serial HDF5 installations via h5cc. The latter
+#   only looks for parallel HDF5 installations via h5pcc. If the optional
+#   argument is omitted, serial installations will be preferred over
+#   parallel ones.
+#
+#   The macro adds a --with-hdf5 option accepting one of three values:
+#
+#     no   - do not check for the HDF5 library.
+#     yes  - do check for HDF5 library in standard locations.
+#     path - complete path to the HDF5 helper script h5cc or h5pcc.
+#
+#   If HDF5 is successfully found, this macro calls
+#
+#     AC_SUBST(HDF5_VERSION)
+#     AC_SUBST(HDF5_CC)
+#     AC_SUBST(HDF5_CFLAGS)
+#     AC_SUBST(HDF5_CPPFLAGS)
+#     AC_SUBST(HDF5_LDFLAGS)
+#     AC_SUBST(HDF5_LIBS)
+#     AC_SUBST(HDF5_FC)
+#     AC_SUBST(HDF5_FFLAGS)
+#     AC_SUBST(HDF5_FLIBS)
+#     AC_DEFINE(HAVE_HDF5)
+#
+#   and sets with_hdf5="yes".  Additionally, the macro sets
+#   with_hdf5_fortran="yes" if a matching Fortran wrapper script is found.
+#   Note that Autconf's Fortran support is not used to perform this check.
+#   H5CC and H5FC will contain the appropriate serial or parallel HDF5
+#   wrapper script locations.
+#
+#   If HDF5 is disabled or not found, this macros sets with_hdf5="no" and
+#   with_hdf5_fortran="no".
+#
+#   Your configuration script can test $with_hdf to take any further
+#   actions. HDF5_{C,CPP,LD}FLAGS may be used when building with C or C++.
+#   HDF5_F{FLAGS,LIBS} should be used when building Fortran applications.
+#
+#   To use the macro, one would code one of the following in "configure.ac"
+#   before AC_OUTPUT:
+#
+#     1) dnl Check for HDF5 support
+#        AX_LIB_HDF5()
+#
+#     2) dnl Check for serial HDF5 support
+#        AX_LIB_HDF5([serial])
+#
+#     3) dnl Check for parallel HDF5 support
+#        AX_LIB_HDF5([parallel])
+#
+#   One could test $with_hdf5 for the outcome or display it as follows
+#
+#     echo "HDF5 support:  $with_hdf5"
+#
+#   You could also for example, override the default CC in "configure.ac" to
+#   enforce compilation with the compiler that HDF5 uses:
+#
+#     AX_LIB_HDF5([parallel])
+#     if test "$with_hdf5" = "yes"; then
+#             CC="$HDF5_CC"
+#     else
+#             AC_MSG_ERROR([Unable to find HDF5, we need parallel HDF5.])
+#     fi
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Timothy Brown <tbrown@freeshell.org>
+#   Copyright (c) 2010 Rhys Ulerich <rhys.ulerich@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 12
+
+# This code was adapted by Holger Hoefling on May 2nd 2016 to also
+# substitute variables HDF5_MAJOR_VERSION, HDF5_MINOR_VERSION
+# as well as HDF5_REVISION_VERSION so that the 3 parts of the
+# version number are available separately for testing
+# Also changed to check for hdf5_hl header library existence
+
+
+
+
+
+#############################################################################
+##
+## Copyright 2016 Novartis Institutes for BioMedical Research Inc.
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+#############################################################################
+
+
+
+# ===========================================================================
+#    http://www.gnu.org/software/autoconf-archive/ax_compare_version.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_COMPARE_VERSION(VERSION_A, OP, VERSION_B, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+#
+# DESCRIPTION
+#
+#   This macro compares two version strings. Due to the various number of
+#   minor-version numbers that can exist, and the fact that string
+#   comparisons are not compatible with numeric comparisons, this is not
+#   necessarily trivial to do in a autoconf script. This macro makes doing
+#   these comparisons easy.
+#
+#   The six basic comparisons are available, as well as checking equality
+#   limited to a certain number of minor-version levels.
+#
+#   The operator OP determines what type of comparison to do, and can be one
+#   of:
+#
+#    eq  - equal (test A == B)
+#    ne  - not equal (test A != B)
+#    le  - less than or equal (test A <= B)
+#    ge  - greater than or equal (test A >= B)
+#    lt  - less than (test A < B)
+#    gt  - greater than (test A > B)
+#
+#   Additionally, the eq and ne operator can have a number after it to limit
+#   the test to that number of minor versions.
+#
+#    eq0 - equal up to the length of the shorter version
+#    ne0 - not equal up to the length of the shorter version
+#    eqN - equal up to N sub-version levels
+#    neN - not equal up to N sub-version levels
+#
+#   When the condition is true, shell commands ACTION-IF-TRUE are run,
+#   otherwise shell commands ACTION-IF-FALSE are run. The environment
+#   variable 'ax_compare_version' is always set to either 'true' or 'false'
+#   as well.
+#
+#   Examples:
+#
+#     AX_COMPARE_VERSION([3.15.7],[lt],[3.15.8])
+#     AX_COMPARE_VERSION([3.15],[lt],[3.15.8])
+#
+#   would both be true.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq],[3.15.8])
+#     AX_COMPARE_VERSION([3.15],[gt],[3.15.8])
+#
+#   would both be false.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq2],[3.15.8])
+#
+#   would be true because it is only comparing two minor versions.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq0],[3.15])
+#
+#   would be true because it is only comparing the lesser number of minor
+#   versions of the two values.
+#
+#   Note: The characters that separate the version numbers do not matter. An
+#   empty string is the same as version 0. OP is evaluated by autoconf, not
+#   configure, so must be a string, not a variable.
+#
+#   The author would like to acknowledge Guido Draheim whose advice about
+#   the m4_case and m4_ifvaln functions make this macro only include the
+#   portions necessary to perform the specific comparison specified by the
+#   OP argument in the final configure script.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Tim Toolan <toolan@ele.uri.edu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 11
+
+
+
+RHDF5LIB_INSTALLED=$(echo 'cat(suppressWarnings(require(Rhdf5lib, quietly=TRUE, character.only=FALSE, warn.conflicts=FALSE)))' | "${R_HOME}/bin/R" --vanilla --slave)
+
+  # Extract the first word of "ggrep", so it can be a program name with args.
+set dummy ggrep; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$GREP"; then
+  ac_cv_prog_GREP="$GREP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_GREP="`which ggrep`"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  test -z "$ac_cv_prog_GREP" && ac_cv_prog_GREP="`which grep`"
+fi
+fi
+GREP=$ac_cv_prog_GREP
+if test -n "$GREP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
+$as_echo "$GREP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+# Extract the first word of "gawk", so it can be a program name with args.
+set dummy gawk; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="`which gawk`"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  test -z "$ac_cv_prog_AWK" && ac_cv_prog_AWK="`which awk`"
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+
+if test -n "$AWK"; then
+    echo "found awk and it's $AWK"
+else
+    echo "no awk!"
+    exit 1
+fi
+
+
+if test "$RHDF5LIB_INSTALLED" == "TRRUE"; then
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: Found RHDF5LIB: $RHDF5LIB_INSTALLED" >&5
+$as_echo "Found RHDF5LIB: $RHDF5LIB_INSTALLED" >&6; }
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if ${ac_cv_path_SED+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+
+
+
+
+
+
+
+
+with_rhdf5lib="yes"
+HDF5R_LIBS=$(echo 'cat(Rhdf5lib::pkgconfig("PKG_C_HL_LIBS"))' | "${R_HOME}/bin/R" --vanilla --slave)
+HDF5R_CPPFLAGS=$(echo 'cat("-I",system.file("include/",package = "Rhdf5lib"))' | "${R_HOME}/bin/R" --vanilla --slave)
+HDF5_VERSION=$(echo 'cat(Rhdf5lib::getHdf5Version())' | "${R_HOME}/bin/R" --vanilla --slave)
+HDF5_MAJOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. '{print $1}')
+HDF5_MINOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $2'})
+HDF5_REVISION_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $3'})
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Found Rhdf5lib with version: $HDF5_MAJOR_VERSION.$HDF5_MINOR_VERSION" >&5
+$as_echo "Found Rhdf5lib with version: $HDF5_MAJOR_VERSION.$HDF5_MINOR_VERSION" >&6; }
+
+
+
+
+
+
+
+
+else
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: Did not find Rhdf5lib: $RHDF5LIB_INSTALLED" >&5
+$as_echo "Did not find Rhdf5lib: $RHDF5LIB_INSTALLED" >&6; }
+   ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+
+
+
+
+
+
+
+
+
+if   test "" = ""        ; then
+    : # Recognized value
+elif test "" = "serial"  ; then
+    : # Recognized value
+elif test "" = "parallel"; then
+    : # Recognized value
+else
+    as_fn_error $? "
+Unrecognized value for AX_LIB_HDF5 within configure.ac.
+If supplied, argument 1 must be either 'serial' or 'parallel'.
+" "$LINENO" 5
+fi
+
+
+# Check whether --with-hdf5 was given.
+if test "${with_hdf5+set}" = set; then :
+  withval=$with_hdf5; if test "$withval" = "no"; then
+     with_hdf5="no"
+   elif test "$withval" = "yes"; then
+     with_hdf5="yes"
+   else
+     with_hdf5="yes"
+     H5CC="$withval"
+   fi
+else
+  with_hdf5="yes"
+
+fi
+
+
+HDF5_CC=""
+HDF5_VERSION=""
+HDF5_CFLAGS=""
+HDF5_CPPFLAGS=""
+HDF5_LDFLAGS=""
+HDF5_LIBS=""
+HDF5_FC=""
+HDF5_FFLAGS=""
+HDF5_FLIBS=""
+
+if test "$with_hdf5" = "yes"; then
+    if test -z "$H5CC"; then
+                for ac_prog in h5cc h5pcc
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_H5CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $H5CC in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_H5CC="$H5CC" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_H5CC="$as_dir/$ac_word$ac_exec_ext"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+H5CC=$ac_cv_path_H5CC
+if test -n "$H5CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $H5CC" >&5
+$as_echo "$H5CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$H5CC" && break
+done
+
+    else
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking Using provided HDF5 C wrapper" >&5
+$as_echo_n "checking Using provided HDF5 C wrapper... " >&6; }
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $H5CC" >&5
+$as_echo "$H5CC" >&6; }
+    fi
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HDF5 libraries" >&5
+$as_echo_n "checking for HDF5 libraries... " >&6; }
+    if test ! -f "$H5CC" || test ! -x "$H5CC"; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING:
+Unable to locate HDF5 compilation helper scripts 'h5cc' or 'h5pcc'.
+Please specify --with-hdf5=<LOCATION> as the full path to h5cc or h5pcc.
+HDF5 support is being disabled (equivalent to --with-hdf5=no).
+" >&5
+$as_echo "$as_me: WARNING:
+Unable to locate HDF5 compilation helper scripts 'h5cc' or 'h5pcc'.
+Please specify --with-hdf5=<LOCATION> as the full path to h5cc or h5pcc.
+HDF5 support is being disabled (equivalent to --with-hdf5=no).
+" >&2;}
+        with_hdf5="no"
+        with_hdf5_fortran="no"
+    else
+                HDF5_SHOW=$(eval $H5CC -show)
+
+                HDF5_CC=$(eval $H5CC -show | $AWK '{print $1}')
+        if test "$HDF5_CC" = "ccache"; then
+            HDF5_CC=$(eval $H5CC -show | $AWK '{print $2}')
+        fi
+
+
+                HDF5_VERSION=$(eval $H5CC -showconfig | $GREP 'HDF5 Version:' | $AWK '{print $3}')
+        HDF5_MAJOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. '{print $1}')
+        HDF5_MINOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $2'})
+        HDF5_REVISION_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $3'})
+
+                                                                                HDF5_tmp_flags=$(eval $H5CC -showconfig \
+            | $GREP 'FLAGS\|Extra libraries:' \
+            | $AWK -F: '{printf("%s "), $2}' )
+
+                HDF5_tmp_inst=$(eval $H5CC -showconfig \
+            | $GREP 'Installation point:' \
+            | $AWK '{print $NF}' )
+
+                HDF5_CPPFLAGS="-I${HDF5_tmp_inst}/include"
+
+                for arg in $HDF5_SHOW $HDF5_tmp_flags ; do
+          case "$arg" in
+            -I*) echo $HDF5_CPPFLAGS | $GREP -e "$arg" 2>&1 >/dev/null \
+                  || HDF5_CPPFLAGS="$arg $HDF5_CPPFLAGS"
+              ;;
+            -L*) echo $HDF5_LDFLAGS | $GREP -e "$arg" 2>&1 >/dev/null \
+                  || HDF5_LDFLAGS="$arg $HDF5_LDFLAGS"
+              ;;
+            -l*) echo $HDF5_LIBS | $GREP -e "$arg" 2>&1 >/dev/null \
+                  || HDF5_LIBS="$arg $HDF5_LIBS"
+              ;;
+          esac
+        done
+
+        HDF5_LIBS="$HDF5_LIBS -lhdf5"
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (version $HDF5_VERSION)" >&5
+$as_echo "yes (version $HDF5_VERSION)" >&6; }
+
+                ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+        ax_lib_hdf5_save_CC=$CC
+        ax_lib_hdf5_save_CPPFLAGS=$CPPFLAGS
+        ax_lib_hdf5_save_LIBS=$LIBS
+        ax_lib_hdf5_save_LDFLAGS=$LDFLAGS
+        CC=$HDF5_CC
+        CPPFLAGS=$HDF5_CPPFLAGS
+        LIBS=$HDF5_LIBS
+        LDFLAGS=$HDF5_LDFLAGS
+        ac_fn_c_check_header_mongrel "$LINENO" "hdf5.h" "ac_cv_header_hdf5_h" "$ac_includes_default"
+if test "x$ac_cv_header_hdf5_h" = xyes; then :
+  ac_cv_hadf5_h=yes
+else
+  ac_cv_hadf5_h=no
+fi
+
+
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for H5Fcreate in -lhdf5" >&5
+$as_echo_n "checking for H5Fcreate in -lhdf5... " >&6; }
+if ${ac_cv_lib_hdf5_H5Fcreate+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lhdf5  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char H5Fcreate ();
+int
+main ()
+{
+return H5Fcreate ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_hdf5_H5Fcreate=yes
+else
+  ac_cv_lib_hdf5_H5Fcreate=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_hdf5_H5Fcreate" >&5
+$as_echo "$ac_cv_lib_hdf5_H5Fcreate" >&6; }
+if test "x$ac_cv_lib_hdf5_H5Fcreate" = xyes; then :
+  ac_cv_libhdf5=yes
+else
+  ac_cv_libhdf5=no
+fi
+
+        if test "$ac_cv_hadf5_h" = "no" && test "$ac_cv_libhdf5" = "no" ; then
+          { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to compile HDF5 test program" >&5
+$as_echo "$as_me: WARNING: Unable to compile HDF5 test program" >&2;}
+        fi
+        ac_fn_c_check_header_compile "$LINENO" "hdf5_hl.h" "ac_cv_header_hdf5_hl_h" "#include <hdf5.h>
+"
+if test "x$ac_cv_header_hdf5_hl_h" = xyes; then :
+  ac_cv_hadf5_hl_h=yes
+else
+  ac_cv_hadf5_hl_h=no
+fi
+
+
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for H5LTpath_valid in -lhdf5_hl" >&5
+$as_echo_n "checking for H5LTpath_valid in -lhdf5_hl... " >&6; }
+if ${ac_cv_lib_hdf5_hl_H5LTpath_valid+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lhdf5_hl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char H5LTpath_valid ();
+int
+main ()
+{
+return H5LTpath_valid ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_hdf5_hl_H5LTpath_valid=yes
+else
+  ac_cv_lib_hdf5_hl_H5LTpath_valid=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_hdf5_hl_H5LTpath_valid" >&5
+$as_echo "$ac_cv_lib_hdf5_hl_H5LTpath_valid" >&6; }
+if test "x$ac_cv_lib_hdf5_hl_H5LTpath_valid" = xyes; then :
+  ac_cv_libhdf5_hl=yes
+else
+  ac_cv_libhdf5_hl=no
+fi
+
+        if test "$ac_cv_hadf5_hl_h" = "no" && test "$ac_cv_libhdf5_hl" = "no"; then
+          { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to compile HDF5_HL test program" >&5
+$as_echo "$as_me: WARNING: Unable to compile HDF5_HL test program" >&2;}
+        fi
+                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lhdf5_hl" >&5
+$as_echo_n "checking for main in -lhdf5_hl... " >&6; }
+if ${ac_cv_lib_hdf5_hl_main+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lhdf5_hl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+int
+main ()
+{
+return main ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_hdf5_hl_main=yes
+else
+  ac_cv_lib_hdf5_hl_main=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_hdf5_hl_main" >&5
+$as_echo "$ac_cv_lib_hdf5_hl_main" >&6; }
+if test "x$ac_cv_lib_hdf5_hl_main" = xyes; then :
+  HDF5_LIBS="$HDF5_LIBS -lhdf5_hl"
+fi
+ac_cv_lib_hdf5_hl=ac_cv_lib_hdf5_hl_main
+
+
+        CC=$ax_lib_hdf5_save_CC
+        CPPFLAGS=$ax_lib_hdf5_save_CPPFLAGS
+        LIBS=$ax_lib_hdf5_save_LIBS
+        LDFLAGS=$ax_lib_hdf5_save_LDFLAGS
+        ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for matching HDF5 Fortran wrapper" >&5
+$as_echo_n "checking for matching HDF5 Fortran wrapper... " >&6; }
+                H5FC=$(eval echo -n $H5CC | $SED -n 's/cc$/fc/p')
+        if test -x "$H5FC"; then
+            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $H5FC" >&5
+$as_echo "$H5FC" >&6; }
+            with_hdf5_fortran="yes"
+
+
+                        for arg in `$H5FC -show`
+            do
+              case "$arg" in #(
+                -I*) echo $HDF5_FFLAGS | $GREP -e "$arg" >/dev/null \
+                      || HDF5_FFLAGS="$arg $HDF5_FFLAGS"
+                  ;;#(
+                -L*) echo $HDF5_FFLAGS | $GREP -e "$arg" >/dev/null \
+                      || HDF5_FFLAGS="$arg $HDF5_FFLAGS"
+                                                               echo $HDF5_FFLAGS | $GREP -e "-I${arg#-L}" >/dev/null \
+                      || HDF5_FFLAGS="-I${arg#-L} $HDF5_FFLAGS"
+                  ;;
+              esac
+            done
+
+                        for arg in $HDF5_LIBS
+            do
+              case "$arg" in #(
+                -lhdf5_hl) HDF5_FLIBS="$HDF5_FLIBS -lhdf5hl_fortran $arg"
+                  ;; #(
+                -lhdf5)    HDF5_FLIBS="$HDF5_FLIBS -lhdf5_fortran $arg"
+                  ;; #(
+                *) HDF5_FLIBS="$HDF5_FLIBS $arg"
+                  ;;
+              esac
+            done
+        else
+            { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+            with_hdf5_fortran="no"
+        fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+$as_echo "#define HAVE_HDF5 1" >>confdefs.h
+
+    fi
+fi
+
+
+fi
+
+
+
+
+
+if test "$with_hdf5" = "yes" || test "$with_rhdf5lib" = "yes"; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Found hdf5 with version: $HDF5_VERSION" >&5
+$as_echo "Found hdf5 with version: $HDF5_VERSION" >&6; }
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.8.13" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    hdf5_version_sufficient="yes"
+    else as_fn_error $? "The version of hdf5 installed on your system is not sufficient. Please ensure that at least version 1.8.13 is installed" "$LINENO" 5
+  fi
+
+else
+  as_fn_error $? "hdf5 does not seem to be installed on your platform.
+  Please install the hdf5 library.
+  The required HDF5 library files can be installed as follows:
+      -
+      - Debian-based (e.g. Debian >= 8.0, Ubuntu >= 15.04): 'sudo apt-get install libhdf5-dev'
+        - Old Debian-based (e.g Debian < 8.0, Ubuntu < 15.04): Install from source (see INSTALL)
+        - OS X using Homebrew: 'brew install hdf5'
+        - RPM-based (e.g Fedora): 'sudo yum install hdf5-devel'" "$LINENO" 5
+fi
+
+
+if test "$hdf5_version_sufficient" = "yes"; then
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.8.13" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_8_14"
+      fi
+
+
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.8.14" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_8_14"
+      fi
+
+
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.8.16" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_8_16"
+      fi
+
+
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.10.0" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_10_0"
+      fi
+
+
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.10.2" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_10_2"
+      fi
+
+
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.10.3" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_10_3"
+      fi
+
+
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.10.4" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_10_3"
+      fi
+
+
+
+
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+
+  ax_compare_version_A=`echo "$HDF5_VERSION" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+  ax_compare_version_B=`echo "1.10.5" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
+                     -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
+                     -e 's/[^0-9]//g'`
+
+
+    ax_compare_version=`echo "x$ax_compare_version_A
+x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
+
+
+
+    if test "$ax_compare_version" = "true" ; then
+    HDF5_VERSION_USE="1_10_5"
+      fi
+
+fi
+
+
+
+
+
+
+
+
+
+: ${R_HOME=`R RHOME`}
+if test -z "${R_HOME}"; then
+  echo "could not determine R_HOME"
+  exit 1
+fi
+
+ if test "$with_hdf5" = "yes"; then
+if test -z "${LIBS}"; then
+    # Extract the first word of "ggrep", so it can be a program name with args.
+set dummy ggrep; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$GREP"; then
+  ac_cv_prog_GREP="$GREP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_GREP="`which ggrep`"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  test -z "$ac_cv_prog_GREP" && ac_cv_prog_GREP="`which grep`"
+fi
+fi
+GREP=$ac_cv_prog_GREP
+if test -n "$GREP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
+$as_echo "$GREP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${GREP} accepts -o" >&5
+$as_echo_n "checking whether ${GREP} accepts -o... " >&6; }
+  if `echo '' | ${GREP} -o '' >/dev/null 2>&1`
+  then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    as_fn_error $? "${GREP} does not support option -o" "$LINENO" 5
+  fi
+
+  LIBS=`${H5CC} -show | ${GREP} -o "\-L[^[:space:]]\+" | tr "\n" " "`
+
+
+    HDF5R_LIBS="${LIBS} -L. -lhdf5_hl -lhdf5 -lz -lm"
+
+fi
+
+if test -z "${CPPFLAGS}"; then
+    # Extract the first word of "ggrep", so it can be a program name with args.
+set dummy ggrep; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$GREP"; then
+  ac_cv_prog_GREP="$GREP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_GREP="`which ggrep`"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  test -z "$ac_cv_prog_GREP" && ac_cv_prog_GREP="`which grep`"
+fi
+fi
+GREP=$ac_cv_prog_GREP
+if test -n "$GREP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
+$as_echo "$GREP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${GREP} accepts -o" >&5
+$as_echo_n "checking whether ${GREP} accepts -o... " >&6; }
+  if `echo '' | ${GREP} -o '' >/dev/null 2>&1`
+  then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    as_fn_error $? "${GREP} does not support option -o" "$LINENO" 5
+  fi
+
+  echo 'int main() { return; }' > myconftest.c
+
+
+
+  HDF5R_CPPFLAGS=`${H5CC} -show -c myconftest.c | ${GREP} -o "\-I[^[:space:]]\+" | tr "\n" " "`
+
+  rm -f myconftest.c
+fi
+
+fi
+HDF5R_CFLAGS=""
+
+
+
+
+ac_config_files="$ac_config_files src/Makevars"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# Transform confdefs.h into DEFS.
+# Protect against shell expansion while executing Makefile rules.
+# Protect against Makefile macro expansion.
+#
+# If the first sed substitution is executed (which looks for macros that
+# take arguments), then branch to the quote section.  Otherwise,
+# look for a macro that doesn't take arguments.
+ac_script='
+:mline
+/\\$/{
+ N
+ s,\\\n,,
+ b mline
+}
+t clear
+:clear
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+b any
+:quote
+s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
+s/\[/\\&/g
+s/\]/\\&/g
+s/\$/$$/g
+H
+:any
+${
+	g
+	s/^\n//
+	s/\n/ /g
+	p
+}
+'
+DEFS=`sed -n "$ac_script" confdefs.h`
+
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by EigenH5 $as_me 0.1.0, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+
+Configuration files:
+$config_files
+
+Report bugs to <nwknoblauch@gmail.com>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
+ac_cs_version="\\
+EigenH5 config.status 0.1.0
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h |  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "src/Makevars") CONFIG_FILES="$CONFIG_FILES src/Makevars" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+
+eval set X "  :F $CONFIG_FILES      "
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+
+
+
+  esac
+
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
diff --git a/configure.ac b/configure.ac
index 233d0f2..dbf01ea 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,185 +1,172 @@
-# Process this file with autoconf to produce a configure script.
-# author: Nicholas Knoblauch (nwknoblauch@gmail.com)
-AC_PREREQ([2.65])
-AC_INIT([EigenH5], [1.2], [nwknoblauch@gmail.com])
-#AC_CONFIG_SRCDIR([src])
+AC_INIT([EigenH5], 0.1.0, [nwknoblauch@gmail.com])
+dnl Grab that macro that checks for HDF5 availability
 
+m4_include([inst/m4/ax_lib_hdf5.m4])
+m4_include([inst/m4/hh_hdf5rlib.m4])
+m4_include([inst/m4/ax_compare_version.m4])
 
-#m4_include([inst/m4/ax_lib_hdf5.m4])
-#m4_include([inst/m4/ax_compare_version.m4])
-#m4_include([inst/m4/hh_hdf5rlib.m4])
+RHDF5LIB_INSTALLED=$(echo 'cat(suppressWarnings(require(Rhdf5lib, quietly=TRUE, character.only=FALSE, warn.conflicts=FALSE)))' | "${R_HOME}/bin/R" --vanilla --slave)
 
+  AC_CHECK_PROG(GREP,ggrep,`which ggrep`, `which grep`)
+AC_CHECK_PROG(AWK,gawk,`which gawk`, `which awk`)
 
-#AX_LIB_HDF5()
-
-
-dnl if test "$with_hdf5" = "yes"; then
-dnl AC_MSG_RESULT([Found hdf5 with version: $HDF5_VERSION])
-dnl AX_COMPARE_VERSION([$HDF5_VERSION], [ge], [1.10.2], [hdf5_version_sufficient="yes"], AC_MSG_ERROR([The version of hdf5 installed on your system is not sufficient. Please ensure that at least version 1.10.2 is installed]))
-dnl else
-dnl   AC_MSG_ERROR([hdf5 does not seem to be installed on your platform.
-dnl   Please install the hdf5 library.
-dnl   The required HDF5 library files can be installed using conda 'conda install -c crerecombinase r-eigenh5'])
-dnl fi
-
-
-LDFLAGS=`"${R_HOME}/bin/R" CMD config LDFLAGS`
-
-# mkdir _build
-# wget "https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.10/hdf5-1.10.2/src/hdf5-1.10.2.tar.gz" -o _build/hdf5-1.10.2.tar.gz
-# tar -xvzf _build/hdf5-1.10.2.tar.gz -O _build/
-# _build/hdf5-1.10.2/configure --enable-build-mode=production --with-default-plugindir=inst/plugin/
-
-#PKG_CHECK_MODULES([blosc]
-
-dnl if test "$hdf5_version_sufficient" = "yes"; then
-dnl   AX_COMPARE_VERSION(
-dnl 	[$HDF5_VERSION],
-dnl 	[ge],
-dnl 	[1.10.3],
-dnl 	[HDF5_VERSION_USE="1_10_3"])
-dnl fi
-
-dnl AC_SUBST(HDF5_VERSION_USE)
-dnl AC_SUBST(DEFINE_H5FREE_MEMORY)
-
-dnl Now find the compiler and compiler flags to use
-: ${R_HOME=`R RHOME`}
-if test -z "${R_HOME}"; then
-  echo "could not determine R_HOME"
-  exit 1
+if test -n "$AWK"; then
+    echo "found awk and it's $AWK"
+else
+    echo "no awk!"
+    exit 1
 fi
 
 
+if test "$RHDF5LIB_INSTALLED" == "TRUE"; then
 
-dnl if test -z "${BLOSC_LIBS}"; then
-dnl     BLOSC_CFLAGS = `echo 'libblosc::pkgconfig("PKG_CFLAGS")'| "${R_HOME}/bin/R" --vanilla --slave`
-dnl     BLOSC_LIBS = `echo 'libblosc::pkgconfig("PKG_LIBS_static")' | "${R_HOME}/bin/R" --vanilla --slave`
-dnl fi
-dnl AC_MSG_RESULT([looking for .pc files in $PKG_CONFIG_PATH])
-
-dnl PKG_CHECK_MODULES([BLOSC], [blosc], [
-dnl LIBS="${BLOSC_LIBS} ${LIBS}"
-dnl AC_MSG_RESULT([found the blosc package: $BLOSC_LIBS])],[
-dnl ])
+  AC_MSG_RESULT([Found RHDF5LIB: $RHDF5LIB_INSTALLED])
+  HH_HDF5RLIB()
 
+else
+   AC_MSG_RESULT([Did not find Rhdf5lib: $RHDF5LIB_INSTALLED])
+   AX_LIB_HDF5()
 
-dnl PKG_CHECK_MODULES([HDF5], [hdf5], [
-dnl LIBS="${HDF5_LIBS} ${LIBS}"
-dnl AC_MSG_RESULT([found the hdf5 package: $HDF5_LIBS])],[
-dnl ])
-
-if test -z "{HDF5_LIBS}"; then
-   HDF5_LIBS = `echo 'Rhdf5lib::pkgconfig("PKG_C_LIBS")'|\
-    "${R_HOME}/bin/R" --vanilla --slave`
 fi
 
-dnl PKG_CHECK_MODULES([LZF], [lzf], [
-dnl LIBS="${LZF_LIBS} ${LIBS}"
-dnl AC_MSG_RESULT([found the lzf package: LZF_LIBS])],[
-dnl AC_MSG_ERROR([unable to find the lzf package])
-dnl ])
-
 
 
-dnl PKG_CHECK_MODULES([ZSTD], [zstd], [
-dnl LIBS="${ZSTD_LIBS} ${LIBS}"
-dnl AC_MSG_RESULT([found the zstd package: $ZSTD_LIBS])],[
-dnl AC_MSG_ERROR([unable to find the zstd package])
-dnl ])
 
-dnl AC_SEARCH_LIBS([H5open], [hdf5], [], [
-dnl    AC_MSG_ERROR([hdf5 open function])
-dnl    ])
-
-dnl AC_SEARCH_LIBS([H5Oget_info_by_name], [hdf5], [], [
-dnl    AC_MSG_ERROR([hdf5 info_by_name])
-dnl    ])
-
-
-dnl if test -z "${BLOSC_LIBS}"; then
-dnl    AC_SEARCH_LIBS([blosc_compress], [blosc], [], [
-dnl    AC_MSG_ERROR([unable to find the blosc_compress() function])
-dnl    ])
-dnl fi
-
-dnl if test -z "${ZSTD_LIBS}"; then
-dnl AC_SEARCH_LIBS([ZSTD_compress], [zstd], [], [
-dnl   AC_MSG_ERROR([unable to find the ZSTD_compress() function])
-dnl ])
-dnl fi
-
-dnl AC_SEARCH_LIBS([std::filesystem::path::path],[std++fs],[],[
-dnl   AC_MSG_ERROR([unable to find the c++ filesystem library])
-dnl   ])
 
+if test "$with_hdf5" = "yes" || test "$with_rhdf5lib" = "yes"; then
+AC_MSG_RESULT([Found hdf5 with version: $HDF5_VERSION])
+AX_COMPARE_VERSION([$HDF5_VERSION], [ge], [1.8.13], [hdf5_version_sufficient="yes"], AC_MSG_ERROR([The version of hdf5 installed on your system is not sufficient. Please ensure that at least version 1.8.13 is installed]))
+else 
+  AC_MSG_ERROR([hdf5 does not seem to be installed on your platform.
+  Please install the hdf5 library.
+  The required HDF5 library files can be installed as follows:
+      -
+      - Debian-based (e.g. Debian >= 8.0, Ubuntu >= 15.04): 'sudo apt-get install libhdf5-dev'
+        - Old Debian-based (e.g Debian < 8.0, Ubuntu < 15.04): Install from source (see INSTALL)
+        - OS X using Homebrew: 'brew install hdf5'
+        - RPM-based (e.g Fedora): 'sudo yum install hdf5-devel'])
+fi
 
 
+if test "$hdf5_version_sufficient" = "yes"; then 
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION], 
+	[ge], 
+	[1.8.13], 
+	[HDF5_VERSION_USE="1_8_14"])
+
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION], 
+	[ge], 
+	[1.8.14], 
+	[HDF5_VERSION_USE="1_8_14"])
+
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION], 
+	[ge], 
+	[1.8.16], 
+	[HDF5_VERSION_USE="1_8_16"])
+
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION], 
+	[ge], 
+	[1.10.0], 
+	[HDF5_VERSION_USE="1_10_0"])
+
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION], 
+	[ge], 
+	[1.10.2], 
+	[HDF5_VERSION_USE="1_10_2"])
+
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION], 
+	[ge], 
+	[1.10.3], 
+	[HDF5_VERSION_USE="1_10_3"])
+	
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION],
+	[ge],
+	[1.10.4],
+	[HDF5_VERSION_USE="1_10_3"])
+
+  AX_COMPARE_VERSION(
+	[$HDF5_VERSION],
+	[ge],
+	[1.10.5],
+	[HDF5_VERSION_USE="1_10_5"])
+fi
 
-AC_MSG_RESULT([Libs will be : $LIBS])
-AC_MSG_RESULT([HDF5Libs will be : $HDF5_LIBS])
-AC_SUBST(LIBS)
-#AC_SUBST(BLOSC_LIBS)
-#AC_SUBST(BLOSC_CFLAGS)
-AC_SUBST(HDF5_LIBS)
-#AC_SUBST(BLOSC_CFLAGS)
+AC_SUBST(HDF5_VERSION_USE)
 
+AC_SUBST(DEFINE_H5FREE_MEMORY)
 
 
 
 
-dnl if test -z "${LIBS}"; then
-dnl   dnl prefer ggrep if installed
-dnl   AC_CHECK_PROG(GREP,ggrep,`which ggrep`, `which grep`)
 
-dnl   dnl check if $GREP supports option -o
-dnl   AC_MSG_CHECKING([whether ${GREP} accepts -o])
-dnl   if `echo '' | ${GREP} -o '' >/dev/null 2>&1`
-dnl   then
-dnl     AC_MSG_RESULT([yes])
-dnl   else
-dnl     AC_MSG_RESULT([no])
-dnl     AC_MSG_ERROR([${GREP} does not support option -o])
-dnl   fi
-dnl   [
-dnl   LIBS=`${H5CC} -show | ${GREP} -o "\-L[^[:space:]]\+" | tr "\n" " "`
-dnl   ]
+dnl Now find the compiler and compiler flags to use
+: ${R_HOME=`R RHOME`}
+if test -z "${R_HOME}"; then
+  echo "could not determine R_HOME"
+  exit 1
+fi
 
-dnl   dnl Fix for newer Debian versions
-dnl   HDF5R_LIBS="${LIBS} -L. -lhdf5_hl -lhdf5 -lz -lm"
+ if test "$with_hdf5" = "yes"; then
+if test -z "${LIBS}"; then
+  dnl prefer ggrep if installed
+  AC_CHECK_PROG(GREP,ggrep,`which ggrep`, `which grep`)
+
+  dnl check if $GREP supports option -o
+  AC_MSG_CHECKING([whether ${GREP} accepts -o])
+  if `echo '' | ${GREP} -o '' >/dev/null 2>&1`
+  then
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([${GREP} does not support option -o])
+  fi
+  [
+  LIBS=`${H5CC} -show | ${GREP} -o "\-L[^[:space:]]\+" | tr "\n" " "` 
+  ]
+  
+  dnl Fix for newer Debian versions
+  HDF5R_LIBS="${LIBS} -L. -lhdf5_hl -lhdf5 -lz -lm"
 
-dnl fi
+fi
 
-dnl if test -z "${CPPFLAGS}"; then
-dnl   dnl prefer ggrep if installed
-dnl   AC_CHECK_PROG(GREP,ggrep,`which ggrep`, `which grep`)
+if test -z "${CPPFLAGS}"; then
+  dnl prefer ggrep if installed
+  AC_CHECK_PROG(GREP,ggrep,`which ggrep`, `which grep`)
 
-dnl   dnl check if $GREP supports option -o
-dnl   AC_MSG_CHECKING([whether ${GREP} accepts -o])
-dnl   if `echo '' | ${GREP} -o '' >/dev/null 2>&1`
-dnl   then
-dnl     AC_MSG_RESULT([yes])
-dnl   else
-dnl     AC_MSG_RESULT([no])
-dnl     AC_MSG_ERROR([${GREP} does not support option -o])
-dnl   fi
+  dnl check if $GREP supports option -o
+  AC_MSG_CHECKING([whether ${GREP} accepts -o])
+  if `echo '' | ${GREP} -o '' >/dev/null 2>&1`
+  then
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([${GREP} does not support option -o])
+  fi
 
-dnl   echo 'int main() { return; }' > myconftest.c
+  echo 'int main() { return; }' > myconftest.c
 
 
-dnl   [
-dnl   HDF5R_CPPFLAGS=`${H5CC} -show -c myconftest.c | ${GREP} -o "\-I[^[:space:]]\+" | tr "\n" " "`
-dnl   ]
-dnl   rm -f myconftest.c
-dnl fi
+  [
+  HDF5R_CPPFLAGS=`${H5CC} -show -c myconftest.c | ${GREP} -o "\-I[^[:space:]]\+" | tr "\n" " "`
+  ]
+  rm -f myconftest.c
+fi
 
+fi
 dnl dummy substitute HDF5R_CFLAGS
-#HDF5R_CFLAGS=""
-#AC_SUBST(HDF5R_CFLAGS)
+HDF5R_CFLAGS=""
+AC_SUBST(HDF5R_CFLAGS)
 
 dnl substitute CPPFLAGS and LIBS
-#AC_SUBST(HDF5R_CPPFLAGS)
-#AC_SUBST(HDF5R_LIBS)
-dnl and do subsitution in the src/Makevars.in
+AC_SUBST(HDF5R_CPPFLAGS)
+AC_SUBST(HDF5R_LIBS)
+dnl and do subsitution in the src/Makevars.in 
 AC_CONFIG_FILES([src/Makevars])
 AC_OUTPUT
diff --git a/inst/include/EigenH5.h b/inst/include/EigenH5.h
index 612cd5e..6d81cb7 100644
--- a/inst/include/EigenH5.h
+++ b/inst/include/EigenH5.h
@@ -1,15 +1,25 @@
 #pragma once
+#define ZSTD_STATIC_LINKING_ONLY
+
 #include <cmath>
 #include <complex>
 #include <iostream>
 #include <iostream>
+#include <numeric>
 
-#include <boost/optional.hpp>
-#include <boost/optional/optional_io.hpp>
-
-#define EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+#define STRICT_R_HEADERS
 #include <RcppEigen.h>
-//#include "path/path.hpp"
+
+
+
+
+// constexprREV_ACTG <- stats::setNames(c("T", "G", "A", "C"), ACTG)
+
+
+// Snp make_Snp(unsigned char chrom, double pos,char ref, char alt){
+//   return Snp{bit_snp
+
+
 
 
 
@@ -61,7 +71,6 @@ class Path{
     return (ret);
   }
   operator const std::string&() const { return(nodes); }
-
 };
 
 inline std::string operator+(const std::string a, const Path &b){
@@ -74,56 +83,16 @@ inline std::ostream &operator<<(std::ostream &os, const Path &dt) {
 }
 
 #include "highfive/highfive.hpp"
-#ifdef USE_BLOSC
-#include "blosc_filter.h"
-#endif
-#include "lzf/lzf_filter.h"
-#include "zstd/zstd_h5plugin.h"
-#include "zstd/zstd.h"
-
-#include <H5Tpublic.h>
-
-#if __cplusplus < 201402L
-
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
 
 
-namespace std {
-
-template<class T> struct _Unique_if {
-  typedef unique_ptr<T> _Single_object;
-};
-
-template<class T> struct _Unique_if<T[]> {
-  typedef unique_ptr<T[]> _Unknown_bound;
-};
+#include <H5Tpublic.h>
 
-template<class T, size_t N> struct _Unique_if<T[N]> {
-  typedef void _Known_bound;
-};
+SEXP read_attribute(const HighFive::Group &der,const std::string attribute_name);
+SEXP read_attribute(const HighFive::DataSet &der,const std::string attribute_name);
 
-template<class T, class... Args>
-typename _Unique_if<T>::_Single_object
-  make_unique(Args&&... args) {
-    return unique_ptr<T>(new T(std::forward<Args>(args)...));
-  }
 
-template<class T>
-typename _Unique_if<T>::_Unknown_bound
-  make_unique(size_t n) {
-    typedef typename remove_extent<T>::type U;
-    return unique_ptr<T>(new U[n]());
-  }
 
-template<class T, class... Args>
-typename _Unique_if<T>::_Known_bound
-  make_unique(Args&&...) = delete;
-}
 
-#endif
 
 // using Path = std::string;
 // using PathNode = std::string;
@@ -143,6 +112,10 @@ class FileManager{
   void print()const;
 };
 
+
+
+
+
 #include "EigenH5_RcppExports.h"
 
 inline Path root_path(const std::string &input) {
@@ -178,15 +151,47 @@ struct cpp2r<std::string>{
 HighFive::Filter create_filter(std::vector<size_t> data_dimensions,
 			       Rcpp::List &options);
 
-template<SEXPTYPE RTYPE> boost::optional<Rcpp::Vector<RTYPE> > get_list_element(const Rcpp::List &list, const std::string name,const bool empty_is_false = true);
-template<typename T,SEXPTYPE RTYPE = cpp2r<T>::data_t > boost::optional<T> get_list_scalar(const Rcpp::List &list, const std::string name);
-std::vector<boost::optional<Rcpp::IntegerVector> > parse_subset_list(const Rcpp::List &list,std::vector<size_t> datadims);
+template <SEXPTYPE RTYPE>
+std::optional<Rcpp::Vector<RTYPE>>
+get_list_element(const Rcpp::List &list, const std::string name,
+                 const bool empty_is_false = true);
+
+template<SEXPTYPE RTYPE>
+std::optional<Rcpp::Vector<RTYPE> > get_any_list_element(const Rcpp::List &list, const std::vector<std::string> name,const bool empty_is_false=true);
+
+
+template<typename T,SEXPTYPE RTYPE = cpp2r<T>::data_t > std::optional<T> get_list_scalar(const Rcpp::List &list, const std::string name);
+std::vector<std::optional<Rcpp::IntegerVector> > parse_subset_list(const Rcpp::List &list,std::vector<size_t> datadims);
+
+
+SEXPTYPE typeof_h5_dset(const HighFive::DataSet &dset);
+
+
+inline std::vector<std::string> list_R_attr(const HighFive::DataSet &dset){
+  auto attr_n = dset.listAttributeNames();
+  attr_n.erase(std::remove_if(attr_n.begin(),attr_n.end(),[](const std::string& str){
+                                                            if(str.size()<=3)
+                                                              return true;
+                                                            if(str[0]!='R')
+                                                              return true;
+                                                            if(str[1]!=':')
+                                                              return true;
+                                                            return false;
+                                                          }));
+  return attr_n;
+}
+
+
+inline bool has_R_attr(const HighFive::DataSet &dset){
+    return !list_R_attr(dset).empty();
+}
 
 
-inline std::vector<boost::optional<int> > parse_option(const Rcpp::List &list, std::vector<size_t> datadims,std::string prefix){
-  using int_o = boost::optional<int>;
+inline std::vector<std::optional<int> > parse_option(const Rcpp::List &list, std::vector<size_t> datadims,std::string prefix){
+
+  using int_o = std::optional<int>;
   const size_t num_dims= datadims.size();
-  std::vector<int_o> offset_v(num_dims,boost::none);
+  std::vector<int_o> offset_v(num_dims,std::nullopt);
   if(auto offset_o =get_list_element<INTSXP>(list,prefix)){
     if(offset_o->size()!=num_dims){
       Rcpp::stop("subset argument "+prefix+" must satisfy length(offset)==length(dim(data))");
@@ -213,40 +218,16 @@ inline std::vector<boost::optional<int> > parse_option(const Rcpp::List &list, s
 }
 
 
-
-
-
-//std::vector<boost::optional<int> > parse_option(const Rcpp::List &list, std::vector<size_t> datadims,std::string prefix);
-
-
-//std::vector<boost::optional<int> > parse_option(const Rcpp::List &list, std::vector<size_t> datadims,std::string prefix);
-//std::vector<boost::optional<Rcpp::IntegerVector> > parse_subset_list(const Rcpp::List &list,std::vector<size_t> datadims);
-
-
-
-
-
-
-
-
-
-
-
-SEXPTYPE h2r_T(hid_t htype);
+SEXPTYPE h2r_T(const HighFive::DataType htype);
+Rcpp::StringVector h2s_T(const HighFive::DataType htype);
 bool isGroup(const std::string filename, std::string groupname);
 
 
-
-
-
-
-
-
 template<SEXPTYPE RTYPE>
-inline boost::optional<Rcpp::Vector<RTYPE> > get_list_element(const Rcpp::List &list, const std::string name,const bool empty_is_false){
+inline std::optional<Rcpp::Vector<RTYPE> > get_list_element(const Rcpp::List &list, const std::string name,const bool empty_is_false){
   Rcpp::RObject rnames =	list.names();
   if(rnames.isNULL()){
-    return(boost::none);
+    return(std::nullopt);
   }
   Rcpp::CharacterVector colnames(rnames);
   for(auto tc:colnames){
@@ -256,25 +237,36 @@ inline boost::optional<Rcpp::Vector<RTYPE> > get_list_element(const Rcpp::List &
 	if(mvec.size()>0){
 	  return(mvec);
 	}else{
-	  return(boost::none);
+	  return(std::nullopt);
 	}
       }else{
 	return(Rcpp::as<Rcpp::Vector<RTYPE> >(list[name]));
       }
     }
   }
-  return(boost::none);
+  return(std::nullopt);
+}
+
+
+template<SEXPTYPE RTYPE>
+inline std::optional<Rcpp::Vector<RTYPE> > get_any_list_element(const Rcpp::List &list, const std::vector<std::string> name,const bool empty_is_false){
+  for(auto el : name){
+    if(auto ret = get_list_element<RTYPE>(list,el,empty_is_false))
+      return ret;
+  }
+  return std::nullopt;
 }
 
-inline std::vector<boost::optional<Rcpp::IntegerVector> > parse_subset_list(const Rcpp::List &list,std::vector<size_t> datadims){
-  using rvec_o = boost::optional<Rcpp::IntegerVector>;
+
+inline std::vector<std::optional<Rcpp::IntegerVector> > parse_subset_list(const Rcpp::List &list,std::vector<size_t> datadims){
+  using rvec_o = std::optional<Rcpp::IntegerVector>;
   const size_t num_dims= datadims.size();
 
 
   if(num_dims>2){
     Rcpp::stop("Datasets with Dims>2 currently not supported");
   }
-  std::vector<rvec_o> retvec(num_dims,boost::none);
+  std::vector<rvec_o> retvec(num_dims,std::nullopt);
   if(num_dims==1){
     if(auto subset_rv =get_list_element<INTSXP>(list,"subset")){
       retvec[0] = subset_rv.value();
@@ -305,24 +297,24 @@ inline std::vector<boost::optional<Rcpp::IntegerVector> > parse_subset_list(cons
 
 
 template<typename T,SEXPTYPE RTYPE>
-inline boost::optional<T> get_list_scalar(const Rcpp::List &list, const std::string name){
+inline std::optional<T> get_list_scalar(const Rcpp::List &list, const std::string name){
   if(auto rel = get_list_element<RTYPE>(list,name)){
     T rel_b = *(Rcpp::as< std::vector<T> >(*rel).begin());
     return(rel_b);
   }else{
-    return(boost::none);
+    return(std::nullopt);
   }
 }
 
 template<typename T,SEXPTYPE RTYPE>
-  inline boost::optional<T> list_get_any(const Rcpp::List &list, const std::vector<std::string> name_opts){
+  inline std::optional<T> get_list_any(const Rcpp::List &list, std::vector<std::string> name_opts){
   for( auto &name : name_opts){
     auto trel =	get_list_scalar<T>(list,name);
     if(trel){
       return(trel);
     }
   }
-  return(boost::none);
+  return(std::nullopt);
 }
 
 
@@ -332,6 +324,7 @@ template<typename T,SEXPTYPE RTYPE>
 
 
 
+
 std::string get_datapath(const Rcpp::List &list);
 std::string get_filepath(const Rcpp::List &list);
 
@@ -351,10 +344,14 @@ inline HighFive::DataSet getDataSet (const Rcpp::List file_l, std::unique_ptr<Fi
   return(file.getDataSet(dsn));
 }
 
-
 #include <eigenh5/Singleton.hpp>
 #include <eigenh5/Selection.hpp>
 #include <eigenh5/MatSlices.hpp>
+//#include <eigenh5/ChunkSelector.hpp>
+
+
+std::variant<std::pair<int,std::optional<int>>,Rcpp::IntegerVector> dispatch_subset(SEXP x);
+
 
 
 
diff --git a/inst/include/EigenH5_RcppExports.h b/inst/include/EigenH5_RcppExports.h
index 11ac3b1..eed4928 100644
--- a/inst/include/EigenH5_RcppExports.h
+++ b/inst/include/EigenH5_RcppExports.h
@@ -67,6 +67,48 @@ namespace EigenH5 {
         return Rcpp::as<size_t >(rcpp_result_gen);
     }
 
+    inline bool has_blosc() {
+        typedef SEXP(*Ptr_has_blosc)();
+        static Ptr_has_blosc p_has_blosc = NULL;
+        if (p_has_blosc == NULL) {
+            validateSignature("bool(*has_blosc)()");
+            p_has_blosc = (Ptr_has_blosc)R_GetCCallable("EigenH5", "_EigenH5_has_blosc");
+        }
+        RObject rcpp_result_gen;
+        {
+            RNGScope RCPP_rngScope_gen;
+            rcpp_result_gen = p_has_blosc();
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<bool >(rcpp_result_gen);
+    }
+
+    inline bool has_lzf() {
+        typedef SEXP(*Ptr_has_lzf)();
+        static Ptr_has_lzf p_has_lzf = NULL;
+        if (p_has_lzf == NULL) {
+            validateSignature("bool(*has_lzf)()");
+            p_has_lzf = (Ptr_has_lzf)R_GetCCallable("EigenH5", "_EigenH5_has_lzf");
+        }
+        RObject rcpp_result_gen;
+        {
+            RNGScope RCPP_rngScope_gen;
+            rcpp_result_gen = p_has_lzf();
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<bool >(rcpp_result_gen);
+    }
+
     inline void start_blosc() {
         typedef SEXP(*Ptr_start_blosc)();
         static Ptr_start_blosc p_start_blosc = NULL;
@@ -255,6 +297,27 @@ namespace EigenH5 {
         return Rcpp::as<bool >(rcpp_result_gen);
     }
 
+    inline SEXP read_R_attribute_h5(const std::string& filename, std::string datapath) {
+        typedef SEXP(*Ptr_read_R_attribute_h5)(SEXP,SEXP);
+        static Ptr_read_R_attribute_h5 p_read_R_attribute_h5 = NULL;
+        if (p_read_R_attribute_h5 == NULL) {
+            validateSignature("SEXP(*read_R_attribute_h5)(const std::string&,std::string)");
+            p_read_R_attribute_h5 = (Ptr_read_R_attribute_h5)R_GetCCallable("EigenH5", "_EigenH5_read_R_attribute_h5");
+        }
+        RObject rcpp_result_gen;
+        {
+            RNGScope RCPP_rngScope_gen;
+            rcpp_result_gen = p_read_R_attribute_h5(Shield<SEXP>(Rcpp::wrap(filename)), Shield<SEXP>(Rcpp::wrap(datapath)));
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<SEXP >(rcpp_result_gen);
+    }
+
     inline SEXP read_attribute_h5(const std::string& filename, std::string datapath) {
         typedef SEXP(*Ptr_read_attribute_h5)(SEXP,SEXP);
         static Ptr_read_attribute_h5 p_read_attribute_h5 = NULL;
@@ -297,6 +360,48 @@ namespace EigenH5 {
         return Rcpp::as<bool >(rcpp_result_gen);
     }
 
+    inline Rcpp::IntegerVector fast_str2int(Rcpp::StringVector input, const int offset = 0, const int na_val = NA_INTEGER) {
+        typedef SEXP(*Ptr_fast_str2int)(SEXP,SEXP,SEXP);
+        static Ptr_fast_str2int p_fast_str2int = NULL;
+        if (p_fast_str2int == NULL) {
+            validateSignature("Rcpp::IntegerVector(*fast_str2int)(Rcpp::StringVector,const int,const int)");
+            p_fast_str2int = (Ptr_fast_str2int)R_GetCCallable("EigenH5", "_EigenH5_fast_str2int");
+        }
+        RObject rcpp_result_gen;
+        {
+            RNGScope RCPP_rngScope_gen;
+            rcpp_result_gen = p_fast_str2int(Shield<SEXP>(Rcpp::wrap(input)), Shield<SEXP>(Rcpp::wrap(offset)), Shield<SEXP>(Rcpp::wrap(na_val)));
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<Rcpp::IntegerVector >(rcpp_result_gen);
+    }
+
+    inline Rcpp::IntegerVector fast_str2ascii(Rcpp::StringVector input, int offset = 0) {
+        typedef SEXP(*Ptr_fast_str2ascii)(SEXP,SEXP);
+        static Ptr_fast_str2ascii p_fast_str2ascii = NULL;
+        if (p_fast_str2ascii == NULL) {
+            validateSignature("Rcpp::IntegerVector(*fast_str2ascii)(Rcpp::StringVector,int)");
+            p_fast_str2ascii = (Ptr_fast_str2ascii)R_GetCCallable("EigenH5", "_EigenH5_fast_str2ascii");
+        }
+        RObject rcpp_result_gen;
+        {
+            RNGScope RCPP_rngScope_gen;
+            rcpp_result_gen = p_fast_str2ascii(Shield<SEXP>(Rcpp::wrap(input)), Shield<SEXP>(Rcpp::wrap(offset)));
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<Rcpp::IntegerVector >(rcpp_result_gen);
+    }
+
     inline void link_objects_h5(Rcpp::StringVector filename_from, const std::string filename_to, Rcpp::StringVector datapath_from, Rcpp::StringVector datapath_to) {
         typedef SEXP(*Ptr_link_objects_h5)(SEXP,SEXP,SEXP,SEXP);
         static Ptr_link_objects_h5 p_link_objects_h5 = NULL;
@@ -482,6 +587,27 @@ namespace EigenH5 {
         return Rcpp::as<bool >(rcpp_result_gen);
     }
 
+    inline int ArrayTypeSize(const std::string filename, std::string dataname) {
+        typedef SEXP(*Ptr_ArrayTypeSize)(SEXP,SEXP);
+        static Ptr_ArrayTypeSize p_ArrayTypeSize = NULL;
+        if (p_ArrayTypeSize == NULL) {
+            validateSignature("int(*ArrayTypeSize)(const std::string,std::string)");
+            p_ArrayTypeSize = (Ptr_ArrayTypeSize)R_GetCCallable("EigenH5", "_EigenH5_ArrayTypeSize");
+        }
+        RObject rcpp_result_gen;
+        {
+            RNGScope RCPP_rngScope_gen;
+            rcpp_result_gen = p_ArrayTypeSize(Shield<SEXP>(Rcpp::wrap(filename)), Shield<SEXP>(Rcpp::wrap(dataname)));
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<int >(rcpp_result_gen);
+    }
+
     inline bool isDataSet(const std::string filename, std::string dataname) {
         typedef SEXP(*Ptr_isDataSet)(SEXP,SEXP);
         static Ptr_isDataSet p_isDataSet = NULL;
@@ -545,11 +671,11 @@ namespace EigenH5 {
         return Rcpp::as<Rcpp::StringVector >(rcpp_result_gen);
     }
 
-    inline Rcpp::StringVector typeof_h5(const std::string& filename, const std::string& datapath) {
+    inline Rcpp::StringVector typeof_h5(const std::string filename, const std::string datapath) {
         typedef SEXP(*Ptr_typeof_h5)(SEXP,SEXP);
         static Ptr_typeof_h5 p_typeof_h5 = NULL;
         if (p_typeof_h5 == NULL) {
-            validateSignature("Rcpp::StringVector(*typeof_h5)(const std::string&,const std::string&)");
+            validateSignature("Rcpp::StringVector(*typeof_h5)(const std::string,const std::string)");
             p_typeof_h5 = (Ptr_typeof_h5)R_GetCCallable("EigenH5", "_EigenH5_typeof_h5");
         }
         RObject rcpp_result_gen;
@@ -566,6 +692,27 @@ namespace EigenH5 {
         return Rcpp::as<Rcpp::StringVector >(rcpp_result_gen);
     }
 
+    inline Rcpp::List info_h5(const Rcpp::StringVector filename, Rcpp::StringVector datapaths) {
+        typedef SEXP(*Ptr_info_h5)(SEXP,SEXP);
+        static Ptr_info_h5 p_info_h5 = NULL;
+        if (p_info_h5 == NULL) {
+            validateSignature("Rcpp::List(*info_h5)(const Rcpp::StringVector,Rcpp::StringVector)");
+            p_info_h5 = (Ptr_info_h5)R_GetCCallable("EigenH5", "_EigenH5_info_h5");
+        }
+        RObject rcpp_result_gen;
+        {
+            RNGScope RCPP_rngScope_gen;
+            rcpp_result_gen = p_info_h5(Shield<SEXP>(Rcpp::wrap(filename)), Shield<SEXP>(Rcpp::wrap(datapaths)));
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<Rcpp::List >(rcpp_result_gen);
+    }
+
     inline Rcpp::DataFrame file_acc_ct(const std::string filename) {
         typedef SEXP(*Ptr_file_acc_ct)(SEXP);
         static Ptr_file_acc_ct p_file_acc_ct = NULL;
diff --git a/inst/include/concepts/concepts.hpp b/inst/include/concepts/concepts.hpp
new file mode 100644
index 0000000..37a8bb2
--- /dev/null
+++ b/inst/include/concepts/concepts.hpp
@@ -0,0 +1,1233 @@
+/// \file
+//  CPP, the Concepts PreProcessor library
+//
+//  Copyright Eric Niebler 2018-present
+//  Copyright (c) 2018-present, Facebook, Inc.
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef CPP_CONCEPTS_HPP
+#define CPP_CONCEPTS_HPP
+
+// clang-format off
+
+#include <initializer_list>
+#include <utility>
+#include <type_traits>
+#include <concepts/swap.hpp>
+#include <concepts/type_traits.hpp>
+
+// disable buggy compatibility warning about "requires" and "concept" being
+// C++20 keywords.
+#if defined(__clang__) || defined(__GNUC__)
+#define CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN                                        \
+    _Pragma("GCC diagnostic push")                                              \
+    _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")                     \
+    _Pragma("GCC diagnostic ignored \"-Wpragmas\"")                             \
+    _Pragma("GCC diagnostic ignored \"-Wc++2a-compat\"")                        \
+    _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"")                         \
+    /**/
+#define CPP_PP_IGNORE_CXX2A_COMPAT_END                                          \
+    _Pragma("GCC diagnostic pop")
+#else
+#define CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN
+#define CPP_PP_IGNORE_CXX2A_COMPAT_END
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CPP_WORKAROUND_MSVC_779763 // FATAL_UNREACHABLE calling constexpr function via template parameter
+#define CPP_WORKAROUND_MSVC_780775 // Incorrect substitution in function template return type
+#define CPP_WORKAROUND_MSVC_654601 // Failure to invoke *implicit* bool conversion in a constant expression
+#endif
+
+#if !defined(CPP_CXX_CONCEPTS)
+#ifdef CPP_DOXYGEN_INVOKED
+#define CPP_CXX_CONCEPTS 201800L
+#elif defined(__cpp_concepts) && __cpp_concepts > 0
+// gcc-6 concepts are too buggy to use
+#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 7
+#define CPP_CXX_CONCEPTS __cpp_concepts
+#else
+#define CPP_CXX_CONCEPTS 0L
+#endif
+#else
+#define CPP_CXX_CONCEPTS 0L
+#endif
+#endif
+
+CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN
+
+#define CPP_PP_CHECK(...) CPP_PP_CHECK_N(__VA_ARGS__, 0,)
+#define CPP_PP_CHECK_N(x, n, ...) n
+#define CPP_PP_PROBE(x) x, 1,
+#define CPP_PP_PROBE_N(x, n) x, n,
+
+// CPP_CXX_VA_OPT
+#ifndef CPP_CXX_VA_OPT
+#if __cplusplus > 201703L
+#define CPP_CXX_VA_OPT_(...) CPP_PP_CHECK(__VA_OPT__(,) 1)
+#define CPP_CXX_VA_OPT CPP_CXX_VA_OPT_(~)
+#else
+#define CPP_CXX_VA_OPT 0
+#endif
+#endif // CPP_CXX_VA_OPT
+
+#define CPP_PP_CAT_(X, ...)  X ## __VA_ARGS__
+#define CPP_PP_CAT(X, ...)   CPP_PP_CAT_(X, __VA_ARGS__)
+#define CPP_PP_CAT2_(X, ...) X ## __VA_ARGS__
+#define CPP_PP_CAT2(X, ...)  CPP_PP_CAT2_(X, __VA_ARGS__)
+
+#define CPP_PP_EVAL(X, ...) X(__VA_ARGS__)
+#define CPP_PP_EVAL2(X, ...) X(__VA_ARGS__)
+
+#define CPP_PP_EXPAND(...) __VA_ARGS__
+#define CPP_PP_EAT(...)
+
+#define CPP_PP_IS_PAREN(x) CPP_PP_CHECK(CPP_PP_IS_PAREN_PROBE x)
+#define CPP_PP_IS_PAREN_PROBE(...) CPP_PP_PROBE(~)
+
+#define CPP_PP_COUNT(...)                                                       \
+    CPP_PP_COUNT_(__VA_ARGS__,                                                  \
+        50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,            \
+        30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,            \
+        10,9,8,7,6,5,4,3,2,1,)                                                  \
+        /**/
+#define CPP_PP_COUNT_(                                                          \
+    _1, _2, _3, _4, _5, _6, _7, _8, _9, _10,                                    \
+    _11, _12, _13, _14, _15, _16, _17, _18, _19, _20,                           \
+    _21, _22, _23, _24, _25, _26, _27, _28, _29, _30,                           \
+    _31, _32, _33, _34, _35, _36, _37, _38, _39, _40,                           \
+    _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, N, ...)                   \
+    N                                                                           \
+    /**/
+
+#define CPP_PP_IIF(BIT) CPP_PP_CAT_(CPP_PP_IIF_, BIT)
+#define CPP_PP_IIF_0(TRUE, ...) __VA_ARGS__
+#define CPP_PP_IIF_1(TRUE, ...) TRUE
+
+#define CPP_PP_LPAREN (
+
+#define CPP_PP_NOT(BIT) CPP_PP_CAT_(CPP_PP_NOT_, BIT)
+#define CPP_PP_NOT_0 1
+#define CPP_PP_NOT_1 0
+
+#define CPP_PP_EMPTY()
+#define CPP_PP_COMMA() ,
+#define CPP_PP_LBRACE() {
+#define CPP_PP_RBRACE() }
+#define CPP_PP_COMMA_IIF(X)                                                     \
+    CPP_PP_IIF(X)(CPP_PP_EMPTY, CPP_PP_COMMA)()                                 \
+    /**/
+
+#define CPP_assert(...)                                                         \
+    static_assert(static_cast<bool>(__VA_ARGS__),                               \
+        "Concept assertion failed : " #__VA_ARGS__)                             \
+    /**/
+#define CPP_assert_msg static_assert
+
+#ifdef CPP_WORKAROUND_MSVC_654601
+#define CPP_FORCE_TO_BOOL static_cast<bool>
+#else
+#define CPP_FORCE_TO_BOOL
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CPP_INSTANCE(...) ::concepts::detail::instance_<decltype(__VA_ARGS__)>
+#else
+#define CPP_INSTANCE(...) __VA_ARGS__
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// CPP_def
+//   For defining concepts with a syntax similar to C++20. For example:
+//
+//     CPP_def(
+//         // The assignable_from concept from the C++20
+//         template(typename T, typename U)
+//         concept assignable_from,
+//             requires (T t, U &&u) (
+//                 t = (U &&) u,
+//                 ::concepts::requires_<same_as<decltype(t = (U &&) u), T>>
+//             ) &&
+//             std::is_lvalue_reference_v<T>
+//     );
+#define CPP_def(DECL, ...)                                                      \
+    CPP_PP_EVAL(                                                                \
+        CPP_PP_DECL_DEF,                                                        \
+        CPP_PP_CAT(CPP_PP_DEF_DECL_, DECL),                                     \
+        __VA_ARGS__)                                                            \
+    /**/
+#define CPP_PP_DECL_DEF_NAME(...)                                               \
+    CPP_PP_CAT(CPP_PP_DEF_, __VA_ARGS__),                                       \
+    /**/
+#define CPP_PP_DECL_DEF(TPARAM, NAME, ...)                                      \
+    CPP_PP_CAT(CPP_PP_DECL_DEF_, CPP_PP_IS_PAREN(NAME))(                        \
+        TPARAM,                                                                 \
+        NAME,                                                                   \
+        __VA_ARGS__)                                                            \
+    /**/
+// The defn is of the form:
+//   template(typename A, typename B = void, typename... Rest)
+//   (concept Name)(A, B, Rest...),
+//      // requirements...
+#define CPP_PP_DECL_DEF_1(TPARAM, NAME, ...)                                    \
+    CPP_PP_EVAL2(                                                               \
+        CPP_PP_DECL_DEF_IMPL,                                                   \
+        TPARAM,                                                                 \
+        CPP_PP_DECL_DEF_NAME NAME,                                              \
+        __VA_ARGS__)                                                            \
+    /**/
+// The defn is of the form:
+//   template(typename A, typename B)
+//   concept Name,
+//      // requirements...
+// Compute the template arguments (A, B) from the template introducer.
+#define CPP_PP_DECL_DEF_0(TPARAM, NAME, ...)                                    \
+    CPP_PP_DECL_DEF_IMPL(                                                       \
+        TPARAM,                                                                 \
+        CPP_PP_CAT(CPP_PP_DEF_, NAME),                                          \
+        (CPP_PP_CAT(CPP_PP_AUX_, TPARAM)),                                      \
+        __VA_ARGS__)                                                            \
+    /**/
+// Expand the template definition into a struct and template alias like:
+//    struct NameConcept {
+//      template<typename A, typename B>
+//      static auto Requires_(/* args (optional)*/) ->
+//          decltype(/*requirements...*/);
+//      template<typename A, typename B>
+//      static constexpr auto is_satisfied_by(int) ->
+//          decltype(bool(&Requires_<A,B>)) { return true; }
+//      template<typename A, typename B>
+//      static constexpr bool is_satisfied_by(long) { return false; }
+//    };
+//    template<typename A, typename B>
+//    inline constexpr bool Name = NameConcept::is_satisfied_by<A, B>(0);
+#if CPP_CXX_CONCEPTS
+// No requires expression
+#define CPP_PP_DEF_IMPL_0(...)                                                  \
+    __VA_ARGS__                                                                 \
+    /**/
+// Requires expression
+#define CPP_PP_DEF_IMPL_1(...)                                                  \
+    CPP_PP_CAT(CPP_PP_DEF_IMPL_1_, __VA_ARGS__)                                 \
+    /**/
+#define CPP_PP_DEF_IMPL_1_requires                                              \
+    requires CPP_PP_DEF_IMPL_1_REQUIRES                                         \
+    /**/
+#define CPP_PP_DEF_IMPL_1_REQUIRES(...)                                         \
+    (__VA_ARGS__) CPP_PP_DEF_IMPL_1_REQUIRES_BODY                               \
+    /**/
+#define CPP_PP_DEF_IMPL_1_REQUIRES_BODY(...)                                    \
+    { __VA_ARGS__; }                                                            \
+    /**/
+#ifdef CPP_DOXYGEN_INVOKED
+#define CPP_PP_DECL_DEF_IMPL(TPARAM, NAME, ARGS, ...)                           \
+    CPP_PP_CAT(CPP_PP_DEF_, TPARAM)                                             \
+    META_CONCEPT NAME = CPP_PP_DEF_IMPL(__VA_ARGS__,)(__VA_ARGS__)              \
+    /**/
+#else
+#define CPP_PP_DECL_DEF_IMPL(TPARAM, NAME, ARGS, ...)                           \
+    namespace defer {                                                           \
+        CPP_PP_CAT(CPP_PP_DEF_, TPARAM)                                         \
+        META_CONCEPT NAME = CPP_PP_DEF_IMPL(__VA_ARGS__,)(__VA_ARGS__);         \
+    }                                                                           \
+    using defer::NAME                                                           \
+    /**/
+#endif
+#else
+// No requires expression:
+#define CPP_PP_DEF_IMPL_0(...)                                                  \
+    () -> std::enable_if_t<CPP_FORCE_TO_BOOL(__VA_ARGS__), int>                 \
+    /**/
+// Requires expression:
+#define CPP_PP_DEF_IMPL_1(...)                                                  \
+    CPP_PP_CAT(CPP_PP_DEF_IMPL_1_, __VA_ARGS__) ) , int>                        \
+    /**/
+#define CPP_PP_DEF_IMPL_1_requires(...)                                         \
+    (__VA_ARGS__) ->                                                            \
+        std::enable_if_t<CPP_FORCE_TO_BOOL(                                     \
+            ::concepts::detail::requires_ CPP_PP_DEF_REQUIRES_BODY              \
+    /**/
+ #define CPP_PP_DEF_REQUIRES_BODY(...)                                          \
+    <decltype(__VA_ARGS__, void())>()                                           \
+    /**/
+#ifdef CPP_WORKAROUND_MSVC_780775
+#define CPP_PP_DECL_DEF_IMPL_HACK(ARGS)                                         \
+    template<typename C_ = Concept,                                             \
+        decltype(&C_::template Requires_<CPP_PP_EXPAND ARGS>) = nullptr>        \
+    static constexpr bool impl(int) noexcept { return true; }                   \
+    /**/
+#else
+#define CPP_PP_DECL_DEF_IMPL_HACK(ARGS)                                         \
+    template<typename C_ = Concept>                                             \
+    static constexpr decltype(                                                  \
+        &C_::template Requires_<CPP_PP_EXPAND ARGS>, true)                      \
+    impl(int) noexcept { return true; }                                         \
+    /**/
+#endif
+#define CPP_PP_DECL_DEF_IMPL(TPARAM, NAME, ARGS, ...)                           \
+    namespace cpp_detail_ {                                                     \
+        struct CPP_PP_CAT(NAME, _concept) {                                     \
+            using Concept = CPP_PP_CAT(NAME, _concept);                         \
+            CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN                                    \
+            CPP_PP_CAT(CPP_PP_DEF_, TPARAM)                                     \
+            static auto Requires_ CPP_PP_DEF_IMPL(__VA_ARGS__,)(__VA_ARGS__);   \
+            CPP_PP_IGNORE_CXX2A_COMPAT_END                                      \
+            CPP_PP_CAT(CPP_PP_DEF_, TPARAM)                                     \
+            struct Eval {                                                       \
+                CPP_PP_DECL_DEF_IMPL_HACK(ARGS)                                 \
+                static constexpr bool impl(long) noexcept { return false; }     \
+                constexpr operator bool() const noexcept {                      \
+                    return Eval::impl(0);                                       \
+                }                                                               \
+                constexpr auto operator!() const noexcept                       \
+                    -> ::concepts::detail::not_<Eval> {                         \
+                    return {};                                                  \
+                }                                                               \
+                template<typename That>                                         \
+                constexpr auto operator&&(That) const noexcept                  \
+                    -> ::concepts::detail::and_<Eval, That> {                   \
+                    static_assert(                                              \
+                        !META_IS_SAME(That, bool),                              \
+                        "All expressions in a conjunction should be "           \
+                        "defer:: concepts");                                    \
+                    return {};                                                  \
+                }                                                               \
+                template<typename That>                                         \
+                constexpr auto operator||(That) const noexcept                  \
+                    -> ::concepts::detail::or_<Eval, That> {                    \
+                    static_assert(                                              \
+                        !META_IS_SAME(That, bool),                              \
+                        "All expressions in a disjunction should be "           \
+                        "defer:: concepts");                                    \
+                    return {};                                                  \
+                }                                                               \
+            };                                                                  \
+        };                                                                      \
+    }                                                                           \
+    namespace defer {                                                           \
+        CPP_PP_CAT(CPP_PP_DEF_, TPARAM)                                         \
+        CPP_INLINE_VAR constexpr auto NAME =                                    \
+            cpp_detail_::CPP_PP_CAT(NAME, _concept)::Eval<CPP_PP_EXPAND ARGS>{};\
+    }                                                                           \
+    CPP_PP_CAT(CPP_PP_DEF_, TPARAM)                                             \
+    CPP_INLINE_VAR constexpr bool NAME =                                        \
+        (bool) defer::NAME<CPP_PP_EXPAND ARGS>;                                 \
+    using _concepts_int_ = int                                                  \
+    /**/
+#endif
+
+#define CPP_PP_REQUIRES_PROBE_requires                                          \
+    CPP_PP_PROBE(~)                                                             \
+    /**/
+#define CPP_PP_DEF_IMPL(REQUIRES, ...)                                          \
+    CPP_PP_CAT(                                                                 \
+        CPP_PP_DEF_IMPL_IS_PAREN_,                                              \
+        CPP_PP_IS_PAREN(REQUIRES))(REQUIRES)                                    \
+    /**/
+#define CPP_PP_DEF_IMPL_IS_PAREN_0(REQUIRES)                                    \
+    CPP_PP_CAT(                                                                 \
+        CPP_PP_DEF_IMPL_,                                                       \
+        CPP_PP_CHECK(CPP_PP_CAT(CPP_PP_REQUIRES_PROBE_, REQUIRES)))             \
+    /**/
+#define CPP_PP_DEF_IMPL_IS_PAREN_1(REQUIRES)                                    \
+    CPP_PP_DEF_IMPL_0                                                           \
+    /**/
+#define CPP_PP_DEF_DECL_template(...)                                           \
+    template(__VA_ARGS__),                                                      \
+    /**/
+#define CPP_PP_DEF_template(...)                                                \
+    template<__VA_ARGS__>                                                       \
+    /**/
+#define CPP_PP_DEF_concept
+#define CPP_PP_DEF_class
+#define CPP_PP_DEF_typename
+#define CPP_PP_DEF_int
+#define CPP_PP_DEF_bool
+#define CPP_PP_DEF_size_t
+#define CPP_PP_DEF_unsigned
+#define CPP_PP_AUX_template(...)                                                \
+    CPP_PP_CAT2(                                                                \
+        CPP_PP_TPARAM_,                                                         \
+        CPP_PP_COUNT(__VA_ARGS__))(__VA_ARGS__)                                 \
+    /**/
+#define CPP_PP_TPARAM_1(_1)                                                     \
+    CPP_PP_CAT2(CPP_PP_DEF_, _1)
+#define CPP_PP_TPARAM_2(_1, ...)                                                \
+    CPP_PP_CAT2(CPP_PP_DEF_, _1), CPP_PP_TPARAM_1(__VA_ARGS__)
+#define CPP_PP_TPARAM_3(_1, ...)                                                \
+    CPP_PP_CAT2(CPP_PP_DEF_, _1), CPP_PP_TPARAM_2(__VA_ARGS__)
+#define CPP_PP_TPARAM_4(_1, ...)                                                \
+    CPP_PP_CAT2(CPP_PP_DEF_, _1), CPP_PP_TPARAM_3(__VA_ARGS__)
+#define CPP_PP_TPARAM_5(_1, ...)                                                \
+    CPP_PP_CAT2(CPP_PP_DEF_, _1), CPP_PP_TPARAM_4(__VA_ARGS__)
+
+#define CPP_PP_PROBE_EMPTY_PROBE_CPP_PP_PROBE_EMPTY                             \
+    CPP_PP_PROBE(~)                                                             \
+
+#define CPP_PP_PROBE_EMPTY()
+#define CPP_PP_IS_NOT_EMPTY(...)                                                \
+    CPP_PP_CHECK(CPP_PP_CAT(CPP_PP_PROBE_EMPTY_PROBE_,                          \
+        CPP_PP_PROBE_EMPTY __VA_ARGS__ ()))                                     \
+    /**/
+
+////////////////////////////////////////////////////////////////////////////////
+// CPP_template
+// Usage:
+//   CPP_template(typename A, typename B)
+//     (requires Concept1<A> && Concept2<B>)
+//   void foo(A a, B b)
+//   {}
+#if CPP_CXX_CONCEPTS
+#define CPP_template(...)                                                       \
+    template<__VA_ARGS__> CPP_PP_EXPAND                                         \
+    /**/
+#define CPP_template_def CPP_template                                           \
+    /**/
+#define CPP_member
+#define CPP_ctor(TYPE) TYPE CPP_CTOR_IMPL_1_
+#define CPP_CTOR_IMPL_1_(...)                                                   \
+    (__VA_ARGS__) CPP_PP_EXPAND                                                 \
+    /**/
+#else
+#define CPP_template                                                            \
+    CPP_template_sfinae                                                         \
+    /**/
+#define CPP_template_def CPP_template_def_sfinae                                \
+    /**/
+#define CPP_member CPP_member_sfinae
+#define CPP_ctor CPP_ctor_sfinae
+#endif
+
+#define CPP_template_sfinae(...)                                                \
+    template<__VA_ARGS__ CPP_TEMPLATE_SFINAE_AUX_                               \
+    /**/
+#define CPP_TEMPLATE_SFINAE_AUX_(...) ,                                         \
+    typename CPP_true_ = std::true_type,                                        \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__) && CPP_true_{}  \
+        ),                                                                      \
+        int                                                                     \
+    > = 0>                                                                      \
+    /**/
+#define CPP_template_def_sfinae(...)                                            \
+    template<__VA_ARGS__ CPP_TEMPLATE_DEF_SFINAE_AUX_                           \
+    /**/
+#define CPP_TEMPLATE_DEF_SFINAE_AUX_(...) ,                                     \
+    typename CPP_true_,                                                         \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__) && CPP_true_{}  \
+        ),                                                                      \
+        int                                                                     \
+    >>                                                                          \
+    /**/
+#define CPP_TEMPLATE_SFINAE_AUX_3_requires
+#define CPP_member_sfinae                                                       \
+    CPP_broken_friend_member                                                    \
+    /**/
+#define CPP_ctor_sfinae(TYPE) TYPE CPP_CTOR_SFINAE_IMPL_1_
+#define CPP_CTOR_SFINAE_IMPL_1_(...)                                            \
+    (__VA_ARGS__                                                                \
+        CPP_PP_COMMA_IIF(                                                       \
+            CPP_PP_NOT(CPP_PP_IS_NOT_EMPTY(__VA_ARGS__)))                       \
+    CPP_CTOR_SFINAE_REQUIRES                                                    \
+    /**/
+#define CPP_CTOR_SFINAE_PROBE_NOEXCEPT_noexcept                                 \
+    CPP_PP_PROBE(~)                                                             \
+    /**/
+#define CPP_CTOR_SFINAE_MAKE_PROBE(FIRST,...)                                   \
+    CPP_PP_CAT(CPP_CTOR_SFINAE_PROBE_NOEXCEPT_, FIRST)                          \
+    /**/
+#define CPP_CTOR_SFINAE_REQUIRES(...)                                           \
+    CPP_PP_CAT(CPP_CTOR_SFINAE_REQUIRES_,                                       \
+    CPP_PP_CHECK(CPP_CTOR_SFINAE_MAKE_PROBE(__VA_ARGS__,)))(__VA_ARGS__)        \
+    /**/
+// No noexcept-clause:
+#define CPP_CTOR_SFINAE_REQUIRES_0(...)                                         \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__) &&              \
+            CPP_INSTANCE(CPP_true(::concepts::detail::xNil{}))                  \
+        ),                                                                      \
+        ::concepts::detail::Nil                                                 \
+    > = {})                                                                     \
+    /**/
+// Yes noexcept-clause:
+#define CPP_CTOR_SFINAE_REQUIRES_1(...)                                         \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_,                              \
+                CPP_PP_CAT(CPP_CTOR_SFINAE_EAT_NOEXCEPT_, __VA_ARGS__)          \
+            ) && CPP_INSTANCE(CPP_true(::concepts::detail::xNil{}))             \
+        ),                                                                      \
+        ::concepts::detail::Nil                                                 \
+    > = {})                                                                     \
+    CPP_PP_EXPAND(CPP_PP_CAT(CPP_CTOR_SFINAE_SHOW_NOEXCEPT_, __VA_ARGS__)))     \
+    /**/
+#define CPP_CTOR_SFINAE_EAT_NOEXCEPT_noexcept(...)
+#define CPP_CTOR_SFINAE_SHOW_NOEXCEPT_noexcept(...)                             \
+    noexcept(__VA_ARGS__) CPP_PP_EAT CPP_PP_LPAREN                              \
+    /**/
+
+#ifdef CPP_DOXYGEN_INVOKED
+#define CPP_broken_friend_ret(...)                                              \
+    __VA_ARGS__ CPP_PP_EXPAND                                                   \
+    /**/
+#else
+#define CPP_broken_friend_ret(...)                                              \
+    ::concepts::return_t<                                                       \
+        __VA_ARGS__,                                                            \
+        std::enable_if_t<CPP_FORCE_TO_BOOL(CPP_BROKEN_FRIEND_RETURN_TYPE_AUX_   \
+    /**/
+#define CPP_BROKEN_FRIEND_RETURN_TYPE_AUX_(...)                                 \
+    CPP_BROKEN_FRIEND_RETURN_TYPE_AUX_3_(CPP_PP_CAT(                            \
+        CPP_TEMPLATE_AUX_2_, __VA_ARGS__))                                      \
+    /**/
+#define CPP_TEMPLATE_AUX_2_requires
+#define CPP_BROKEN_FRIEND_RETURN_TYPE_AUX_3_(...)                               \
+    __VA_ARGS__ && CPP_INSTANCE(CPP_true(::concepts::detail::xNil{})))>>        \
+    /**/
+#ifdef CPP_WORKAROUND_MSVC_779763
+#define CPP_broken_friend_member                                                \
+    template<::concepts::detail::CPP_true_t const &CPP_true =                   \
+        ::concepts::detail::CPP_true_>                                          \
+    /**/
+#else // ^^^ workaround / no workaround vvv
+#define CPP_broken_friend_member                                                \
+    template<std::true_type (&CPP_true)(::concepts::detail::xNil) =             \
+        ::concepts::detail::CPP_true>                                           \
+    /**/
+#endif // CPP_WORKAROUND_MSVC_779763
+#endif
+
+#if CPP_CXX_CONCEPTS
+#define CPP_ret(...)                                                            \
+    __VA_ARGS__ CPP_PP_EXPAND                                                   \
+    /**/
+#else
+#define CPP_ret                                                                 \
+    CPP_broken_friend_ret                                                       \
+    /**/
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// CPP_fun
+#if CPP_CXX_CONCEPTS
+#define CPP_FUN_IMPL_1_(...)                                                    \
+    (__VA_ARGS__)                                                               \
+    CPP_PP_EXPAND                                                               \
+    /**/
+#define CPP_fun(X) X CPP_FUN_IMPL_1_
+#else
+#define CPP_FUN_IMPL_1_(...)                                                    \
+    (__VA_ARGS__                                                                \
+        CPP_PP_COMMA_IIF(                                                       \
+            CPP_PP_NOT(CPP_PP_IS_NOT_EMPTY(__VA_ARGS__)))                       \
+    CPP_FUN_IMPL_REQUIRES                                                       \
+    /**/
+
+#define CPP_FUN_IMPL_REQUIRES(...)                                              \
+    CPP_FUN_IMPL_SELECT_CONST_(__VA_ARGS__,)(__VA_ARGS__)                       \
+    /**/
+
+#define CPP_FUN_IMPL_SELECT_CONST_(MAYBE_CONST, ...)                            \
+    CPP_PP_CAT(CPP_FUN_IMPL_SELECT_CONST_,                                      \
+        CPP_PP_CHECK(CPP_PP_CAT(                                                \
+            CPP_PP_PROBE_CONST_PROBE_, MAYBE_CONST)))                           \
+    /**/
+
+#define CPP_PP_PROBE_CONST_PROBE_const CPP_PP_PROBE(~)
+
+#define CPP_FUN_IMPL_SELECT_CONST_1(...)                                        \
+    CPP_PP_EVAL(                                                                \
+        CPP_FUN_IMPL_SELECT_CONST_NOEXCEPT_,                                    \
+        CPP_PP_CAT(CPP_FUN_IMPL_EAT_CONST_, __VA_ARGS__),)(                     \
+        CPP_PP_CAT(CPP_FUN_IMPL_EAT_CONST_, __VA_ARGS__))                       \
+    /**/
+
+#define CPP_FUN_IMPL_SELECT_CONST_NOEXCEPT_(MAYBE_NOEXCEPT, ...)                \
+    CPP_PP_CAT(CPP_FUN_IMPL_SELECT_CONST_NOEXCEPT_,                             \
+        CPP_PP_CHECK(CPP_PP_CAT(                                                \
+            CPP_PP_PROBE_NOEXCEPT_PROBE_, MAYBE_NOEXCEPT)))                     \
+    /**/
+
+#define CPP_PP_PROBE_NOEXCEPT_PROBE_noexcept CPP_PP_PROBE(~)
+
+#define CPP_FUN_IMPL_SELECT_CONST_NOEXCEPT_0(...)                               \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(CPP_FUN_IMPL_EAT_REQUIRES_, __VA_ARGS__) &&              \
+            CPP_INSTANCE(CPP_true(::concepts::detail::xNil{}))                  \
+        ),                                                                      \
+        ::concepts::detail::Nil                                                 \
+    > = {}) const                                                               \
+    /**/
+
+#define CPP_FUN_IMPL_SELECT_CONST_NOEXCEPT_1(...)                               \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(                                                         \
+                CPP_FUN_IMPL_EAT_REQUIRES_,                                     \
+                CPP_PP_CAT(CPP_FUN_IMPL_EAT_NOEXCEPT_, __VA_ARGS__)             \
+            ) && CPP_INSTANCE(CPP_true(::concepts::detail::xNil{}))             \
+        ),                                                                      \
+        ::concepts::detail::Nil                                                 \
+    > = {}) const                                                               \
+    CPP_PP_EXPAND(CPP_PP_CAT(CPP_FUN_IMPL_SHOW_NOEXCEPT_, __VA_ARGS__)))        \
+    /**/
+
+#define CPP_FUN_IMPL_EAT_NOEXCEPT_noexcept(...)
+#define CPP_FUN_IMPL_SHOW_NOEXCEPT_noexcept(...)                                \
+    noexcept(__VA_ARGS__) CPP_PP_EAT CPP_PP_LPAREN                              \
+    /**/
+
+#define CPP_FUN_IMPL_EAT_NOEXCEPT_noexcept(...)
+
+#define CPP_FUN_IMPL_EXPAND_NOEXCEPT_noexcept(...)                              \
+    noexcept(__VA_ARGS__)                                                       \
+    /**/
+
+#define CPP_FUN_IMPL_SELECT_CONST_0(...)                                        \
+    CPP_FUN_IMPL_SELECT_NONCONST_NOEXCEPT_(__VA_ARGS__,)(__VA_ARGS__)           \
+    /**/
+
+#define CPP_FUN_IMPL_SELECT_NONCONST_NOEXCEPT_(MAYBE_NOEXCEPT, ...)             \
+    CPP_PP_CAT(CPP_FUN_IMPL_SELECT_NONCONST_NOEXCEPT_,                          \
+          CPP_PP_CHECK(CPP_PP_CAT(                                              \
+            CPP_PP_PROBE_NOEXCEPT_PROBE_, MAYBE_NOEXCEPT)))                     \
+    /**/
+
+#define CPP_FUN_IMPL_SELECT_NONCONST_NOEXCEPT_0(...)                            \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(CPP_FUN_IMPL_EAT_REQUIRES_, __VA_ARGS__) &&              \
+            CPP_INSTANCE(CPP_true(::concepts::detail::xNil{}))                  \
+        ),                                                                      \
+        ::concepts::detail::Nil                                                 \
+    > = {})                                                                     \
+    /**/
+
+#define CPP_FUN_IMPL_SELECT_NONCONST_NOEXCEPT_1(...)                            \
+    std::enable_if_t<                                                           \
+        CPP_FORCE_TO_BOOL(                                                      \
+            CPP_PP_CAT(                                                         \
+                CPP_FUN_IMPL_EAT_REQUIRES_,                                     \
+                CPP_PP_CAT(CPP_FUN_IMPL_EAT_NOEXCEPT_, __VA_ARGS__)             \
+            ) &&                                                                \
+            CPP_INSTANCE(CPP_true(::concepts::detail::xNil{}))                  \
+        ),                                                                      \
+        ::concepts::detail::Nil                                                 \
+    > = {})                                                                     \
+    CPP_PP_EXPAND(CPP_PP_CAT(CPP_FUN_IMPL_SHOW_NOEXCEPT_, __VA_ARGS__)))        \
+    /**/
+
+#define CPP_FUN_IMPL_EAT_CONST_const
+#define CPP_FUN_IMPL_EAT_REQUIRES_requires
+
+////////////////////////////////////////////////////////////////////////////////
+// CPP_fun
+// Usage:
+//   template <typename A, typename B>
+//   void CPP_fun(foo)(A a, B b)([const]opt [noexcept(true)]opt
+//       requires Concept1<A> && Concept2<B>)
+//   {}
+//
+// Note: This macro cannot be used when the last function argument is a
+//       parameter pack.
+#define CPP_fun(X) X CPP_FUN_IMPL_1_
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// CPP_auto_fun
+// Usage:
+//   template <typename A, typename B>
+//   auto CPP_auto_fun(foo)(A a, B b)([const]opt [noexcept(true)]opt)opt
+//   (
+//       return a + b
+//   )
+#define CPP_auto_fun(X) X CPP_AUTO_FUN_IMPL_
+#define CPP_AUTO_FUN_IMPL_(...) (__VA_ARGS__) CPP_AUTO_FUN_RETURNS_
+#define CPP_AUTO_FUN_RETURNS_(...)                                              \
+    CPP_AUTO_FUN_SELECT_RETURNS_(__VA_ARGS__,)(__VA_ARGS__)                     \
+    /**/
+#define CPP_AUTO_FUN_SELECT_RETURNS_(MAYBE_CONST, ...)                          \
+    CPP_PP_CAT(CPP_AUTO_FUN_RETURNS_CONST_,                                     \
+        CPP_PP_CHECK(CPP_PP_CAT(                                                \
+            CPP_PP_PROBE_CONST_MUTABLE_PROBE_, MAYBE_CONST)))                   \
+    /**/
+#define CPP_PP_PROBE_CONST_MUTABLE_PROBE_const CPP_PP_PROBE_N(~, 1)
+#define CPP_PP_PROBE_CONST_MUTABLE_PROBE_mutable CPP_PP_PROBE_N(~, 2)
+#define CPP_PP_EAT_MUTABLE_mutable
+#define CPP_AUTO_FUN_RETURNS_CONST_2(...)                                       \
+    CPP_PP_CAT(CPP_PP_EAT_MUTABLE_, __VA_ARGS__) CPP_AUTO_FUN_RETURNS_CONST_0
+#define CPP_AUTO_FUN_RETURNS_CONST_1(...)                                       \
+    __VA_ARGS__ CPP_AUTO_FUN_RETURNS_CONST_0                                    \
+    /**/
+#define CPP_AUTO_FUN_RETURNS_CONST_0(...)                                       \
+    CPP_PP_EVAL(CPP_AUTO_FUN_DECLTYPE_NOEXCEPT_,                                \
+        CPP_PP_CAT(CPP_AUTO_FUN_RETURNS_, __VA_ARGS__))                         \
+    /**/
+#define CPP_AUTO_FUN_RETURNS_return
+
+#ifdef __cpp_guaranteed_copy_elision
+#define CPP_AUTO_FUN_DECLTYPE_NOEXCEPT_(...)                                    \
+    noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__)                    \
+    { return (__VA_ARGS__); }                                                   \
+    /**/
+#else
+#define CPP_AUTO_FUN_DECLTYPE_NOEXCEPT_(...)                                    \
+    noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__))) ->                   \
+    decltype(__VA_ARGS__)                                                       \
+    { return (__VA_ARGS__); }                                                   \
+    /**/
+#endif
+
+namespace concepts
+{
+    template<bool B>
+    using bool_ = std::integral_constant<bool, B>;
+
+#if defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603
+    template<bool...Bs>
+    CPP_INLINE_VAR constexpr bool and_v = (Bs &&...);
+
+    template<bool...Bs>
+    CPP_INLINE_VAR constexpr bool or_v = (Bs ||...);
+#else
+    namespace detail
+    {
+        template<bool...>
+        struct bools;
+    } // namespace detail
+
+    template<bool...Bs>
+    CPP_INLINE_VAR constexpr bool and_v =
+        META_IS_SAME(detail::bools<Bs..., true>, detail::bools<true, Bs...>);
+
+    template<bool...Bs>
+    CPP_INLINE_VAR constexpr bool or_v =
+        !META_IS_SAME(detail::bools<Bs..., false>, detail::bools<false, Bs...>);
+#endif
+
+    template<typename>
+    struct return_t_
+    {
+        template<typename T>
+        using invoke = T;
+    };
+
+    template<typename T, typename EnableIf>
+    using return_t = meta::invoke<return_t_<EnableIf>, T>;
+
+    namespace detail
+    {
+        template<typename T>
+        CPP_INLINE_VAR constexpr T instance_ = T{};
+
+        template<typename>
+        constexpr bool requires_()
+        {
+            return true;
+        }
+
+        struct boolean
+        {
+            friend bool operator&&(boolean, bool) = delete;
+            friend bool operator&&(bool, boolean) = delete;
+            friend bool operator||(boolean, bool) = delete;
+            friend bool operator||(bool, boolean) = delete;
+        };
+        template<typename T, typename U>
+        struct and_;
+        template<typename T, typename U>
+        struct or_;
+        template<typename T>
+        struct not_ : boolean
+        {
+            constexpr operator bool() const noexcept
+            {
+                return !(bool) T{};
+            }
+            constexpr T operator!() const noexcept
+            {
+                return T{};
+            }
+            template<typename That>
+            constexpr and_<not_, That> operator&&(That) const noexcept
+            {
+                return {};
+            }
+            template<typename That>
+            constexpr or_<not_, That> operator||(That) const noexcept
+            {
+                return {};
+            }
+        };
+
+        template<typename T, typename U>
+        struct and_ : boolean
+        {
+            static constexpr bool impl(std::false_type) noexcept
+            {
+                return false;
+            }
+            static constexpr bool impl(std::true_type) noexcept
+            {
+                return (bool) U{};
+            }
+            constexpr operator bool() const noexcept
+            {
+                return and_::impl(bool_<(bool) T{}>{});
+            }
+            constexpr not_<and_> operator!() const noexcept
+            {
+                return not_<and_>{};
+            }
+            template<typename That>
+            constexpr and_<and_, That> operator&&(That) const noexcept
+            {
+                static_assert(
+                    !META_IS_SAME(That, bool),
+                    "All expressions in a conjunction should be "
+                    "defer:: concepts");
+                return {};
+            }
+            template<typename That>
+            constexpr or_<and_, That> operator||(That) const noexcept
+            {
+                static_assert(
+                    !META_IS_SAME(That, bool),
+                    "All expressions in a disjunction should be "
+                    "defer:: concepts");
+                return {};
+            }
+        };
+
+        template<typename T, typename U>
+        struct or_ : boolean
+        {
+            static constexpr bool impl(std::true_type) noexcept
+            {
+                return true;
+            }
+            static constexpr bool impl(std::false_type) noexcept
+            {
+                return (bool) U{};
+            }
+            constexpr operator bool() const noexcept
+            {
+                return or_::impl(bool_<(bool) T{}>{});
+            }
+            constexpr not_<or_> operator!() const noexcept
+            {
+                return {};
+            }
+            template<typename That>
+            constexpr detail::and_<or_, That> operator&&(That) const noexcept
+            {
+                static_assert(
+                    !META_IS_SAME(That, bool),
+                    "All expressions in a disjunction should be "
+                    "defer:: concepts");
+                return {};
+            }
+            template<typename That>
+            constexpr detail::or_<or_, That> operator||(That) const noexcept
+            {
+                static_assert(
+                    !META_IS_SAME(That, bool),
+                    "All expressions in a disjunction should be "
+                    "defer:: concepts");
+                return {};
+            }
+        };
+
+        struct Nil
+        {};
+
+#ifdef CPP_WORKAROUND_MSVC_779763
+        enum class xNil {};
+
+        struct CPP_true_t
+        {
+            constexpr std::true_type operator()(Nil) const noexcept
+            {
+                return {};
+            }
+            constexpr std::true_type operator()(xNil) const noexcept
+            {
+                return {};
+            }
+        };
+
+        CPP_INLINE_VAR constexpr CPP_true_t CPP_true_{};
+
+        constexpr std::true_type CPP_true(xNil)
+        {
+            return {};
+        }
+#else
+        using xNil = Nil;
+#endif
+
+        constexpr std::true_type CPP_true(Nil)
+        {
+            return {};
+        }
+
+        template<typename T>
+        using remove_cvref_t =
+            typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept weakly_equality_comparable_with_,
+                requires (detail::as_cref_t<T> t, detail::as_cref_t<U> u)
+                (
+                    (t == u) ? 1 : 0,
+                    (t != u) ? 1 : 0,
+                    (u == t) ? 1 : 0,
+                    (u != t) ? 1 : 0
+                )
+        );
+    } // namespace detail
+
+#if defined(__clang__) || defined(_MSC_VER)
+    template<bool B>
+    std::enable_if_t<B> requires_()
+    {}
+#else
+    template<bool B>
+    CPP_INLINE_VAR constexpr std::enable_if_t<B, int> requires_ = 0;
+#endif
+
+    inline namespace defs
+    {
+        ////////////////////////////////////////////////////////////////////////////////////////
+        // Utility concepts
+        ////////////////////////////////////////////////////////////////////////////////////////
+
+        CPP_def
+        (
+            template(bool B)
+            (concept is_true)(B),
+                B
+        );
+
+        CPP_def
+        (
+            template(typename... Args)
+            (concept type)(Args...),
+                true
+        );
+
+        CPP_def
+        (
+            template(class T, template<typename...> class Trait, typename... Args)
+            (concept satisfies)(T, Trait, Args...),
+                static_cast<bool>(Trait<T, Args...>::type::value)
+        );
+
+        ////////////////////////////////////////////////////////////////////////////////////////
+        // Core language concepts
+        ////////////////////////////////////////////////////////////////////////////////////////
+
+        CPP_def
+        (
+            template(typename A, typename B)
+            concept same_as,
+                META_IS_SAME(A, B) && META_IS_SAME(B, A)
+        );
+
+        /// \cond
+        CPP_def
+        (
+            template(typename A, typename B)
+            concept not_same_as_,
+                (!same_as<detail::remove_cvref_t<A>, detail::remove_cvref_t<B>>)
+        );
+
+        // Workaround bug in the Standard Library:
+        // From cannot be an incomplete class type despite that
+        // is_convertible<X, Y> should be equivalent to is_convertible<X&&, Y>
+        // in such a case.
+        CPP_def
+        (
+            template(typename From, typename To)
+            concept implicitly_convertible_to,
+                std::is_convertible<typename std::add_rvalue_reference<From>::type, To>::value
+        );
+
+        CPP_def
+        (
+            template(typename From, typename To)
+            concept explicitly_convertible_to,
+                requires (From (&from)())
+                (
+                    static_cast<To>(from())
+                )
+        );
+        /// \endcond
+
+        CPP_def
+        (
+            template(typename From, typename To)
+            concept convertible_to,
+                implicitly_convertible_to<From, To> &&
+                explicitly_convertible_to<From, To>
+        );
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept derived_from,
+                META_IS_BASE_OF(U, T) &&
+                convertible_to<T const volatile *, U const volatile *>
+        );
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept common_reference_with,
+                same_as<common_reference_t<T, U>, common_reference_t<U, T>> &&
+                convertible_to<T, common_reference_t<T, U>> &&
+                convertible_to<U, common_reference_t<T, U>>
+        );
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept common_with,
+                same_as<common_type_t<T, U>, common_type_t<U, T>> &&
+                convertible_to<T, common_type_t<T, U>> &&
+                convertible_to<U, common_type_t<T, U>> &&
+                common_reference_with<
+                    typename std::add_lvalue_reference<T const>::type,
+                    typename std::add_lvalue_reference<U const>::type> &&
+                common_reference_with<
+                    typename std::add_lvalue_reference<common_type_t<T, U>>::type,
+                    common_reference_t<
+                        typename std::add_lvalue_reference<T const>::type,
+                        typename std::add_lvalue_reference<U const>::type>>
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept integral,
+                std::is_integral<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept signed_integral,
+                integral<T> &&
+                std::is_signed<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept unsigned_integral,
+                integral<T> &&
+                !signed_integral<T>
+        );
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept assignable_from,
+                requires (T t, U &&u)
+                (
+                    t = (U &&) u,
+                    requires_<same_as<T, decltype(t = (U &&) u)>>
+                ) &&
+                std::is_lvalue_reference<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept swappable,
+                requires (T &t, T &u)
+                (
+                    concepts::swap(t, u)
+                )
+        );
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept swappable_with,
+                requires (T &&t, U &&u)
+                (
+                    concepts::swap((T &&) t, (T &&) t),
+                    concepts::swap((U &&) u, (U &&) u),
+                    concepts::swap((U &&) u, (T &&) t),
+                    concepts::swap((T &&) t, (U &&) u)
+                ) &&
+                common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>>
+        );
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Comparison concepts
+        ////////////////////////////////////////////////////////////////////////////////////////////
+
+        CPP_def
+        (
+            template(typename T)
+            concept equality_comparable,
+                detail::weakly_equality_comparable_with_<T, T>
+        );
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept equality_comparable_with,
+                equality_comparable<T> &&
+                equality_comparable<U> &&
+                detail::weakly_equality_comparable_with_<T, U> &&
+                common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
+                equality_comparable<
+                    common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept totally_ordered,
+                requires (detail::as_cref_t<T> t, detail::as_cref_t<T> u)
+                (
+                    t < u ? 1 : 0,
+                    t > u ? 1 : 0,
+                    u <= t ? 1 : 0,
+                    u >= t ? 1 : 0
+                ) &&
+                equality_comparable<T>
+        );
+
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept totally_ordered_with,
+                requires (detail::as_cref_t<T> t, detail::as_cref_t<U> u)
+                (
+                    t < u ? 1 : 0,
+                    t > u ? 1 : 0,
+                    t <= u ? 1 : 0,
+                    t >= u ? 1 : 0,
+                    u < t ? 1 : 0,
+                    u > t ? 1 : 0,
+                    u <= t ? 1 : 0,
+                    u >= t ? 1 : 0
+                ) &&
+                totally_ordered<T> &&
+                totally_ordered<U> &&
+                equality_comparable_with<T, U> &&
+                common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
+                totally_ordered<
+                    common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>
+        );
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Object concepts
+        ////////////////////////////////////////////////////////////////////////////////////////////
+
+        CPP_def
+        (
+            template(typename T)
+            concept destructible,
+                std::is_nothrow_destructible<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T, typename... Args)
+            (concept constructible_from)(T, Args...),
+                destructible<T> &&
+                META_IS_CONSTRUCTIBLE(T, Args...)
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept default_constructible,
+                constructible_from<T>
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept move_constructible,
+                constructible_from<T, T> &&
+                convertible_to<T, T>
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept copy_constructible,
+                move_constructible<T> &&
+                constructible_from<T, T &> &&
+                constructible_from<T, T const &> &&
+                constructible_from<T, T const> &&
+                convertible_to<T &, T> &&
+                convertible_to<T const &, T> &&
+                convertible_to<T const, T>
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept movable,
+                std::is_object<T>::value &&
+                move_constructible<T> &&
+                assignable_from<T &, T> &&
+                swappable<T>
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept copyable,
+                copy_constructible<T> &&
+                movable<T> &&
+                assignable_from<T &, T const &>
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept semiregular,
+                copyable<T> &&
+                default_constructible<T>
+            // Axiom: copies are independent. See Fundamentals of Generic Programming
+            // http://www.stepanovpapers.com/DeSt98.pdf
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept regular,
+                semiregular<T> &&
+                equality_comparable<T>
+        );
+    } // inline namespace defs
+} // namespace concepts
+
+CPP_PP_IGNORE_CXX2A_COMPAT_END
+
+#endif // RANGES_V3_UTILITY_CONCEPTS_HPP
diff --git a/inst/include/concepts/swap.hpp b/inst/include/concepts/swap.hpp
new file mode 100644
index 0000000..ae99faa
--- /dev/null
+++ b/inst/include/concepts/swap.hpp
@@ -0,0 +1,326 @@
+/// \file
+// Concepts library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#ifndef CPP_SWAP_HPP
+#define CPP_SWAP_HPP
+
+#include <tuple>
+#include <utility>
+#include <type_traits>
+#include <meta/meta.hpp>
+
+// Note: constexpr implies inline, to retain the same visibility
+// C++14 constexpr functions are inline in C++11
+#if (defined(__cpp_constexpr) && __cpp_constexpr >= 201304L) ||\
+    (!defined(__cpp_constexpr) && __cplusplus >= 201402L)
+#define CPP_CXX14_CONSTEXPR constexpr
+#else
+#define CPP_CXX14_CONSTEXPR inline
+#endif
+
+#ifndef CPP_CXX_INLINE_VARIABLES
+#ifdef __cpp_inline_variables // TODO: fix this if SD-6 picks another name
+#define CPP_CXX_INLINE_VARIABLES __cpp_inline_variables
+// TODO: remove once clang defines __cpp_inline_variables (or equivalent)
+#elif defined(__clang__) && \
+    (__clang_major__ > 3 || __clang_major__ == 3 && __clang_minor__ == 9) && \
+    __cplusplus > 201402L
+#define CPP_CXX_INLINE_VARIABLES 201606L
+#else
+#define CPP_CXX_INLINE_VARIABLES __cplusplus
+#endif  // __cpp_inline_variables
+#endif  // CPP_CXX_INLINE_VARIABLES
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CPP_WORKAROUND_MSVC_895622 // Error when phase 1 name binding finds only deleted function
+#endif
+
+#if CPP_CXX_INLINE_VARIABLES < 201606L
+#define CPP_INLINE_VAR
+#define CPP_INLINE_VARIABLE(type, name)                                         \
+    inline namespace                                                            \
+    {                                                                           \
+        constexpr auto &name = ::concepts::detail::static_const<type>::value;   \
+    }                                                                           \
+    /**/
+#else  // CPP_CXX_INLINE_VARIABLES >= 201606L
+#define CPP_INLINE_VAR inline
+#define CPP_INLINE_VARIABLE(type, name)                                         \
+    inline constexpr type name{};                                               \
+    /**/
+#endif // CPP_CXX_INLINE_VARIABLES
+
+#if CPP_CXX_INLINE_VARIABLES < 201606L
+#define CPP_DEFINE_CPO(type, name)                                              \
+    inline namespace                                                            \
+    {                                                                           \
+        constexpr auto &name = ::concepts::detail::static_const<type>::value;   \
+    }                                                                           \
+    /**/
+#else  // CPP_CXX_INLINE_VARIABLES >= 201606L
+#define CPP_DEFINE_CPO(type, name)                                              \
+    inline namespace _                                                          \
+    {                                                                           \
+        inline constexpr type name{};                                           \
+    }                                                                           \
+    /**/
+#endif // CPP_CXX_INLINE_VARIABLES
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CPP_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME
+#else // ^^^ defined(_MSC_VER) ^^^ / vvv !defined(_MSC_VER) vvv
+#if defined(__GNUC__) || defined(__clang__)
+#define CPP_PRAGMA(X) _Pragma(#X)
+#define CPP_DIAGNOSTIC_IGNORE_PRAGMAS \
+    CPP_PRAGMA(GCC diagnostic ignored "-Wpragmas")
+#define CPP_DIAGNOSTIC_IGNORE(X) \
+    CPP_DIAGNOSTIC_IGNORE_PRAGMAS \
+    CPP_PRAGMA(GCC diagnostic ignored "-Wunknown-pragmas") \
+    CPP_PRAGMA(GCC diagnostic ignored X)
+#define CPP_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME \
+    CPP_DIAGNOSTIC_IGNORE("-Wunknown-warning-option") \
+    CPP_DIAGNOSTIC_IGNORE("-Winit-list-lifetime")
+#else
+#define CPP_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME
+#endif
+#endif // MSVC/Generic configuration switch
+
+namespace concepts
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        CPP_INLINE_VAR constexpr bool is_movable_v =
+            std::is_object<T>::value &&
+            std::is_move_constructible<T>::value &&
+            std::is_move_assignable<T>::value;
+
+        template<typename T>
+        struct static_const
+        {
+            static constexpr T const value {};
+        };
+        template<typename T>
+        constexpr T const static_const<T>::value;
+    }
+    /// \endcond
+
+    template<typename T>
+    struct is_swappable;
+
+    template<typename T>
+    struct is_nothrow_swappable;
+
+    template<typename T, typename U>
+    struct is_swappable_with;
+
+    template<typename T, typename U>
+    struct is_nothrow_swappable_with;
+
+    template<typename T, typename U = T>
+    CPP_CXX14_CONSTEXPR
+    meta::if_c<
+        std::is_move_constructible<T>::value &&
+        std::is_assignable<T &, U>::value, T>
+    exchange(T &t, U &&u)
+        noexcept(
+            std::is_nothrow_move_constructible<T>::value &&
+            std::is_nothrow_assignable<T &, U>::value)
+    {
+        T tmp((T &&) t);
+        t = (U &&) u;
+        CPP_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME
+        return tmp;
+    }
+
+    /// \cond
+    namespace adl_swap_detail
+    {
+        struct nope
+        {};
+
+        // Intentionally create an ambiguity with std::swap, which is
+        // (possibly) unconstrained.
+        template<typename T>
+        nope swap(T &, T &) = delete;
+
+        template<typename T, std::size_t N>
+        nope swap(T (&)[N], T (&)[N]) = delete;
+
+#ifdef CPP_WORKAROUND_MSVC_895622
+        nope swap();
+#endif
+
+        template<typename T, typename U>
+        decltype(swap(std::declval<T>(), std::declval<U>())) try_adl_swap_(int);
+
+        template<typename T, typename U>
+        nope try_adl_swap_(long);
+
+        template<typename T, typename U = T>
+        CPP_INLINE_VAR constexpr bool is_adl_swappable_v =
+            !META_IS_SAME(decltype(adl_swap_detail::try_adl_swap_<T, U>(42)), nope);
+
+        struct swap_fn
+        {
+            // Dispatch to user-defined swap found via ADL:
+            template<typename T, typename U>
+            CPP_CXX14_CONSTEXPR
+            meta::if_c<is_adl_swappable_v<T, U>>
+            operator()(T &&t, U &&u) const
+            noexcept(noexcept(swap((T &&) t, (U &&) u)))
+            {
+                swap((T &&) t, (U &&) u);
+            }
+
+            // For intrinsically swappable (i.e., movable) types for which
+            // a swap overload cannot be found via ADL, swap by moving.
+            template<typename T>
+            CPP_CXX14_CONSTEXPR
+            meta::if_c<
+                !is_adl_swappable_v<T &> &&
+                detail::is_movable_v<T>>
+            operator()(T &a, T &b) const
+            noexcept(noexcept(b = concepts::exchange(a, (T &&) b)))
+            {
+                b = concepts::exchange(a, (T &&) b);
+            }
+
+            // For arrays of intrinsically swappable (i.e., movable) types
+            // for which a swap overload cannot be found via ADL, swap array
+            // elements by moving.
+            template<typename T, typename U, std::size_t N>
+            CPP_CXX14_CONSTEXPR
+            meta::if_c<
+                !is_adl_swappable_v<T (&)[N], U (&)[N]> &&
+                is_swappable_with<T &, U &>::value>
+            operator()(T (&t)[N], U (&u)[N]) const
+                noexcept(is_nothrow_swappable_with<T &, U &>::value)
+            {
+                for(std::size_t i = 0; i < N; ++i)
+                    (*this)(t[i], u[i]);
+            }
+
+            // For rvalue pairs and tuples of swappable types, swap the
+            // members. This permits code like:
+            //   ranges::swap(std::tie(a,b,c), std::tie(d,e,f));
+            template<typename F0, typename S0, typename F1, typename S1>
+            CPP_CXX14_CONSTEXPR
+            meta::if_c<is_swappable_with<F0, F1>::value && is_swappable_with<S0, S1>::value>
+            operator()(std::pair<F0, S0> &&left, std::pair<F1, S1> &&right) const
+                noexcept(
+                    is_nothrow_swappable_with<F0, F1>::value &&
+                    is_nothrow_swappable_with<S0, S1>::value)
+            {
+                swap_fn()(static_cast<std::pair<F0, S0> &&>(left).first,
+                            static_cast<std::pair<F1, S1> &&>(right).first);
+                swap_fn()(static_cast<std::pair<F0, S0> &&>(left).second,
+                            static_cast<std::pair<F1, S1> &&>(right).second);
+            }
+
+            template<typename ...Ts, typename ...Us>
+            CPP_CXX14_CONSTEXPR
+            meta::if_c<meta::and_c<is_swappable_with<Ts, Us>::value...>::value>
+            operator()(std::tuple<Ts...> &&left, std::tuple<Us...> &&right) const
+                noexcept(meta::and_c<is_nothrow_swappable_with<Ts, Us>::value...>::value)
+            {
+                swap_fn::impl(
+                    static_cast<std::tuple<Ts...> &&>(left),
+                    static_cast<std::tuple<Us...> &&>(right),
+                    meta::make_index_sequence<sizeof...(Ts)>{});
+            }
+
+        private:
+            template<typename... Ts>
+            static constexpr int ignore_unused(Ts &&...)
+            {
+                return 0;
+            }
+            template<typename T, typename U, std::size_t ...Is>
+            CPP_CXX14_CONSTEXPR
+            static void impl(T &&left, U &&right, meta::index_sequence<Is...>)
+            {
+                (void) swap_fn::ignore_unused(
+                    (swap_fn()(std::get<Is>(static_cast<T &&>(left)),
+                                std::get<Is>(static_cast<U &&>(right))), 42)...);
+            }
+        };
+
+        template<typename T, typename U, typename = void>
+        struct is_swappable_with_
+            : std::false_type
+        {};
+
+        template<typename T, typename U>
+        struct is_swappable_with_<T, U, meta::void_<
+            decltype(swap_fn()(std::declval<T>(), std::declval<U>())),
+            decltype(swap_fn()(std::declval<U>(), std::declval<T>()))>>
+            : std::true_type
+        {};
+
+        template<typename T, typename U>
+        struct is_nothrow_swappable_with_
+            : meta::bool_<noexcept(swap_fn()(std::declval<T>(), std::declval<U>())) &&
+                        noexcept(swap_fn()(std::declval<U>(), std::declval<T>()))>
+        {};
+
+        // Q: Should std::reference_wrapper be considered a proxy wrt swapping rvalues?
+        // A: No. Its operator= is currently defined to reseat the references, so
+        //    std::swap(ra, rb) already means something when ra and rb are (lvalue)
+        //    reference_wrappers. That reseats the reference wrappers but leaves the
+        //    referents unmodified. Treating rvalue reference_wrappers differently would
+        //    be confusing.
+
+        // Q: Then why is it OK to "re"-define swap for pairs and tuples of references?
+        // A: Because as defined above, swapping an rvalue tuple of references has the same
+        //    semantics as swapping an lvalue tuple of references. Rather than reseat the
+        //    references, assignment happens *through* the references.
+
+        // Q: But I have an iterator whose operator* returns an rvalue
+        //    std::reference_wrapper<T>. How do I make it model indirectly_swappable?
+        // A: With an overload of iter_swap.
+    }
+    /// \endcond
+
+    /// \ingroup group-utility
+    template<typename T, typename U>
+    struct is_swappable_with
+        : adl_swap_detail::is_swappable_with_<T, U>
+    {};
+
+    /// \ingroup group-utility
+    template<typename T, typename U>
+    struct is_nothrow_swappable_with
+        : meta::and_<
+            is_swappable_with<T, U>,
+            adl_swap_detail::is_nothrow_swappable_with_<T, U>>
+    {};
+
+    /// \ingroup group-utility
+    template<typename T>
+    struct is_swappable
+        : is_swappable_with<T &, T &>
+    {};
+
+    /// \ingroup group-utility
+    template<typename T>
+    struct is_nothrow_swappable
+        : is_nothrow_swappable_with<T &, T &>
+    {};
+
+    /// \ingroup group-utility
+    /// \relates adl_swap_detail::swap_fn
+    CPP_DEFINE_CPO(adl_swap_detail::swap_fn, swap)
+}
+
+#endif
diff --git a/inst/include/concepts/type_traits.hpp b/inst/include/concepts/type_traits.hpp
new file mode 100644
index 0000000..f8ee95c
--- /dev/null
+++ b/inst/include/concepts/type_traits.hpp
@@ -0,0 +1,379 @@
+/// \file
+// Concepts library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#ifndef CPP_TYPE_TRAITS_HPP
+#define CPP_TYPE_TRAITS_HPP
+
+#include <tuple>
+#include <utility>
+#include <type_traits>
+#include <meta/meta.hpp>
+
+namespace concepts
+{
+    template<typename T>
+    using remove_cvref_t =
+        typename std::remove_cv<
+            typename std::remove_reference<T>::type>::type;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename From, typename To>
+        using is_convertible = std::is_convertible<meta::_t<std::add_rvalue_reference<From>>, To>;
+
+        template<bool>
+        struct if_else_
+        {
+            template<typename, typename U>
+            using invoke = U;
+        };
+        template<>
+        struct if_else_<true>
+        {
+            template<typename T, typename>
+            using invoke = T;
+        };
+        template<bool B, typename T, typename U>
+        using if_else_t = meta::invoke<if_else_<B>, T, U>;
+
+        template<bool>
+        struct if_
+        {};
+        template<>
+        struct if_<true>
+        {
+            template<typename T>
+            using invoke = T;
+        };
+        template<bool B, typename T = void>
+        using if_t = meta::invoke<if_<B>, T>;
+
+        template<typename From, typename To>
+        struct _copy_cv_
+        {
+            using type = To;
+        };
+        template<typename From, typename To>
+        struct _copy_cv_<From const, To>
+        {
+            using type = To const;
+        };
+        template<typename From, typename To>
+        struct _copy_cv_<From volatile, To>
+        {
+            using type = To volatile;
+        };
+        template<typename From, typename To>
+        struct _copy_cv_<From const volatile, To>
+        {
+            using type = To const volatile;
+        };
+        template<typename From, typename To>
+        using _copy_cv = meta::_t<_copy_cv_<From, To>>;
+
+        ////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T, typename U, typename = void>
+        struct _builtin_common;
+
+        template<typename T, typename U>
+        using _builtin_common_t = meta::_t<_builtin_common<T, U>>;
+
+        template<typename T, typename U>
+        using _cond_res = decltype(true ? std::declval<T>() : std::declval<U>());
+
+        template<typename T, typename U, typename R = _builtin_common_t<T &, U &>>
+        using _rref_res =
+            if_else_t<std::is_reference<R>::value, meta::_t<std::remove_reference<R>> &&, R>;
+
+        template<typename T, typename U>
+        using _lref_res = _cond_res<_copy_cv<T, U> &, _copy_cv<U, T> &>;
+
+        template<typename T>
+        struct as_cref_
+        {
+            using type = T const &;
+        };
+        template<typename T>
+        struct as_cref_<T &>
+        {
+            using type = T const &;
+        };
+        template<typename T>
+        struct as_cref_<T &&>
+        {
+            using type = T const &;
+        };
+        template<>
+        struct as_cref_<void>
+        {
+            using type = void;
+        };
+        template<>
+        struct as_cref_<void const>
+        {
+            using type = void const;
+        };
+
+        template<typename T>
+        using as_cref_t = typename as_cref_<T>::type;
+
+        template<typename T>
+        using decay_t = typename std::decay<T>::type;
+
+    #if !defined(__GNUC__) || defined(__clang__)
+        template<typename T, typename U, typename = void>
+        struct _builtin_common_3
+        {};
+        template<typename T, typename U>
+        struct _builtin_common_3<T, U, meta::void_<_cond_res<as_cref_t<T>, as_cref_t<U>>>>
+            : std::decay<_cond_res<as_cref_t<T>, as_cref_t<U>>>
+        {};
+        template<typename T, typename U, typename = void>
+        struct _builtin_common_2
+            : _builtin_common_3<T, U>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common_2<T, U, meta::void_<_cond_res<T, U>>>
+            : std::decay<_cond_res<T, U>>
+        {};
+        template<typename T, typename U, typename /* = void */>
+        struct _builtin_common
+            : _builtin_common_2<T, U>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common<T &&, U &&, if_t<
+            is_convertible<T &&, _rref_res<T, U>>::value &&
+            is_convertible<U &&, _rref_res<T, U>>::value>>
+        {
+            using type = _rref_res<T, U>;
+        };
+        template<typename T, typename U>
+        struct _builtin_common<T &, U &>
+            : meta::defer<_lref_res, T, U>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common<T &, U &&, if_t<
+            is_convertible<U &&, _builtin_common_t<T &, U const &>>::value>>
+            : _builtin_common<T &, U const &>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common<T &&, U &>
+            : _builtin_common<U &, T &&>
+        {};
+    #else
+        template<typename T, typename U, typename = void>
+        struct _builtin_common_3
+        {};
+        template<typename T, typename U>
+        struct _builtin_common_3<T, U, meta::void_<_cond_res<as_cref_t<T>, as_cref_t<U>>>>
+            : std::decay<_cond_res<as_cref_t<T>, as_cref_t<U>>>
+        {};
+        template<typename T, typename U, typename = void>
+        struct _builtin_common_2
+            : _builtin_common_3<T, U>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common_2<T, U, meta::void_<_cond_res<T, U>>>
+            : std::decay<_cond_res<T, U>>
+        {};
+        template<typename T, typename U, typename /* = void */>
+        struct _builtin_common
+            : _builtin_common_2<T, U>
+        {};
+        template<typename T, typename U, typename = void>
+        struct _builtin_common_rr
+            : _builtin_common_2<T &&, U &&>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common_rr<T, U, if_t<
+            is_convertible<T &&, _rref_res<T, U>>::value &&
+            is_convertible<U &&, _rref_res<T, U>>::value>>
+        {
+            using type = _rref_res<T, U>;
+        };
+        template<typename T, typename U>
+        struct _builtin_common<T &&, U &&>
+            : _builtin_common_rr<T, U>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common<T &, U &>
+            : meta::defer<_lref_res, T, U>
+        {};
+        template<typename T, typename U, typename = void>
+        struct _builtin_common_lr
+            : _builtin_common_2<T &, T &&>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common_lr<T, U, if_t<
+            is_convertible<U &&, _builtin_common_t<T &, U const &>>::value>>
+            : _builtin_common<T &, U const &>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common<T &, U &&>
+            : _builtin_common_lr<T, U>
+        {};
+        template<typename T, typename U>
+        struct _builtin_common<T &&, U &>
+            : _builtin_common<U &, T &&>
+        {};
+    #endif
+    }
+    /// \endcond
+
+    /// \addtogroup group-utility Utility
+    /// @{
+    ///
+
+    /// Users should specialize this to hook the \c common_with concept
+    /// until \c std gets a SFINAE-friendly \c std::common_type and there's
+    /// some sane way to deal with cv and ref qualifiers.
+    template<typename ...Ts>
+    struct common_type
+    {};
+
+    template<typename T>
+    struct common_type<T>
+        : std::decay<T>
+    {};
+
+    template<typename T, typename U>
+    struct common_type<T, U>
+        : detail::if_else_t<
+            (META_IS_SAME(detail::decay_t<T>, T) &&
+                META_IS_SAME(detail::decay_t<U>, U) ),
+            meta::defer<detail::_builtin_common_t, T, U>,
+            common_type<detail::decay_t<T>, detail::decay_t<U>>>
+    {};
+
+    template<typename... Ts>
+    using common_type_t = typename common_type<Ts...>::type;
+
+    template<typename T, typename U, typename... Vs>
+    struct common_type<T, U, Vs...>
+        : meta::lazy::fold<meta::list<U, Vs...>, T, meta::quote<common_type_t>>
+    {};
+
+    /// @}
+
+    /// \addtogroup group-utility Utility
+    /// @{
+    ///
+
+    /// Users can specialize this to hook the \c common_reference_with concept.
+    /// \sa `common_reference`
+    template<
+        typename T,
+        typename U,
+        template<typename> class TQual,
+        template<typename> class UQual>
+    struct basic_common_reference
+    {};
+
+    /// \cond
+    namespace detail
+    {
+        using _rref =
+            meta::quote_trait<std::add_rvalue_reference>;
+        using _lref =
+            meta::quote_trait<std::add_lvalue_reference>;
+
+        template<typename>
+        struct _xref
+        {
+            template<typename T>
+            using invoke = T;
+        };
+        template<typename T>
+        struct _xref<T &&>
+        {
+            template<typename U>
+            using invoke =
+                meta::_t<std::add_rvalue_reference<meta::invoke<_xref<T>, U>>>;
+        };
+        template<typename T>
+        struct _xref<T &>
+        {
+            template<typename U>
+            using invoke =
+                meta::_t<std::add_lvalue_reference<meta::invoke<_xref<T>, U>>>;
+        };
+        template<typename T>
+        struct _xref<T const>
+        {
+            template<typename U>
+            using invoke = U const;
+        };
+        template<typename T>
+        struct _xref<T volatile>
+        {
+            template<typename U>
+            using invoke = U volatile;
+        };
+        template<typename T>
+        struct _xref<T const volatile>
+        {
+            template<typename U>
+            using invoke = U const volatile;
+        };
+
+        template<typename T, typename U>
+        using _basic_common_reference =
+            basic_common_reference<
+                remove_cvref_t<T>,
+                remove_cvref_t<U>,
+                _xref<T>::template invoke,
+                _xref<U>::template invoke>;
+
+        template<typename T, typename U, typename = void>
+        struct _common_reference2
+            : if_else_t<
+                meta::is_trait<_basic_common_reference<T, U>>::value,
+                _basic_common_reference<T, U>,
+                common_type<T, U>>
+        {};
+
+        template<typename T, typename U>
+        struct _common_reference2<T, U, if_t<std::is_reference<_builtin_common_t<T, U>>::value>>
+            : _builtin_common<T, U>
+        {};
+    }
+    /// \endcond
+
+    /// Users can specialize this to hook the \c common_reference_with concept.
+    /// \sa `basic_common_reference`
+    template<typename ...Ts>
+    struct common_reference
+    {};
+
+    template<typename T>
+    struct common_reference<T>
+    {
+        using type = T;
+    };
+
+    template<typename T, typename U>
+    struct common_reference<T, U>
+        : detail::_common_reference2<T, U>
+    {};
+
+    template<typename... Ts>
+    using common_reference_t = typename common_reference<Ts...>::type;
+
+    template<typename T, typename U, typename... Vs>
+    struct common_reference<T, U, Vs...>
+        : meta::lazy::fold<meta::list<U, Vs...>, T, meta::quote<common_reference_t>>
+    {};
+    /// @}
+} // namespace concepts
+
+#endif
diff --git a/inst/include/eigenh5/MatSlices.hpp b/inst/include/eigenh5/MatSlices.hpp
index e7fef72..4acc96a 100644
--- a/inst/include/eigenh5/MatSlices.hpp
+++ b/inst/include/eigenh5/MatSlices.hpp
@@ -7,7 +7,7 @@
 #include <memory>
 
 
-
+#define EIGEN_RUNTIME_NO_MALLOC
 
 // template<typename T>
 // class DataHandle{
@@ -26,6 +26,8 @@ class DataQueue{
 public:
   std::vector< DatasetSelection<Dims> >	selections;
 private:
+
+  // Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> data_buffer;
   FileManager<isReadOnly> &f_map;
   std::unordered_map<std::string,std::shared_ptr<HighFive::DataSet> > dataset_map;
   std::vector<std::string> file_selections;
@@ -47,6 +49,7 @@ class DataQueue{
 								f_map(f_map_){
     selections.reserve(num_selections);
     file_selections.reserve(num_selections);
+    // size_t max_dims=0;
     for(int i=0; i<num_selections;i++){
       auto fn =	get_list_scalar<std::string>(options(i),"filename");
       auto dn =	get_list_scalar<std::string>(options(i),"datapath");
@@ -55,11 +58,17 @@ class DataQueue{
       }
       auto td = get_dataset(*fn,*dn);
       std::vector<size_t> tdims	= td->getDataDimensions();
-      std::array<size_t,Dims> a_dims;
-      std::copy_n(tdims.begin(),Dims,a_dims.begin());
-      selections.push_back(DatasetSelection<Dims>::ProcessList(options(i),a_dims));
-      file_selections.push_back(*fn+*dn);
+      std::array<size_t, Dims> a_dims;
+      std::copy_n(tdims.begin(), Dims, a_dims.begin());
+       selections.push_back(
+          DatasetSelection<Dims>::ProcessList(options(i), a_dims));
+      // size_t tsize_dim = std::accumulate(dsl.dataset_dimensions.begin(),dsl.dataset_dimensions.end(),1,std::multiplies<size_t>());
+      // if (tsize_dim > max_dims) {
+      //   max_dims = tsize_dim;
+      // }
+      file_selections.push_back(*fn + *dn);
     }
+    // data_buffer.resize(max_dims);
   }
   std::vector<std::array<size_t,Dims> > get_selection_dims() const{
     std::vector<std::array<size_t,Dims> > retvec(num_selections);
@@ -91,12 +100,32 @@ class DataQueue{
     auto n_elem = file_sel.getDataDimensions();
     const size_t elem_total= std::accumulate(n_elem.begin(),n_elem.end(),1,std::multiplies<size_t>());
     datamat.resize(n_elem[0],n_elem[1]);
+  
     Eigen::Map<Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,Options> > retd(datamat.data(),n_elem[0],n_elem[1]);
     data_sel.readEigen(file_sel,retd);
     if(doTranspose){
       datamat.transposeInPlace();
     }
   }
+  // template<int Options = Eigen::ColMajor>
+  // Eigen::Map<Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> >readMat(const size_t i,bool doTranspose=false){
+  // 
+  //   auto data_r = get_index(i);
+  //   auto &dataset = data_r.first;
+  //   auto &data_sel = data_r.second;
+  // 
+  //   auto file_sel = data_sel.makeSelection(*dataset);
+  //   auto n_elem = file_sel.getDataDimensions();
+  //   const size_t elem_total= std::accumulate(n_elem.begin(),n_elem.end(),1,std::multiplies<size_t>());
+  // 
+  //   Eigen::Map<Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,Options> > retd(data_buffer.data(),n_elem[0],n_elem[1]);
+  //   data_sel.readEigen(file_sel,retd);
+  //   if (doTranspose) {
+  //     retd.transposeInPlace();
+  //   }
+  //   return (retd);
+  // }
+
   void readVector(const size_t i,Eigen::Matrix<T,Eigen::Dynamic,1> &datamat){
 
     auto data_r = get_index(i);
@@ -110,7 +139,23 @@ class DataQueue{
     Eigen::Map<Eigen::Matrix<T,Eigen::Dynamic,1> > retd(datamat.data(),n_elem[0]);
     data_sel.readEigen(file_sel,retd);
   }
-  
+
+  // Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1>>  readVector(const size_t i) {
+  // 
+  //   auto data_r = get_index(i);
+  //   auto &dataset = data_r.first;
+  //   auto &data_sel = data_r.second;
+  // 
+  //   auto file_sel = data_sel.makeSelection(*dataset);
+  //   auto n_elem = file_sel.getDataDimensions();
+  //   const size_t elem_total = std::accumulate(n_elem.begin(), n_elem.end(), 1,
+  //                                             std::multiplies<size_t>());
+  //   Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1>> retd(data_buffer.data(),
+  //                                                        n_elem[0]);
+  //   data_sel.readEigen(file_sel, retd);
+  //   return (retd);
+  // }
+
   template<int Options = Eigen::ColMajor>
   void writeMat(const size_t i,Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,Options>  &retmat){
     static_assert(isReadOnly ==false,"cannot write to a readOnly DataQueue!");
diff --git a/inst/include/eigenh5/Selection.hpp b/inst/include/eigenh5/Selection.hpp
index 2161385..99d1c53 100644
--- a/inst/include/eigenh5/Selection.hpp
+++ b/inst/include/eigenh5/Selection.hpp
@@ -135,7 +135,10 @@ struct dim_sel{
 };
 
 inline std::vector<dim_sel> dim_sel::parse_chunk_list(const Rcpp::List &list,std::vector<size_t> datadims){
-    using int_o = boost::optional<int>;
+    using int_o = std::optional<int>;
+
+
+
 
   const size_t num_dims= datadims.size();
   if(num_dims>2){
@@ -160,7 +163,7 @@ inline std::vector<dim_sel> dim_sel::parse_chunk_list(const Rcpp::List &list,std
 
 
 
-
+//template<typename T
 
 
 
@@ -192,7 +195,7 @@ class DimRange{
     isRepeated_(false){}
 
   static DimRange construct_dimrange(dim_sel chunk,
-				   boost::optional<Rcpp::IntegerVector> subset);
+				   std::optional<Rcpp::IntegerVector> subset);
   Eigen::ArrayXi permutation_order() const;
 
 
@@ -218,8 +221,6 @@ class DimRange{
   bool isCompact_;
   bool all_sorted;
   bool isRepeated_;
-  //  static std::vector<dim_sel> find_cont(Rcpp::IntegerVector::const_iterator itb,Rcpp::IntegerVector::const_iterator ite);
-
 };
 
 
@@ -253,7 +254,7 @@ inline Eigen::ArrayXi DimRange::permutation_order() const {
 
 
 inline DimRange DimRange::construct_dimrange(dim_sel chunk,
-			    boost::optional<Rcpp::IntegerVector> subset){
+			    std::optional<Rcpp::IntegerVector> subset){
   if(subset){
     return(DimRange(subset->begin(),subset->end()));
   }
@@ -459,7 +460,6 @@ inline DatasetSelection<Dims> DatasetSelection<Dims>::ProcessList(const Rcpp::Li
 
 inline DimRange::DimRange(Rcpp::IntegerVector::const_iterator itb,Rcpp::IntegerVector::const_iterator ite){
   using namespace Rcpp;
-  // using namespace ranges;
   using namespace boost;
   using namespace boost::icl;
 
@@ -501,15 +501,16 @@ inline DimRange::DimRange(Rcpp::IntegerVector::const_iterator itb,Rcpp::IntegerV
 	}
       }
       if(ins){
-	if((t_it-itbb)!=abs((*t_it-*itbb))){
-	  Rcpp::stop("dim_sel is not compact!");
-	}
-	dim_sel tds((*itbb)-1,*(t_it)-1,tot_dist,tot_dist+(t_it-itbb));
-	in_sels.insert(construct<discrete_interval<int> >(tds.in_start,tds.in_stop,interval_bounds::closed()));
-	dim_sels.push_back(tds);
-	tot_dist=tot_dist+tds.chunksize;
-	itbb=nit;
-	t_it=nit;
+        if ((t_it - itbb) != abs((*t_it - *itbb))) {
+          Rcpp::stop("dim_sel is not compact!");
+        }
+        dim_sel tds((*itbb) - 1, *(t_it)-1, tot_dist, tot_dist + (t_it - itbb));
+        in_sels.insert(construct<discrete_interval<int>>(
+            tds.in_start, tds.in_stop, interval_bounds::closed()));
+        dim_sels.push_back(tds);
+        tot_dist = tot_dist + tds.chunksize;
+        itbb = nit;
+        t_it = nit;
       }
     }
   }
@@ -527,45 +528,12 @@ inline DimRange::DimRange(Rcpp::IntegerVector::const_iterator itb,Rcpp::IntegerV
     Rcpp::Rcerr<<"size of space for it is :"<<out_size<<std::endl;
     Rcpp::stop("out size must be greater than equal to in_size");
   }
-  if(!all_sorted){
-    std::sort(dim_sels.begin(),dim_sels.end());
+  if (!all_sorted) {
+    std::sort(dim_sels.begin(), dim_sels.end());
   }
 }
 
 
-
-  // while(it!=ite){
-  //   it = std::adjacent_find(itb,ite,[](int i,int j){
-  //     // Rcpp::Rcout<<"i is : "<<i<<std::endl;
-  //     // Rcpp::Rcout<<"j is : "<<j<<std::endl;
-  //     return(std::abs(j-i)!=1);
-  //   });
-  //   int iti = (it==ite ? *(it-1) : *(it))-1;
-  //   //    int itb_pos = itb-itbb;
-  //   int reg_size = it==ite ? it-itb : (it-itb+1);
-  //   dim_sel tds
-  //   dim_se.push_back(dim_sel((*itb)-1,iti,tot_dist,tot_dist+reg_size-1));
-  //   //			 piarray{{{*itb,iti}},{{tot_dist,tot_dist+reg_size-1}}});
-  //   if(it!=ite){
-  //     it++;
-  //   }
-  //   tot_dist=tot_dist+reg_size;
-  //   itb=it;
-  // }
-
-  // for(auto &te : ds){
-  //   in_sels.insert(
-  //   tout_size+=te.out_stop-te.out_start+1;
-  // }
-
-
-
-
-
-
-
-
-
 template<size_t Dims>
 inline HighFive::Selection DatasetSelection<Dims>::makeSelection(const HighFive::DataSet &dset) const{
   if(offsets_in.empty()){
diff --git a/inst/include/eigenh5/indexers.hpp b/inst/include/eigenh5/indexers.hpp
new file mode 100644
index 0000000..a1d61aa
--- /dev/null
+++ b/inst/include/eigenh5/indexers.hpp
@@ -0,0 +1,623 @@
+#include <array>
+#include <Rcpp.h>
+#include <Rinternals.h>
+// [[Rcpp::interfaces(r, cpp)]]
+//[[Rcpp::plugins(cpp17)]]
+//#include <boost/variant/multivisitors.hpp>
+#include "highfive/H5DataSet.hpp"
+#include "xtensor-r/rarray.hpp"
+#include "xtensor-r/rtensor.hpp"
+#include "xtensor-r/rvectorize.hpp"
+#include "xtensor-r/rcontainer.hpp"
+#include <cstddef>
+#include <iterator>
+#include <xtensor/xarray.hpp>
+#include <xtensor/xdynamic_view.hpp>
+#include <xtensor/xview.hpp>
+#include <range/v3/all.hpp>
+#include <optional>
+
+class Interval{
+  size_t offset;
+  size_t size;
+public:
+  Interval(int offset_,int size_):offset(offset_),size(size_){}
+  const size_t get_offset() const{return offset;}
+  const size_t get_size() const{return size;}
+};
+
+
+class SubInterval{
+  size_t offset;
+  size_t size;
+public:
+  constexpr SubInterval(size_t offset_,int chunksize_):
+    offset(offset_),
+    size(std::max(chunksize_,0)){
+    if(chunksize_<0){
+      Rcpp::Rcerr<<offset<<"-"<<chunksize_<<std::endl;
+      Rcpp::stop("Cannot specify negative offset in SubInterval constructor without specifying total_size_");
+    }
+  }
+  constexpr SubInterval(std::pair<int,int> offset_chunksize):
+    offset(offset_chunksize.first),
+    size(std::max(offset_chunksize.second,0)){
+    if(offset_chunksize.second<0){
+      Rcpp::Rcerr<<offset<<"-"<<offset_chunksize.second<<std::endl;
+      Rcpp::stop("Cannot specify negative offset in SubInterval constructor without specifying total_size_");
+    }
+  }
+
+  constexpr SubInterval(std::pair<int,std::optional<int> > offset_chunksize,size_t total_size_):
+    offset(offset_chunksize.first),
+    size(size=offset_chunksize.second.value_or(total_size_-offset))
+  {
+    if(offset_chunksize.second.has_value()  && offset_chunksize.second<0){
+      Rcpp::stop("negative chunksize has been deprecated in SubInterval");
+    }
+    if(offset+size > total_size_){
+      Rcpp::Rcerr<<"offset_chunksize is: "<<offset_chunksize.first<<","<<*offset_chunksize.second<<std::endl;
+      Rcpp::Rcerr<<"total_size_ is: "<<total_size_<<std::endl;
+      Rcpp::Rcerr<<"SubInterval is: "<<offset<<"-"<<offset+size<<std::endl;
+      Rcpp::Rcerr<<"Interval is: (0)-"<<total_size_<<std::endl;
+      Rcpp::stop("SubInterval is out of bounds");
+    }
+  }
+  constexpr SubInterval(int offset_,int chunksize_,size_t total_size_):
+    offset(offset_),
+    size(chunksize_){
+    if(chunksize_<0){
+      Rcpp::stop("negative chunksize has been deprecated in SubInterval");
+    }
+    if(offset+size >= total_size_){
+      Rcpp::Rcerr<<"SubInterval is: "<<offset<<"-"<<offset+size<<std::endl;
+      Rcpp::Rcerr<<"Interval is: (0)-"<<total_size_<<std::endl;
+      Rcpp::stop("SubInterval is out of bounds");
+    }
+
+  }
+  constexpr SubInterval chunk_selection(const SubInterval selection,const size_t chunksize) const noexcept {
+    const auto chunk_sel_start = selection.offset-selection.offset%chunksize;
+    const auto new_sel_size = std::min(SubInterval(chunk_sel_start,selection.size+(selection.offset-chunk_sel_start)).num_chunks(chunksize)*chunksize,size-chunk_sel_start);
+    return SubInterval(chunk_sel_start,new_sel_size);
+  }
+  constexpr SubInterval chunk_i(const size_t i, const size_t chunksize) const noexcept{
+    return(SubInterval(i*chunksize,std::min(size-(i*chunksize),chunksize)));
+  }
+  constexpr bool operator==(const SubInterval &y) const noexcept {
+    return(y.size==size && y.offset==offset);
+  }
+  constexpr bool operator!=(const SubInterval &y) const noexcept {
+    return(y.size!=size or y.offset !=offset);
+  }
+
+
+  // x.sub_chunk(y) returns the SubInterval of x that corresponds to it's overlap with y
+  constexpr SubInterval sub_chunk(const SubInterval &y) const noexcept{
+
+    // const auto sub_offset = y.offset;
+    // const auto chunk_offset = size;
+
+    const auto y_end = y.offset+y.size-1;
+    const auto end = offset+size-1;
+    if(y.offset<offset){
+      return SubInterval(0,y_end>=end ? size : y_end-offset+1);
+    }
+    if(y_end>end){
+      return SubInterval(y.offset-offset,end-(y.offset-offset)+1);
+    }
+    return SubInterval(y.offset-offset, y.size);
+  }
+
+  constexpr size_t get_offset() const noexcept{
+    return offset;
+  }
+  constexpr size_t get_size() const noexcept{
+    return size;
+  }
+  constexpr size_t get_back() const noexcept{
+    return offset+size-1;
+  }
+  constexpr size_t num_chunks(const size_t chunksize)const noexcept{
+    return 1 + ((size - 1) / chunksize);
+  }
+  friend class chunk_chunker;
+
+
+  // static std::vector<SubInterval> make_chunked_selection( const SubInterval parent, const SubInterval selection,const size_t chunksize){
+
+
+
+
+
+  //   //    const size_t
+
+
+  // }
+
+};
+
+
+
+
+class rep_chunk_indexer{
+  std::array<size_t,2> offset_size; //Logical offset/size of chunk on disk
+  std::vector<int> chunk_indexes; //indexes within chunk
+  std::vector<int> out_indexes; //indexes in source/dest memory
+  using	i_it= std::vector<int>::const_iterator;
+public:
+  rep_chunk_indexer(const std::array<size_t,2> offset_size_):
+    offset_size(offset_size_),
+    chunk_indexes([](const size_t res_num){
+		    std::vector<int> retv;
+		    retv.reserve(res_num);
+		    return(retv);
+		  }(offset_size[1])),
+    out_indexes([](const size_t res_num){
+		  std::vector<int> retv;
+		  retv.reserve(res_num);
+		  return(retv);
+		}(offset_size[1])){
+  }
+  int push_back(const int index,const int i) noexcept
+  {
+    chunk_indexes.push_back(index-offset_size[0]);
+    out_indexes.push_back(i);
+    return out_indexes.size();
+  }
+  size_t disk_offset()const noexcept{
+    return offset_size[0];
+  }
+  size_t disk_size()const noexcept{
+    return offset_size[1];
+  }
+  size_t chunk_size()const noexcept{
+    return chunk_indexes.size();
+  }
+  auto chunk_slice() const{
+    return xt::keep(chunk_indexes);
+  }
+
+  auto mem_slice() const{
+    return xt::keep(out_indexes);
+  }
+
+  int chunk_i(size_t i)const noexcept{
+    return chunk_indexes[i];
+  }
+  int mem_i(size_t i)const noexcept{
+    return out_indexes[i];
+  }
+};
+
+
+
+
+class IndexParser{
+public:
+private:
+  int p;
+  int dimsize;
+  int chunksize;
+  int num_chunks;
+  std::vector<rep_chunk_indexer> needed_chunks;
+  std::vector<std::unique_ptr<rep_chunk_indexer>> tneeded_chunks;
+
+  using	chunk_it =std::vector<rep_chunk_indexer>::const_iterator;
+  int chunks_used;
+  bool is_unsorted;
+  using Iv=Rcpp::IntegerVector;
+  //  const
+  size_t max_chunksize;
+
+public:
+  using chunk_type=rep_chunk_indexer;
+  IndexParser(const size_t dimsize_,const size_t chunksize_,const Iv input,bool whole_only=false): p(input.size()),
+												   dimsize(dimsize_),
+												   chunksize(chunksize_),
+												   num_chunks(ceilf(static_cast<float>(dimsize)/static_cast<float>(chunksize))),
+												   tneeded_chunks(num_chunks),
+												   chunks_used(0),
+												   is_unsorted(false),
+												   max_chunksize(0)
+  {
+
+    if(whole_only){
+      Rcpp::stop("IndexParser not available when whole_only set to true");
+    }
+
+    // super easy to calculate which chunks we need
+    int i=0;
+    int oi=-1;
+    int ix=0;
+    for(auto inp: input){
+      i=inp-1;
+      if(i<=oi){
+	is_unsorted=true;
+      }
+
+      int chunk_no = i/chunksize;
+      if(chunk_no>=tneeded_chunks.size()){
+	//	  Rcpp::Rcerr<<"in index_dimension"<<index_dimension_<<std::endl;
+	Rcpp::Rcerr<<"indexing beyond the end of the dataset! ("<<inp<<">="<<dimsize<<")"<<std::endl;
+	Rcpp::stop("indexing error!");
+      }
+      auto &it_el = tneeded_chunks[chunk_no];
+      if(it_el==nullptr){
+
+	it_el=std::unique_ptr<rep_chunk_indexer>(
+              new rep_chunk_indexer({static_cast<size_t>(chunk_no * chunksize),
+				     static_cast<size_t>(chunksize)}));
+	chunks_used++;
+		 // shared_ptr<Employee> TempEmp(new Employee());
+      }
+      int tc = it_el->push_back(i,ix);
+      if(tc>max_chunksize){
+	max_chunksize=tc;
+      }
+      oi=i;
+      ix++;
+    }
+
+
+    tneeded_chunks.erase(std::remove_if(tneeded_chunks.begin(),tneeded_chunks.end(),[](const auto&  data_el){
+										      return(data_el==nullptr);
+										 }),tneeded_chunks.end());
+    if(tneeded_chunks.size()!=chunks_used){
+      Rcpp::Rcerr<<"counted chunks is: "<<chunks_used<<", but there are: "<<needed_chunks.size()<<" chunk indexers!"<<std::endl;
+      Rcpp::stop("the last chunk is bad!");
+    }
+    needed_chunks.reserve(chunks_used);
+    for(auto &a:tneeded_chunks){
+      needed_chunks.emplace_back(std::move(*a));
+    }
+  }
+
+  chunk_it begin() const noexcept{
+    return(needed_chunks.cbegin());
+  }
+  chunk_it end() const noexcept{
+    return(needed_chunks.cend());
+  }
+
+  int total_size()const noexcept{
+    return p;
+  }
+  int total_chunksize() const noexcept{ return chunksize; }
+
+  size_t max_read_chunksize() const noexcept{
+    return max_chunksize;
+  }
+
+  size_t n_chunks() const noexcept{
+    return chunks_used;
+  }
+  bool sorted() const noexcept{
+    return !is_unsorted;
+  }
+  auto n_c() const{
+    return ranges::view::all(needed_chunks);
+  }
+  IndexParser ( IndexParser && ) = default;
+  IndexParser &  operator= ( IndexParser && ) = default;
+  IndexParser ( const IndexParser & ) = delete;
+  IndexParser & operator= ( const IndexParser & ) = delete;
+};
+
+
+
+class chunk_chunker{
+  SubInterval global_interval;
+  SubInterval relative_interval;
+  //offset in source/dest memory
+  //  const std::array<size_t,2> sub_offset_size; // offset/size within chunk
+  size_t  dest_d_offset;
+public:
+  chunk_chunker(const SubInterval interval_,
+                const SubInterval &chunk_,
+		const size_t dest_offset_)
+    : global_interval(interval_),
+      relative_interval(global_interval.sub_chunk(chunk_)),
+      dest_d_offset(dest_offset_){
+  }
+
+  size_t chunk_size() const noexcept{
+    return(relative_interval.size);
+  }
+  size_t chunk_offset() const noexcept{
+    return(relative_interval.offset);
+  }
+  auto chunk_slice() const{
+    return(xt::range(chunk_offset(),chunk_offset()+chunk_size()));
+  }
+  auto mem_slice() const{
+    return(xt::range(dest_offset(),dest_offset()+dest_size()));
+  }
+
+  size_t disk_offset() const noexcept{
+    return global_interval.offset;
+  }
+
+  size_t disk_size() const noexcept{
+    return global_interval.size;
+  }
+
+  size_t dest_offset() const noexcept{
+    return dest_d_offset;
+  }
+
+  size_t dest_size() const noexcept{
+    return chunk_size();
+  }
+
+  int chunk_i(size_t i)const noexcept{
+    return relative_interval.offset+i;
+  }
+
+  int mem_i(size_t i)const noexcept{
+    return dest_d_offset+i;
+  }
+};
+
+
+
+class ChunkParser{
+private:
+  int dimsize;
+  SubInterval selection;
+  int chunksize;
+  int p;
+  int chunks_used;
+
+  std::vector<chunk_chunker> needed_chunks;
+public:
+  using	chunk_it =std::vector<chunk_chunker>::const_iterator;
+  using	chunk_type=chunk_chunker;
+  ChunkParser(const size_t  dimsize_,const size_t chunksize_,const std::pair<int,std::optional<int>> selection_p,const bool whole_only=false):
+    dimsize(dimsize_),
+    selection(selection_p,dimsize),
+    chunksize(chunksize_),
+    p(selection.get_size())
+  {
+    const auto chunk_selection = SubInterval(0,dimsize).chunk_selection(selection,chunksize);
+    if(whole_only){
+      if(chunk_selection.get_offset()!=selection.get_offset()){
+        Rcpp::stop("chunk offset must be on a chunk boundary when whole_only set to true");
+      }
+      if(selection.get_size()%chunksize!=0){
+	Rcpp::stop("size of selection must be a multiple of chunksize when whole_only set to true");
+      }
+    }
+
+    chunks_used = chunk_selection.num_chunks(chunksize);
+    needed_chunks.reserve(chunks_used);
+    int	out_o=0;
+    for(int i=0; i<chunks_used; i++){
+      auto &new_chunker = needed_chunks.emplace_back(chunk_selection.chunk_i(i,chunksize),
+                                                    selection,
+                                                    out_o);
+      out_o+=new_chunker.chunk_size();
+    }
+
+    if(needed_chunks.size()!=chunks_used){
+      // back_chunk.
+      Rcpp::Rcerr<<"needed_chunks.size() is: "<<needed_chunks.size()<<" while chunks_used is :"<<chunks_used<<std::endl;
+      Rcpp::Rcerr<<"needed_chunks is of size: "<<needed_chunks.size();
+      Rcpp::stop("something has gone wrong with the chunk iteration");
+    }
+  }
+  //  std::vector<
+
+  chunk_it begin() const{
+    return(needed_chunks.cbegin());
+  }
+  chunk_it end() const{
+    return(needed_chunks.cend());
+  }
+  constexpr bool sorted() const{
+    return true;
+  }
+  size_t total_size() const{
+    return p;
+  }
+  size_t total_chunksize()const{
+    return chunksize;
+  }
+  size_t n_chunks()const{
+    return chunks_used;
+  }
+  size_t max_read_chunksize() const{
+    return chunksize;
+  }
+  auto n_c() const{
+    return(ranges::view::all(needed_chunks));
+  }
+};
+
+
+template<typename T>
+struct t2chunk_t;
+
+template<> struct t2chunk_t<std::pair<int,std::optional<int>> >{
+  typedef ChunkParser c_type;
+};
+
+
+template<> struct t2chunk_t<Rcpp::IntegerVector >{
+  typedef IndexParser c_type;
+};
+
+
+template<typename D>
+struct xtm_t;
+
+template<>
+struct xtm_t<int>{
+  typedef	xt::rtensor<int,1> retvec_type;
+  typedef	xt::rtensor<int,2> retmat_type;
+  typedef	xt::rtensor<int,3> reta_type;
+  typedef	xt::xtensor<int,1,xt::layout_type::row_major> buffvec_type;
+  typedef	xt::xtensor<int,2,xt::layout_type::row_major> buffmat_type;
+  typedef	xt::xtensor<int,3,xt::layout_type::row_major> buffa_type;
+  typedef       Rcpp::IntegerVector rrvec_type;
+  typedef       Rcpp::IntegerMatrix rrmat_type;
+};
+
+template<>
+struct xtm_t<double>{
+  typedef	xt::rtensor<double,1> retvec_type;
+  typedef	xt::rtensor<double,2> retmat_type;
+  typedef	xt::rtensor<double,3> reta_type;
+  typedef	xt::xtensor<double,1,xt::layout_type::row_major> buffvec_type;
+  typedef	xt::xtensor<double,2,xt::layout_type::row_major> buffmat_type;
+  typedef	xt::xtensor<double,3,xt::layout_type::row_major> buffa_type;
+  typedef       Rcpp::NumericVector rrvec_type;
+  typedef       Rcpp::NumericMatrix rrmat_type;
+};
+
+
+template<>
+struct xtm_t<std::string>{
+  typedef	Rcpp::StringVector retvec_type;
+  typedef	Rcpp::StringMatrix retmat_type;
+  typedef	std::false_type reta_type;
+  typedef	xt::xtensor<char,2,xt::layout_type::row_major> buffvec_type;
+  typedef       xt::xtensor<char,3,xt::layout_type::row_major> buffmat_type;
+
+  typedef	std::false_type buffa_type;
+  typedef       Rcpp::StringVector rrvec_type;
+  typedef       Rcpp::StringMatrix rrmat_type;
+};
+
+
+
+template<>
+struct xtm_t<unsigned char>{
+  typedef	xt::rtensor<unsigned char,1> retvec_type;
+  typedef	xt::rtensor<unsigned char,2> retmat_type;
+  typedef	xt::rtensor<unsigned char,3> reta_type;
+  typedef	xt::xtensor<unsigned char,1,xt::layout_type::row_major> buffvec_type;
+  typedef	xt::xtensor<unsigned char,2,xt::layout_type::row_major> buffmat_type;
+  typedef	xt::xtensor<unsigned char,3,xt::layout_type::row_major> buffa_type;
+  typedef       Rcpp::RawVector rrvec_type;
+  typedef       Rcpp::RawMatrix rrmat_type;
+};
+
+
+
+
+
+template<typename D>
+class DataSet_Context{
+
+public:
+  const HighFive::DataSet& d;
+private:
+
+  using tensor_type=typename xtm_t<D>::buffmat_type;
+  const size_t elem_size;
+  const std::vector<size_t> dataset_chunksizes;
+  std::vector<std::byte> raw_chunk_buffer;
+public:
+  DataSet_Context(const HighFive::DataSet& d_):d(d_),elem_size(d.getDataType().n_elem()),dataset_chunksizes(d.getFilter().get_chunksizes()){
+    auto raw_size=std::accumulate(dataset_chunksizes.begin(),dataset_chunksizes.end(),sizeof(typename tensor_type::value_type)*elem_size,std::multiplies<size_t>());
+    raw_chunk_buffer.resize(raw_size);
+  }
+
+  template<class TA,class LC>
+  void write_dataset(const TA& tchunk_r, LC& lambda){
+    auto res = lambda(tchunk_r,raw_chunk_buffer.data(),raw_chunk_buffer.size(),elem_size);
+    d.write_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset()},res);
+  }
+
+  template<class TA, class TB,class LC>
+  void write_dataset(const TA& tchunk_r, const TB& tchunk_c, LC& lambda){
+    auto res = lambda(tchunk_r,tchunk_c,raw_chunk_buffer.data(),raw_chunk_buffer.size(),elem_size);
+    d.write_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset(),tchunk_c.disk_offset()},res);
+  }
+
+  template<class TA, class TB,class TC,class LC>
+  void write_dataset(const TA& tchunk_r, const TB& tchunk_c,const TC& tchunk_a,  LC& lambda){
+    auto res = lambda(tchunk_r,tchunk_c,tchunk_a,raw_chunk_buffer.data(),raw_chunk_buffer.size(),elem_size);
+    d.write_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset(),tchunk_c.disk_offset(),tchunk_a.disk_offset()},res);
+  }
+
+
+  template<class TA,class LC>
+  void read_dataset(const TA& tchunk_r, LC& lambda){
+    auto res = d.read_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset()});
+    lambda(tchunk_r,raw_chunk_buffer.data(),res,elem_size);
+  }
+
+  template<class TA, class TB,class LC>
+  void read_dataset(const TA& tchunk_r, const TB& tchunk_c, LC& lambda){
+    auto res = d.read_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset(),tchunk_c.disk_offset()});
+    lambda(tchunk_r,tchunk_c,raw_chunk_buffer.data(),res,elem_size);
+
+  }
+
+  template<class TA, class TB,class TC,class LC>
+  void read_dataset(const TA& tchunk_r, const TB& tchunk_c,const TC& tchunk_a, LC& lambda){
+    auto res = d.read_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset(),tchunk_c.disk_offset(),tchunk_a.disk_offset()});
+    lambda(tchunk_r,tchunk_c,tchunk_a,raw_chunk_buffer.data(),res,elem_size);
+  }
+
+
+  template<class RngA,class LC>
+  void iter_dataset_read(const RngA& RowChunksBegin,const RngA& RowChunksEnd,LC& lambda){
+    for(auto &tchunk_r = RowChunksBegin; tchunk_r!=RowChunksEnd; ++tchunk_r){
+      read_dataset(tchunk_r,lambda);
+    }
+  }
+
+  template<class RngA, class RngB,class LC>
+    void iter_dataset_read(const RngA& RowChunksBegin,const RngA& RowChunksEnd, const RngB& ColChunksBegin,const RngB& ColChunksEnd,LC& lambda){
+    for(auto &tchunk_r = RowChunksBegin; tchunk_r!=RowChunksEnd; ++tchunk_r){
+      for(auto &tchunk_c = ColChunksBegin; tchunk_c!=ColChunksEnd; ++tchunk_c){
+	read_dataset(tchunk_r,tchunk_c,lambda);
+      }
+    }
+  }
+
+
+
+  template<class RngA, class RngB,class RngC,class LC>
+  void iter_dataset_read(const RngA& RowChunksBegin,const RngA& RowChunksEnd, const RngB& ColChunksBegin,const RngB& ColChunksEnd,const RngC& AChunksBegin,const RngC& AChunksEnd,LC& lambda){
+    for(auto &tchunk_r = RowChunksBegin; tchunk_r!=RowChunksEnd; ++tchunk_r){
+      for(auto &tchunk_c = ColChunksBegin; tchunk_c!=ColChunksEnd; ++tchunk_c){
+	for(auto &tchunk_a = AChunksBegin; tchunk_a!=AChunksEnd; ++tchunk_a){
+	  read_dataset(tchunk_r,tchunk_c,tchunk_a,lambda);
+	}
+      }
+    }
+  }
+
+  template<class RngA,class LC>
+  void iter_dataset_write(const RngA& RowChunksBegin,const RngA& RowChunksEnd,LC& lambda){
+    for(auto &tchunk_r = RowChunksBegin; tchunk_r!=RowChunksEnd; ++tchunk_r){
+      write_dataset(tchunk_r,lambda);
+    }
+  }
+
+
+  template<class RngA, class RngB,class LC>
+  void iter_dataset_write(const RngA& RowChunksBegin,const RngA& RowChunksEnd, const RngB& ColChunksBegin,const RngB& ColChunksEnd,LC& lambda){
+    for(auto &tchunk_r = RowChunksBegin; tchunk_r!=RowChunksEnd; ++tchunk_r){
+      for(auto &tchunk_c = ColChunksBegin; tchunk_c!=ColChunksEnd; ++tchunk_c){
+	write_dataset(tchunk_r,tchunk_c,lambda);
+      }
+    }
+  }
+
+  template<class RngA, class RngB,class RngC,class LC>
+  void iter_dataset_write(const RngA& RowChunksBegin,const RngA& RowChunksEnd, const RngB& ColChunksBegin,const RngB& ColChunksEnd,const RngC& AChunksBegin,const RngC& AChunksEnd,LC& lambda){
+    for(auto &tchunk_r = RowChunksBegin; tchunk_r!=RowChunksEnd; ++tchunk_r){
+      for(auto &tchunk_c = ColChunksBegin; tchunk_c!=ColChunksEnd; ++tchunk_c){
+	for(auto &tchunk_a = AChunksBegin; tchunk_a!=AChunksEnd; ++tchunk_a){
+	  write_dataset(tchunk_r,tchunk_c,tchunk_a,lambda);
+	}
+      }
+    }
+  }
+
+};
diff --git a/inst/include/gsl/gsl b/inst/include/gsl/gsl
deleted file mode 100644
index 55862eb..0000000
--- a/inst/include/gsl/gsl
+++ /dev/null
@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_GSL_H
-#define GSL_GSL_H
-
-#include <gsl/gsl_algorithm> // copy
-#include <gsl/gsl_assert>    // Ensures/Expects
-#include <gsl/gsl_byte>      // byte
-#include <gsl/gsl_util>      // finally()/narrow()/narrow_cast()...
-#include <gsl/multi_span>    // multi_span, strided_span...
-#include <gsl/pointers>      // owner, not_null
-#include <gsl/span>          // span
-#include <gsl/string_span>   // zstring, string_span, zstring_builder...
-
-#endif // GSL_GSL_H
diff --git a/inst/include/gsl/gsl_algorithm b/inst/include/gsl/gsl_algorithm
deleted file mode 100644
index 710792f..0000000
--- a/inst/include/gsl/gsl_algorithm
+++ /dev/null
@@ -1,63 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_ALGORITHM_H
-#define GSL_ALGORITHM_H
-
-#include <gsl/gsl_assert> // for Expects
-#include <gsl/span>       // for dynamic_extent, span
-
-#include <algorithm>   // for copy_n
-#include <cstddef>     // for ptrdiff_t
-#include <type_traits> // for is_assignable
-
-#ifdef _MSC_VER
-#pragma warning(push)
-
-// turn off some warnings that are noisy about our Expects statements
-#pragma warning(disable : 4127) // conditional expression is constant
-#pragma warning(disable : 4996) // unsafe use of std::copy_n
-
-// blanket turn off warnings from CppCoreCheck for now
-// so people aren't annoyed by them when running the tool.
-// more targeted suppressions will be added in a future update to the GSL
-#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495)
-#endif // _MSC_VER
-
-namespace gsl
-{
-
-template <class SrcElementType, std::ptrdiff_t SrcExtent, class DestElementType,
-          std::ptrdiff_t DestExtent>
-void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest)
-{
-    static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,
-                  "Elements of source span can not be assigned to elements of destination span");
-    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
-                      (SrcExtent <= DestExtent),
-                  "Source range is longer than target range");
-
-    Expects(dest.size() >= src.size());
-    std::copy_n(src.data(), src.size(), dest.data());
-}
-
-} // namespace gsl
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-#endif // GSL_ALGORITHM_H
diff --git a/inst/include/gsl/gsl_assert b/inst/include/gsl/gsl_assert
deleted file mode 100644
index 131fa8b..0000000
--- a/inst/include/gsl/gsl_assert
+++ /dev/null
@@ -1,145 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_CONTRACTS_H
-#define GSL_CONTRACTS_H
-
-#include <exception>
-#include <stdexcept> // for logic_error
-
-//
-// Temporary until MSVC STL supports no-exceptions mode.
-// Currently terminate is a no-op in this mode, so we add termination behavior back
-//
-#if defined(_MSC_VER) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
-#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
-#endif
-
-//
-// There are three configuration options for this GSL implementation's behavior
-// when pre/post conditions on the GSL types are violated:
-//
-// 1. GSL_TERMINATE_ON_CONTRACT_VIOLATION: std::terminate will be called (default)
-// 2. GSL_THROW_ON_CONTRACT_VIOLATION: a gsl::fail_fast exception will be thrown
-// 3. GSL_UNENFORCED_ON_CONTRACT_VIOLATION: nothing happens
-//
-#if !(defined(GSL_THROW_ON_CONTRACT_VIOLATION) || defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) ||  \
-      defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION))
-#define GSL_TERMINATE_ON_CONTRACT_VIOLATION
-#endif
-
-#define GSL_STRINGIFY_DETAIL(x) #x
-#define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)
-
-#if defined(__clang__) || defined(__GNUC__)
-#define GSL_LIKELY(x) __builtin_expect(!!(x), 1)
-#define GSL_UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define GSL_LIKELY(x) (!!(x))
-#define GSL_UNLIKELY(x) (!!(x))
-#endif
-
-//
-// GSL_ASSUME(cond)
-//
-// Tell the optimizer that the predicate cond must hold. It is unspecified
-// whether or not cond is actually evaluated.
-//
-#ifdef _MSC_VER
-#define GSL_ASSUME(cond) __assume(cond)
-#elif defined(__GNUC__)
-#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
-#else
-#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
-#endif
-
-//
-// GSL.assert: assertions
-//
-
-namespace gsl
-{
-struct fail_fast : public std::logic_error
-{
-    explicit fail_fast(char const* const message) : std::logic_error(message) {}
-};
-
-namespace details
-{
-#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-
-    typedef void  (__cdecl *terminate_handler)();
-
-    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
-    {
-        static terminate_handler handler = &abort;
-        return handler;
-    }
-
-#endif
-
-    [[noreturn]] inline void terminate() noexcept
-    {
-#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-        (*gsl::details::get_terminate_handler())();
-#else
-        std::terminate();
-#endif
-    }
-
-#if defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
-
-    template <typename Exception>
-    [[noreturn]] void throw_exception(Exception&&)
-    {
-        gsl::details::terminate();
-    }
-
-#else
-
-    template <typename Exception>
-    [[noreturn]] void throw_exception(Exception&& exception)
-    {
-        throw std::forward<Exception>(exception);
-    }
-
-#endif
-
-} // namespace details
-} // namespace gsl
-
-#if defined(GSL_THROW_ON_CONTRACT_VIOLATION)
-
-#define GSL_CONTRACT_CHECK(type, cond)                                                             \
-    (GSL_LIKELY(cond) ? static_cast<void>(0)                                                       \
-                      : gsl::details::throw_exception(gsl::fail_fast(                              \
-                            "GSL: " type " failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__))))
-
-#elif defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
-
-#define GSL_CONTRACT_CHECK(type, cond)                                                             \
-    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())
-
-#elif defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)
-
-#define GSL_CONTRACT_CHECK(type, cond) GSL_ASSUME(cond)
-
-#endif
-
-#define Expects(cond) GSL_CONTRACT_CHECK("Precondition", cond)
-#define Ensures(cond) GSL_CONTRACT_CHECK("Postcondition", cond)
-
-#endif // GSL_CONTRACTS_H
diff --git a/inst/include/gsl/gsl_byte b/inst/include/gsl/gsl_byte
deleted file mode 100644
index e861173..0000000
--- a/inst/include/gsl/gsl_byte
+++ /dev/null
@@ -1,181 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_BYTE_H
-#define GSL_BYTE_H
-
-#include <type_traits>
-
-#ifdef _MSC_VER
-
-#pragma warning(push)
-
-// don't warn about function style casts in byte related operators
-#pragma warning(disable : 26493)
-
-#ifndef GSL_USE_STD_BYTE
-// this tests if we are under MSVC and the standard lib has std::byte and it is enabled
-#if defined(_HAS_STD_BYTE) && _HAS_STD_BYTE
-
-#define GSL_USE_STD_BYTE 1
-
-#else // defined(_HAS_STD_BYTE) && _HAS_STD_BYTE
-
-#define GSL_USE_STD_BYTE 0
-
-#endif // defined(_HAS_STD_BYTE) && _HAS_STD_BYTE
-#endif // GSL_USE_STD_BYTE
-
-#else // _MSC_VER
-
-#ifndef GSL_USE_STD_BYTE
-// this tests if we are under GCC or Clang with enough -std:c++1z power to get us std::byte
-#if defined(__cplusplus) && (__cplusplus >= 201703L)
-
-#define GSL_USE_STD_BYTE 1
-#include <cstddef>
-
-#else // defined(__cplusplus) && (__cplusplus >= 201703L)
-
-#define GSL_USE_STD_BYTE 0
-
-#endif //defined(__cplusplus) && (__cplusplus >= 201703L)
-#endif // GSL_USE_STD_BYTE
-
-#endif           // _MSC_VER
-
-// Use __may_alias__ attribute on gcc and clang
-#if defined __clang__ || (__GNUC__ > 5)
-#define byte_may_alias __attribute__((__may_alias__))
-#else // defined __clang__ || defined __GNUC__
-#define byte_may_alias
-#endif // defined __clang__ || defined __GNUC__
-
-namespace gsl
-{
-#if GSL_USE_STD_BYTE
-
-
-using std::byte;
-using std::to_integer;
-
-#else // GSL_USE_STD_BYTE
-
-// This is a simple definition for now that allows
-// use of byte within span<> to be standards-compliant
-enum class byte_may_alias byte : unsigned char
-{
-};
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
-{
-    return b = byte(static_cast<unsigned char>(b) << shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte operator<<(byte b, IntegerType shift) noexcept
-{
-    return byte(static_cast<unsigned char>(b) << shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
-{
-    return b = byte(static_cast<unsigned char>(b) >> shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte operator>>(byte b, IntegerType shift) noexcept
-{
-    return byte(static_cast<unsigned char>(b) >> shift);
-}
-
-constexpr byte& operator|=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
-}
-
-constexpr byte operator|(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
-}
-
-constexpr byte& operator&=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
-}
-
-constexpr byte operator&(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
-}
-
-constexpr byte& operator^=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
-}
-
-constexpr byte operator^(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
-}
-
-constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr IntegerType to_integer(byte b) noexcept
-{
-    return static_cast<IntegerType>(b);
-}
-
-#endif // GSL_USE_STD_BYTE
-
-template <bool E, typename T>
-constexpr byte to_byte_impl(T t) noexcept
-{
-    static_assert(
-        E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
-           "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");
-    return static_cast<byte>(t);
-}
-template <>
-constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
-{
-    return byte(t);
-}
-
-template <typename T>
-constexpr byte to_byte(T t) noexcept
-{
-    return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
-}
-
-template <int I>
-constexpr byte to_byte() noexcept
-{
-    static_assert(I >= 0 && I <= 255,
-                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
-    return static_cast<byte>(I);
-}
-
-} // namespace gsl
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-#endif // GSL_BYTE_H
diff --git a/inst/include/gsl/gsl_util b/inst/include/gsl/gsl_util
deleted file mode 100644
index 25f8502..0000000
--- a/inst/include/gsl/gsl_util
+++ /dev/null
@@ -1,158 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_UTIL_H
-#define GSL_UTIL_H
-
-#include <gsl/gsl_assert> // for Expects
-
-#include <array>
-#include <cstddef>          // for ptrdiff_t, size_t
-#include <exception>        // for exception
-#include <initializer_list> // for initializer_list
-#include <type_traits>      // for is_signed, integral_constant
-#include <utility>          // for forward
-
-#if defined(_MSC_VER)
-
-#pragma warning(push)
-#pragma warning(disable : 4127) // conditional expression is constant
-
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-#endif                          // _MSC_VER < 1910
-#endif                          // _MSC_VER
-
-namespace gsl
-{
-//
-// GSL.util: utilities
-//
-
-// index type for all container indexes/subscripts/sizes
-using index = std::ptrdiff_t;
-
-// final_action allows you to ensure something gets run at the end of a scope
-template <class F>
-class final_action
-{
-public:
-    explicit final_action(F f) noexcept : f_(std::move(f)) {}
-
-    final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_)
-    {
-        other.invoke_ = false;
-    }
-
-    final_action(const final_action&) = delete;
-    final_action& operator=(const final_action&) = delete;
-    final_action& operator=(final_action&&) = delete;
-
-    ~final_action() noexcept
-    {
-        if (invoke_) f_();
-    }
-
-private:
-    F f_;
-    bool invoke_ {true};
-};
-
-// finally() - convenience function to generate a final_action
-template <class F>
-
-final_action<F> finally(const F& f) noexcept
-{
-    return final_action<F>(f);
-}
-
-template <class F>
-final_action<F> finally(F&& f) noexcept
-{
-    return final_action<F>(std::forward<F>(f));
-}
-
-// narrow_cast(): a searchable way to do narrowing casts of values
-template <class T, class U>
-constexpr T narrow_cast(U&& u) noexcept
-{
-    return static_cast<T>(std::forward<U>(u));
-}
-
-struct narrowing_error : public std::exception
-{
-};
-
-namespace details
-{
-    template <class T, class U>
-    struct is_same_signedness
-        : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
-    {
-    };
-}
-
-// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
-template <class T, class U>
-T narrow(U u)
-{
-    T t = narrow_cast<T>(u);
-    if (static_cast<U>(t) != u) gsl::details::throw_exception(narrowing_error());
-    if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
-        gsl::details::throw_exception(narrowing_error());
-    return t;
-}
-
-//
-// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
-//
-template <class T, std::size_t N>
-constexpr T& at(T (&arr)[N], const index i)
-{
-    Expects(i >= 0 && i < narrow_cast<index>(N));
-    return arr[static_cast<std::size_t>(i)];
-}
-
-template <class Cont>
-constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
-{
-    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
-    using size_type = decltype(cont.size());
-    return cont[static_cast<size_type>(i)];
-}
-
-template <class T>
-constexpr T at(const std::initializer_list<T> cont, const index i)
-{
-    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
-    return *(cont.begin() + i);
-}
-
-} // namespace gsl
-
-#if defined(_MSC_VER)
-#if _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // _MSC_VER < 1910
-
-#pragma warning(pop)
-
-#endif // _MSC_VER
-
-#endif // GSL_UTIL_H
diff --git a/inst/include/gsl/multi_span b/inst/include/gsl/multi_span
deleted file mode 100644
index f697093..0000000
--- a/inst/include/gsl/multi_span
+++ /dev/null
@@ -1,2242 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_MULTI_SPAN_H
-#define GSL_MULTI_SPAN_H
-
-#include <gsl/gsl_assert> // for Expects
-#include <gsl/gsl_byte>   // for byte
-#include <gsl/gsl_util>   // for narrow_cast
-
-#include <algorithm> // for transform, lexicographical_compare
-#include <array>     // for array
-#include <cassert>
-#include <cstddef>          // for ptrdiff_t, size_t, nullptr_t
-#include <cstdint>          // for PTRDIFF_MAX
-#include <functional>       // for divides, multiplies, minus, negate, plus
-#include <initializer_list> // for initializer_list
-#include <iterator>         // for iterator, random_access_iterator_tag
-#include <limits>           // for numeric_limits
-#include <new>
-#include <numeric>
-#include <stdexcept>
-#include <string>      // for basic_string
-#include <type_traits> // for enable_if_t, remove_cv_t, is_same, is_co...
-#include <utility>
-
-#ifdef _MSC_VER
-
-// turn off some warnings that are noisy about our Expects statements
-#pragma warning(push)
-#pragma warning(disable : 4127) // conditional expression is constant
-#pragma warning(disable : 4702) // unreachable code
-
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif                          // _MSC_VER < 1910
-#endif                          // _MSC_VER
-
-// GCC 7 does not like the signed unsigned missmatch (size_t ptrdiff_t)
-// While there is a conversion from signed to unsigned, it happens at 
-// compiletime, so the compiler wouldn't have to warn indiscriminently, but 
-// could check if the source value actually doesn't fit into the target type 
-// and only warn in those cases.
-#if __GNUC__ > 6
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#endif
-
-#ifdef GSL_THROW_ON_CONTRACT_VIOLATION
-#define GSL_NOEXCEPT /*noexcept*/
-#else
-#define GSL_NOEXCEPT noexcept
-#endif // GSL_THROW_ON_CONTRACT_VIOLATION
-
-namespace gsl
-{
-
-/*
-** begin definitions of index and bounds
-*/
-namespace details
-{
-    template <typename SizeType>
-    struct SizeTypeTraits
-    {
-        static const SizeType max_value = std::numeric_limits<SizeType>::max();
-    };
-
-    template <typename... Ts>
-    class are_integral : public std::integral_constant<bool, true>
-    {
-    };
-
-    template <typename T, typename... Ts>
-    class are_integral<T, Ts...>
-        : public std::integral_constant<bool,
-                                        std::is_integral<T>::value && are_integral<Ts...>::value>
-    {
-    };
-}
-
-template <std::size_t Rank>
-class multi_span_index final
-{
-    static_assert(Rank > 0, "Rank must be greater than 0!");
-
-    template <std::size_t OtherRank>
-    friend class multi_span_index;
-
-public:
-    static const std::size_t rank = Rank;
-    using value_type = std::ptrdiff_t;
-    using size_type = value_type;
-    using reference = std::add_lvalue_reference_t<value_type>;
-    using const_reference = std::add_lvalue_reference_t<std::add_const_t<value_type>>;
-
-    constexpr multi_span_index() GSL_NOEXCEPT {}
-
-    constexpr multi_span_index(const value_type (&values)[Rank]) GSL_NOEXCEPT
-    {
-        std::copy(values, values + Rank, elems);
-    }
-
-    template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) &&
-                                                          details::are_integral<Ts...>::value>>
-    constexpr multi_span_index(Ts... ds) GSL_NOEXCEPT : elems{narrow_cast<value_type>(ds)...}
-    {
-    }
-
-    constexpr multi_span_index(const multi_span_index& other) GSL_NOEXCEPT = default;
-
-    constexpr multi_span_index& operator=(const multi_span_index& rhs) GSL_NOEXCEPT = default;
-
-    // Preconditions: component_idx < rank
-    constexpr reference operator[](std::size_t component_idx)
-    {
-        Expects(component_idx < Rank); // Component index must be less than rank
-        return elems[component_idx];
-    }
-
-    // Preconditions: component_idx < rank
-    constexpr const_reference operator[](std::size_t component_idx) const GSL_NOEXCEPT
-    {
-        Expects(component_idx < Rank); // Component index must be less than rank
-        return elems[component_idx];
-    }
-
-    constexpr bool operator==(const multi_span_index& rhs) const GSL_NOEXCEPT
-    {
-        return std::equal(elems, elems + rank, rhs.elems);
-    }
-
-    constexpr bool operator!=(const multi_span_index& rhs) const GSL_NOEXCEPT { return !(*this == rhs); }
-
-    constexpr multi_span_index operator+() const GSL_NOEXCEPT { return *this; }
-
-    constexpr multi_span_index operator-() const GSL_NOEXCEPT
-    {
-        multi_span_index ret = *this;
-        std::transform(ret, ret + rank, ret, std::negate<value_type>{});
-        return ret;
-    }
-
-    constexpr multi_span_index operator+(const multi_span_index& rhs) const GSL_NOEXCEPT
-    {
-        multi_span_index ret = *this;
-        ret += rhs;
-        return ret;
-    }
-
-    constexpr multi_span_index operator-(const multi_span_index& rhs) const GSL_NOEXCEPT
-    {
-        multi_span_index ret = *this;
-        ret -= rhs;
-        return ret;
-    }
-
-    constexpr multi_span_index& operator+=(const multi_span_index& rhs) GSL_NOEXCEPT
-    {
-        std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{});
-        return *this;
-    }
-
-    constexpr multi_span_index& operator-=(const multi_span_index& rhs) GSL_NOEXCEPT
-    {
-        std::transform(elems, elems + rank, rhs.elems, elems, std::minus<value_type>{});
-        return *this;
-    }
-
-    constexpr multi_span_index operator*(value_type v) const GSL_NOEXCEPT
-    {
-        multi_span_index ret = *this;
-        ret *= v;
-        return ret;
-    }
-
-    constexpr multi_span_index operator/(value_type v) const GSL_NOEXCEPT
-    {
-        multi_span_index ret = *this;
-        ret /= v;
-        return ret;
-    }
-
-    friend constexpr multi_span_index operator*(value_type v, const multi_span_index& rhs) GSL_NOEXCEPT
-    {
-        return rhs * v;
-    }
-
-    constexpr multi_span_index& operator*=(value_type v) GSL_NOEXCEPT
-    {
-        std::transform(elems, elems + rank, elems,
-                       [v](value_type x) { return std::multiplies<value_type>{}(x, v); });
-        return *this;
-    }
-
-    constexpr multi_span_index& operator/=(value_type v) GSL_NOEXCEPT
-    {
-        std::transform(elems, elems + rank, elems,
-                       [v](value_type x) { return std::divides<value_type>{}(x, v); });
-        return *this;
-    }
-
-private:
-    value_type elems[Rank] = {};
-};
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1910
-
-struct static_bounds_dynamic_range_t
-{
-    template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
-    constexpr operator T() const GSL_NOEXCEPT
-    {
-        return narrow_cast<T>(-1);
-    }
-};
-
-constexpr bool operator==(static_bounds_dynamic_range_t, static_bounds_dynamic_range_t) GSL_NOEXCEPT
-{
-    return true;
-}
-
-constexpr bool operator!=(static_bounds_dynamic_range_t, static_bounds_dynamic_range_t) GSL_NOEXCEPT
-{
-    return false;
-}
-
-template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
-constexpr bool operator==(static_bounds_dynamic_range_t, T other) GSL_NOEXCEPT
-{
-    return narrow_cast<T>(-1) == other;
-}
-
-template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
-constexpr bool operator==(T left, static_bounds_dynamic_range_t right) GSL_NOEXCEPT
-{
-    return right == left;
-}
-
-template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
-constexpr bool operator!=(static_bounds_dynamic_range_t, T other) GSL_NOEXCEPT
-{
-    return narrow_cast<T>(-1) != other;
-}
-
-template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
-constexpr bool operator!=(T left, static_bounds_dynamic_range_t right) GSL_NOEXCEPT
-{
-    return right != left;
-}
-
-constexpr static_bounds_dynamic_range_t dynamic_range{};
-#else
-const std::ptrdiff_t dynamic_range = -1;
-#endif
-
-struct generalized_mapping_tag
-{
-};
-struct contiguous_mapping_tag : generalized_mapping_tag
-{
-};
-
-namespace details
-{
-
-    template <std::ptrdiff_t Left, std::ptrdiff_t Right>
-    struct LessThan
-    {
-        static const bool value = Left < Right;
-    };
-
-    template <std::ptrdiff_t... Ranges>
-    struct BoundsRanges
-    {
-        using size_type = std::ptrdiff_t;
-        static const size_type Depth = 0;
-        static const size_type DynamicNum = 0;
-        static const size_type CurrentRange = 1;
-        static const size_type TotalSize = 1;
-
-        // TODO : following signature is for work around VS bug
-        template <typename OtherRange>
-        BoundsRanges(const OtherRange&, bool /* firstLevel */)
-        {
-        }
-
-        BoundsRanges(const std::ptrdiff_t* const) {}
-        BoundsRanges() = default;
-
-        template <typename T, std::size_t Dim>
-        void serialize(T&) const
-        {
-        }
-
-        template <typename T, std::size_t Dim>
-        size_type linearize(const T&) const
-        {
-            return 0;
-        }
-
-        template <typename T, std::size_t Dim>
-        size_type contains(const T&) const
-        {
-            return -1;
-        }
-
-        size_type elementNum(std::size_t) const GSL_NOEXCEPT { return 0; }
-
-        size_type totalSize() const GSL_NOEXCEPT { return TotalSize; }
-
-        bool operator==(const BoundsRanges&) const GSL_NOEXCEPT { return true; }
-    };
-
-    template <std::ptrdiff_t... RestRanges>
-    struct BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...>
-    {
-        using Base = BoundsRanges<RestRanges...>;
-        using size_type = std::ptrdiff_t;
-        static const std::size_t Depth = Base::Depth + 1;
-        static const std::size_t DynamicNum = Base::DynamicNum + 1;
-        static const size_type CurrentRange = dynamic_range;
-        static const size_type TotalSize = dynamic_range;
-
-    private:
-        size_type m_bound;
-
-    public:
-        BoundsRanges(const std::ptrdiff_t* const arr)
-            : Base(arr + 1), m_bound(*arr * this->Base::totalSize())
-        {
-            Expects(0 <= *arr);
-        }
-
-        BoundsRanges() : m_bound(0) {}
-
-        template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges>
-        BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
-                     bool /* firstLevel */ = true)
-            : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false)
-            , m_bound(other.totalSize())
-        {
-        }
-
-        template <typename T, std::size_t Dim = 0>
-        void serialize(T& arr) const
-        {
-            arr[Dim] = elementNum();
-            this->Base::template serialize<T, Dim + 1>(arr);
-        }
-
-        template <typename T, std::size_t Dim = 0>
-        size_type linearize(const T& arr) const
-        {
-            const size_type index = this->Base::totalSize() * arr[Dim];
-            Expects(index < m_bound);
-            return index + this->Base::template linearize<T, Dim + 1>(arr);
-        }
-
-        template <typename T, std::size_t Dim = 0>
-        size_type contains(const T& arr) const
-        {
-            const ptrdiff_t last = this->Base::template contains<T, Dim + 1>(arr);
-            if (last == -1) return -1;
-            const ptrdiff_t cur = this->Base::totalSize() * arr[Dim];
-            return cur < m_bound ? cur + last : -1;
-        }
-
-        size_type totalSize() const GSL_NOEXCEPT { return m_bound; }
-
-        size_type elementNum() const GSL_NOEXCEPT { return totalSize() / this->Base::totalSize(); }
-
-        size_type elementNum(std::size_t dim) const GSL_NOEXCEPT
-        {
-            if (dim > 0)
-                return this->Base::elementNum(dim - 1);
-            else
-                return elementNum();
-        }
-
-        bool operator==(const BoundsRanges& rhs) const GSL_NOEXCEPT
-        {
-            return m_bound == rhs.m_bound &&
-                   static_cast<const Base&>(*this) == static_cast<const Base&>(rhs);
-        }
-    };
-
-    template <std::ptrdiff_t CurRange, std::ptrdiff_t... RestRanges>
-    struct BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...>
-    {
-        using Base = BoundsRanges<RestRanges...>;
-        using size_type = std::ptrdiff_t;
-        static const std::size_t Depth = Base::Depth + 1;
-        static const std::size_t DynamicNum = Base::DynamicNum;
-        static const size_type CurrentRange = CurRange;
-        static const size_type TotalSize =
-            Base::TotalSize == dynamic_range ? dynamic_range : CurrentRange * Base::TotalSize;
-
-        BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {}
-        BoundsRanges() = default;
-
-        template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges>
-        BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
-                     bool firstLevel = true)
-            : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false)
-        {
-            (void) firstLevel;
-        }
-
-        template <typename T, std::size_t Dim = 0>
-        void serialize(T& arr) const
-        {
-            arr[Dim] = elementNum();
-            this->Base::template serialize<T, Dim + 1>(arr);
-        }
-
-        template <typename T, std::size_t Dim = 0>
-        size_type linearize(const T& arr) const
-        {
-            Expects(arr[Dim] >= 0 && arr[Dim] < CurrentRange); // Index is out of range
-            return this->Base::totalSize() * arr[Dim] +
-                   this->Base::template linearize<T, Dim + 1>(arr);
-        }
-
-        template <typename T, std::size_t Dim = 0>
-        size_type contains(const T& arr) const
-        {
-            if (arr[Dim] >= CurrentRange) return -1;
-            const size_type last = this->Base::template contains<T, Dim + 1>(arr);
-            if (last == -1) return -1;
-            return this->Base::totalSize() * arr[Dim] + last;
-        }
-
-        size_type totalSize() const GSL_NOEXCEPT { return CurrentRange * this->Base::totalSize(); }
-
-        size_type elementNum() const GSL_NOEXCEPT { return CurrentRange; }
-
-        size_type elementNum(std::size_t dim) const GSL_NOEXCEPT
-        {
-            if (dim > 0)
-                return this->Base::elementNum(dim - 1);
-            else
-                return elementNum();
-        }
-
-        bool operator==(const BoundsRanges& rhs) const GSL_NOEXCEPT
-        {
-            return static_cast<const Base&>(*this) == static_cast<const Base&>(rhs);
-        }
-    };
-
-    template <typename SourceType, typename TargetType>
-    struct BoundsRangeConvertible
-        : public std::integral_constant<bool, (SourceType::TotalSize >= TargetType::TotalSize ||
-                                               TargetType::TotalSize == dynamic_range ||
-                                               SourceType::TotalSize == dynamic_range ||
-                                               TargetType::TotalSize == 0)>
-    {
-    };
-
-    template <typename TypeChain>
-    struct TypeListIndexer
-    {
-        const TypeChain& obj_;
-        TypeListIndexer(const TypeChain& obj) : obj_(obj) {}
-
-        template <std::size_t N>
-        const TypeChain& getObj(std::true_type)
-        {
-            return obj_;
-        }
-
-        template <std::size_t N, typename MyChain = TypeChain,
-                  typename MyBase = typename MyChain::Base>
-        auto getObj(std::false_type)
-            -> decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>())
-        {
-            return TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>();
-        }
-
-        template <std::size_t N>
-        auto get() -> decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>()))
-        {
-            return getObj<N - 1>(std::integral_constant<bool, N == 0>());
-        }
-    };
-
-    template <typename TypeChain>
-    TypeListIndexer<TypeChain> createTypeListIndexer(const TypeChain& obj)
-    {
-        return TypeListIndexer<TypeChain>(obj);
-    }
-
-    template <std::size_t Rank, bool Enabled = (Rank > 1),
-              typename Ret = std::enable_if_t<Enabled, multi_span_index<Rank - 1>>>
-    constexpr Ret shift_left(const multi_span_index<Rank>& other) GSL_NOEXCEPT
-    {
-        Ret ret{};
-        for (std::size_t i = 0; i < Rank - 1; ++i) {
-            ret[i] = other[i + 1];
-        }
-        return ret;
-    }
-}
-
-template <typename IndexType>
-class bounds_iterator;
-
-template <std::ptrdiff_t... Ranges>
-class static_bounds
-{
-public:
-    static_bounds(const details::BoundsRanges<Ranges...>&) {}
-};
-
-template <std::ptrdiff_t FirstRange, std::ptrdiff_t... RestRanges>
-class static_bounds<FirstRange, RestRanges...>
-{
-    using MyRanges = details::BoundsRanges<FirstRange, RestRanges...>;
-
-    MyRanges m_ranges;
-    constexpr static_bounds(const MyRanges& range) : m_ranges(range) {}
-
-    template <std::ptrdiff_t... OtherRanges>
-    friend class static_bounds;
-
-public:
-    static const std::size_t rank = MyRanges::Depth;
-    static const std::size_t dynamic_rank = MyRanges::DynamicNum;
-    static const std::ptrdiff_t static_size = MyRanges::TotalSize;
-
-    using size_type = std::ptrdiff_t;
-    using index_type = multi_span_index<rank>;
-    using const_index_type = std::add_const_t<index_type>;
-    using iterator = bounds_iterator<const_index_type>;
-    using const_iterator = bounds_iterator<const_index_type>;
-    using difference_type = std::ptrdiff_t;
-    using sliced_type = static_bounds<RestRanges...>;
-    using mapping_type = contiguous_mapping_tag;
-
-    constexpr static_bounds(const static_bounds&) = default;
-
-    template <typename SourceType, typename TargetType, std::size_t Rank>
-    struct BoundsRangeConvertible2;
-
-    template <std::size_t Rank, typename SourceType, typename TargetType,
-              typename Ret = BoundsRangeConvertible2<typename SourceType::Base,
-                                                     typename TargetType::Base, Rank>>
-    static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret;
-
-    template <std::size_t Rank, typename SourceType, typename TargetType>
-    static auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type;
-
-    template <typename SourceType, typename TargetType, std::size_t Rank>
-    struct BoundsRangeConvertible2
-        : decltype(helpBoundsRangeConvertible<Rank - 1>(
-              SourceType(), TargetType(),
-              std::integral_constant<bool,
-                                     SourceType::Depth == TargetType::Depth &&
-                                         (SourceType::CurrentRange == TargetType::CurrentRange ||
-                                          TargetType::CurrentRange == dynamic_range ||
-                                          SourceType::CurrentRange == dynamic_range)>()))
-    {
-    };
-
-    template <typename SourceType, typename TargetType>
-    struct BoundsRangeConvertible2<SourceType, TargetType, 0> : std::true_type
-    {
-    };
-
-    template <typename SourceType, typename TargetType, std::ptrdiff_t Rank = TargetType::Depth>
-    struct BoundsRangeConvertible
-        : decltype(helpBoundsRangeConvertible<Rank - 1>(
-              SourceType(), TargetType(),
-              std::integral_constant<bool,
-                                     SourceType::Depth == TargetType::Depth &&
-                                         (!details::LessThan<SourceType::CurrentRange,
-                                                             TargetType::CurrentRange>::value ||
-                                          TargetType::CurrentRange == dynamic_range ||
-                                          SourceType::CurrentRange == dynamic_range)>()))
-    {
-    };
-
-    template <typename SourceType, typename TargetType>
-    struct BoundsRangeConvertible<SourceType, TargetType, 0> : std::true_type
-    {
-    };
-
-    template <std::ptrdiff_t... Ranges,
-              typename = std::enable_if_t<details::BoundsRangeConvertible<
-                  details::BoundsRanges<Ranges...>,
-                  details::BoundsRanges<FirstRange, RestRanges...>>::value>>
-    constexpr static_bounds(const static_bounds<Ranges...>& other) : m_ranges(other.m_ranges)
-    {
-        Expects((MyRanges::DynamicNum == 0 && details::BoundsRanges<Ranges...>::DynamicNum == 0) ||
-                MyRanges::DynamicNum > 0 || other.m_ranges.totalSize() >= m_ranges.totalSize());
-    }
-
-    constexpr static_bounds(std::initializer_list<size_type> il)
-        : m_ranges(static_cast<const std::ptrdiff_t*>(il.begin()))
-    {
-        // Size of the initializer list must match the rank of the array
-        Expects((MyRanges::DynamicNum == 0 && il.size() == 1 && *il.begin() == static_size) ||
-                MyRanges::DynamicNum == il.size());
-        // Size of the range must be less than the max element of the size type
-        Expects(m_ranges.totalSize() <= PTRDIFF_MAX);
-    }
-
-    constexpr static_bounds() = default;
-
-    constexpr sliced_type slice() const GSL_NOEXCEPT
-    {
-        return sliced_type{static_cast<const details::BoundsRanges<RestRanges...>&>(m_ranges)};
-    }
-
-    constexpr size_type stride() const GSL_NOEXCEPT { return rank > 1 ? slice().size() : 1; }
-
-    constexpr size_type size() const GSL_NOEXCEPT { return m_ranges.totalSize(); }
-
-    constexpr size_type total_size() const GSL_NOEXCEPT { return m_ranges.totalSize(); }
-
-    constexpr size_type linearize(const index_type& idx) const { return m_ranges.linearize(idx); }
-
-    constexpr bool contains(const index_type& idx) const GSL_NOEXCEPT
-    {
-        return m_ranges.contains(idx) != -1;
-    }
-
-    constexpr size_type operator[](std::size_t idx) const GSL_NOEXCEPT
-    {
-        return m_ranges.elementNum(idx);
-    }
-
-    template <std::size_t Dim = 0>
-    constexpr size_type extent() const GSL_NOEXCEPT
-    {
-        static_assert(Dim < rank,
-                      "dimension should be less than rank (dimension count starts from 0)");
-        return details::createTypeListIndexer(m_ranges).template get<Dim>().elementNum();
-    }
-
-    template <typename IntType>
-    constexpr size_type extent(IntType dim) const GSL_NOEXCEPT
-    {
-        static_assert(std::is_integral<IntType>::value,
-                      "Dimension parameter must be supplied as an integral type.");
-        auto real_dim = narrow_cast<std::size_t>(dim);
-        Expects(real_dim < rank);
-
-        return m_ranges.elementNum(real_dim);
-    }
-
-    constexpr index_type index_bounds() const GSL_NOEXCEPT
-    {
-        size_type extents[rank] = {};
-        m_ranges.serialize(extents);
-        return {extents};
-    }
-
-    template <std::ptrdiff_t... Ranges>
-    constexpr bool operator==(const static_bounds<Ranges...>& rhs) const GSL_NOEXCEPT
-    {
-        return this->size() == rhs.size();
-    }
-
-    template <std::ptrdiff_t... Ranges>
-    constexpr bool operator!=(const static_bounds<Ranges...>& rhs) const GSL_NOEXCEPT
-    {
-        return !(*this == rhs);
-    }
-
-    constexpr const_iterator begin() const GSL_NOEXCEPT
-    {
-        return const_iterator(*this, index_type{});
-    }
-
-    constexpr const_iterator end() const GSL_NOEXCEPT
-    {
-        return const_iterator(*this, this->index_bounds());
-    }
-};
-
-template <std::size_t Rank>
-class strided_bounds
-{
-    template <std::size_t OtherRank>
-    friend class strided_bounds;
-
-public:
-    static const std::size_t rank = Rank;
-    using value_type = std::ptrdiff_t;
-    using reference = std::add_lvalue_reference_t<value_type>;
-    using const_reference = std::add_const_t<reference>;
-    using size_type = value_type;
-    using difference_type = value_type;
-    using index_type = multi_span_index<rank>;
-    using const_index_type = std::add_const_t<index_type>;
-    using iterator = bounds_iterator<const_index_type>;
-    using const_iterator = bounds_iterator<const_index_type>;
-    static const value_type dynamic_rank = rank;
-    static const value_type static_size = dynamic_range;
-    using sliced_type = std::conditional_t<rank != 0, strided_bounds<rank - 1>, void>;
-    using mapping_type = generalized_mapping_tag;
-
-    constexpr strided_bounds(const strided_bounds&) GSL_NOEXCEPT = default;
-
-    constexpr strided_bounds& operator=(const strided_bounds&) GSL_NOEXCEPT = default;
-
-    constexpr strided_bounds(const value_type (&values)[rank], index_type strides)
-        : m_extents(values), m_strides(std::move(strides))
-    {
-    }
-
-    constexpr strided_bounds(const index_type& extents, const index_type& strides) GSL_NOEXCEPT
-        : m_extents(extents),
-          m_strides(strides)
-    {
-    }
-
-    constexpr index_type strides() const GSL_NOEXCEPT { return m_strides; }
-
-    constexpr size_type total_size() const GSL_NOEXCEPT
-    {
-        size_type ret = 0;
-        for (std::size_t i = 0; i < rank; ++i) {
-            ret += (m_extents[i] - 1) * m_strides[i];
-        }
-        return ret + 1;
-    }
-
-    constexpr size_type size() const GSL_NOEXCEPT
-    {
-        size_type ret = 1;
-        for (std::size_t i = 0; i < rank; ++i) {
-            ret *= m_extents[i];
-        }
-        return ret;
-    }
-
-    constexpr bool contains(const index_type& idx) const GSL_NOEXCEPT
-    {
-        for (std::size_t i = 0; i < rank; ++i) {
-            if (idx[i] < 0 || idx[i] >= m_extents[i]) return false;
-        }
-        return true;
-    }
-
-    constexpr size_type linearize(const index_type& idx) const GSL_NOEXCEPT
-    {
-        size_type ret = 0;
-        for (std::size_t i = 0; i < rank; i++) {
-            Expects(idx[i] < m_extents[i]); // index is out of bounds of the array
-            ret += idx[i] * m_strides[i];
-        }
-        return ret;
-    }
-
-    constexpr size_type stride() const GSL_NOEXCEPT { return m_strides[0]; }
-
-    template <bool Enabled = (rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>
-    constexpr sliced_type slice() const
-    {
-        return {details::shift_left(m_extents), details::shift_left(m_strides)};
-    }
-
-    template <std::size_t Dim = 0>
-    constexpr size_type extent() const GSL_NOEXCEPT
-    {
-        static_assert(Dim < Rank,
-                      "dimension should be less than rank (dimension count starts from 0)");
-        return m_extents[Dim];
-    }
-
-    constexpr index_type index_bounds() const GSL_NOEXCEPT { return m_extents; }
-    constexpr const_iterator begin() const GSL_NOEXCEPT
-    {
-        return const_iterator{*this, index_type{}};
-    }
-
-    constexpr const_iterator end() const GSL_NOEXCEPT
-    {
-        return const_iterator{*this, index_bounds()};
-    }
-
-private:
-    index_type m_extents;
-    index_type m_strides;
-};
-
-template <typename T>
-struct is_bounds : std::integral_constant<bool, false>
-{
-};
-template <std::ptrdiff_t... Ranges>
-struct is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true>
-{
-};
-template <std::size_t Rank>
-struct is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true>
-{
-};
-
-template <typename IndexType>
-class bounds_iterator
-{
-public:
-    static const std::size_t rank = IndexType::rank;
-    using iterator_category = std::random_access_iterator_tag;
-    using value_type = IndexType;
-    using difference_type = std::ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
-    using index_type = value_type;
-    using index_size_type = typename IndexType::value_type;
-    template <typename Bounds>
-    explicit bounds_iterator(const Bounds& bnd, value_type curr) GSL_NOEXCEPT
-        : boundary_(bnd.index_bounds()),
-          curr_(std::move(curr))
-    {
-        static_assert(is_bounds<Bounds>::value, "Bounds type must be provided");
-    }
-
-    constexpr reference operator*() const GSL_NOEXCEPT { return curr_; }
-
-    constexpr pointer operator->() const GSL_NOEXCEPT { return &curr_; }
-
-    constexpr bounds_iterator& operator++() GSL_NOEXCEPT
-    {
-        for (std::size_t i = rank; i-- > 0;) {
-            if (curr_[i] < boundary_[i] - 1) {
-                curr_[i]++;
-                return *this;
-            }
-            curr_[i] = 0;
-        }
-        // If we're here we've wrapped over - set to past-the-end.
-        curr_ = boundary_;
-        return *this;
-    }
-
-    constexpr bounds_iterator operator++(int) GSL_NOEXCEPT
-    {
-        auto ret = *this;
-        ++(*this);
-        return ret;
-    }
-
-    constexpr bounds_iterator& operator--() GSL_NOEXCEPT
-    {
-        if (!less(curr_, boundary_)) {
-            // if at the past-the-end, set to last element
-            for (std::size_t i = 0; i < rank; ++i) {
-                curr_[i] = boundary_[i] - 1;
-            }
-            return *this;
-        }
-        for (std::size_t i = rank; i-- > 0;) {
-            if (curr_[i] >= 1) {
-                curr_[i]--;
-                return *this;
-            }
-            curr_[i] = boundary_[i] - 1;
-        }
-        // If we're here the preconditions were violated
-        // "pre: there exists s such that r == ++s"
-        Expects(false);
-        return *this;
-    }
-
-    constexpr bounds_iterator operator--(int) GSL_NOEXCEPT
-    {
-        auto ret = *this;
-        --(*this);
-        return ret;
-    }
-
-    constexpr bounds_iterator operator+(difference_type n) const GSL_NOEXCEPT
-    {
-        bounds_iterator ret{*this};
-        return ret += n;
-    }
-
-    constexpr bounds_iterator& operator+=(difference_type n) GSL_NOEXCEPT
-    {
-        auto linear_idx = linearize(curr_) + n;
-        std::remove_const_t<value_type> stride = 0;
-        stride[rank - 1] = 1;
-        for (std::size_t i = rank - 1; i-- > 0;) {
-            stride[i] = stride[i + 1] * boundary_[i + 1];
-        }
-        for (std::size_t i = 0; i < rank; ++i) {
-            curr_[i] = linear_idx / stride[i];
-            linear_idx = linear_idx % stride[i];
-        }
-        // index is out of bounds of the array
-        Expects(!less(curr_, index_type{}) && !less(boundary_, curr_));
-        return *this;
-    }
-
-    constexpr bounds_iterator operator-(difference_type n) const GSL_NOEXCEPT
-    {
-        bounds_iterator ret{*this};
-        return ret -= n;
-    }
-
-    constexpr bounds_iterator& operator-=(difference_type n) GSL_NOEXCEPT { return *this += -n; }
-
-    constexpr difference_type operator-(const bounds_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return linearize(curr_) - linearize(rhs.curr_);
-    }
-
-    constexpr value_type operator[](difference_type n) const GSL_NOEXCEPT { return *(*this + n); }
-
-    constexpr bool operator==(const bounds_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return curr_ == rhs.curr_;
-    }
-
-    constexpr bool operator!=(const bounds_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return !(*this == rhs);
-    }
-
-    constexpr bool operator<(const bounds_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return less(curr_, rhs.curr_);
-    }
-
-    constexpr bool operator<=(const bounds_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return !(rhs < *this);
-    }
-
-    constexpr bool operator>(const bounds_iterator& rhs) const GSL_NOEXCEPT { return rhs < *this; }
-
-    constexpr bool operator>=(const bounds_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return !(rhs > *this);
-    }
-
-    void swap(bounds_iterator& rhs) GSL_NOEXCEPT
-    {
-        std::swap(boundary_, rhs.boundary_);
-        std::swap(curr_, rhs.curr_);
-    }
-
-private:
-    constexpr bool less(index_type& one, index_type& other) const GSL_NOEXCEPT
-    {
-        for (std::size_t i = 0; i < rank; ++i) {
-            if (one[i] < other[i]) return true;
-        }
-        return false;
-    }
-
-    constexpr index_size_type linearize(const value_type& idx) const GSL_NOEXCEPT
-    {
-        // TODO: Smarter impl.
-        // Check if past-the-end
-        index_size_type multiplier = 1;
-        index_size_type res = 0;
-        if (!less(idx, boundary_)) {
-            res = 1;
-            for (std::size_t i = rank; i-- > 0;) {
-                res += (idx[i] - 1) * multiplier;
-                multiplier *= boundary_[i];
-            }
-        }
-        else
-        {
-            for (std::size_t i = rank; i-- > 0;) {
-                res += idx[i] * multiplier;
-                multiplier *= boundary_[i];
-            }
-        }
-        return res;
-    }
-
-    value_type boundary_;
-    std::remove_const_t<value_type> curr_;
-};
-
-template <typename IndexType>
-bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::difference_type n,
-                                     const bounds_iterator<IndexType>& rhs) GSL_NOEXCEPT
-{
-    return rhs + n;
-}
-
-namespace details
-{
-    template <typename Bounds>
-    constexpr std::enable_if_t<
-        std::is_same<typename Bounds::mapping_type, generalized_mapping_tag>::value,
-        typename Bounds::index_type>
-    make_stride(const Bounds& bnd) GSL_NOEXCEPT
-    {
-        return bnd.strides();
-    }
-
-    // Make a stride vector from bounds, assuming contiguous memory.
-    template <typename Bounds>
-    constexpr std::enable_if_t<
-        std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value,
-        typename Bounds::index_type>
-    make_stride(const Bounds& bnd) GSL_NOEXCEPT
-    {
-        auto extents = bnd.index_bounds();
-        typename Bounds::size_type stride[Bounds::rank] = {};
-
-        stride[Bounds::rank - 1] = 1;
-        for (std::size_t i = 1; i < Bounds::rank; ++i) {
-            stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i];
-        }
-        return {stride};
-    }
-
-    template <typename BoundsSrc, typename BoundsDest>
-    void verifyBoundsReshape(const BoundsSrc& src, const BoundsDest& dest)
-    {
-        static_assert(is_bounds<BoundsSrc>::value && is_bounds<BoundsDest>::value,
-                      "The src type and dest type must be bounds");
-        static_assert(std::is_same<typename BoundsSrc::mapping_type, contiguous_mapping_tag>::value,
-                      "The source type must be a contiguous bounds");
-        static_assert(BoundsDest::static_size == dynamic_range ||
-                          BoundsSrc::static_size == dynamic_range ||
-                          BoundsDest::static_size == BoundsSrc::static_size,
-                      "The source bounds must have same size as dest bounds");
-        Expects(src.size() == dest.size());
-    }
-
-} // namespace details
-
-template <typename Span>
-class contiguous_span_iterator;
-template <typename Span>
-class general_span_iterator;
-
-template <std::ptrdiff_t DimSize = dynamic_range>
-struct dim_t
-{
-    static const std::ptrdiff_t value = DimSize;
-};
-template <>
-struct dim_t<dynamic_range>
-{
-    static const std::ptrdiff_t value = dynamic_range;
-    const std::ptrdiff_t dvalue;
-    constexpr dim_t(std::ptrdiff_t size) GSL_NOEXCEPT : dvalue(size) {}
-};
-
-template <std::ptrdiff_t N, class = std::enable_if_t<(N >= 0)>>
-constexpr dim_t<N> dim() GSL_NOEXCEPT
-{
-    return dim_t<N>();
-}
-
-template <std::ptrdiff_t N = dynamic_range, class = std::enable_if_t<N == dynamic_range>>
-constexpr dim_t<N> dim(std::ptrdiff_t n) GSL_NOEXCEPT
-{
-    return dim_t<>(n);
-}
-
-template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range,
-          std::ptrdiff_t... RestDimensions>
-class multi_span;
-template <typename ValueType, std::size_t Rank>
-class strided_span;
-
-namespace details
-{
-    template <typename T, typename = std::true_type>
-    struct SpanTypeTraits
-    {
-        using value_type = T;
-        using size_type = std::size_t;
-    };
-
-    template <typename Traits>
-    struct SpanTypeTraits<Traits, typename std::is_reference<typename Traits::span_traits&>::type>
-    {
-        using value_type = typename Traits::span_traits::value_type;
-        using size_type = typename Traits::span_traits::size_type;
-    };
-
-    template <typename T, std::ptrdiff_t... Ranks>
-    struct SpanArrayTraits
-    {
-        using type = multi_span<T, Ranks...>;
-        using value_type = T;
-        using bounds_type = static_bounds<Ranks...>;
-        using pointer = T*;
-        using reference = T&;
-    };
-    template <typename T, std::ptrdiff_t N, std::ptrdiff_t... Ranks>
-    struct SpanArrayTraits<T[N], Ranks...> : SpanArrayTraits<T, Ranks..., N>
-    {
-    };
-
-    template <typename BoundsType>
-    BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size
-    {
-        Expects(totalSize >= 0 && totalSize <= PTRDIFF_MAX);
-        return BoundsType{totalSize};
-    }
-    template <typename BoundsType>
-    BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size
-    {
-        Expects(BoundsType::static_size <= totalSize);
-        return {};
-    }
-    template <typename BoundsType>
-    BoundsType newBoundsHelper(std::ptrdiff_t totalSize)
-    {
-        static_assert(BoundsType::dynamic_rank <= 1, "dynamic rank must less or equal to 1");
-        return newBoundsHelperImpl<BoundsType>(
-            totalSize, std::integral_constant<bool, BoundsType::dynamic_rank == 1>());
-    }
-
-    struct Sep
-    {
-    };
-
-    template <typename T, typename... Args>
-    T static_as_multi_span_helper(Sep, Args... args)
-    {
-        return T{narrow_cast<typename T::size_type>(args)...};
-    }
-    template <typename T, typename Arg, typename... Args>
-    std::enable_if_t<
-        !std::is_same<Arg, dim_t<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T>
-    static_as_multi_span_helper(Arg, Args... args)
-    {
-        return static_as_multi_span_helper<T>(args...);
-    }
-    template <typename T, typename... Args>
-    T static_as_multi_span_helper(dim_t<dynamic_range> val, Args... args)
-    {
-        return static_as_multi_span_helper<T>(args..., val.dvalue);
-    }
-
-    template <typename... Dimensions>
-    struct static_as_multi_span_static_bounds_helper
-    {
-        using type = static_bounds<(Dimensions::value)...>;
-    };
-
-    template <typename T>
-    struct is_multi_span_oracle : std::false_type
-    {
-    };
-
-    template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    struct is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>>
-        : std::true_type
-    {
-    };
-
-    template <typename ValueType, std::ptrdiff_t Rank>
-    struct is_multi_span_oracle<strided_span<ValueType, Rank>> : std::true_type
-    {
-    };
-
-    template <typename T>
-    struct is_multi_span : is_multi_span_oracle<std::remove_cv_t<T>>
-    {
-    };
-}
-
-template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-class multi_span
-{
-    // TODO do we still need this?
-    template <typename ValueType2, std::ptrdiff_t FirstDimension2,
-              std::ptrdiff_t... RestDimensions2>
-    friend class multi_span;
-
-public:
-    using bounds_type = static_bounds<FirstDimension, RestDimensions...>;
-    static const std::size_t Rank = bounds_type::rank;
-    using size_type = typename bounds_type::size_type;
-    using index_type = typename bounds_type::index_type;
-    using value_type = ValueType;
-    using const_value_type = std::add_const_t<value_type>;
-    using pointer = std::add_pointer_t<value_type>;
-    using reference = std::add_lvalue_reference_t<value_type>;
-    using iterator = contiguous_span_iterator<multi_span>;
-    using const_span = multi_span<const_value_type, FirstDimension, RestDimensions...>;
-    using const_iterator = contiguous_span_iterator<const_span>;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    using sliced_type =
-        std::conditional_t<Rank == 1, value_type, multi_span<value_type, RestDimensions...>>;
-
-private:
-    pointer data_;
-    bounds_type bounds_;
-
-    friend iterator;
-    friend const_iterator;
-
-public:
-    // default constructor - same as constructing from nullptr_t
-    constexpr multi_span() GSL_NOEXCEPT : multi_span(nullptr, bounds_type{})
-    {
-        static_assert(bounds_type::dynamic_rank != 0 ||
-                          (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
-                      "Default construction of multi_span<T> only possible "
-                      "for dynamic or fixed, zero-length spans.");
-    }
-
-    // construct from nullptr - get an empty multi_span
-    constexpr multi_span(std::nullptr_t) GSL_NOEXCEPT : multi_span(nullptr, bounds_type{})
-    {
-        static_assert(bounds_type::dynamic_rank != 0 ||
-                          (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
-                      "nullptr_t construction of multi_span<T> only possible "
-                      "for dynamic or fixed, zero-length spans.");
-    }
-
-    // construct from nullptr with size of 0 (helps with template function calls)
-    template <class IntType, typename = std::enable_if_t<std::is_integral<IntType>::value>>
-    constexpr multi_span(std::nullptr_t, IntType size) GSL_NOEXCEPT
-        : multi_span(nullptr, bounds_type{})
-    {
-        static_assert(bounds_type::dynamic_rank != 0 ||
-                          (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
-                      "nullptr_t construction of multi_span<T> only possible "
-                      "for dynamic or fixed, zero-length spans.");
-        Expects(size == 0);
-    }
-
-    // construct from a single element
-    constexpr multi_span(reference data) GSL_NOEXCEPT : multi_span(&data, bounds_type{1})
-    {
-        static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 ||
-                          bounds_type::static_size == 1,
-                      "Construction from a single element only possible "
-                      "for dynamic or fixed spans of length 0 or 1.");
-    }
-
-    // prevent constructing from temporaries for single-elements
-    constexpr multi_span(value_type&&) = delete;
-
-    // construct from pointer + length
-    constexpr multi_span(pointer ptr, size_type size) GSL_NOEXCEPT
-        : multi_span(ptr, bounds_type{size})
-    {
-    }
-
-    // construct from pointer + length - multidimensional
-    constexpr multi_span(pointer data, bounds_type bounds) GSL_NOEXCEPT : data_(data),
-                                                                          bounds_(std::move(bounds))
-    {
-        Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0);
-    }
-
-    // construct from begin,end pointer pair
-    template <typename Ptr,
-              typename = std::enable_if_t<std::is_convertible<Ptr, pointer>::value &&
-                                          details::LessThan<bounds_type::dynamic_rank, 2>::value>>
-    constexpr multi_span(pointer begin, Ptr end)
-        : multi_span(begin,
-                     details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin))
-    {
-        Expects(begin != nullptr && end != nullptr && begin <= static_cast<pointer>(end));
-    }
-
-    // construct from n-dimensions static array
-    template <typename T, std::size_t N, typename Helper = details::SpanArrayTraits<T, N>>
-    constexpr multi_span(T (&arr)[N])
-        : multi_span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}})
-    {
-        static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value,
-                      "Cannot convert from source type to target multi_span type.");
-        static_assert(std::is_convertible<typename Helper::bounds_type, bounds_type>::value,
-                      "Cannot construct a multi_span from an array with fewer elements.");
-    }
-
-    // construct from n-dimensions dynamic array (e.g. new int[m][4])
-    // (precedence will be lower than the 1-dimension pointer)
-    template <typename T, typename Helper = details::SpanArrayTraits<T, dynamic_range>>
-    constexpr multi_span(T* const& data, size_type size)
-        : multi_span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size})
-    {
-        static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value,
-                      "Cannot convert from source type to target multi_span type.");
-    }
-
-    // construct from std::array
-    template <typename T, std::size_t N>
-    constexpr multi_span(std::array<T, N>& arr)
-        : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
-    {
-        static_assert(
-            std::is_convertible<T(*)[], typename std::remove_const_t<value_type>(*)[]>::value,
-            "Cannot convert from source type to target multi_span type.");
-        static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
-                      "You cannot construct a multi_span from a std::array of smaller size.");
-    }
-
-    // construct from const std::array
-    template <typename T, std::size_t N>
-    constexpr multi_span(const std::array<T, N>& arr)
-        : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
-    {
-        static_assert(std::is_convertible<T(*)[], typename std::remove_const_t<value_type>(*)[]>::value,
-                      "Cannot convert from source type to target multi_span type.");
-        static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
-                      "You cannot construct a multi_span from a std::array of smaller size.");
-    }
-
-    // prevent constructing from temporary std::array
-    template <typename T, std::size_t N>
-    constexpr multi_span(std::array<T, N>&& arr) = delete;
-
-    // construct from containers
-    // future: could use contiguous_iterator_traits to identify only contiguous containers
-    // type-requirements: container must have .size(), operator[] which are value_type compatible
-    template <typename Cont, typename DataType = typename Cont::value_type,
-              typename = std::enable_if_t<
-                  !details::is_multi_span<Cont>::value &&
-                  std::is_convertible<DataType (*)[], value_type (*)[]>::value &&
-                  std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
-                                                     *std::declval<Cont>().data())>,
-                               DataType>::value>>
-    constexpr multi_span(Cont& cont)
-        : multi_span(static_cast<pointer>(cont.data()),
-                     details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size())))
-    {
-    }
-
-    // prevent constructing from temporary containers
-    template <typename Cont, typename DataType = typename Cont::value_type,
-              typename = std::enable_if_t<
-                  !details::is_multi_span<Cont>::value &&
-                  std::is_convertible<DataType (*)[], value_type (*)[]>::value &&
-                  std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
-                                                     *std::declval<Cont>().data())>,
-                               DataType>::value>>
-    explicit constexpr multi_span(Cont&& cont) = delete;
-
-    // construct from a convertible multi_span
-    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
-              typename OtherBounds = static_bounds<OtherDimensions...>,
-              typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value &&
-                                          std::is_convertible<OtherBounds, bounds_type>::value>>
-    constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other) GSL_NOEXCEPT
-        : data_(other.data_),
-          bounds_(other.bounds_)
-    {
-    }
-
-    // trivial copy and move
-    constexpr multi_span(const multi_span&) = default;
-    constexpr multi_span(multi_span&&) = default;
-
-    // trivial assignment
-    constexpr multi_span& operator=(const multi_span&) = default;
-    constexpr multi_span& operator=(multi_span&&) = default;
-
-    // first() - extract the first Count elements into a new multi_span
-    template <std::ptrdiff_t Count>
-    constexpr multi_span<ValueType, Count> first() const GSL_NOEXCEPT
-    {
-        static_assert(Count >= 0, "Count must be >= 0.");
-        static_assert(bounds_type::static_size == dynamic_range ||
-                          Count <= bounds_type::static_size,
-                      "Count is out of bounds.");
-
-        Expects(bounds_type::static_size != dynamic_range || Count <= this->size());
-        return {this->data(), Count};
-    }
-
-    // first() - extract the first count elements into a new multi_span
-    constexpr multi_span<ValueType, dynamic_range> first(size_type count) const GSL_NOEXCEPT
-    {
-        Expects(count >= 0 && count <= this->size());
-        return {this->data(), count};
-    }
-
-    // last() - extract the last Count elements into a new multi_span
-    template <std::ptrdiff_t Count>
-    constexpr multi_span<ValueType, Count> last() const GSL_NOEXCEPT
-    {
-        static_assert(Count >= 0, "Count must be >= 0.");
-        static_assert(bounds_type::static_size == dynamic_range ||
-                          Count <= bounds_type::static_size,
-                      "Count is out of bounds.");
-
-        Expects(bounds_type::static_size != dynamic_range || Count <= this->size());
-        return {this->data() + this->size() - Count, Count};
-    }
-
-    // last() - extract the last count elements into a new multi_span
-    constexpr multi_span<ValueType, dynamic_range> last(size_type count) const GSL_NOEXCEPT
-    {
-        Expects(count >= 0 && count <= this->size());
-        return {this->data() + this->size() - count, count};
-    }
-
-    // subspan() - create a subview of Count elements starting at Offset
-    template <std::ptrdiff_t Offset, std::ptrdiff_t Count>
-    constexpr multi_span<ValueType, Count> subspan() const GSL_NOEXCEPT
-    {
-        static_assert(Count >= 0, "Count must be >= 0.");
-        static_assert(Offset >= 0, "Offset must be >= 0.");
-        static_assert(bounds_type::static_size == dynamic_range ||
-                          ((Offset <= bounds_type::static_size) &&
-                           Count <= bounds_type::static_size - Offset),
-                      "You must describe a sub-range within bounds of the multi_span.");
-
-        Expects(bounds_type::static_size != dynamic_range ||
-                (Offset <= this->size() && Count <= this->size() - Offset));
-        return {this->data() + Offset, Count};
-    }
-
-    // subspan() - create a subview of count elements starting at offset
-    // supplying dynamic_range for count will consume all available elements from offset
-    constexpr multi_span<ValueType, dynamic_range>
-    subspan(size_type offset, size_type count = dynamic_range) const GSL_NOEXCEPT
-    {
-        Expects((offset >= 0 && offset <= this->size()) &&
-                (count == dynamic_range || (count <= this->size() - offset)));
-        return {this->data() + offset, count == dynamic_range ? this->length() - offset : count};
-    }
-
-    // section - creates a non-contiguous, strided multi_span from a contiguous one
-    constexpr strided_span<ValueType, Rank> section(index_type origin,
-                                                    index_type extents) const GSL_NOEXCEPT
-    {
-        size_type size = this->bounds().total_size() - this->bounds().linearize(origin);
-        return {&this->operator[](origin), size,
-                strided_bounds<Rank>{extents, details::make_stride(bounds())}};
-    }
-
-    // length of the multi_span in elements
-    constexpr size_type size() const GSL_NOEXCEPT { return bounds_.size(); }
-
-    // length of the multi_span in elements
-    constexpr size_type length() const GSL_NOEXCEPT { return this->size(); }
-
-    // length of the multi_span in bytes
-    constexpr size_type size_bytes() const GSL_NOEXCEPT
-    {
-        return narrow_cast<size_type>(sizeof(value_type)) * this->size();
-    }
-
-    // length of the multi_span in bytes
-    constexpr size_type length_bytes() const GSL_NOEXCEPT { return this->size_bytes(); }
-
-    constexpr bool empty() const GSL_NOEXCEPT { return this->size() == 0; }
-
-    static constexpr std::size_t rank() { return Rank; }
-
-    template <std::size_t Dim = 0>
-    constexpr size_type extent() const GSL_NOEXCEPT
-    {
-        static_assert(Dim < Rank,
-                      "Dimension should be less than rank (dimension count starts from 0).");
-        return bounds_.template extent<Dim>();
-    }
-
-    template <typename IntType>
-    constexpr size_type extent(IntType dim) const GSL_NOEXCEPT
-    {
-        return bounds_.extent(dim);
-    }
-
-    constexpr bounds_type bounds() const GSL_NOEXCEPT { return bounds_; }
-
-    constexpr pointer data() const GSL_NOEXCEPT { return data_; }
-
-    template <typename FirstIndex>
-    constexpr reference operator()(FirstIndex idx)
-    {
-        return this->operator[](narrow_cast<std::ptrdiff_t>(idx));
-    }
-
-    template <typename FirstIndex, typename... OtherIndices>
-    constexpr reference operator()(FirstIndex firstIndex, OtherIndices... indices)
-    {
-        index_type idx = {narrow_cast<std::ptrdiff_t>(firstIndex),
-                          narrow_cast<std::ptrdiff_t>(indices)...};
-        return this->operator[](idx);
-    }
-
-    constexpr reference operator[](const index_type& idx) const GSL_NOEXCEPT
-    {
-        return data_[bounds_.linearize(idx)];
-    }
-
-    template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>
-    constexpr Ret operator[](size_type idx) const GSL_NOEXCEPT
-    {
-        Expects(idx >= 0 && idx < bounds_.size()); // index is out of bounds of the array
-        const size_type ridx = idx * bounds_.stride();
-
-        // index is out of bounds of the underlying data
-        Expects(ridx < bounds_.total_size());
-        return Ret{data_ + ridx, bounds_.slice()};
-    }
-
-    constexpr iterator begin() const GSL_NOEXCEPT { return iterator{this, true}; }
-
-    constexpr iterator end() const GSL_NOEXCEPT { return iterator{this, false}; }
-
-    constexpr const_iterator cbegin() const GSL_NOEXCEPT
-    {
-        return const_iterator{reinterpret_cast<const const_span*>(this), true};
-    }
-
-    constexpr const_iterator cend() const GSL_NOEXCEPT
-    {
-        return const_iterator{reinterpret_cast<const const_span*>(this), false};
-    }
-
-    constexpr reverse_iterator rbegin() const GSL_NOEXCEPT { return reverse_iterator{end()}; }
-
-    constexpr reverse_iterator rend() const GSL_NOEXCEPT { return reverse_iterator{begin()}; }
-
-    constexpr const_reverse_iterator crbegin() const GSL_NOEXCEPT
-    {
-        return const_reverse_iterator{cend()};
-    }
-
-    constexpr const_reverse_iterator crend() const GSL_NOEXCEPT
-    {
-        return const_reverse_iterator{cbegin()};
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator==(const multi_span<OtherValueType, OtherDimensions...>& other) const GSL_NOEXCEPT
-    {
-        return bounds_.size() == other.bounds_.size() &&
-               (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin()));
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator!=(const multi_span<OtherValueType, OtherDimensions...>& other) const GSL_NOEXCEPT
-    {
-        return !(*this == other);
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator<(const multi_span<OtherValueType, OtherDimensions...>& other) const GSL_NOEXCEPT
-    {
-        return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end());
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator<=(const multi_span<OtherValueType, OtherDimensions...>& other) const GSL_NOEXCEPT
-    {
-        return !(other < *this);
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator>(const multi_span<OtherValueType, OtherDimensions...>& other) const GSL_NOEXCEPT
-    {
-        return (other < *this);
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator>=(const multi_span<OtherValueType, OtherDimensions...>& other) const GSL_NOEXCEPT
-    {
-        return !(*this < other);
-    }
-};
-
-//
-// Free functions for manipulating spans
-//
-
-// reshape a multi_span into a different dimensionality
-// DimCount and Enabled here are workarounds for a bug in MSVC 2015
-template <typename SpanType, typename... Dimensions2, std::size_t DimCount = sizeof...(Dimensions2),
-          bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
-constexpr auto as_multi_span(SpanType s, Dimensions2... dims)
-    -> multi_span<typename SpanType::value_type, Dimensions2::value...>
-{
-    static_assert(details::is_multi_span<SpanType>::value,
-                  "Variadic as_multi_span() is for reshaping existing spans.");
-    using BoundsType =
-        typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type;
-    auto tobounds = details::static_as_multi_span_helper<BoundsType>(dims..., details::Sep{});
-    details::verifyBoundsReshape(s.bounds(), tobounds);
-    return {s.data(), tobounds};
-}
-
-// convert a multi_span<T> to a multi_span<const byte>
-template <typename U, std::ptrdiff_t... Dimensions>
-multi_span<const byte, dynamic_range> as_bytes(multi_span<U, Dimensions...> s) GSL_NOEXCEPT
-{
-    static_assert(std::is_trivial<std::decay_t<U>>::value,
-                  "The value_type of multi_span must be a trivial type.");
-    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
-}
-
-// convert a multi_span<T> to a multi_span<byte> (a writeable byte multi_span)
-// this is not currently a portable function that can be relied upon to work
-// on all implementations. It should be considered an experimental extension
-// to the standard GSL interface.
-template <typename U, std::ptrdiff_t... Dimensions>
-multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) GSL_NOEXCEPT
-{
-    static_assert(std::is_trivial<std::decay_t<U>>::value,
-                  "The value_type of multi_span must be a trivial type.");
-    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
-}
-
-// convert a multi_span<const byte> to a multi_span<const T>
-// this is not currently a portable function that can be relied upon to work
-// on all implementations. It should be considered an experimental extension
-// to the standard GSL interface.
-template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto
-as_multi_span(multi_span<const byte, Dimensions...> s) GSL_NOEXCEPT -> multi_span<
-    const U, static_cast<std::ptrdiff_t>(
-                 multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
-                     ? (static_cast<std::size_t>(
-                            multi_span<const byte, Dimensions...>::bounds_type::static_size) /
-                        sizeof(U))
-                     : dynamic_range)>
-{
-    using ConstByteSpan = multi_span<const byte, Dimensions...>;
-    static_assert(
-        std::is_trivial<std::decay_t<U>>::value &&
-            (ConstByteSpan::bounds_type::static_size == dynamic_range ||
-             ConstByteSpan::bounds_type::static_size % narrow_cast<std::ptrdiff_t>(sizeof(U)) == 0),
-        "Target type must be a trivial type and its size must match the byte array size");
-
-    Expects((s.size_bytes() % narrow_cast<std::ptrdiff_t>(sizeof(U))) == 0 &&
-            (s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))) < PTRDIFF_MAX);
-    return {reinterpret_cast<const U*>(s.data()),
-            s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))};
-}
-
-// convert a multi_span<byte> to a multi_span<T>
-// this is not currently a portable function that can be relied upon to work
-// on all implementations. It should be considered an experimental extension
-// to the standard GSL interface.
-template <typename U, std::ptrdiff_t... Dimensions>
-constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) GSL_NOEXCEPT
-    -> multi_span<U, narrow_cast<std::ptrdiff_t>(
-                         multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
-                             ? static_cast<std::size_t>(
-                                   multi_span<byte, Dimensions...>::bounds_type::static_size) /
-                                   sizeof(U)
-                             : dynamic_range)>
-{
-    using ByteSpan = multi_span<byte, Dimensions...>;
-    static_assert(
-        std::is_trivial<std::decay_t<U>>::value &&
-            (ByteSpan::bounds_type::static_size == dynamic_range ||
-             ByteSpan::bounds_type::static_size % static_cast<std::size_t>(sizeof(U)) == 0),
-        "Target type must be a trivial type and its size must match the byte array size");
-
-    Expects((s.size_bytes() % sizeof(U)) == 0);
-    return {reinterpret_cast<U*>(s.data()),
-            s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))};
-}
-
-template <typename T, std::ptrdiff_t... Dimensions>
-constexpr auto as_multi_span(T* const& ptr, dim_t<Dimensions>... args)
-    -> multi_span<std::remove_all_extents_t<T>, Dimensions...>
-{
-    return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr),
-            details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args...,
-                                                                               details::Sep{})};
-}
-
-template <typename T>
-constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) ->
-    typename details::SpanArrayTraits<T, dynamic_range>::type
-{
-    return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len};
-}
-
-template <typename T, std::size_t N>
-constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type
-{
-    return {arr};
-}
-
-template <typename T, std::size_t N>
-constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr)
-{
-    return {arr};
-}
-
-template <typename T, std::size_t N>
-constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete;
-
-template <typename T, std::size_t N>
-constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr)
-{
-    return {arr};
-}
-
-template <typename T>
-constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end)
-{
-    return {begin, end};
-}
-
-template <typename Cont>
-constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t<
-    !details::is_multi_span<std::decay_t<Cont>>::value,
-    multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
-{
-    Expects(arr.size() < PTRDIFF_MAX);
-    return {arr.data(), narrow_cast<std::ptrdiff_t>(arr.size())};
-}
-
-template <typename Cont>
-constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t<
-    !details::is_multi_span<std::decay_t<Cont>>::value,
-    multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;
-
-// from basic_string which doesn't have nonconst .data() member like other contiguous containers
-template <typename CharT, typename Traits, typename Allocator>
-constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str)
-    -> multi_span<CharT, dynamic_range>
-{
-    Expects(str.size() < PTRDIFF_MAX);
-    return {&str[0], narrow_cast<std::ptrdiff_t>(str.size())};
-}
-
-// strided_span is an extension that is not strictly part of the GSL at this time.
-// It is kept here while the multidimensional interface is still being defined.
-template <typename ValueType, std::size_t Rank>
-class strided_span
-{
-public:
-    using bounds_type = strided_bounds<Rank>;
-    using size_type = typename bounds_type::size_type;
-    using index_type = typename bounds_type::index_type;
-    using value_type = ValueType;
-    using const_value_type = std::add_const_t<value_type>;
-    using pointer = std::add_pointer_t<value_type>;
-    using reference = std::add_lvalue_reference_t<value_type>;
-    using iterator = general_span_iterator<strided_span>;
-    using const_strided_span = strided_span<const_value_type, Rank>;
-    using const_iterator = general_span_iterator<const_strided_span>;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    using sliced_type =
-        std::conditional_t<Rank == 1, value_type, strided_span<value_type, Rank - 1>>;
-
-private:
-    pointer data_;
-    bounds_type bounds_;
-
-    friend iterator;
-    friend const_iterator;
-    template <typename OtherValueType, std::size_t OtherRank>
-    friend class strided_span;
-
-public:
-    // from raw data
-    constexpr strided_span(pointer ptr, size_type size, bounds_type bounds)
-        : data_(ptr), bounds_(std::move(bounds))
-    {
-        Expects((bounds_.size() > 0 && ptr != nullptr) || bounds_.size() == 0);
-        // Bounds cross data boundaries
-        Expects(this->bounds().total_size() <= size);
-        (void) size;
-    }
-
-    // from static array of size N
-    template <size_type N>
-    constexpr strided_span(value_type (&values)[N], bounds_type bounds)
-        : strided_span(values, N, std::move(bounds))
-    {
-    }
-
-    // from array view
-    template <typename OtherValueType, std::ptrdiff_t... Dimensions,
-              bool Enabled1 = (sizeof...(Dimensions) == Rank),
-              bool Enabled2 = std::is_convertible<OtherValueType*, ValueType*>::value,
-              typename = std::enable_if_t<Enabled1 && Enabled2>>
-    constexpr strided_span(multi_span<OtherValueType, Dimensions...> av, bounds_type bounds)
-        : strided_span(av.data(), av.bounds().total_size(), std::move(bounds))
-    {
-    }
-
-    // convertible
-    template <typename OtherValueType, typename = std::enable_if_t<std::is_convertible<
-                                           OtherValueType (*)[], value_type (*)[]>::value>>
-    constexpr strided_span(const strided_span<OtherValueType, Rank>& other)
-        : data_(other.data_), bounds_(other.bounds_)
-    {
-    }
-
-    // convert from bytes
-    template <typename OtherValueType>
-    constexpr strided_span<
-        typename std::enable_if<std::is_same<value_type, const byte>::value, OtherValueType>::type,
-        Rank>
-    as_strided_span() const
-    {
-        static_assert((sizeof(OtherValueType) >= sizeof(value_type)) &&
-                          (sizeof(OtherValueType) % sizeof(value_type) == 0),
-                      "OtherValueType should have a size to contain a multiple of ValueTypes");
-        auto d = narrow_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type));
-
-        size_type size = this->bounds().total_size() / d;
-        return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())),
-                size,
-                bounds_type{resize_extent(this->bounds().index_bounds(), d),
-                            resize_stride(this->bounds().strides(), d)}};
-    }
-
-    constexpr strided_span section(index_type origin, index_type extents) const
-    {
-        size_type size = this->bounds().total_size() - this->bounds().linearize(origin);
-        return {&this->operator[](origin), size,
-                bounds_type{extents, details::make_stride(bounds())}};
-    }
-
-    constexpr reference operator[](const index_type& idx) const
-    {
-        return data_[bounds_.linearize(idx)];
-    }
-
-    template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>
-    constexpr Ret operator[](size_type idx) const
-    {
-        Expects(idx < bounds_.size()); // index is out of bounds of the array
-        const size_type ridx = idx * bounds_.stride();
-
-        // index is out of bounds of the underlying data
-        Expects(ridx < bounds_.total_size());
-        return {data_ + ridx, bounds_.slice().total_size(), bounds_.slice()};
-    }
-
-    constexpr bounds_type bounds() const GSL_NOEXCEPT { return bounds_; }
-
-    template <std::size_t Dim = 0>
-    constexpr size_type extent() const GSL_NOEXCEPT
-    {
-        static_assert(Dim < Rank,
-                      "dimension should be less than Rank (dimension count starts from 0)");
-        return bounds_.template extent<Dim>();
-    }
-
-    constexpr size_type size() const GSL_NOEXCEPT { return bounds_.size(); }
-
-    constexpr pointer data() const GSL_NOEXCEPT { return data_; }
-
-    constexpr explicit operator bool() const GSL_NOEXCEPT { return data_ != nullptr; }
-
-    constexpr iterator begin() const { return iterator{this, true}; }
-
-    constexpr iterator end() const { return iterator{this, false}; }
-
-    constexpr const_iterator cbegin() const
-    {
-        return const_iterator{reinterpret_cast<const const_strided_span*>(this), true};
-    }
-
-    constexpr const_iterator cend() const
-    {
-        return const_iterator{reinterpret_cast<const const_strided_span*>(this), false};
-    }
-
-    constexpr reverse_iterator rbegin() const { return reverse_iterator{end()}; }
-
-    constexpr reverse_iterator rend() const { return reverse_iterator{begin()}; }
-
-    constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator{cend()}; }
-
-    constexpr const_reverse_iterator crend() const { return const_reverse_iterator{cbegin()}; }
-
-    template <typename OtherValueType, std::ptrdiff_t OtherRank,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator==(const strided_span<OtherValueType, OtherRank>& other) const GSL_NOEXCEPT
-    {
-        return bounds_.size() == other.bounds_.size() &&
-               (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin()));
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t OtherRank,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator!=(const strided_span<OtherValueType, OtherRank>& other) const GSL_NOEXCEPT
-    {
-        return !(*this == other);
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t OtherRank,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator<(const strided_span<OtherValueType, OtherRank>& other) const GSL_NOEXCEPT
-    {
-        return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end());
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t OtherRank,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator<=(const strided_span<OtherValueType, OtherRank>& other) const GSL_NOEXCEPT
-    {
-        return !(other < *this);
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t OtherRank,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator>(const strided_span<OtherValueType, OtherRank>& other) const GSL_NOEXCEPT
-    {
-        return (other < *this);
-    }
-
-    template <typename OtherValueType, std::ptrdiff_t OtherRank,
-              typename = std::enable_if_t<std::is_same<
-                  std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool
-    operator>=(const strided_span<OtherValueType, OtherRank>& other) const GSL_NOEXCEPT
-    {
-        return !(*this < other);
-    }
-
-private:
-    static index_type resize_extent(const index_type& extent, std::ptrdiff_t d)
-    {
-        // The last dimension of the array needs to contain a multiple of new type elements
-        Expects(extent[Rank - 1] >= d && (extent[Rank - 1] % d == 0));
-
-        index_type ret = extent;
-        ret[Rank - 1] /= d;
-
-        return ret;
-    }
-
-    template <bool Enabled = (Rank == 1), typename = std::enable_if_t<Enabled>>
-    static index_type resize_stride(const index_type& strides, std::ptrdiff_t, void* = nullptr)
-    {
-        // Only strided arrays with regular strides can be resized
-        Expects(strides[Rank - 1] == 1);
-
-        return strides;
-    }
-
-    template <bool Enabled = (Rank > 1), typename = std::enable_if_t<Enabled>>
-    static index_type resize_stride(const index_type& strides, std::ptrdiff_t d)
-    {
-        // Only strided arrays with regular strides can be resized
-        Expects(strides[Rank - 1] == 1);
-        // The strides must have contiguous chunks of
-        // memory that can contain a multiple of new type elements
-        Expects(strides[Rank - 2] >= d && (strides[Rank - 2] % d == 0));
-
-        for (std::size_t i = Rank - 1; i > 0; --i) {
-            // Only strided arrays with regular strides can be resized
-            Expects((strides[i - 1] >= strides[i]) && (strides[i - 1] % strides[i] == 0));
-        }
-
-        index_type ret = strides / d;
-        ret[Rank - 1] = 1;
-
-        return ret;
-    }
-};
-
-template <class Span>
-class contiguous_span_iterator
-{
-public:
-    using iterator_category = std::random_access_iterator_tag;
-    using value_type = typename Span::value_type;
-    using difference_type = std::ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
-
-private:
-    template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    friend class multi_span;
-
-    pointer data_;
-    const Span* m_validator;
-    void validateThis() const
-    {
-        // iterator is out of range of the array
-        Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size());
-    }
-    contiguous_span_iterator(const Span* container, bool isbegin)
-        : data_(isbegin ? container->data_ : container->data_ + container->size())
-        , m_validator(container)
-    {
-    }
-
-public:
-    reference operator*() const GSL_NOEXCEPT
-    {
-        validateThis();
-        return *data_;
-    }
-    pointer operator->() const GSL_NOEXCEPT
-    {
-        validateThis();
-        return data_;
-    }
-    contiguous_span_iterator& operator++() GSL_NOEXCEPT
-    {
-        ++data_;
-        return *this;
-    }
-    contiguous_span_iterator operator++(int) GSL_NOEXCEPT
-    {
-        auto ret = *this;
-        ++(*this);
-        return ret;
-    }
-    contiguous_span_iterator& operator--() GSL_NOEXCEPT
-    {
-        --data_;
-        return *this;
-    }
-    contiguous_span_iterator operator--(int) GSL_NOEXCEPT
-    {
-        auto ret = *this;
-        --(*this);
-        return ret;
-    }
-    contiguous_span_iterator operator+(difference_type n) const GSL_NOEXCEPT
-    {
-        contiguous_span_iterator ret{*this};
-        return ret += n;
-    }
-    contiguous_span_iterator& operator+=(difference_type n) GSL_NOEXCEPT
-    {
-        data_ += n;
-        return *this;
-    }
-    contiguous_span_iterator operator-(difference_type n) const GSL_NOEXCEPT
-    {
-        contiguous_span_iterator ret{*this};
-        return ret -= n;
-    }
-    contiguous_span_iterator& operator-=(difference_type n) GSL_NOEXCEPT { return *this += -n; }
-    difference_type operator-(const contiguous_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        Expects(m_validator == rhs.m_validator);
-        return data_ - rhs.data_;
-    }
-    reference operator[](difference_type n) const GSL_NOEXCEPT { return *(*this + n); }
-    bool operator==(const contiguous_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        Expects(m_validator == rhs.m_validator);
-        return data_ == rhs.data_;
-    }
-    bool operator!=(const contiguous_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return !(*this == rhs);
-    }
-    bool operator<(const contiguous_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        Expects(m_validator == rhs.m_validator);
-        return data_ < rhs.data_;
-    }
-    bool operator<=(const contiguous_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return !(rhs < *this);
-    }
-    bool operator>(const contiguous_span_iterator& rhs) const GSL_NOEXCEPT { return rhs < *this; }
-    bool operator>=(const contiguous_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        return !(rhs > *this);
-    }
-    void swap(contiguous_span_iterator& rhs) GSL_NOEXCEPT
-    {
-        std::swap(data_, rhs.data_);
-        std::swap(m_validator, rhs.m_validator);
-    }
-};
-
-template <typename Span>
-contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>::difference_type n,
-                                         const contiguous_span_iterator<Span>& rhs) GSL_NOEXCEPT
-{
-    return rhs + n;
-}
-
-template <typename Span>
-class general_span_iterator
-{
-public:
-    using iterator_category = std::random_access_iterator_tag;
-    using value_type = typename Span::value_type;
-    using difference_type = std::ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
-
-private:
-    template <typename ValueType, std::size_t Rank>
-    friend class strided_span;
-
-    const Span* m_container;
-    typename Span::bounds_type::iterator m_itr;
-    general_span_iterator(const Span* container, bool isbegin)
-        : m_container(container)
-        , m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end())
-    {
-    }
-
-public:
-    reference operator*() GSL_NOEXCEPT { return (*m_container)[*m_itr]; }
-    pointer operator->() GSL_NOEXCEPT { return &(*m_container)[*m_itr]; }
-    general_span_iterator& operator++() GSL_NOEXCEPT
-    {
-        ++m_itr;
-        return *this;
-    }
-    general_span_iterator operator++(int) GSL_NOEXCEPT
-    {
-        auto ret = *this;
-        ++(*this);
-        return ret;
-    }
-    general_span_iterator& operator--() GSL_NOEXCEPT
-    {
-        --m_itr;
-        return *this;
-    }
-    general_span_iterator operator--(int) GSL_NOEXCEPT
-    {
-        auto ret = *this;
-        --(*this);
-        return ret;
-    }
-    general_span_iterator operator+(difference_type n) const GSL_NOEXCEPT
-    {
-        general_span_iterator ret{*this};
-        return ret += n;
-    }
-    general_span_iterator& operator+=(difference_type n) GSL_NOEXCEPT
-    {
-        m_itr += n;
-        return *this;
-    }
-    general_span_iterator operator-(difference_type n) const GSL_NOEXCEPT
-    {
-        general_span_iterator ret{*this};
-        return ret -= n;
-    }
-    general_span_iterator& operator-=(difference_type n) GSL_NOEXCEPT { return *this += -n; }
-    difference_type operator-(const general_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        Expects(m_container == rhs.m_container);
-        return m_itr - rhs.m_itr;
-    }
-    value_type operator[](difference_type n) const GSL_NOEXCEPT { return (*m_container)[m_itr[n]]; }
-
-    bool operator==(const general_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        Expects(m_container == rhs.m_container);
-        return m_itr == rhs.m_itr;
-    }
-    bool operator!=(const general_span_iterator& rhs) const GSL_NOEXCEPT { return !(*this == rhs); }
-    bool operator<(const general_span_iterator& rhs) const GSL_NOEXCEPT
-    {
-        Expects(m_container == rhs.m_container);
-        return m_itr < rhs.m_itr;
-    }
-    bool operator<=(const general_span_iterator& rhs) const GSL_NOEXCEPT { return !(rhs < *this); }
-    bool operator>(const general_span_iterator& rhs) const GSL_NOEXCEPT { return rhs < *this; }
-    bool operator>=(const general_span_iterator& rhs) const GSL_NOEXCEPT { return !(rhs > *this); }
-    void swap(general_span_iterator& rhs) GSL_NOEXCEPT
-    {
-        std::swap(m_itr, rhs.m_itr);
-        std::swap(m_container, rhs.m_container);
-    }
-};
-
-template <typename Span>
-general_span_iterator<Span> operator+(typename general_span_iterator<Span>::difference_type n,
-                                      const general_span_iterator<Span>& rhs) GSL_NOEXCEPT
-{
-    return rhs + n;
-}
-
-} // namespace gsl
-
-#undef GSL_NOEXCEPT
-
-#ifdef _MSC_VER
-#if _MSC_VER < 1910
-
-#undef constexpr
-#pragma pop_macro("constexpr")
-#endif // _MSC_VER < 1910
-
-#pragma warning(pop)
-
-#endif // _MSC_VER
-
-#if __GNUC__ > 6 
-#pragma GCC diagnostic pop
-#endif // __GNUC__ > 6
-
-#endif // GSL_MULTI_SPAN_H
diff --git a/inst/include/gsl/pointers b/inst/include/gsl/pointers
deleted file mode 100644
index 69499d6..0000000
--- a/inst/include/gsl/pointers
+++ /dev/null
@@ -1,193 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_POINTERS_H
-#define GSL_POINTERS_H
-
-#include <gsl/gsl_assert>  // for Ensures, Expects
-
-#include <algorithm>    // for forward
-#include <iosfwd>       // for ptrdiff_t, nullptr_t, ostream, size_t
-#include <memory>       // for shared_ptr, unique_ptr
-#include <system_error> // for hash
-#include <type_traits>  // for enable_if_t, is_convertible, is_assignable
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif                          // defined(_MSC_VER) && _MSC_VER < 1910
-
-namespace gsl
-{
-
-//
-// GSL.owner: ownership pointers
-//
-using std::unique_ptr;
-using std::shared_ptr;
-
-//
-// owner
-//
-// owner<T> is designed as a bridge for code that must deal directly with owning pointers for some reason
-//
-// T must be a pointer type
-// - disallow construction from any type other than pointer type
-//
-template <class T, class = std::enable_if_t<std::is_pointer<T>::value>>
-using owner = T;
-
-//
-// not_null
-//
-// Restricts a pointer or smart pointer to only hold non-null values.
-//
-// Has zero size overhead over T.
-//
-// If T is a pointer (i.e. T == U*) then
-// - allow construction from U*
-// - disallow construction from nullptr_t
-// - disallow default construction
-// - ensure construction from null U* fails
-// - allow implicit conversion to U*
-//
-template <class T>
-class not_null
-{
-public:
-    static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr.");
-
-    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr explicit not_null(U&& u) : ptr_(std::forward<U>(u))
-    {
-        Expects(ptr_ != nullptr);
-    }
-
-    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
-    constexpr explicit not_null(T u) : ptr_(u)
-    {
-        Expects(ptr_ != nullptr);
-    }
-
-    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr not_null(const not_null<U>& other) : not_null(other.get())
-    {
-    }
-
-    not_null(not_null&& other) = default;
-    not_null(const not_null& other) = default;
-    not_null& operator=(const not_null& other) = default;
-
-    constexpr T get() const
-    {
-        Ensures(ptr_ != nullptr);
-        return ptr_;
-    }
-
-    constexpr operator T() const { return get(); }
-    constexpr T operator->() const { return get(); }
-    constexpr decltype(auto) operator*() const { return *get(); } 
-
-    // prevents compilation when someone attempts to assign a null pointer constant
-    not_null(std::nullptr_t) = delete;
-    not_null& operator=(std::nullptr_t) = delete;
-
-    // unwanted operators...pointers only point to single objects!
-    not_null& operator++() = delete;
-    not_null& operator--() = delete;
-    not_null operator++(int) = delete;
-    not_null operator--(int) = delete;
-    not_null& operator+=(std::ptrdiff_t) = delete;
-    not_null& operator-=(std::ptrdiff_t) = delete;
-    void operator[](std::ptrdiff_t) const = delete;
-
-private:
-    T ptr_;
-};
-
-template <class T>
-std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
-{
-    os << val.get();
-    return os;
-}
-
-template <class T, class U>
-auto operator==(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() == rhs.get())
-{
-    return lhs.get() == rhs.get();
-}
-
-template <class T, class U>
-auto operator!=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() != rhs.get())
-{
-    return lhs.get() != rhs.get();
-}
-
-template <class T, class U>
-auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() < rhs.get())
-{
-    return lhs.get() < rhs.get();
-}
-
-template <class T, class U>
-auto operator<=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() <= rhs.get())
-{
-    return lhs.get() <= rhs.get();
-}
-
-template <class T, class U>
-auto operator>(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() > rhs.get())
-{
-    return lhs.get() > rhs.get();
-}
-
-template <class T, class U>
-auto operator>=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() >= rhs.get())
-{
-    return lhs.get() >= rhs.get();
-}
-
-// more unwanted operators
-template <class T, class U>
-std::ptrdiff_t operator-(const not_null<T>&, const not_null<U>&) = delete;
-template <class T>
-not_null<T> operator-(const not_null<T>&, std::ptrdiff_t) = delete;
-template <class T>
-not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete;
-template <class T>
-not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete;
-
-} // namespace gsl
-
-namespace std
-{
-template <class T>
-struct hash<gsl::not_null<T>>
-{
-    std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); }
-};
-
-} // namespace std
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // defined(_MSC_VER) && _MSC_VER < 1910
-
-#endif // GSL_POINTERS_H
diff --git a/inst/include/gsl/span b/inst/include/gsl/span
deleted file mode 100644
index 2fa9cc5..0000000
--- a/inst/include/gsl/span
+++ /dev/null
@@ -1,766 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_SPAN_H
-#define GSL_SPAN_H
-
-#include <gsl/gsl_assert> // for Expects
-#include <gsl/gsl_byte>   // for byte
-#include <gsl/gsl_util>   // for narrow_cast, narrow
-
-#include <algorithm> // for lexicographical_compare
-#include <array>     // for array
-#include <cstddef>   // for ptrdiff_t, size_t, nullptr_t
-#include <iterator>  // for reverse_iterator, distance, random_access_...
-#include <limits>
-#include <stdexcept>
-#include <type_traits> // for enable_if_t, declval, is_convertible, inte...
-#include <utility>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-
-// turn off some warnings that are noisy about our Expects statements
-#pragma warning(disable : 4127) // conditional expression is constant
-#pragma warning(disable : 4702) // unreachable code
-
-// blanket turn off warnings from CppCoreCheck for now
-// so people aren't annoyed by them when running the tool.
-// more targeted suppressions will be added in a future update to the GSL
-#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495)
-
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
-
-#endif                          // _MSC_VER < 1910
-#else                           // _MSC_VER
-
-// See if we have enough C++17 power to use a static constexpr data member
-// without needing an out-of-line definition
-#if !(defined(__cplusplus) && (__cplusplus >= 201703L))
-#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
-#endif // !(defined(__cplusplus) && (__cplusplus >= 201703L))
-
-#endif                          // _MSC_VER
-
-// GCC 7 does not like the signed unsigned missmatch (size_t ptrdiff_t)
-// While there is a conversion from signed to unsigned, it happens at 
-// compiletime, so the compiler wouldn't have to warn indiscriminently, but 
-// could check if the source value actually doesn't fit into the target type 
-// and only warn in those cases.
-#if __GNUC__ > 6
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#endif
-
-namespace gsl
-{
-
-// [views.constants], constants
-constexpr const std::ptrdiff_t dynamic_extent = -1;
-
-template <class ElementType, std::ptrdiff_t Extent = dynamic_extent>
-class span;
-
-// implementation details
-namespace details
-{
-    template <class T>
-    struct is_span_oracle : std::false_type
-    {
-    };
-
-    template <class ElementType, std::ptrdiff_t Extent>
-    struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
-    {
-    };
-
-    template <class T>
-    struct is_span : public is_span_oracle<std::remove_cv_t<T>>
-    {
-    };
-
-    template <class T>
-    struct is_std_array_oracle : std::false_type
-    {
-    };
-
-    template <class ElementType, std::size_t Extent>
-    struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type
-    {
-    };
-
-    template <class T>
-    struct is_std_array : public is_std_array_oracle<std::remove_cv_t<T>>
-    {
-    };
-
-    template <std::ptrdiff_t From, std::ptrdiff_t To>
-    struct is_allowed_extent_conversion
-        : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent ||
-                                                  To == gsl::dynamic_extent>
-    {
-    };
-
-    template <class From, class To>
-    struct is_allowed_element_type_conversion
-        : public std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value>
-    {
-    };
-
-    template <class Span, bool IsConst>
-    class span_iterator
-    {
-        using element_type_ = typename Span::element_type;
-
-    public:
-
-#ifdef _MSC_VER
-        // Tell Microsoft standard library that span_iterators are checked.
-        using _Unchecked_type = typename Span::pointer;
-#endif
-
-        using iterator_category = std::random_access_iterator_tag;
-        using value_type = std::remove_cv_t<element_type_>;
-        using difference_type = typename Span::index_type;
-
-        using reference = std::conditional_t<IsConst, const element_type_, element_type_>&;
-        using pointer = std::add_pointer_t<reference>;
-
-        span_iterator() = default;
-
-        constexpr span_iterator(const Span* span, typename Span::index_type idx) noexcept
-            : span_(span), index_(idx)
-        {}
-
-        friend span_iterator<Span, true>;
-        template<bool B, std::enable_if_t<!B && IsConst>* = nullptr>
-        constexpr span_iterator(const span_iterator<Span, B>& other) noexcept
-            : span_iterator(other.span_, other.index_)
-        {
-        }
-
-        constexpr reference operator*() const
-        {
-            Expects(index_ != span_->size());
-            return *(span_->data() + index_);
-        }
-
-        constexpr pointer operator->() const
-        {
-            Expects(index_ != span_->size());
-            return span_->data() + index_;
-        }
-
-        constexpr span_iterator& operator++()
-        {
-            Expects(0 <= index_ && index_ != span_->size());
-            ++index_;
-            return *this;
-        }
-
-        constexpr span_iterator operator++(int)
-        {
-            auto ret = *this;
-            ++(*this);
-            return ret;
-        }
-
-        constexpr span_iterator& operator--()
-        {
-            Expects(index_ != 0 && index_ <= span_->size());
-            --index_;
-            return *this;
-        }
-
-        constexpr span_iterator operator--(int)
-        {
-            auto ret = *this;
-            --(*this);
-            return ret;
-        }
-
-        constexpr span_iterator operator+(difference_type n) const
-        {
-            auto ret = *this;
-            return ret += n;
-        }
-
-        friend constexpr span_iterator operator+(difference_type n, span_iterator const& rhs)
-        {
-            return rhs + n;
-        }
-
-        constexpr span_iterator& operator+=(difference_type n)
-        {
-            Expects((index_ + n) >= 0 && (index_ + n) <= span_->size());
-            index_ += n;
-            return *this;
-        }
-
-        constexpr span_iterator operator-(difference_type n) const
-        {
-            auto ret = *this;
-            return ret -= n;
-        }
-
-        constexpr span_iterator& operator-=(difference_type n) { return *this += -n; }
-
-        constexpr difference_type operator-(span_iterator rhs) const
-        {
-            Expects(span_ == rhs.span_);
-            return index_ - rhs.index_;
-        }
-
-        constexpr reference operator[](difference_type n) const
-        {
-            return *(*this + n);
-        }
-
-        constexpr friend bool operator==(span_iterator lhs,
-                                         span_iterator rhs) noexcept
-        {
-            return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_;
-        }
-
-        constexpr friend bool operator!=(span_iterator lhs,
-                                         span_iterator rhs) noexcept
-        {
-            return !(lhs == rhs);
-        }
-
-        constexpr friend bool operator<(span_iterator lhs,
-                                        span_iterator rhs) noexcept
-        {
-            return lhs.index_ < rhs.index_;
-        }
-
-        constexpr friend bool operator<=(span_iterator lhs,
-                                         span_iterator rhs) noexcept
-        {
-            return !(rhs < lhs);
-        }
-
-        constexpr friend bool operator>(span_iterator lhs,
-                                        span_iterator rhs) noexcept
-        {
-            return rhs < lhs;
-        }
-
-        constexpr friend bool operator>=(span_iterator lhs,
-                                         span_iterator rhs) noexcept
-        {
-            return !(rhs > lhs);
-        }
-
-#ifdef _MSC_VER
-        // MSVC++ iterator debugging support; allows STL algorithms in 15.8+
-        // to unwrap span_iterator to a pointer type after a range check in STL
-        // algorithm calls
-        friend constexpr void _Verify_range(span_iterator lhs,
-                                            span_iterator rhs) noexcept
-        {   // test that [lhs, rhs) forms a valid range inside an STL algorithm
-            Expects(lhs.span_ == rhs.span_ // range spans have to match
-                && lhs.index_ <= rhs.index_); // range must not be transposed
-        }
-
-        constexpr void _Verify_offset(const difference_type n) const noexcept
-        {   // test that the iterator *this + n is a valid range in an STL
-            // algorithm call
-            Expects((index_ + n) >= 0 && (index_ + n) <= span_->size());
-        }
-
-        constexpr pointer _Unwrapped() const noexcept
-        {   // after seeking *this to a high water mark, or using one of the
-            // _Verify_xxx functions above, unwrap this span_iterator to a raw
-            // pointer
-            return span_->data() + index_;
-        }
-
-        // Tell the STL that span_iterator should not be unwrapped if it can't
-        // validate in advance, even in release / optimized builds:
-#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
-        static constexpr const bool _Unwrap_when_unverified = false;
-#else
-        static constexpr bool _Unwrap_when_unverified = false;
-#endif
-        constexpr void _Seek_to(const pointer p) noexcept
-        {   // adjust the position of *this to previously verified location p
-            // after _Unwrapped
-            index_ = p - span_->data();
-        }
-#endif
-
-    protected:
-        const Span* span_ = nullptr;
-        std::ptrdiff_t index_ = 0;
-    };
-
-    template <std::ptrdiff_t Ext>
-    class extent_type
-    {
-    public:
-        using index_type = std::ptrdiff_t;
-
-        static_assert(Ext >= 0, "A fixed-size span must be >= 0 in size.");
-
-        constexpr extent_type() noexcept {}
-
-        template <index_type Other>
-        constexpr extent_type(extent_type<Other> ext)
-        {
-            static_assert(Other == Ext || Other == dynamic_extent,
-                          "Mismatch between fixed-size extent and size of initializing data.");
-            Expects(ext.size() == Ext);
-        }
-
-        constexpr extent_type(index_type size) { Expects(size == Ext); }
-
-        constexpr index_type size() const noexcept { return Ext; }
-    };
-
-    template <>
-    class extent_type<dynamic_extent>
-    {
-    public:
-        using index_type = std::ptrdiff_t;
-
-        template <index_type Other>
-        explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
-        {
-        }
-
-        explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); }
-
-        constexpr index_type size() const noexcept { return size_; }
-
-    private:
-        index_type size_;
-    };
-
-    template <class ElementType, std::ptrdiff_t Extent, std::ptrdiff_t Offset, std::ptrdiff_t Count>
-    struct calculate_subspan_type
-    {
-      using type = span<ElementType, Count != dynamic_extent ? Count : (Extent != dynamic_extent ? Extent - Offset : Extent)>;
-    };
-} // namespace details
-
-// [span], class template span
-template <class ElementType, std::ptrdiff_t Extent>
-class span
-{
-public:
-    // constants and types
-    using element_type = ElementType;
-    using value_type = std::remove_cv_t<ElementType>;
-    using index_type = std::ptrdiff_t;
-    using pointer = element_type*;
-    using reference = element_type&;
-
-    using iterator = details::span_iterator<span<ElementType, Extent>, false>;
-    using const_iterator = details::span_iterator<span<ElementType, Extent>, true>;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-    using size_type = index_type;
-
-#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
-    static constexpr const index_type extent { Extent };
-#else
-    static constexpr index_type extent { Extent };
-#endif
-
-    // [span.cons], span constructors, copy, assignment, and destructor
-    template <bool Dependent = false,
-              // "Dependent" is needed to make "std::enable_if_t<Dependent || Extent <= 0>" SFINAE,
-              // since "std::enable_if_t<Extent <= 0>" is ill-formed when Extent is greater than 0.
-              class = std::enable_if_t<(Dependent || Extent <= 0)>>
-    constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())
-    {
-    }
-
-    constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {}
-
-    constexpr span(pointer firstElem, pointer lastElem)
-        : storage_(firstElem, std::distance(firstElem, lastElem))
-    {
-    }
-
-    template <std::size_t N>
-    constexpr span(element_type (&arr)[N]) noexcept
-        : storage_(KnownNotNull{&arr[0]}, details::extent_type<N>())
-    {
-    }
-
-    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
-    constexpr span(std::array<ArrayElementType, N>& arr) noexcept
-        : storage_(&arr[0], details::extent_type<N>())
-    {
-    }
-
-    template <std::size_t N>
-    constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept
-        : storage_(&arr[0], details::extent_type<N>())
-    {
-    }
-
-    // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement
-    // on Container to be a contiguous sequence container.
-    template <class Container,
-              class = std::enable_if_t<
-                  !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
-                  std::is_convertible<typename Container::pointer, pointer>::value &&
-                  std::is_convertible<typename Container::pointer,
-                                      decltype(std::declval<Container>().data())>::value>>
-    constexpr span(Container& cont) : span(cont.data(), narrow<index_type>(cont.size()))
-    {
-    }
-
-    template <class Container,
-              class = std::enable_if_t<
-                  std::is_const<element_type>::value && !details::is_span<Container>::value &&
-                  std::is_convertible<typename Container::pointer, pointer>::value &&
-                  std::is_convertible<typename Container::pointer,
-                                      decltype(std::declval<Container>().data())>::value>>
-    constexpr span(const Container& cont) : span(cont.data(), narrow<index_type>(cont.size()))
-    {
-    }
-
-    constexpr span(const span& other) noexcept = default;
-
-    template <
-        class OtherElementType, std::ptrdiff_t OtherExtent,
-        class = std::enable_if_t<
-            details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
-            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
-    constexpr span(const span<OtherElementType, OtherExtent>& other)
-        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
-    {
-    }
-
-    ~span() noexcept = default;
-    constexpr span& operator=(const span& other) noexcept = default;
-
-    // [span.sub], span subviews
-    template <std::ptrdiff_t Count>
-    constexpr span<element_type, Count> first() const
-    {
-        Expects(Count >= 0 && Count <= size());
-        return {data(), Count};
-    }
-
-    template <std::ptrdiff_t Count>
-    constexpr span<element_type, Count> last() const
-    {
-        Expects(Count >= 0 && size() - Count >= 0);
-        return {data() + (size() - Count), Count};
-    }
-
-    template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent>
-    constexpr auto subspan() const -> typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
-    {
-        Expects((Offset >= 0 && size() - Offset >= 0) &&
-                (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size())));
-
-        return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
-    }
-
-    constexpr span<element_type, dynamic_extent> first(index_type count) const
-    {
-        Expects(count >= 0 && count <= size());
-        return {data(), count};
-    }
-
-    constexpr span<element_type, dynamic_extent> last(index_type count) const
-    {
-        return make_subspan(size() - count, dynamic_extent, subspan_selector<Extent>{});
-    }
-
-    constexpr span<element_type, dynamic_extent> subspan(index_type offset,
-                                                         index_type count = dynamic_extent) const
-    {
-        return make_subspan(offset, count, subspan_selector<Extent>{});
-    }
-
-
-    // [span.obs], span observers
-    constexpr index_type size() const noexcept { return storage_.size(); }
-    constexpr index_type size_bytes() const noexcept
-    {
-        return size() * narrow_cast<index_type>(sizeof(element_type));
-    }
-    constexpr bool empty() const noexcept { return size() == 0; }
-
-    // [span.elem], span element access
-    constexpr reference operator[](index_type idx) const
-    {
-        Expects(idx >= 0 && idx < storage_.size());
-        return data()[idx];
-    }
-
-    constexpr reference at(index_type idx) const { return this->operator[](idx); }
-    constexpr reference operator()(index_type idx) const { return this->operator[](idx); }
-    constexpr pointer data() const noexcept { return storage_.data(); }
-
-    // [span.iter], span iterator support
-    constexpr iterator begin() const noexcept { return {this, 0}; }
-    constexpr iterator end() const noexcept { return {this, size()}; }
-
-    constexpr const_iterator cbegin() const noexcept { return {this, 0}; }
-    constexpr const_iterator cend() const noexcept { return {this, size()}; }
-
-    constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
-    constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
-
-    constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator{cend()}; }
-    constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator{cbegin()}; }
-
-#ifdef _MSC_VER
-    // Tell MSVC how to unwrap spans in range-based-for
-    constexpr pointer _Unchecked_begin() const noexcept { return data(); }
-    constexpr pointer _Unchecked_end() const noexcept { return data() + size(); }
-#endif // _MSC_VER
-
-private:
-
-    // Needed to remove unnecessary null check in subspans
-    struct KnownNotNull
-    {
-        pointer p;
-    };
-
-    // this implementation detail class lets us take advantage of the
-    // empty base class optimization to pay for only storage of a single
-    // pointer in the case of fixed-size spans
-    template <class ExtentType>
-    class storage_type : public ExtentType
-    {
-    public:
-        // KnownNotNull parameter is needed to remove unnecessary null check
-        // in subspans and constructors from arrays
-        template <class OtherExtentType>
-        constexpr storage_type(KnownNotNull data, OtherExtentType ext) : ExtentType(ext), data_(data.p)
-        {
-             Expects(ExtentType::size() >= 0);
-        }
-
-
-        template <class OtherExtentType>
-        constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data)
-        {
-             Expects(ExtentType::size() >= 0);
-             Expects(data || ExtentType::size() == 0);
-        }
-
-        constexpr pointer data() const noexcept { return data_; }
-
-    private:
-        pointer data_;
-    };
-
-    storage_type<details::extent_type<Extent>> storage_;
-
-    // The rest is needed to remove unnecessary null check
-    // in subspans and constructors from arrays
-    constexpr span(KnownNotNull ptr, index_type count) : storage_(ptr, count) {}
-
-    template <std::ptrdiff_t CallerExtent>
-    class subspan_selector {};
-
-    template <std::ptrdiff_t CallerExtent>
-    span<element_type, dynamic_extent> make_subspan(index_type offset,
-                                                    index_type count,
-                                                    subspan_selector<CallerExtent>) const
-    {
-        span<element_type, dynamic_extent> tmp(*this);
-        return tmp.subspan(offset, count);
-    }
-
-    span<element_type, dynamic_extent> make_subspan(index_type offset,
-                                                    index_type count,
-                                                    subspan_selector<dynamic_extent>) const
-    {
-        Expects(offset >= 0 && size() - offset >= 0);
-        if (count == dynamic_extent)
-        {
-            return { KnownNotNull{ data() + offset }, size() - offset };
-        }
-
-        Expects(count >= 0 && size() - offset >= count);
-        return { KnownNotNull{ data() + offset },  count };
-    }
-};
-
-#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
-template <class ElementType, std::ptrdiff_t Extent>
-constexpr const typename span<ElementType, Extent>::index_type span<ElementType, Extent>::extent;
-#endif
-
-
-// [span.comparison], span comparison operators
-template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent>
-constexpr bool operator==(span<ElementType, FirstExtent> l,
-                          span<ElementType, SecondExtent> r)
-{
-    return std::equal(l.begin(), l.end(), r.begin(), r.end());
-}
-
-template <class ElementType, std::ptrdiff_t Extent>
-constexpr bool operator!=(span<ElementType, Extent> l,
-                          span<ElementType, Extent> r)
-{
-    return !(l == r);
-}
-
-template <class ElementType, std::ptrdiff_t Extent>
-constexpr bool operator<(span<ElementType, Extent> l,
-                         span<ElementType, Extent> r)
-{
-    return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
-}
-
-template <class ElementType, std::ptrdiff_t Extent>
-constexpr bool operator<=(span<ElementType, Extent> l,
-                          span<ElementType, Extent> r)
-{
-    return !(l > r);
-}
-
-template <class ElementType, std::ptrdiff_t Extent>
-constexpr bool operator>(span<ElementType, Extent> l,
-                         span<ElementType, Extent> r)
-{
-    return r < l;
-}
-
-template <class ElementType, std::ptrdiff_t Extent>
-constexpr bool operator>=(span<ElementType, Extent> l,
-                          span<ElementType, Extent> r)
-{
-    return !(l < r);
-}
-
-namespace details
-{
-    // if we only supported compilers with good constexpr support then
-    // this pair of classes could collapse down to a constexpr function
-
-    // we should use a narrow_cast<> to go to std::size_t, but older compilers may not see it as
-    // constexpr
-    // and so will fail compilation of the template
-    template <class ElementType, std::ptrdiff_t Extent>
-    struct calculate_byte_size
-        : std::integral_constant<std::ptrdiff_t,
-                                 static_cast<std::ptrdiff_t>(sizeof(ElementType) *
-                                                             static_cast<std::size_t>(Extent))>
-    {
-    };
-
-    template <class ElementType>
-    struct calculate_byte_size<ElementType, dynamic_extent>
-        : std::integral_constant<std::ptrdiff_t, dynamic_extent>
-    {
-    };
-}
-
-// [span.objectrep], views of object representation
-template <class ElementType, std::ptrdiff_t Extent>
-span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
-as_bytes(span<ElementType, Extent> s) noexcept
-{
-    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
-}
-
-template <class ElementType, std::ptrdiff_t Extent,
-          class = std::enable_if_t<!std::is_const<ElementType>::value>>
-span<byte, details::calculate_byte_size<ElementType, Extent>::value>
-as_writeable_bytes(span<ElementType, Extent> s) noexcept
-{
-    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
-}
-
-//
-// make_span() - Utility functions for creating spans
-//
-template <class ElementType>
-constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::index_type count)
-{
-    return span<ElementType>(ptr, count);
-}
-
-template <class ElementType>
-constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem)
-{
-    return span<ElementType>(firstElem, lastElem);
-}
-
-template <class ElementType, std::size_t N>
-constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept
-{
-    return span<ElementType, N>(arr);
-}
-
-template <class Container>
-constexpr span<typename Container::value_type> make_span(Container& cont)
-{
-    return span<typename Container::value_type>(cont);
-}
-
-template <class Container>
-constexpr span<const typename Container::value_type> make_span(const Container& cont)
-{
-    return span<const typename Container::value_type>(cont);
-}
-
-template <class Ptr>
-constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::ptrdiff_t count)
-{
-    return span<typename Ptr::element_type>(cont, count);
-}
-
-template <class Ptr>
-constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
-{
-    return span<typename Ptr::element_type>(cont);
-}
-
-// Specialization of gsl::at for span
-template <class ElementType, std::ptrdiff_t Extent>
-constexpr ElementType& at(span<ElementType, Extent> s, index i)
-{
-    // No bounds checking here because it is done in span::operator[] called below
-    return s[i];
-}
-
-} // namespace gsl
-
-#ifdef _MSC_VER
-#if _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // _MSC_VER < 1910
-
-#pragma warning(pop)
-#endif // _MSC_VER
-
-#if __GNUC__ > 6 
-#pragma GCC diagnostic pop
-#endif // __GNUC__ > 6
-
-#endif // GSL_SPAN_H
diff --git a/inst/include/gsl/string_span b/inst/include/gsl/string_span
deleted file mode 100644
index c08f246..0000000
--- a/inst/include/gsl/string_span
+++ /dev/null
@@ -1,730 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_STRING_SPAN_H
-#define GSL_STRING_SPAN_H
-
-#include <gsl/gsl_assert> // for Ensures, Expects
-#include <gsl/gsl_util>   // for narrow_cast
-#include <gsl/span>       // for operator!=, operator==, dynamic_extent
-
-#include <algorithm> // for equal, lexicographical_compare
-#include <array>     // for array
-#include <cstddef>   // for ptrdiff_t, size_t, nullptr_t
-#include <cstdint>   // for PTRDIFF_MAX
-#include <cstring>
-#include <string>      // for basic_string, allocator, char_traits
-#include <type_traits> // for declval, is_convertible, enable_if_t, add_...
-
-#ifdef _MSC_VER
-#pragma warning(push)
-
-// blanket turn off warnings from CppCoreCheck for now
-// so people aren't annoyed by them when running the tool.
-// more targeted suppressions will be added in a future update to the GSL
-#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495)
-
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif // _MSC_VER < 1910
-#endif // _MSC_VER
-
-// In order to test the library, we need it to throw exceptions that we can catch
-#ifdef GSL_THROW_ON_CONTRACT_VIOLATION
-#define GSL_NOEXCEPT /*noexcept*/
-#else
-#define GSL_NOEXCEPT noexcept
-#endif // GSL_THROW_ON_CONTRACT_VIOLATION
-
-namespace gsl
-{
-//
-// czstring and wzstring
-//
-// These are "tag" typedefs for C-style strings (i.e. null-terminated character arrays)
-// that allow static analysis to help find bugs.
-//
-// There are no additional features/semantics that we can find a way to add inside the
-// type system for these types that will not either incur significant runtime costs or
-// (sometimes needlessly) break existing programs when introduced.
-//
-
-template <typename CharT, std::ptrdiff_t Extent = dynamic_extent>
-using basic_zstring = CharT*;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using czstring = basic_zstring<const char, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using cwzstring = basic_zstring<const wchar_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using cu16zstring = basic_zstring<const char16_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using cu32zstring = basic_zstring<const char32_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using zstring = basic_zstring<char, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using wzstring = basic_zstring<wchar_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using u16zstring = basic_zstring<char16_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using u32zstring = basic_zstring<char32_t, Extent>;
-
-namespace details
-{
-    template <class CharT>
-    std::ptrdiff_t string_length(const CharT* str, std::ptrdiff_t n)
-    {
-        if (str == nullptr || n <= 0) return 0;
-
-        const span<const CharT> str_span{str, n};
-
-        std::ptrdiff_t len = 0;
-        while (len < n && str_span[len]) len++;
-
-        return len;
-    }
-}
-
-//
-// ensure_sentinel()
-//
-// Provides a way to obtain an span from a contiguous sequence
-// that ends with a (non-inclusive) sentinel value.
-//
-// Will fail-fast if sentinel cannot be found before max elements are examined.
-//
-template <typename T, const T Sentinel>
-span<T, dynamic_extent> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
-{
-    auto cur = seq;
-    while ((cur - seq) < max && *cur != Sentinel) ++cur;
-    Ensures(*cur == Sentinel);
-    return {seq, cur - seq};
-}
-
-//
-// ensure_z - creates a span for a zero terminated strings.
-// Will fail fast if a null-terminator cannot be found before
-// the limit of size_type.
-//
-template <typename CharT>
-span<CharT, dynamic_extent> ensure_z(CharT* const& sz, std::ptrdiff_t max = PTRDIFF_MAX)
-{
-    return ensure_sentinel<CharT, CharT(0)>(sz, max);
-}
-
-template <typename CharT, std::size_t N>
-span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
-{
-    return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N));
-}
-
-template <class Cont>
-span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
-ensure_z(Cont& cont)
-{
-    return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.size()));
-}
-
-template <typename CharT, std::ptrdiff_t>
-class basic_string_span;
-
-namespace details
-{
-    template <typename T>
-    struct is_basic_string_span_oracle : std::false_type
-    {
-    };
-
-    template <typename CharT, std::ptrdiff_t Extent>
-    struct is_basic_string_span_oracle<basic_string_span<CharT, Extent>> : std::true_type
-    {
-    };
-
-    template <typename T>
-    struct is_basic_string_span : is_basic_string_span_oracle<std::remove_cv_t<T>>
-    {
-    };
-}
-
-//
-// string_span and relatives
-//
-template <typename CharT, std::ptrdiff_t Extent = dynamic_extent>
-class basic_string_span
-{
-public:
-    using element_type = CharT;
-    using pointer = std::add_pointer_t<element_type>;
-    using reference = std::add_lvalue_reference_t<element_type>;
-    using const_reference = std::add_lvalue_reference_t<std::add_const_t<element_type>>;
-    using impl_type = span<element_type, Extent>;
-
-    using index_type = typename impl_type::index_type;
-    using iterator = typename impl_type::iterator;
-    using const_iterator = typename impl_type::const_iterator;
-    using reverse_iterator = typename impl_type::reverse_iterator;
-    using const_reverse_iterator = typename impl_type::const_reverse_iterator;
-
-    // default (empty)
-    constexpr basic_string_span() GSL_NOEXCEPT = default;
-
-    // copy
-    constexpr basic_string_span(const basic_string_span& other) GSL_NOEXCEPT = default;
-
-    // assign
-    constexpr basic_string_span& operator=(const basic_string_span& other) GSL_NOEXCEPT = default;
-
-    constexpr basic_string_span(pointer ptr, index_type length) : span_(ptr, length) {}
-    constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {}
-
-    // From static arrays - if 0-terminated, remove 0 from the view
-    // All other containers allow 0s within the length, so we do not remove them
-    template <std::size_t N>
-    constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr))
-    {
-    }
-
-    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
-    constexpr basic_string_span(std::array<ArrayElementType, N>& arr) GSL_NOEXCEPT : span_(arr)
-    {
-    }
-
-    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
-    constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) GSL_NOEXCEPT
-        : span_(arr)
-    {
-    }
-
-    // Container signature should work for basic_string after C++17 version exists
-    template <class Traits, class Allocator>
-    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str)
-        : span_(&str[0], narrow_cast<std::ptrdiff_t>(str.length()))
-    {
-    }
-
-    template <class Traits, class Allocator>
-    constexpr basic_string_span(const std::basic_string<element_type, Traits, Allocator>& str)
-        : span_(&str[0], str.length())
-    {
-    }
-
-    // from containers. Containers must have a pointer type and data() function signatures
-    template <class Container,
-              class = std::enable_if_t<
-                  !details::is_basic_string_span<Container>::value &&
-                  std::is_convertible<typename Container::pointer, pointer>::value &&
-                  std::is_convertible<typename Container::pointer,
-                                      decltype(std::declval<Container>().data())>::value>>
-    constexpr basic_string_span(Container& cont) : span_(cont)
-    {
-    }
-
-    template <class Container,
-              class = std::enable_if_t<
-                  !details::is_basic_string_span<Container>::value &&
-                  std::is_convertible<typename Container::pointer, pointer>::value &&
-                  std::is_convertible<typename Container::pointer,
-                                      decltype(std::declval<Container>().data())>::value>>
-    constexpr basic_string_span(const Container& cont) : span_(cont)
-    {
-    }
-
-    // from string_span
-    template <
-        class OtherValueType, std::ptrdiff_t OtherExtent,
-        class = std::enable_if_t<std::is_convertible<
-            typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
-    constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other)
-        : span_(other.data(), other.length())
-    {
-    }
-
-    template <index_type Count>
-    constexpr basic_string_span<element_type, Count> first() const
-    {
-        return {span_.template first<Count>()};
-    }
-
-    constexpr basic_string_span<element_type, dynamic_extent> first(index_type count) const
-    {
-        return {span_.first(count)};
-    }
-
-    template <index_type Count>
-    constexpr basic_string_span<element_type, Count> last() const
-    {
-        return {span_.template last<Count>()};
-    }
-
-    constexpr basic_string_span<element_type, dynamic_extent> last(index_type count) const
-    {
-        return {span_.last(count)};
-    }
-
-    template <index_type Offset, index_type Count>
-    constexpr basic_string_span<element_type, Count> subspan() const
-    {
-        return {span_.template subspan<Offset, Count>()};
-    }
-
-    constexpr basic_string_span<element_type, dynamic_extent>
-    subspan(index_type offset, index_type count = dynamic_extent) const
-    {
-        return {span_.subspan(offset, count)};
-    }
-
-    constexpr reference operator[](index_type idx) const { return span_[idx]; }
-    constexpr reference operator()(index_type idx) const { return span_[idx]; }
-
-    constexpr pointer data() const { return span_.data(); }
-
-    constexpr index_type length() const GSL_NOEXCEPT { return span_.size(); }
-    constexpr index_type size() const GSL_NOEXCEPT { return span_.size(); }
-    constexpr index_type size_bytes() const GSL_NOEXCEPT { return span_.size_bytes(); }
-    constexpr index_type length_bytes() const GSL_NOEXCEPT { return span_.length_bytes(); }
-    constexpr bool empty() const GSL_NOEXCEPT { return size() == 0; }
-
-    constexpr iterator begin() const GSL_NOEXCEPT { return span_.begin(); }
-    constexpr iterator end() const GSL_NOEXCEPT { return span_.end(); }
-
-    constexpr const_iterator cbegin() const GSL_NOEXCEPT { return span_.cbegin(); }
-    constexpr const_iterator cend() const GSL_NOEXCEPT { return span_.cend(); }
-
-    constexpr reverse_iterator rbegin() const GSL_NOEXCEPT { return span_.rbegin(); }
-    constexpr reverse_iterator rend() const GSL_NOEXCEPT { return span_.rend(); }
-
-    constexpr const_reverse_iterator crbegin() const GSL_NOEXCEPT { return span_.crbegin(); }
-    constexpr const_reverse_iterator crend() const GSL_NOEXCEPT { return span_.crend(); }
-
-private:
-    static impl_type remove_z(pointer const& sz, std::ptrdiff_t max)
-    {
-        return {sz, details::string_length(sz, max)};
-    }
-
-    template <std::size_t N>
-    static impl_type remove_z(element_type (&sz)[N])
-    {
-        return remove_z(&sz[0], narrow_cast<std::ptrdiff_t>(N));
-    }
-
-    impl_type span_;
-};
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using string_span = basic_string_span<char, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using cstring_span = basic_string_span<const char, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using wstring_span = basic_string_span<wchar_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using cwstring_span = basic_string_span<const wchar_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using u16string_span = basic_string_span<char16_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using cu16string_span = basic_string_span<const char16_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using u32string_span = basic_string_span<char32_t, Extent>;
-
-template <std::ptrdiff_t Extent = dynamic_extent>
-using cu32string_span = basic_string_span<const char32_t, Extent>;
-
-//
-// to_string() allow (explicit) conversions from string_span to string
-//
-
-template <typename CharT, std::ptrdiff_t Extent>
-std::basic_string<typename std::remove_const<CharT>::type>
-to_string(basic_string_span<CharT, Extent> view)
-{
-    return {view.data(), static_cast<std::size_t>(view.length())};
-}
-
-template <typename CharT, typename Traits = typename std::char_traits<CharT>,
-          typename Allocator = std::allocator<CharT>, typename gCharT, std::ptrdiff_t Extent>
-std::basic_string<CharT, Traits, Allocator> to_basic_string(basic_string_span<gCharT, Extent> view)
-{
-    return {view.data(), static_cast<std::size_t>(view.length())};
-}
-
-template <class ElementType, std::ptrdiff_t Extent>
-basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
-as_bytes(basic_string_span<ElementType, Extent> s) noexcept
-{
-	return { reinterpret_cast<const byte*>(s.data()), s.size_bytes() };
-}
-
-template <class ElementType, std::ptrdiff_t Extent,
-          class = std::enable_if_t<!std::is_const<ElementType>::value>>
-basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
-as_writeable_bytes(basic_string_span<ElementType, Extent> s) noexcept
-{
-    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
-}
-
-// zero-terminated string span, used to convert
-// zero-terminated spans to legacy strings
-template <typename CharT, std::ptrdiff_t Extent = dynamic_extent>
-class basic_zstring_span
-{
-public:
-    using value_type = CharT;
-    using const_value_type = std::add_const_t<CharT>;
-
-    using pointer = std::add_pointer_t<value_type>;
-    using const_pointer = std::add_pointer_t<const_value_type>;
-
-    using zstring_type = basic_zstring<value_type, Extent>;
-    using const_zstring_type = basic_zstring<const_value_type, Extent>;
-
-    using impl_type = span<value_type, Extent>;
-    using string_span_type = basic_string_span<value_type, Extent>;
-
-    constexpr basic_zstring_span(impl_type s) GSL_NOEXCEPT : span_(s)
-    {
-        // expects a zero-terminated span
-        Expects(s[s.size() - 1] == '\0');
-    }
-
-    // copy
-    constexpr basic_zstring_span(const basic_zstring_span& other) = default;
-
-    // move
-    constexpr basic_zstring_span(basic_zstring_span&& other) = default;
-
-    // assign
-    constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default;
-
-    // move assign
-    constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default;
-
-    constexpr bool empty() const GSL_NOEXCEPT { return span_.size() == 0; }
-
-    constexpr string_span_type as_string_span() const GSL_NOEXCEPT
-    {
-        auto sz = span_.size();
-        return { span_.data(), sz > 1 ? sz - 1 : 0 };
-    }
-    constexpr string_span_type ensure_z() const GSL_NOEXCEPT { return gsl::ensure_z(span_); }
-
-    constexpr const_zstring_type assume_z() const GSL_NOEXCEPT { return span_.data(); }
-
-private:
-    impl_type span_;
-};
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using zstring_span = basic_zstring_span<char, Max>;
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using wzstring_span = basic_zstring_span<wchar_t, Max>;
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using u16zstring_span = basic_zstring_span<char16_t, Max>;
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using u32zstring_span = basic_zstring_span<char32_t, Max>;
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using czstring_span = basic_zstring_span<const char, Max>;
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using cwzstring_span = basic_zstring_span<const wchar_t, Max>;
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using cu16zstring_span = basic_zstring_span<const char16_t, Max>;
-
-template <std::ptrdiff_t Max = dynamic_extent>
-using cu32zstring_span = basic_zstring_span<const char32_t, Max>;
-
-// operator ==
-template <class CharT, std::ptrdiff_t Extent, class T,
-          class = std::enable_if_t<
-              details::is_basic_string_span<T>::value ||
-              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
-bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other) GSL_NOEXCEPT
-{
-    const gsl::basic_string_span<std::add_const_t<CharT>> tmp(other);
-    return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end());
-}
-
-template <class CharT, std::ptrdiff_t Extent, class T,
-          class = std::enable_if_t<
-              !details::is_basic_string_span<T>::value &&
-              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
-bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other) GSL_NOEXCEPT
-{
-    gsl::basic_string_span<std::add_const_t<CharT>> tmp(one);
-    return std::equal(tmp.begin(), tmp.end(), other.begin(), other.end());
-}
-
-// operator !=
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-          typename = std::enable_if_t<std::is_convertible<
-              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
-bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    return !(one == other);
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
-        !gsl::details::is_basic_string_span<T>::value>>
-bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    return !(one == other);
-}
-
-// operator<
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-          typename = std::enable_if_t<std::is_convertible<
-              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
-bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    const gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
-    return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
-        !gsl::details::is_basic_string_span<T>::value>>
-bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
-    return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end());
-}
-
-#ifndef _MSC_VER
-
-// VS treats temp and const containers as convertible to basic_string_span,
-// so the cases below are already covered by the previous operators
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
-    return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
-    return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end());
-}
-#endif
-
-// operator <=
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-          typename = std::enable_if_t<std::is_convertible<
-              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
-bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    return !(other < one);
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
-        !gsl::details::is_basic_string_span<T>::value>>
-bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    return !(other < one);
-}
-
-#ifndef _MSC_VER
-
-// VS treats temp and const containers as convertible to basic_string_span,
-// so the cases below are already covered by the previous operators
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    return !(other < one);
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    return !(other < one);
-}
-#endif
-
-// operator>
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-          typename = std::enable_if_t<std::is_convertible<
-              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
-bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    return other < one;
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
-        !gsl::details::is_basic_string_span<T>::value>>
-bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    return other < one;
-}
-
-#ifndef _MSC_VER
-
-// VS treats temp and const containers as convertible to basic_string_span,
-// so the cases below are already covered by the previous operators
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    return other < one;
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    return other < one;
-}
-#endif
-
-// operator >=
-template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-          typename = std::enable_if_t<std::is_convertible<
-              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
-bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    return !(one < other);
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename = std::enable_if_t<
-        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
-        !gsl::details::is_basic_string_span<T>::value>>
-bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    return !(one < other);
-}
-
-#ifndef _MSC_VER
-
-// VS treats temp and const containers as convertible to basic_string_span,
-// so the cases below are already covered by the previous operators
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) GSL_NOEXCEPT
-{
-    return !(one < other);
-}
-
-template <
-    typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T,
-    typename DataType = typename T::value_type,
-    typename = std::enable_if_t<
-        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
-        std::is_convertible<DataType*, CharT*>::value &&
-        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
-                     DataType>::value>>
-bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) GSL_NOEXCEPT
-{
-    return !(one < other);
-}
-#endif
-} // namespace gsl
-
-#undef GSL_NOEXCEPT
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-
-#if _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // _MSC_VER < 1910
-#endif // _MSC_VER
-
-#endif // GSL_STRING_SPAN_H
diff --git a/inst/include/highfive/H5DataSet.hpp b/inst/include/highfive/H5DataSet.hpp
index 33bbc20..2accea1 100644
--- a/inst/include/highfive/H5DataSet.hpp
+++ b/inst/include/highfive/H5DataSet.hpp
@@ -35,25 +35,43 @@ class DataSet : public Object,
   void extend(const std::vector<size_t> &new_dims);
     size_t getStorageSize() const;
 
+
+  ///
+  /// /brief get_num_chunks
+  /// /return return the number of chunks in each dimension
+  std::vector<hsize_t> get_num_chunks() const;
+
+
+  ///
+  /// /brief get_chunk_offset
+  /// /return return the chunk offset at the specified chunk index
+  std::vector<hsize_t> get_chunk_offset(const std::vector<hsize_t> &chunk_idx) const;
+
     ///
     /// \brief getDataType
     /// \return return the datatype associated with this dataset
     ///
-    DataType getDataType() const;
+  DataType getDataType() const;
 
-    //std::vector<size_t> getDataDimensions() const;
 
-    ///
-    /// \brief getSpace
-    /// \return return the dataspace associated with this dataset
-    ///
-    DataSpace getSpace() const;
 
-    ///
-    /// \brief getFilter
-    /// \return return the filter(compression) associated with this dataset 
-    ///
-    Filter getFilter() const;
+  std::optional<size_t> read_raw_chunk(std::vector<std::byte> &data_buff,const std::vector<size_t> &offsets)const;
+
+
+  void write_raw_chunk(std::vector<std::byte> &data_buff, const std::vector<size_t> &offsets,std::optional<size_t> buff_size) const;
+  //std::vector<size_t> getDataDimensions() const;
+
+  ///
+  /// \brief getSpace
+  /// \return return the dataspace associated with this dataset
+  ///
+  DataSpace getSpace() const;
+
+  ///
+  /// \brief getFilter
+  /// \return return the filter(compression) associated with this dataset
+  ///
+  Filter getFilter() const;
 
     ///
     /// \brief getMemSpace
diff --git a/inst/include/highfive/H5DataType.hpp b/inst/include/highfive/H5DataType.hpp
index 6ac58f3..5cf3399 100644
--- a/inst/include/highfive/H5DataType.hpp
+++ b/inst/include/highfive/H5DataType.hpp
@@ -12,26 +12,33 @@
 #include <boost/optional.hpp>
 namespace HighFive {
 
-struct TypeMapper;
+  struct TypeMapper;
 
-///
-/// \brief HDF5 Data Type
-///
-class DataType : public Object {
+  ///
+  /// \brief HDF5 Data Type
+  ///
+  class DataType : public Object {
   public:
     DataType();
 
     bool operator == (const DataType& other) const;
 
     bool operator != (const DataType& other) const;
+    H5T_class_t get_class() const{
+      return H5Tget_class(_hid);
+    }
+    bool same_class(const DataType& other) const{
+      return this->get_class()==other.get_class();
+    }
 
+    size_t n_elem() const;
 
-protected:
 
+  protected:
     friend class Attribute;
     friend class File;
     friend class DataSet;
-};
+  };
 
 ///
 /// \brief create an HDF5 DataType from a C++ type
diff --git a/inst/include/highfive/H5File.hpp b/inst/include/highfive/H5File.hpp
index a4c1a2f..5a486d8 100644
--- a/inst/include/highfive/H5File.hpp
+++ b/inst/include/highfive/H5File.hpp
@@ -52,13 +52,13 @@ class File : public Object,
     /// Open or create a new HDF5 file
   explicit File(const std::string& filename, int openFlags = ReadOnly,
 		const FileDriver& driver = DefaultFileDriver());
-  bool start_swmr();
+ // bool start_swmr();
     ///
     /// \brief Return the name of the file
     ///
   const std::string& getName() const;
   size_t getObjCount(unsigned int types) const;
-  static boost::optional<File> openFile(const std::string& filename, int openFlags = ReadOnly,
+  static std::optional<File> openFile(const std::string& filename, int openFlags = ReadOnly,
 				      const FileDriver& driver = DefaultFileDriver());
     ///
     /// \brief flush
diff --git a/inst/include/highfive/H5Filter.hpp b/inst/include/highfive/H5Filter.hpp
index 13ba0ce..025c70d 100644
--- a/inst/include/highfive/H5Filter.hpp
+++ b/inst/include/highfive/H5Filter.hpp
@@ -10,65 +10,349 @@
 #include "H5DataSpace.hpp"
 #include <functional>
 #include <numeric>
-
+#include <optional>
+#include <variant>
 #include <Eigen/Core>
 
 
+#ifdef USE_BLOSC
+#include "blosc_filter.h"
+#endif
 
+#ifdef USE_LZF
+#include "lzf/lzf_filter.h"
+#endif
 
 
+#include "zstd/zstd_h5plugin.h"
+#include "zstd/zstd.h"
+#include "zlib.h"
 
 
-namespace HighFive {
+class NoCompressor{
+public:
+  NoCompressor(const std::vector<unsigned int> &cd){}
 
+  void decompress(void* uncompressed,size_t uc_size,const void* compressed,std::optional<size_t> cb_size){
+    std::memcpy(uncompressed,compressed,cb_size.value_or(uc_size));
+  }
 
-  // class VFilter :public Object{
+  std::optional<size_t> compress(void* compressed,size_t cb_size,const void* uncompressed,size_t uc_size){
+#ifdef DEBUG
+    if(uc_size>cb_size){
+      Rcpp::stop("compressed buffer is smaller than uncompressed buffer in NoCompressor");
+    }
+#endif
+    std::memcpy(compressed,uncompressed,uc_size);
+    return uc_size;
+  }
+};
 
-  // };
-///
+
+
+class GzipCompressor{
+public:
+  const int aggression;
+  GzipCompressor(const std::vector<unsigned int> &cd_):aggression(static_cast<int>(cd_[0])){}
+  void decompress(void* uncompressed,size_t uc_size,const void* compressed,std::optional<size_t> cb_size){
+    if(cb_size){
+      size_t tcb_size=uc_size;
+
+      auto ret = uncompress(reinterpret_cast<unsigned char*>(uncompressed),
+			    &tcb_size,
+			    reinterpret_cast<const unsigned char*>(compressed),
+			    cb_size.value());
+      // ret = uncompress((Bytef *)read_dst_buf, (uLongf *)&buf_size, pt_readbuf, (uLong)read_chunk_nbytes);
+
+      if(Z_BUF_ERROR == ret) {
+	Rcpp::stop("Error decompressing data");
+      }
+    }
+    else{
+      std::memcpy(uncompressed,compressed,uc_size);
+    }
+  }
+
+
+  std::optional<size_t> compress(void* compressed,size_t cb_size,const void* uncompressed,size_t uc_size){
+    size_t o_cb_size=cb_size;
+    auto ret = compress2(reinterpret_cast<unsigned char*>(compressed), &cb_size,reinterpret_cast<const unsigned char*>(uncompressed),uc_size, aggression);
+    if(Z_BUF_ERROR == ret) {
+      Rcpp::stop("zbuff overflow");
+    } else if(Z_MEM_ERROR == ret) {
+      Rcpp::stop("deflate memory error");
+    } else if(Z_OK != ret) {
+      Rcpp::stop("other deflate error");
+    }
+    if(cb_size<o_cb_size){
+      return cb_size;
+    }else{
+      std::memcpy(compressed,uncompressed,uc_size);
+      return std::nullopt;
+    }
+  }
+};
+
+
+class LzfCompressor{
+public:
+  LzfCompressor(const std::vector<unsigned int> &cd_){
+#ifndef USE_LZF
+    Rcpp::stop("please recompile EigenH5 with -DUSE_LZF (and the lzf library)");
+#endif
+
+  }
+  void memcpy(void* output,size_t osize,const void* input,size_t isize){
+    std::memcpy(output,input,osize);
+  }
+  void decompress(void* uncompressed,size_t uc_size,const void* compressed,std::optional<size_t> cb_size){
+#ifndef USE_LZF
+    Rcpp::stop("please recompile EigenH5 with -DUSE_LZF (and the lzf library)");
+#else
+
+    if(cb_size){
+      auto ret = lzf_decompress(compressed,cb_size.value(),uncompressed,uc_size);
+      if(!ret){
+	if(errno == E2BIG){
+	  Rcpp::stop("lzf too small");
+	} else if(errno == EINVAL) {
+
+	  Rcpp::stop("Invalid data for LZF decompression");
+
+	} else {
+	  Rcpp::stop("Unknown LZF decompression error");
+	}
+
+
+	if(Z_BUF_ERROR == ret) {
+	  Rcpp::stop("Error decompressing data");
+	}
+      }
+    }else{
+      std::memcpy(uncompressed,compressed,uc_size);
+    }
+#endif
+  }
+  std::optional<size_t> compress(void* compressed,size_t cb_size,const void* uncompressed,const size_t uc_size) noexcept{
+#ifndef USE_LZF
+    Rcpp::stop("please recompile EigenH5 with -DUSE_LZF (and the lzf library)");
+#else
+    auto ret = lzf_compress(uncompressed,uc_size,compressed,cb_size);
+    if(ret>0){
+      return(ret);
+    }else{
+      std::memcpy(compressed,uncompressed,uc_size);
+      return std::nullopt;
+    }
+#endif
+  }
+
+  
+};
+  
+  
+  
+class BloscCompressor{
+#ifdef USE_BLOSC
+  int clevel;
+  int doshuffle;
+  int compcode;
+  int code;
+  int typesize;
+  int outbuf_size;
+#endif
+
+public:
+  BloscCompressor(const std::vector<unsigned int> cd_){
+#ifndef USE_BLOSC
+    Rcpp::stop("please recompile EigenH5 with -DUSE_BLOSC (and the blosc library)");
+#else
+
+    char tstr [] = "blosclz";
+    const char* compname = tstr;     /* The compressor by default */
+    auto cds =cd_.size();
+    if(cds>4){
+      typesize=static_cast<int>(cd_[2]);
+      outbuf_size=static_cast<int>(cd_[3]);
+    }else{
+      Rcpp::stop("Blosc Compressor needs the values from cd_");
+    }
+    if(cds>=5){
+      clevel=static_cast<int>(cd_[4]);
+    }else{
+      clevel=5;
+    }
+    if(cds>=6){
+      doshuffle=static_cast<int>(cd_[5]);
+    }else{
+      doshuffle=1;
+    }
+    if(cds>=7){
+      compcode=static_cast<int>(cd_[6]);
+      auto complist = blosc_list_compressors();
+      code = blosc_compcode_to_compname(compcode, &compname);
+      if (code == -1) {
+	Rcpp::Rcerr<<"this Blosc library does not have support for the "<<compname<<" compressor, but only for:"<<complist<<std::endl;
+	Rcpp::stop("Can't initialize blosc");
+      }
+    }
+
+    blosc_set_compressor(compname);
+#endif
+  }
+  void decompress(void* uncompressed,size_t uc_size,const void* compressed,std::optional<size_t> cb_size){
+#ifdef USE_BLOSC
+    if(cb_size){
+      size_t cbytes, blocksize,outbuf_size;
+      size_t osize=uc_size;
+      blosc_cbuffer_sizes(compressed, &outbuf_size, &cbytes, &blocksize);
+      if(outbuf_size>osize){
+	Rcpp::stop("output buffer size larger than total size!");
+      }
+      auto  status = blosc_decompress(compressed, uncompressed, uc_size);
+      if (status <= 0) {    /* decompression failed */
+	Rcpp::stop("Blosc decompression error");
+      }
+    }else{
+      std::memcpy(uncompressed,compressed,uc_size);
+    }
+#endif
+  }
+
+  std::optional<size_t> compress(void* compressed,size_t cb_size,const void* uncompressed,size_t uc_size){
+#ifdef USE_BLOSC
+    size_t cbytes, blocksize,outbuf_size;
+    auto  status = blosc_compress(clevel,doshuffle,typesize,uc_size,uncompressed,compressed,cb_size);
+    if (status <= 0) {    /* decompression failed */
+      std::memcpy(compressed,uncompressed,uc_size);
+      return std::nullopt;
+    }
+    return(status);
+    #else
+    Rcpp::stop("Rebuild EigenH5 using BLOSC");
+    return(std::nullopt);
+#endif
+  }
+};
+  
+  
+  
+  
+class ZstdCompressor{
+public:
+  std::unique_ptr<ZSTD_DCtx,decltype(&ZSTD_freeDCtx)> ctxt_d;
+  std::unique_ptr<ZSTD_CCtx,decltype(&ZSTD_freeCCtx)> ctxt_c;
+  int aggression;
+  ZstdCompressor(const std::vector<unsigned int> cd_):ctxt_d(ZSTD_createDCtx(),&ZSTD_freeDCtx),
+						      ctxt_c(ZSTD_createCCtx(),&ZSTD_freeCCtx){
+    if(cd_.size()>0){
+      aggression=static_cast<int>(cd_[0]);
+    }else{
+      aggression=22;
+    }
+  }
+  //  std::optional<size_t> compress(void* compressed,size_t cb_size,const void* uncompressed,size_t uc_size){
+  void decompress(void* uncompressed,size_t uc_size,const void* compressed,std::optional<size_t> cb_size){
+    if(cb_size){
+      auto rc = ZSTD_decompressDCtx(ctxt_d.get(),uncompressed, uc_size, compressed,cb_size.value());
+      if(ZSTD_isError(rc)){
+	Rcpp::Rcerr<<ZSTD_getErrorName(rc)<<std::endl;
+	if(ZSTD_isFrame((void*) compressed, cb_size.value())){
+	  Rcpp::Rcerr<<"Frame is valid"<<std::endl;
+	}
+	else{
+	  Rcpp::Rcerr<<"Frame is not valid"<<std::endl;
+	}
+	auto ret2 = ZSTD_getFrameContentSize((void*) compressed,cb_size.value());
+
+	if(ret2==0){
+	  Rcpp::Rcerr<<"Frame valid but empty"<<std::endl;
+	  Rcpp::stop("Error decompressing zstd");
+	}
+	if(ret2==ZSTD_CONTENTSIZE_ERROR){
+	  Rcpp::Rcerr<<"invalid magic number, or srcSize is too small"<<std::endl;
+	  Rcpp::stop("Error decompressing zstd");
+	}
+	if(ret2==ZSTD_CONTENTSIZE_UNKNOWN){
+	  Rcpp::Rcerr<<"Frame size cannot be determined"<<std::endl;
+	  Rcpp::stop("Error decompressing zstd");
+	}else{
+	  Rcpp::Rcerr<<"Frame size is :"<<ret2<<" and you said it was :"<<uc_size<<std::endl;
+	  Rcpp::stop("Error decompressing zstd");
+	}
+	Rcpp::stop("Error decompressing zstd");
+      }
+    }else{
+      std::memcpy(uncompressed,compressed,uc_size);
+    }
+  }
+
+  std::optional<size_t> compress(void* compressed,size_t cb_size,const void* uncompressed,size_t uc_size){
+
+    auto rc = ZSTD_compressCCtx(ctxt_c.get(),compressed, cb_size,uncompressed,uc_size,aggression);
+    if(ZSTD_isError(rc)){
+      Rcpp::Rcerr<<"There was an error with compression!"<<std::endl;
+      Rcpp::Rcerr<<ZSTD_getErrorName(rc)<<std::endl;
+      return std::nullopt;
+    }
+    if(rc<0){
+      std::memcpy(compressed,uncompressed,uc_size);
+      return std::nullopt;
+    }
+    return rc;
+  }
+  
+};
+  
+
+
+namespace HighFive {
 /// \brief Generic HDF5 property List
 ///
-    class Filter {
-    public:
-      static const hid_t gzip;// = 1;
-      static const hid_t blosc;// = 32001;
-      static const hid_t lzf4;// = 32000;
-      static const hid_t zstd;// = 32015;
-      static const hid_t no_filter;// = 0;
-      static const size_t CHUNK_BASE = 16*1024;
-      static const size_t CHUNK_MIN = 8*1024;
-      static const size_t CHUNK_MAX = 1024*1024;
-      Filter(const std::vector<size_t> &chunk_dims, const hid_t filter_id, std::vector<unsigned int> cd_values);
-      Filter();
-      static std::vector<size_t> guess_chunk(const std::vector<size_t> data_shape);
-      static Filter From(const DataSpace &dataspace,const hid_t filter_id,std::vector<unsigned int> cd_values={});
-      hid_t getId() const;
-      std::vector<size_t> get_chunksizes()const;
-      std::pair<std::string,std::vector<unsigned int> > get_filter_info() const;
-    protected:
-      std::vector<size_t> chunksizes;
-      hid_t _hid;
-      friend class ::HighFive::DataSet;
-    };
 
+  class Filter: public Object {
+
+  public:
+    static const hid_t gzip;// = 1;
+    static const hid_t blosc;// = 32001;
+    static const hid_t lzf4;// = 32000;
+    static const hid_t zstd;// = 32015;
+    static const hid_t no_filter;// = 0;
+    static const size_t CHUNK_BASE = 16*1024;
+    static const size_t CHUNK_MIN = 8*1024;
+    static const size_t CHUNK_MAX = 1024*1024;
+    Filter(const std::vector<size_t> &chunk_dims, const hid_t filter_id, std::vector<unsigned int> cd_values);
+    using compressors = std::variant<NoCompressor,LzfCompressor,BloscCompressor,GzipCompressor,ZstdCompressor>;
+    Filter();
+    static std::vector<size_t> guess_chunk(const std::vector<size_t> data_shape);
+    static Filter From(const DataSpace &dataspace,const hid_t filter_id,std::vector<unsigned int> cd_values={});
+    hid_t getId() const;
+    std::vector<size_t> get_chunksizes()const;
+    compressors getDecompressor() const;
+    std::pair<std::string,std::vector<unsigned int> > get_filter_info() const;
+  protected:
+    std::vector<size_t> chunksizes;
+    //    hid_t _hid;
+    friend class ::HighFive::DataSet;
+  };
 
-} // HighFive
 
+} // HighFive
 
 
-namespace HighFive {
 
 
 
+namespace HighFive {
 
-const hid_t filter_gzip = 1;
-const hid_t filter_blosc = 32001;
-const hid_t filter_lzf4 = 32000;
-const hid_t filter_zstd = 32015;
-const hid_t filter_no_filter = 0;
 
 
 
+  const hid_t filter_gzip = 1;
+  const hid_t filter_blosc = 32001;
+  const hid_t filter_lzf4 = 32000;
+  const hid_t filter_zstd = 32015;
+  const hid_t filter_no_filter = 0;
 
   inline Filter::Filter() {
     _hid = H5Pcreate(H5P_DATASET_CREATE);
@@ -140,9 +424,7 @@ const hid_t filter_no_filter = 0;
     }
     auto chunk_size=data_shape;
     size_t prop_chunk_size = std::accumulate(chunk_size.begin(), chunk_size.end(), 1, std::multiplies<size_t>());
-    size_t iti=0;
     while(prop_chunk_size>=CHUNK_MAX){
-      // auto it=data_shape[(iti++ %
       auto it=chunk_size.begin();
       *it/=2;
       prop_chunk_size = std::accumulate(chunk_size.begin(), chunk_size.end(), 1, std::multiplies<size_t>());
@@ -173,6 +455,9 @@ const hid_t filter_no_filter = 0;
 				  nname,
 				  name.data(),
 				  &tflg);
+      if(filt_ret<0){
+	HDF5ErrMapper::ToException<FilterException>("Unable to get filter");
+      }
       std::string	nameret(name.data());
       std::vector<unsigned int> ret(ncd);
       std::copy(cd.begin(),cd.begin()+ncd,ret.begin());
@@ -180,9 +465,54 @@ const hid_t filter_no_filter = 0;
     }else{
       return(std::make_pair("no_filter",std::vector<unsigned int>()));
     }
+  }
 
-
-
+  inline Filter::compressors Filter::getDecompressor() const{
+    std::vector<unsigned int> cd(10);
+    std::array<unsigned int,10> flgs;
+    unsigned int tflg;
+    std::vector<char> name(30);
+    size_t ncd=cd.size();
+    size_t nname = name.size();
+    //We want to get the last filter
+    int num_filt=H5Pget_nfilters(_hid);
+    if(num_filt>0){
+      auto filt_ret=H5Pget_filter(_hid,
+				  num_filt-1,
+				  flgs.data(),
+				  &ncd,
+				  cd.data(),
+				  nname,
+				  name.data(),
+				  &tflg);
+      if(filt_ret<0){
+	HDF5ErrMapper::ToException<FilterException>("Unable to get filter");
+      }
+      switch(filt_ret){
+      case H5Z_FILTER_DEFLATE:{
+	//	GzipCompressor gzd(cd);
+	return(GzipCompressor(cd));
+      }
+      case 32001:{
+	//	BloscCompressor blodo(cd);
+      	return(BloscCompressor(cd));
+      }
+      case 32000:{
+	//	LzfCompressor lzd(cd);
+	return(LzfCompressor(cd));
+      }
+      case 32015:{
+	//        ZstdCompressor zstdd(cd);
+	return(ZstdCompressor(cd));
+      }
+      default: {
+	Rcpp::Rcerr<<"Invalid filter:"<< filt_ret<<std::endl;
+	return NoCompressor(cd);
+      }
+      }
+    }else{
+      return NoCompressor(cd);
+    }
   }
 
   inline std::vector<size_t> Filter::get_chunksizes()const{
diff --git a/inst/include/highfive/bits/H5Annotate_traits.hpp b/inst/include/highfive/bits/H5Annotate_traits.hpp
index 6f1f65e..69a5aab 100644
--- a/inst/include/highfive/bits/H5Annotate_traits.hpp
+++ b/inst/include/highfive/bits/H5Annotate_traits.hpp
@@ -49,7 +49,7 @@ class AnnotateTraits {
     /// \return the attribute object
     ///
     Attribute getAttribute(const std::string& attribute_name) const;
-  boost::optional<Attribute> openAttribute(const std::string& attribute_name) const;
+  std::optional<Attribute> openAttribute(const std::string& attribute_name) const;
 
     ///
     /// \brief return the number of attributes of the node / group
diff --git a/inst/include/highfive/bits/H5Annotate_traits_misc.hpp b/inst/include/highfive/bits/H5Annotate_traits_misc.hpp
index 9d8d554..cfac6e9 100644
--- a/inst/include/highfive/bits/H5Annotate_traits_misc.hpp
+++ b/inst/include/highfive/bits/H5Annotate_traits_misc.hpp
@@ -49,10 +49,10 @@ AnnotateTraits<Derivate>::createAttribute(const std::string& attribute_name,
 
 
 template <typename Derivate>
-inline boost::optional<Attribute> AnnotateTraits<Derivate>::openAttribute(
+inline std::optional<Attribute> AnnotateTraits<Derivate>::openAttribute(
     const std::string& attribute_name) const {
   if(!this->hasAttribute(attribute_name)){
-    return(boost::none);
+    return(std::nullopt);
   }else{
     return(this->getAttribute(attribute_name));
   }
@@ -89,14 +89,14 @@ inline std::vector<std::string>
 AnnotateTraits<Derivate>::listAttributeNames() const {
 
     std::vector<std::string> names;
-    details::HighFiveIterateData iterateData(names);
+    details::HighFiveIterateData<std::string> iterateData(names);
 
     size_t num_objs = getNumberAttributes();
     names.reserve(num_objs);
 
     if (H5Aiterate2(static_cast<const Derivate*>(this)->getId(), H5_INDEX_NAME,
                     H5_ITER_INC, NULL,
-                    &details::internal_high_five_iterate<H5A_info_t>,
+                    &details::internal_high_five_iterate<H5A_info_t,std::string>,
                     static_cast<void*>(&iterateData)) < 0) {
         HDF5ErrMapper::ToException<AttributeException>(
             std::string("Unable to list attributes in group"));
diff --git a/inst/include/highfive/bits/H5Converter_misc.hpp b/inst/include/highfive/bits/H5Converter_misc.hpp
index 761c774..ebcd50c 100644
--- a/inst/include/highfive/bits/H5Converter_misc.hpp
+++ b/inst/include/highfive/bits/H5Converter_misc.hpp
@@ -101,7 +101,7 @@ namespace HighFive {
       inline data_converter(std::vector<T> &vec, DataSpace &space,const DataType dt)
 	: _space(
 		 &space), _dim(0) {
-	assert(_space->getDimensions().size() > dim);
+	assert(_space->getDimensions().size() > _dim);
 	(void)vec;
       }
 
@@ -588,6 +588,10 @@ struct data_converter<std::vector<char*>, void> {
     DataSpace& _space;
     };
 
+
+
+
+
     // template<>
     // struct data_converter<std::vector<char*>, void> {
     //   inline data_converter(std::vector<char*> &vec, DataSpace &space,const size_t dim=0)
diff --git a/inst/include/highfive/bits/H5DataSet_misc.hpp b/inst/include/highfive/bits/H5DataSet_misc.hpp
index 0ea7bcd..781b61e 100644
--- a/inst/include/highfive/bits/H5DataSet_misc.hpp
+++ b/inst/include/highfive/bits/H5DataSet_misc.hpp
@@ -30,17 +30,144 @@
 
 namespace HighFive {
 
-inline DataSet::DataSet() {}
+  inline DataSet::DataSet() {}
 
-inline size_t DataSet::getStorageSize() const {
+  inline size_t DataSet::getStorageSize() const {
     return H5Dget_storage_size(_hid);
-}
+  }
 
-inline DataType DataSet::getDataType() const {
+  inline DataType DataSet::getDataType() const {
     DataType res;
     res._hid = H5Dget_type(_hid);
     return res;
-}
+  }
+
+
+
+
+
+
+  inline std::vector<hsize_t> DataSet::get_num_chunks() const{
+
+
+    auto dim_size = this->getSpace().getDimensions();
+    auto filt =	this->getFilter();
+    const size_t num_dims_ds = dim_size.size();
+
+    const size_t num_dims_chunks = filt.chunksizes.size();
+
+    std::vector<hsize_t> retvec(num_dims_chunks);
+
+
+    if(num_dims_chunks==0){
+      return(retvec);
+    }
+
+    if (num_dims_chunks != num_dims_ds) {
+      HDF5ErrMapper::ToException<DataSetException>(
+          "Filter chunksize rank does not match dataset rank");
+    }
+
+    std::transform(dim_size.begin(),dim_size.end(),filt.chunksizes.begin(),retvec.begin(),std::divides<hsize_t>());
+    return(retvec);
+
+  }
+
+
+  inline std::vector<hsize_t> DataSet::get_chunk_offset(const std::vector<hsize_t> &chunk_idx) const{
+    auto num_chunk_v=get_num_chunks();
+    if(chunk_idx.size()!=num_chunk_v.size()){
+        HDF5ErrMapper::ToException<DataSetException>(
+            "Filter chunksize rank does not match chunk_idx.size()");
+      }
+    std::vector<hsize_t> retvec(chunk_idx.size());
+
+    if(retvec.size()==0){
+      return(retvec);
+    }
+
+    if (chunk_idx > num_chunk_v) {
+      HDF5ErrMapper::ToException<DataSetException>(
+						   "Chunk index greater than number of chunks!");
+    }
+
+    auto filt = this->getFilter();
+    const size_t num_dims_chunks = filt.chunksizes.size();
+
+    std::transform(chunk_idx.begin(), chunk_idx.end(), filt.chunksizes.begin(), retvec.begin(),
+                   std::multiplies<hsize_t>());
+    return (retvec);
+  }
+
+
+  inline std::optional<size_t> DataSet::read_raw_chunk(std::vector<std::byte> &data_buff, const std::vector<size_t> &offsets) const {
+    hsize_t chunk_nbytes;
+
+    //    T ret_vec(read_chunk_nbytes);
+    uint32_t    read_filter_mask = 0; //filter mask after direct read
+    std::vector<hsize_t> h_offsets(offsets.size());
+    std::copy(offsets.begin(),offsets.end(),h_offsets.begin());
+
+    auto ret =H5Dget_chunk_storage_size(_hid, h_offsets.data(), &chunk_nbytes);
+    auto buff_size = data_buff.size();
+    if(chunk_nbytes>buff_size){
+      size_t newsize=chunk_nbytes;
+      //      Rcpp::Rcerr<<"resizing from "<<data_buff.size()<<"to "<<newsize<<std::endl;
+      data_buff.resize(newsize);
+    }
+
+    if ((H5Dread_chunk(_hid, H5P_DEFAULT, h_offsets.data(),
+		       &read_filter_mask, data_buff.data())) < 0) {
+      HDF5ErrMapper::ToException<DataSetException>(
+						   "Unable to read direct chunk");
+    }
+    if(read_filter_mask!=0){
+      return(std::nullopt);
+    }
+
+    return chunk_nbytes;
+  }
+
+
+
+  inline void DataSet::write_raw_chunk(std::vector<std::byte> &data_buff, const std::vector<size_t> &offsets,std::optional<size_t> buff_size) const {
+    uint32_t    filter_mask = 0; //filter mask after direct read
+
+    std::vector<hsize_t> h_offsets(offsets.size());
+    std::copy(offsets.begin(),offsets.end(),h_offsets.begin());
+    if(buff_size){
+      if(H5Dwrite_chunk(_hid, H5P_DEFAULT, filter_mask,
+			h_offsets.data(), buff_size.value(), data_buff.data())<0){
+	      HDF5ErrMapper::ToException<DataSetException>(
+							   "Unable to write direct chunk");
+      }
+    }else{
+      filter_mask = 0x00000001;
+      if(H5Dwrite_chunk(_hid, H5P_DEFAULT, filter_mask,
+			h_offsets.data(), data_buff.size(), data_buff.data())){
+	HDF5ErrMapper::ToException<DataSetException>(
+						     "Unable to write direct chunk");
+      }
+    }
+  }
+  // template<typename T>
+  // inline T DataSet::read_raw_chunk(const std::vector<hsize_t> &chunk_idx) const {
+
+  //   hsize_t read_chunk_nbytes;
+
+
+  //   auto offset_vec = get_chunk_offset(chunk_idx);
+  //   auto ret =H5Dget_chunk_storage_size(_hid, offset_vec.data(), &read_chunk_nbytes);
+  //   T ret_vec(read_chunk_nbytes);
+  //   unsigned    read_filter_mask = 0; filter mask after direct read
+
+  //   if ((H5Dread_chunk(_hid, H5P_DEFAULT, offset_vec.data(),
+  //                      &read_filter_mask, (void *)&ret_vec[0])) < 0) {
+  //     HDF5ErrMapper::ToException<DataSetException>(
+  //         "Unable to read direct chunk");
+  //   }
+  //   return (ret_vec);
+  // }
 
   inline bool DataSet::isTransposed() const {
     int transpose_int = 0;
@@ -51,9 +178,15 @@ inline DataType DataSet::getDataType() const {
   }
 
   inline void DataSet::extend(const std::vector<size_t> &new_dims) {
-    std::vector<hsize_t> real_new_dims(new_dims.size());
-    std::copy(new_dims.begin(), new_dims.end(), real_new_dims.begin());
-    if ((_hid =  H5Dset_extent(_hid,real_new_dims.data())) < 0) {
+    const size_t numDimensions = getSpace().getDimensions().size();
+    if(new_dims.size()!=numDimensions){
+       HDF5ErrMapper::ToException<DataSetException>(
+            "Invalid dataspace dimensions, got " + std::to_string(new_dims.size()) +
+            " expected " + std::to_string(numDimensions));
+    }
+    std::vector<hsize_t> real_new_dims(new_dims.begin(),new_dims.end());
+      //    std::copy(new_dims.begin(), new_dims.end(), real_new_dims.begin());
+    if ((H5Dset_extent(_hid,real_new_dims.data())) < 0) {
 	HDF5ErrMapper::ToException<DataSetException>(
             "Unable to extend DataSet");
     }
diff --git a/inst/include/highfive/bits/H5DataType_misc.hpp b/inst/include/highfive/bits/H5DataType_misc.hpp
index 8aaf545..66487f9 100644
--- a/inst/include/highfive/bits/H5DataType_misc.hpp
+++ b/inst/include/highfive/bits/H5DataType_misc.hpp
@@ -19,6 +19,17 @@ namespace HighFive {
 
   inline DataType::DataType(){}
 
+  inline size_t	DataType::n_elem() const{
+    auto sup =H5Tget_class(_hid);
+    bool is_str = sup==H5T_STRING;
+    //    H5Tclose(sup);
+    if(is_str){
+
+      return(H5Tget_size(_hid));
+    }
+    return 1;
+  }
+
 inline bool DataType::operator==(const DataType& other) const {
     return (H5Tequal(_hid, other._hid) > 0);
 }
@@ -135,9 +146,9 @@ inline AtomicType<std::string>::AtomicType() {
 template <>
 inline AtomicType<std::string>::AtomicType(int size) {
   _hid = H5Tcopy(H5T_C_S1);
-  size = (size < 0) ? H5T_VARIABLE : size;
+  size_t rsize = (size < 0) ? H5T_VARIABLE : static_cast<size_t>(size);
 
-  if (H5Tset_size(_hid, size) < 0) {
+  if (H5Tset_size(_hid, rsize) < 0) {
     HDF5ErrMapper::ToException<DataTypeException>(
 						  "Unable to define datatype size to variable");
   }
diff --git a/inst/include/highfive/bits/H5File_misc.hpp b/inst/include/highfive/bits/H5File_misc.hpp
index c4969df..e20baa7 100644
--- a/inst/include/highfive/bits/H5File_misc.hpp
+++ b/inst/include/highfive/bits/H5File_misc.hpp
@@ -40,9 +40,9 @@ inline int convert_open_flag(int openFlags) {
     //     return (stat (name.c_str(), &buffer) == 0);
     // }
 
-  inline bool File::start_swmr(){
-    return(H5Fstart_swmr_write(_hid) > 0);
-  }
+//  inline bool File::start_swmr(){
+//    return(H5Fstart_swmr_write(_hid) > 0);
+ // }
 
   inline size_t File::getObjCount(unsigned int types) const{
     return (H5Fget_obj_count( _hid,types ));
@@ -96,14 +96,14 @@ inline File::File(const std::string& filename, int openFlags,
     }
 }
 
-  inline boost::optional<File> File::openFile(const std::string& filename, int openFlags,const FileDriver& driver){
+  inline std::optional<File> File::openFile(const std::string& filename, int openFlags,const FileDriver& driver){
     try{
       HighFive::SilenceHDF5 silence;
       File file(filename,openFlags,driver);
       return(file);
     }catch (HighFive::Exception& err) {
       // Rcpp::StringVector retvec(1);
-      return(boost::none);
+      return(std::nullopt);
     }
 
   }
diff --git a/inst/include/highfive/bits/H5Iterables_misc.hpp b/inst/include/highfive/bits/H5Iterables_misc.hpp
index 54ddcbf..562a657 100644
--- a/inst/include/highfive/bits/H5Iterables_misc.hpp
+++ b/inst/include/highfive/bits/H5Iterables_misc.hpp
@@ -37,12 +37,12 @@ inline herr_t convert_to_string(void *elem, hid_t type_id, unsigned ndim,
 namespace details {
 
 // iterator for H5 iterate
-
+  template<typename T>
 struct HighFiveIterateData {
-    inline HighFiveIterateData(std::vector<Path>& my_names)
+    inline HighFiveIterateData(std::vector<T>& my_names)
         : names(my_names), err(NULL) {}
 
-    std::vector<Path>& names;
+    std::vector<T>& names;
     std::exception* err;
 
     inline void throwIfError() {
@@ -52,21 +52,21 @@ struct HighFiveIterateData {
     }
 };
 
-template <typename InfoType>
+  template <typename InfoType, typename T>
 inline herr_t internal_high_five_iterate(hid_t id, const char* name,
                                          const InfoType* info, void* op_data) {
     (void)id;
     (void)info;
 
-    HighFiveIterateData* data = static_cast<HighFiveIterateData*>(op_data);
+    HighFiveIterateData<T>* data = static_cast<HighFiveIterateData<T>*>(op_data);
     try {
-      H5O_info_t tid;
+      //      H5O_info_t tid;
 #if defined(H5_USE_110_API)
-      auto ret = H5Oget_info_by_name2(id,name,&tid,H5O_INFO_ALL,H5P_DEFAULT);
+      //      auto ret = H5Oget_info_by_name2(id,name,&tid,H5O_INFO_ALL,H5P_DEFAULT);
       #else
-      auto ret = H5Oget_info_by_name(static_cast<const Derivate *>(this)->getId(), object_name.c_str(), &tid,H5P_DEFAULT);
+      //      auto ret = H5Oget_info_by_name(static_cast<const Derivate *>(this)->getId(), object_name.c_str(), &tid,H5P_DEFAULT);
 #endif
-      data->names.push_back(Path(std::string(name)));
+      data->names.push_back(T(std::string(name)));
         return 0;
     } catch (...) {
       data->err =
diff --git a/inst/include/highfive/bits/H5Node_traits.hpp b/inst/include/highfive/bits/H5Node_traits.hpp
index e6b8c67..af23399 100644
--- a/inst/include/highfive/bits/H5Node_traits.hpp
+++ b/inst/include/highfive/bits/H5Node_traits.hpp
@@ -13,6 +13,8 @@
 #include <boost/optional.hpp>
 #include "../H5Filter.hpp"
 
+class Path;
+
 
 namespace HighFive {
 
@@ -81,7 +83,7 @@ class NodeTraits {
   DataSet getDataSet(const Path& dataset_name) const;
 
 
-  boost::optional<DataSet> openDataSet(const Path& dataset_name) const;
+  std::optional<DataSet> openDataSet(const Path& dataset_name) const;
 
 
 
@@ -101,7 +103,7 @@ class NodeTraits {
 
 
 
-  boost::optional<Group> openGroup(const Path& group_name) const;
+  std::optional<Group> openGroup(const Path& group_name) const;
 
 
 
@@ -131,17 +133,17 @@ class NodeTraits {
   ///
   /// \brief return either a group or dataset
   /// \return variant containing either a group or dataset
-  boost::variant<DataSet,Group> getObject(const Path & object_name) const;
+  std::variant<DataSet,Group> getObject(const Path & object_name) const;
 
 
 
-  boost::optional<boost::variant<DataSet,Group>> openObject(const Path & object_name) const;
+  std::optional<std::variant<DataSet,Group>> openObject(const Path & object_name) const;
 
 
   ///
   /// \brief return all leaf objects
-  /// \return zero or more objects (represented as boost::variants)
-  std::vector<boost::variant<DataSet,Group> > getObjects() const;
+  /// \return zero or more objects (represented as std::variants)
+  std::vector<std::variant<DataSet,Group> > getObjects() const;
 
 
   bool _exist(const std::string& node_name) const;
@@ -154,7 +156,7 @@ class NodeTraits {
   bool exist(const Path& node_name) const;
 private:
   static Group grpCreate(const hid_t root_id, const char* name);
-  boost::variant<DataSet,Group> getObj(const hid_t root_id, const char* name) const;
+  std::variant<DataSet,Group> getObj(const hid_t root_id, const char* name) const;
   typedef Derivate derivate_type;
 };
 }
diff --git a/inst/include/highfive/bits/H5Node_traits_misc.hpp b/inst/include/highfive/bits/H5Node_traits_misc.hpp
index 8f079a5..3f9cd98 100644
--- a/inst/include/highfive/bits/H5Node_traits_misc.hpp
+++ b/inst/include/highfive/bits/H5Node_traits_misc.hpp
@@ -85,11 +85,11 @@ namespace HighFive {
   }
 
   template <typename Derivate>
-  inline boost::optional<DataSet>
+  inline std::optional<DataSet>
   NodeTraits<Derivate>::openDataSet(const Path & dataset_name) const {
 
     if(!this->exist(dataset_name)){
-      return(boost::none);
+      return(std::nullopt);
     } else {
       return (this->getDataSet(dataset_name));
     }
@@ -100,7 +100,7 @@ namespace HighFive {
 
 
     auto gcpl = H5Pcreate (H5P_LINK_CREATE);
-    auto status = H5Pset_create_intermediate_group (gcpl, 1);
+    H5Pset_create_intermediate_group (gcpl, 1);
     Group group;
     if ((group._hid = H5Gcreate2(static_cast<const Derivate *>(this)->getId(),
 				 group_name.c_str(), gcpl, H5P_DEFAULT,
@@ -127,10 +127,10 @@ namespace HighFive {
   }
 
   template <typename Derivate>
-  inline boost::optional<Group>
+  inline std::optional<Group>
   NodeTraits<Derivate>::openGroup(const Path  &group_name) const {
     if(!this->exist(group_name)){
-      return(boost::none);
+      return(std::nullopt);
     } else {
       return (this->getGroup(group_name));
     }
@@ -209,31 +209,31 @@ namespace HighFive {
 
 
   template<typename Derivate>
-  inline boost::variant<DataSet,Group> NodeTraits<Derivate>::getObject(const Path  & object_name) const{
+  inline std::variant<DataSet,Group> NodeTraits<Derivate>::getObject(const Path  & object_name) const{
 
     if(isGroup(object_name)){
       return (getGroup(object_name));
     }
-    if (isDataSet(object_name)) {
-      return (getDataSet(object_name));
+    if (!isDataSet(object_name)) {
+      HDF5ErrMapper::ToException<ObjectException>(std::string("Object is not a Group or DataSet: ") + object_name);
     }
-    HDF5ErrMapper::ToException<ObjectException>(std::string("Object is not a Group or DataSet: ") + object_name);
+    return (getDataSet(object_name));
   }
 
   template<typename Derivate>
-  inline boost::optional<boost::variant<DataSet,Group> > NodeTraits<Derivate>::openObject(const Path & object_name) const{
+  inline std::optional<std::variant<DataSet,Group> > NodeTraits<Derivate>::openObject(const Path & object_name) const{
     if(this->exist(object_name)){
       return(this->getObject(object_name));
     }else{
-      return(boost::none);
+      return(std::nullopt);
     }
   }
 
   template <typename Derivate>
-  inline std::vector<boost::variant<DataSet,Group> > NodeTraits<Derivate>::getObjects() const {
+  inline std::vector<std::variant<DataSet,Group> > NodeTraits<Derivate>::getObjects() const {
     auto names = this->listObjectNames();
     const int num_objs=names.size();
-    std::vector<boost::variant<DataSet,Group> > retvec(num_objs);
+    std::vector<std::variant<DataSet,Group> > retvec(num_objs);
     for (int i = 0; i < num_objs; i++) {
       retvec[i] = this->getObject(names[i]);
     }
@@ -273,14 +273,14 @@ namespace HighFive {
 
     
     std::vector<Path> names;
-    details::HighFiveIterateData iterateData(names);
+    details::HighFiveIterateData<Path> iterateData(names);
 
     size_t num_objs = getNumberObjects();
     names.reserve(num_objs);
 
     if (H5Literate(static_cast<const Derivate *>(this)->getId(), H5_INDEX_NAME,
                    H5_ITER_NATIVE, NULL,
-                   &details::internal_high_five_iterate<H5L_info_t>,
+                   &details::internal_high_five_iterate<H5L_info_t,Path>,
                    static_cast<void *>(&iterateData)) < 0) {
       HDF5ErrMapper::ToException<GroupException>(
           std::string("Unable to list objects in group"));
diff --git a/inst/include/highfive/bits/H5Slice_traits.hpp b/inst/include/highfive/bits/H5Slice_traits.hpp
index 2094990..a6b95f1 100644
--- a/inst/include/highfive/bits/H5Slice_traits.hpp
+++ b/inst/include/highfive/bits/H5Slice_traits.hpp
@@ -116,7 +116,6 @@ class SliceTraits {
     /// dimensional array )
     template <typename T>
     void write(const T& buffer);
-
     ///
     /// Write from a raw buffer into this dataset
     ///
diff --git a/inst/include/highfive/bits/H5Slice_traits_misc.hpp b/inst/include/highfive/bits/H5Slice_traits_misc.hpp
index 707cdfa..8d8bdd9 100644
--- a/inst/include/highfive/bits/H5Slice_traits_misc.hpp
+++ b/inst/include/highfive/bits/H5Slice_traits_misc.hpp
@@ -135,11 +135,6 @@ inline ElementSet::ElementSet(const std::vector<std::size_t>& element_ids)
         std::copy(offset[i].begin(), offset[i].end(), offset_local.begin());
         std::copy(count[i].begin(), count[i].end(), count_local.begin());
 
-	// for(size_t j=0; j<Dims;j++){
-	//   count_total[j]=count_total[j]+count_local[j];
-	// }
-
-
         if (H5Sselect_hyperslab(space.getId(),H5S_SELECT_OR, offset_local.data(),
                                 nullptr,
                                 count_local.data(), NULL) < 0) {
@@ -298,10 +293,6 @@ SliceTraits<Derivate>::select(const ElementSet& elements) const {
 template <typename Derivate>
 inline std::vector<size_t> SliceTraits<Derivate>::getDataDimensions() const {
   const bool doTranspose = details::get_dataset(static_cast<const Derivate *>(this)).isTransposed();
-  // if(doTranspose){
-  //   HDF5ErrMapper::ToException<DataSpaceException>(
-  // 						     "Transposed data has been deprecated");
-  // }
   std::vector<size_t> dims =static_cast<const Derivate*>(this)->getMemSpace().getDimensions();
   if (doTranspose) {
     std::reverse(dims.begin(), dims.end());
@@ -343,9 +334,10 @@ inline void SliceTraits<Derivate>::read(T &array) {
 
   auto mem_datatype = array_datatype.getId();
   auto u_id=mem_datatype;
-  if(H5Tget_size(dt.getId())>255){
-    u_id=dt.getId();
-  }
+  // if(H5Tget_size(dt.getId())>255){
+  //   u_id=dt.getId();
+  // }
+  u_id = dt.getId();
 
   if (H5Dread(
 	      details::get_dataset(static_cast<const Derivate *>(this)).getId(),
@@ -401,8 +393,8 @@ inline void SliceTraits<Derivate>::write(const T& buffer) {
         throw DataSpaceException(ss.str());
     }
 
-    const AtomicType<typename details::type_of_array<type_no_const>::type>
-        array_datatype;
+    // const AtomicType<typename details::type_of_array<type_no_const>::type>
+    //     array_datatype;
     auto dt = ds.getDataType();
     // Apply pre write convertions
     bool isTranspose = details::get_dataset(static_cast<const Derivate *>(this)).isTransposed();
@@ -412,22 +404,33 @@ inline void SliceTraits<Derivate>::write(const T& buffer) {
     }
     details::data_converter<type_no_const> converter(nocv_buffer, mem_space,dt);
 
-    auto u_id=array_datatype.getId();;
-    if(H5Tget_size(dt.getId())>255){
-      u_id=dt.getId();
-    }
+    auto u_id=dt.getId();
+    //array_datatype.getId();
+
+    // if(H5Tget_size(dt.getId())>255){
+    //   u_id=
+    // }
+
+    auto tw = static_cast<const void*>(converter.transform_write(nocv_buffer));
 
     if (H5Dwrite(details::get_dataset(static_cast<Derivate*>(this)).getId(),
                  u_id,
                  details::get_memspace_id((static_cast<Derivate*>(this))),
                  space.getId(), H5P_DEFAULT,
-                 static_cast<const void*>(
-                     converter.transform_write(nocv_buffer))) < 0) {
+		 tw) < 0) {
         HDF5ErrMapper::ToException<DataSetException>(
             "Error during HDF5 Write: ");
     }
 }
 
+
+
+
+
+
+
+
+
 template <typename Derivate>
 template <typename T>
 inline void SliceTraits<Derivate>::write(const T* buffer) {
diff --git a/inst/include/highfive/bits/H5Utils.hpp b/inst/include/highfive/bits/H5Utils.hpp
index 8c44b8b..5a521d6 100644
--- a/inst/include/highfive/bits/H5Utils.hpp
+++ b/inst/include/highfive/bits/H5Utils.hpp
@@ -22,9 +22,9 @@
 #include <boost/numeric/ublas/matrix.hpp>
 #endif
 
-
-
-#include <Eigen/Core>
+#pragma warning(push, 0)
+#include <RcppEigen.h>
+#pragma warning(pop)
 
 
 
@@ -33,143 +33,144 @@
 namespace HighFive {
 
 
-    namespace details {
-
-// determine at compile time number of dimensions of in memory datasets
-template <typename T>
-struct array_dims {
-    static const size_t value = 0;
-};
-
-template <typename T>
-struct array_dims<std::vector<T> > {
-    static const size_t value = 1 + array_dims<T>::value;
-};
-
-template <typename T>
-struct array_dims<T*> {
-    static const size_t value = 1 + array_dims<T>::value;
-};
-
-template <typename T, std::size_t N>
-struct array_dims<T[N]> {
-    static const size_t value = 1 + array_dims<T>::value;
-};
-
-
-
-
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct array_dims<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > {
-            static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
-        };
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct array_dims<Eigen::Map<const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
-            static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
-        };
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct array_dims<const Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
-            static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
-        };
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct array_dims<Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
-            static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
-        };
-
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        std::vector<size_t>
-        get_dim_vector(const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> &mat) {
-            const size_t dim_num = array_dims<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> >::value;
-            std::vector<size_t> dims(dim_num);
-            if (dim_num > 0) {
-                dims[0] = mat.rows();
-            }
-            if (dim_num > 1) {
-                dims[1] = mat.cols();
-            }
-            return dims;
-        }
-
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        std::vector<size_t>
-        get_dim_vector(const Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > &mat) {
-            const size_t dim_num = array_dims<Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > >::value;
-            std::vector<size_t> dims(dim_num);
-            if (dim_num > 0) {
-                dims[0] = mat.rows();
-            }
-            if (dim_num > 1) {
-                dims[1] = mat.cols();
-            }
-            return dims;
-        }
+  namespace details {
+
+    // determine at compile time number of dimensions of in memory datasets
+    template <typename T>
+    struct array_dims {
+      static const size_t value = 0;
+    };
+
+    template <typename T>
+    struct array_dims<std::vector<T> > {
+      static const size_t value = 1 + array_dims<T>::value;
+    };
+
+    template <typename T>
+    struct array_dims<T*> {
+      static const size_t value = 1 + array_dims<T>::value;
+    };
+
+    template <typename T, std::size_t N>
+    struct array_dims<T[N]> {
+      static const size_t value = 1 + array_dims<T>::value;
+    };
+
+
+
+
+
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct array_dims<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > {
+      static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
+    };
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct array_dims<Eigen::Map<const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
+      static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
+    };
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct array_dims<const Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
+      static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
+    };
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct array_dims<Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
+      static const size_t value = (RowsAtCompileTime != 1 ? 1 : 0) + (ColsAtCompileTime != 1 ? 1 : 0);
+    };
+
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    std::vector<size_t>
+    get_dim_vector(const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> &mat) {
+      const size_t dim_num = array_dims<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> >::value;
+      std::vector<size_t> dims(dim_num);
+      if (dim_num > 0) {
+        dims[0] = mat.rows();
+      }
+      if (dim_num > 1) {
+        dims[1] = mat.cols();
+      }
+      return dims;
+    }
+
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    std::vector<size_t>
+    get_dim_vector(const Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > &mat) {
+      const size_t dim_num = array_dims<Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > >::value;
+      std::vector<size_t> dims(dim_num);
+      if (dim_num > 0) {
+        dims[0] = mat.rows();
+      }
+      if (dim_num > 1) {
+        dims[1] = mat.cols();
+      }
+      return dims;
+    }
 
 
 #ifdef H5_USE_BOOST
-template <typename T, std::size_t Dims>
-struct array_dims<boost::multi_array<T, Dims> > {
-    static const size_t value = Dims;
-};
-
-template <typename T>
-struct array_dims<boost::numeric::ublas::matrix<T,boost::numeric::ublas::row_major> > {
-    static const size_t value = 2;
-};
-
-template <typename T>
-struct array_dims<boost::numeric::ublas::matrix<T,boost::numeric::ublas::column_major> > {
-    static const size_t value = 2;
-};  
+    template <typename T, std::size_t Dims>
+    struct array_dims<boost::multi_array<T, Dims> > {
+      static const size_t value = Dims;
+    };
+
+    template <typename T>
+    struct array_dims<boost::numeric::ublas::matrix<T,boost::numeric::ublas::row_major> > {
+      static const size_t value = 2;
+    };
+
+    template <typename T>
+    struct array_dims<boost::numeric::ublas::matrix<T,boost::numeric::ublas::column_major> > {
+      static const size_t value = 2;
+    };
 #endif
 
-// determine recursively the size of each dimension of a N dimension vector
-template <typename T>
-void get_dim_vector_rec(const T& vec, std::vector<size_t>& dims) {
-    (void)dims;
-    (void)vec;
-}
+    // determine recursively the size of each dimension of a N dimension vector
+    template <typename T>
+    void get_dim_vector_rec(const T& vec, std::vector<size_t>& dims) {
+      (void)dims;
+      (void)vec;
+    }
 
-template <typename T>
-void get_dim_vector_rec(const std::vector<T>& vec, std::vector<size_t>& dims) {
-    dims.push_back(vec.size());
-    get_dim_vector_rec(vec[0], dims);
-}
+    template <typename T>
+    void get_dim_vector_rec(const std::vector<T>& vec, std::vector<size_t>& dims) {
+      dims.push_back(vec.size());
+      get_dim_vector_rec(vec[0], dims);
+    }
 
-template <typename T>
-std::vector<size_t> get_dim_vector(const std::vector<T>& vec) {
-    std::vector<size_t> dims;
-    get_dim_vector_rec(vec, dims);
-    return dims;
-}
+    template <typename T>
+    std::vector<size_t> get_dim_vector(const std::vector<T>& vec) {
+      std::vector<size_t> dims;
+      get_dim_vector_rec(vec, dims);
+      return dims;
+    }
 
-// determine at compile time recursively the basic type of the data
-template <typename T>
-struct type_of_array {
-    typedef T type;
-};
+    // determine at compile time recursively the basic type of the data
+    template <typename T>
+    struct type_of_array {
+      typedef T type;
+    };
 
-template <typename T>
-struct type_of_array<std::vector<T> > {
-    typedef typename type_of_array<T>::type type;
-};
+    template <typename T>
+    struct type_of_array<std::vector<T> > {
+      typedef typename type_of_array<T>::type type;
+    };
 
 
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct type_of_array<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > {
-            typedef typename type_of_array<Scalar>::type type;
-        };
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct type_of_array<Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
-            typedef typename type_of_array<Scalar>::type type;
-        };
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct type_of_array<const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > {
-            typedef typename type_of_array<Scalar>::type type;
-        };
-        template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
-        struct type_of_array<Eigen::Map<const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
-            typedef typename type_of_array<Scalar>::type type;
-        };
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct type_of_array<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > {
+      typedef typename type_of_array<Scalar>::type type;
+    };
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct type_of_array<Eigen::Map<Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
+      typedef typename type_of_array<Scalar>::type type;
+    };
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct type_of_array<const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > {
+      typedef typename type_of_array<Scalar>::type type;
+    };
+    template<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime, int Options>
+    struct type_of_array<Eigen::Map<const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options> > > {
+      typedef typename type_of_array<Scalar>::type type;
+    };
 
 
 
@@ -177,94 +178,94 @@ struct type_of_array<std::vector<T> > {
 
 
 #ifdef H5_USE_BOOST
-template <typename T, std::size_t Dims>
-struct type_of_array<boost::multi_array<T, Dims> > {
-    typedef typename type_of_array<T>::type type;
-};
-
-template <typename T>
-struct type_of_array<boost::numeric::ublas::matrix<T,boost::numeric::ublas::row_major> > {
-    typedef typename type_of_array<T>::type type;
-};
-
-template <typename T>
-struct type_of_array<boost::numeric::ublas::matrix<T,boost::numeric::ublas::column_major> > {
-    typedef typename type_of_array<T>::type type;
-};
+    template <typename T, std::size_t Dims>
+    struct type_of_array<boost::multi_array<T, Dims> > {
+      typedef typename type_of_array<T>::type type;
+    };
+
+    template <typename T>
+    struct type_of_array<boost::numeric::ublas::matrix<T,boost::numeric::ublas::row_major> > {
+      typedef typename type_of_array<T>::type type;
+    };
+
+    template <typename T>
+    struct type_of_array<boost::numeric::ublas::matrix<T,boost::numeric::ublas::column_major> > {
+      typedef typename type_of_array<T>::type type;
+    };
 #endif
 
-template <typename T>
-struct type_of_array<T*> {
-    typedef typename type_of_array<T>::type type;
-};
-
-template <typename T, std::size_t N>
-struct type_of_array<T[N]> {
-    typedef typename type_of_array<T>::type type;
-};
-
-// same type compile time check
-template <typename T, typename U>
-struct is_same {
-    static const bool value = false;
-};
-
-template <typename T>
-struct is_same<T, T> {
-    static const bool value = true;
-};
-
-// check if the type is a container ( only vector supported for now )
-template <typename>
-struct is_container {
-    static const bool value = false;
-};
-
-template <typename T>
-struct is_container<std::vector<T> > {
-    static const bool value = true;
-};
-
-// check if the type is a basic C-Array
-// check if the type is a container ( only vector supported for now )
-template <typename>
-struct is_c_array {
-    static const bool value = false;
-};
-
-template <typename T>
-struct is_c_array<T*> {
-    static const bool value = true;
-};
-
-template <typename T, std::size_t N>
-struct is_c_array<T[N]> {
-    static const bool value = true;
-};
-
-// enable if implem for not c++11 compiler
-template <bool Cond, typename T = void>
-struct enable_if {};
-
-template <typename T>
-struct enable_if<true, T> {
-    typedef T type;
-};
-
-// remove const
-template <typename Type>
-struct remove_const {
-    typedef Type type;
-};
-
-template <typename Type>
-struct remove_const<Type const> {
-    typedef Type type;
-};
-
-
-
-
-} // end details
+    template <typename T>
+    struct type_of_array<T*> {
+      typedef typename type_of_array<T>::type type;
+    };
+
+    template <typename T, std::size_t N>
+    struct type_of_array<T[N]> {
+      typedef typename type_of_array<T>::type type;
+    };
+
+    // same type compile time check
+    template <typename T, typename U>
+    struct is_same {
+      static const bool value = false;
+    };
+
+    template <typename T>
+    struct is_same<T, T> {
+      static const bool value = true;
+    };
+
+    // check if the type is a container ( only vector supported for now )
+    template <typename>
+    struct is_container {
+      static const bool value = false;
+    };
+
+    template <typename T>
+    struct is_container<std::vector<T> > {
+      static const bool value = true;
+    };
+
+    // check if the type is a basic C-Array
+    // check if the type is a container ( only vector supported for now )
+    template <typename>
+    struct is_c_array {
+      static const bool value = false;
+    };
+
+    template <typename T>
+    struct is_c_array<T*> {
+      static const bool value = true;
+    };
+
+    template <typename T, std::size_t N>
+    struct is_c_array<T[N]> {
+      static const bool value = true;
+    };
+
+    // enable if implem for not c++11 compiler
+    template <bool Cond, typename T = void>
+    struct enable_if {};
+
+    template <typename T>
+    struct enable_if<true, T> {
+      typedef T type;
+    };
+
+    // remove const
+    template <typename Type>
+    struct remove_const {
+      typedef Type type;
+    };
+
+    template <typename Type>
+    struct remove_const<Type const> {
+      typedef Type type;
+    };
+
+
+
+
+  } // end details
 }
 
diff --git a/inst/include/meta/meta.hpp b/inst/include/meta/meta.hpp
index 4acd1de..91eedc6 100644
--- a/inst/include/meta/meta.hpp
+++ b/inst/include/meta/meta.hpp
@@ -21,11 +21,12 @@
 #include <type_traits>
 #include <utility>
 
-#if defined(__clang__)
+#ifdef __clang__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunknown-pragmas"
 #pragma GCC diagnostic ignored "-Wpragmas"
 #pragma GCC diagnostic ignored "-Wdocumentation-deprecated-sync"
+#pragma GCC diagnostic ignored "-Wmissing-variable-declarations"
 #endif
 
 /// \defgroup meta Meta
@@ -68,7 +69,7 @@
 /// Datatypes.
 /// \ingroup meta
 
-/// \defgroup list List
+/// \defgroup list list_like
 /// \ingroup datatype
 
 /// \defgroup integral Integer sequence
@@ -113,3356 +114,3827 @@
 /// Tiny metaprogramming library
 namespace meta
 {
-    /// \cond
-    inline namespace v1
+    namespace detail
     {
-        /// \endcond
-
-        namespace detail
-        {
-            /// Returns a \p T nullptr
-            template <typename T>
-            constexpr T *_nullptr_v()
-            {
-                return nullptr;
-            }
-        } // namespace detail
-
-        /// An empty type.
-        /// \ingroup datatype
-        struct nil_
-        {
-        };
-
-        /// Type alias for \p T::type.
-        /// \ingroup invocation
-        template <typename T>
-        using _t = typename T::type;
-
-#if defined(__cpp_variable_templates) || defined(META_DOXYGEN_INVOKED)
-        /// Variable alias for \c T::type::value
-        /// \note Requires C++14 or greater.
-        /// \ingroup invocation
+        /// Returns a \p T nullptr
         template <typename T>
-        constexpr typename _t<T>::value_type _v = _t<T>::value;
-#endif
-
-        /// Lazy versions of meta actions
-        namespace lazy
+        constexpr T *_nullptr_v()
         {
-            /// \sa `meta::_t`
-            /// \ingroup lazy_invocation
-            template <typename T>
-            using _t = defer<_t, T>;
+            return nullptr;
         }
 
-        /// An integral constant wrapper for \c std::size_t.
-        /// \ingroup integral
-        template <std::size_t N>
-        using size_t = std::integral_constant<std::size_t, N>;
-
-        /// An integral constant wrapper for \c bool.
-        /// \ingroup integral
-        template <bool B>
-        using bool_ = std::integral_constant<bool, B>;
+#if META_CXX_VARIABLE_TEMPLATES
+        template <typename T>
+        META_INLINE_VAR constexpr T *nullptr_v = nullptr;
+#endif
+    } // namespace detail
 
-        /// An integral constant wrapper for \c int.
-        /// \ingroup integral
-        template <int I>
-        using int_ = std::integral_constant<int, I>;
+    /// An empty type.
+    /// \ingroup datatype
+    struct nil_
+    {
+    };
+
+    /// Type alias for \p T::type.
+    /// \ingroup invocation
+    template <META_TYPE_CONSTRAINT(trait) T>
+    using _t = typename T::type;
+
+#if META_CXX_VARIABLE_TEMPLATES || defined(META_DOXYGEN_INVOKED)
+    /// Variable alias for \c T::type::value
+    /// \note Requires C++14 or greater.
+    /// \ingroup invocation
+    template <META_TYPE_CONSTRAINT(integral) T>
+    constexpr typename T::type::value_type _v = T::type::value;
+#endif
 
-        /// An integral constant wrapper for \c char.
-        /// \ingroup integral
-        template <char Ch>
-        using char_ = std::integral_constant<char, Ch>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // Math operations
-        /// An integral constant wrapper around the result of incrementing the wrapped
-        /// integer \c
-        /// T::type::value.
+    /// Lazy versions of meta actions
+    namespace lazy
+    {
+        /// \sa `meta::_t`
+        /// \ingroup lazy_invocation
+        template <typename T>
+        using _t = defer<_t, T>;
+    } // namespace lazy
+
+    /// An integral constant wrapper for \c std::size_t.
+    /// \ingroup integral
+    template <std::size_t N>
+    using size_t = std::integral_constant<std::size_t, N>;
+
+    /// An integral constant wrapper for \c bool.
+    /// \ingroup integral
+    template <bool B>
+    using bool_ = std::integral_constant<bool, B>;
+
+    /// An integral constant wrapper for \c int.
+    /// \ingroup integral
+    template <int I>
+    using int_ = std::integral_constant<int, I>;
+
+    /// An integral constant wrapper for \c char.
+    /// \ingroup integral
+    template <char Ch>
+    using char_ = std::integral_constant<char, Ch>;
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Math operations
+    /// An integral constant wrapper around the result of incrementing the wrapped integer \c
+    /// T::type::value.
+    template <META_TYPE_CONSTRAINT(integral) T>
+    using inc = std::integral_constant<decltype(T::type::value + 1), T::type::value + 1>;
+
+    /// An integral constant wrapper around the result of decrementing the wrapped integer \c
+    /// T::type::value.
+    template <META_TYPE_CONSTRAINT(integral) T>
+    using dec = std::integral_constant<decltype(T::type::value - 1), T::type::value - 1>;
+
+    /// An integral constant wrapper around the result of adding the two wrapped integers
+    /// \c T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using plus = std::integral_constant<decltype(T::type::value + U::type::value),
+                                        T::type::value + U::type::value>;
+
+    /// An integral constant wrapper around the result of subtracting the two wrapped integers
+    /// \c T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using minus = std::integral_constant<decltype(T::type::value - U::type::value),
+                                            T::type::value - U::type::value>;
+
+    /// An integral constant wrapper around the result of multiplying the two wrapped integers
+    /// \c T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using multiplies = std::integral_constant<decltype(T::type::value * U::type::value),
+                                                T::type::value * U::type::value>;
+
+    /// An integral constant wrapper around the result of dividing the two wrapped integers \c
+    /// T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using divides = std::integral_constant<decltype(T::type::value / U::type::value),
+                                            T::type::value / U::type::value>;
+
+    /// An integral constant wrapper around the result of negating the wrapped integer
+    /// \c T::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T>
+    using negate = std::integral_constant<decltype(-T::type::value), -T::type::value>;
+
+    /// An integral constant wrapper around the remainder of dividing the two wrapped integers
+    /// \c T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using modulus = std::integral_constant<decltype(T::type::value % U::type::value),
+                                            T::type::value % U::type::value>;
+
+    /// A Boolean integral constant wrapper around the result of comparing \c T::type::value and
+    /// \c U::type::value for equality.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using equal_to = bool_<T::type::value == U::type::value>;
+
+    /// A Boolean integral constant wrapper around the result of comparing \c T::type::value and
+    /// \c U::type::value for inequality.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using not_equal_to = bool_<T::type::value != U::type::value>;
+
+    /// A Boolean integral constant wrapper around \c true if \c T::type::value is greater than
+    /// \c U::type::value; \c false, otherwise.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using greater = bool_<(T::type::value > U::type::value)>;
+
+    /// A Boolean integral constant wrapper around \c true if \c T::type::value is less than \c
+    /// U::type::value; \c false, otherwise.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using less = bool_<(T::type::value < U::type::value)>;
+
+    /// A Boolean integral constant wrapper around \c true if \c T::type::value is greater than
+    /// or equal to \c U::type::value; \c false, otherwise.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using greater_equal = bool_<(T::type::value >= U::type::value)>;
+
+    /// A Boolean integral constant wrapper around \c true if \c T::type::value is less than or
+    /// equal to \c U::type::value; \c false, otherwise.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using less_equal = bool_<(T::type::value <= U::type::value)>;
+
+    /// An integral constant wrapper around the result of bitwise-and'ing the two wrapped
+    /// integers \c T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using bit_and = std::integral_constant<decltype(T::type::value & U::type::value),
+                                            T::type::value & U::type::value>;
+
+    /// An integral constant wrapper around the result of bitwise-or'ing the two wrapped
+    /// integers \c T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using bit_or = std::integral_constant<decltype(T::type::value | U::type::value),
+                                            T::type::value | U::type::value>;
+
+    /// An integral constant wrapper around the result of bitwise-exclusive-or'ing the two
+    /// wrapped integers \c T::type::value and \c U::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
+    using bit_xor = std::integral_constant<decltype(T::type::value ^ U::type::value),
+                                            T::type::value ^ U::type::value>;
+
+    /// An integral constant wrapper around the result of bitwise-complementing the wrapped
+    /// integer \c T::type::value.
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral) T>
+    using bit_not = std::integral_constant<decltype(~T::type::value), ~T::type::value>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::int'
+        /// \ingroup lazy_math
         template <typename T>
-        using inc = std::integral_constant<decltype(T::type::value + 1), T::type::value + 1>;
+        using inc = defer<inc, T>;
 
-        /// An integral constant wrapper around the result of decrementing the wrapped
-        /// integer \c
-        /// T::type::value.
+        /// \sa 'meta::dec'
+        /// \ingroup lazy_math
         template <typename T>
-        using dec = std::integral_constant<decltype(T::type::value - 1), T::type::value - 1>;
+        using dec = defer<dec, T>;
 
-        /// An integral constant wrapper around the result of adding the two wrapped
-        /// integers
-        /// \c T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::plus'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using plus = std::integral_constant<decltype(T::type::value + U::type::value),
-                                            T::type::value + U::type::value>;
+        using plus = defer<plus, T, U>;
 
-        /// An integral constant wrapper around the result of subtracting the two
-        /// wrapped integers
-        /// \c T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::minus'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using minus = std::integral_constant<decltype(T::type::value - U::type::value),
-                                             T::type::value - U::type::value>;
+        using minus = defer<minus, T, U>;
 
-        /// An integral constant wrapper around the result of multiplying the two
-        /// wrapped integers
-        /// \c T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::multiplies'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using multiplies = std::integral_constant<decltype(T::type::value * U::type::value),
-                                                  T::type::value * U::type::value>;
+        using multiplies = defer<multiplies, T, U>;
 
-        /// An integral constant wrapper around the result of dividing the two wrapped
-        /// integers \c
-        /// T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::divides'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using divides = std::integral_constant<decltype(T::type::value / U::type::value),
-                                               T::type::value / U::type::value>;
+        using divides = defer<divides, T, U>;
 
-        /// An integral constant wrapper around the result of negating the wrapped
-        /// integer
-        /// \c T::type::value.
-        /// \ingroup math
+        /// \sa 'meta::negate'
+        /// \ingroup lazy_math
         template <typename T>
-        using negate = std::integral_constant<decltype(-T::type::value), -T::type::value>;
+        using negate = defer<negate, T>;
 
-        /// An integral constant wrapper around the remainder of dividing the two
-        /// wrapped integers
-        /// \c T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::modulus'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using modulus = std::integral_constant<decltype(T::type::value % U::type::value),
-                                               T::type::value % U::type::value>;
+        using modulus = defer<modulus, T, U>;
 
-        /// A Boolean integral constant wrapper around the result of comparing \c
-        /// T::type::value and
-        /// \c U::type::value for equality.
-        /// \ingroup math
+        /// \sa 'meta::equal_to'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using equal_to = bool_<T::type::value == U::type::value>;
+        using equal_to = defer<equal_to, T, U>;
 
-        /// A Boolean integral constant wrapper around the result of comparing \c
-        /// T::type::value and
-        /// \c U::type::value for inequality.
-        /// \ingroup math
+        /// \sa 'meta::not_equal_t'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using not_equal_to = bool_<T::type::value != U::type::value>;
+        using not_equal_to = defer<not_equal_to, T, U>;
 
-        /// A Boolean integral constant wrapper around \c true if \c T::type::value is
-        /// greater than
-        /// \c U::type::value; \c false, otherwise.
-        /// \ingroup math
+        /// \sa 'meta::greater'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using greater = bool_<(T::type::value > U::type::value)>;
+        using greater = defer<greater, T, U>;
 
-        /// A Boolean integral constant wrapper around \c true if \c T::type::value is
-        /// less than \c
-        /// U::type::value; \c false, otherwise.
-        /// \ingroup math
+        /// \sa 'meta::less'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using less = bool_<(T::type::value < U::type::value)>;
+        using less = defer<less, T, U>;
 
-        /// A Boolean integral constant wrapper around \c true if \c T::type::value is
-        /// greater than
-        /// or equal to \c U::type::value; \c false, otherwise.
-        /// \ingroup math
+        /// \sa 'meta::greater_equal'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using greater_equal = bool_<(T::type::value >= U::type::value)>;
+        using greater_equal = defer<greater_equal, T, U>;
 
-        /// A Boolean integral constant wrapper around \c true if \c T::type::value is
-        /// less than or
-        /// equal to \c U::type::value; \c false, otherwise.
-        /// \ingroup math
+        /// \sa 'meta::less_equal'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using less_equal = bool_<(T::type::value <= U::type::value)>;
+        using less_equal = defer<less_equal, T, U>;
 
-        /// An integral constant wrapper around the result of bitwise-and'ing the two
-        /// wrapped
-        /// integers \c T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::bit_and'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using bit_and = std::integral_constant<decltype(T::type::value & U::type::value),
-                                               T::type::value & U::type::value>;
+        using bit_and = defer<bit_and, T, U>;
 
-        /// An integral constant wrapper around the result of bitwise-or'ing the two
-        /// wrapped
-        /// integers \c T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::bit_or'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using bit_or = std::integral_constant<decltype(T::type::value | U::type::value),
-                                              T::type::value | U::type::value>;
+        using bit_or = defer<bit_or, T, U>;
 
-        /// An integral constant wrapper around the result of bitwise-exclusive-or'ing
-        /// the two
-        /// wrapped integers \c T::type::value and \c U::type::value.
-        /// \ingroup math
+        /// \sa 'meta::bit_xor'
+        /// \ingroup lazy_math
         template <typename T, typename U>
-        using bit_xor = std::integral_constant<decltype(T::type::value ^ U::type::value),
-                                               T::type::value ^ U::type::value>;
+        using bit_xor = defer<bit_xor, T, U>;
 
-        /// An integral constant wrapper around the result of bitwise-complementing the
-        /// wrapped
-        /// integer \c T::type::value.
-        /// \ingroup math
+        /// \sa 'meta::bit_not'
+        /// \ingroup lazy_math
         template <typename T>
-        using bit_not = std::integral_constant<decltype(~T::type::value), ~T::type::value>;
+        using bit_not = defer<bit_not, T>;
+    } // namespace lazy
 
-        namespace lazy
+    /// \cond
+    namespace detail
+    {
+        enum class indices_strategy_
         {
-            /// \sa 'meta::int'
-            /// \ingroup lazy_math
-            template <typename T>
-            using inc = defer<inc, T>;
+            done,
+            repeat,
+            recurse
+        };
 
-            /// \sa 'meta::dec'
-            /// \ingroup lazy_math
-            template <typename T>
-            using dec = defer<dec, T>;
-
-            /// \sa 'meta::plus'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using plus = defer<plus, T, U>;
-
-            /// \sa 'meta::minus'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using minus = defer<minus, T, U>;
-
-            /// \sa 'meta::multiplies'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using multiplies = defer<multiplies, T, U>;
-
-            /// \sa 'meta::divides'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using divides = defer<divides, T, U>;
-
-            /// \sa 'meta::negate'
-            /// \ingroup lazy_math
-            template <typename T>
-            using negate = defer<negate, T>;
-
-            /// \sa 'meta::modulus'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using modulus = defer<modulus, T, U>;
-
-            /// \sa 'meta::equal_to'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using equal_to = defer<equal_to, T, U>;
-
-            /// \sa 'meta::not_equal_t'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using not_equal_to = defer<not_equal_to, T, U>;
-
-            /// \sa 'meta::greater'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using greater = defer<greater, T, U>;
-
-            /// \sa 'meta::less'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using less = defer<less, T, U>;
-
-            /// \sa 'meta::greater_equal'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using greater_equal = defer<greater_equal, T, U>;
-
-            /// \sa 'meta::less_equal'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using less_equal = defer<less_equal, T, U>;
-
-            /// \sa 'meta::bit_and'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using bit_and = defer<bit_and, T, U>;
-
-            /// \sa 'meta::bit_or'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using bit_or = defer<bit_or, T, U>;
-
-            /// \sa 'meta::bit_xor'
-            /// \ingroup lazy_math
-            template <typename T, typename U>
-            using bit_xor = defer<bit_xor, T, U>;
-
-            /// \sa 'meta::bit_not'
-            /// \ingroup lazy_math
-            template <typename T>
-            using bit_not = defer<bit_not, T>;
+        constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
+        {
+            return cur >= end ? indices_strategy_::done
+                              : cur * 2 <= end ? indices_strategy_::repeat
+                                               : indices_strategy_::recurse;
         }
 
-        /// \cond
-        namespace detail
+        template <typename T>
+        constexpr std::size_t range_distance_(T begin, T end)
         {
-            enum class indices_strategy_
-            {
-                done,
-                repeat,
-                recurse
-            };
-
-            constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
-            {
-                return cur >= end ? indices_strategy_::done
-                                  : cur * 2 <= end ? indices_strategy_::repeat
-                                                   : indices_strategy_::recurse;
-            }
-
-            template <typename T>
-            constexpr std::size_t range_distance_(T begin, T end)
-            {
-                return begin <= end ? static_cast<std::size_t>(end - begin)
-                                    : throw "The start of the integer_sequence must not be "
-                                            "greater than the end";
-            }
-
-            template <std::size_t End, typename State, indices_strategy_ Status_>
-            struct make_indices_
-            {
-                using type = State;
-            };
-
-            template <typename T, T, typename>
-            struct coerce_indices_
-            {
-            };
+            return begin <= end ? static_cast<std::size_t>(end - begin)
+                                : throw "The start of the integer_sequence must not be "
+                                        "greater than the end";
         }
-/// \endcond
 
-///////////////////////////////////////////////////////////////////////////////////////////////
-// integer_sequence
-#ifndef __cpp_lib_integer_sequence
-        /// A container for a sequence of compile-time integer constants.
-        /// \ingroup integral
-        template <typename T, T... Is>
-        struct integer_sequence
+        template <std::size_t End, typename State, indices_strategy_ Status_>
+        struct make_indices_
         {
-            using value_type = T;
-            /// \return `sizeof...(Is)`
-            static constexpr std::size_t size() noexcept { return sizeof...(Is); }
+            using type = State;
         };
-#endif
 
-        ///////////////////////////////////////////////////////////////////////////////////////////////
-        // index_sequence
-        /// A container for a sequence of compile-time integer constants of type
-        /// \c std::size_t
-        /// \ingroup integral
-        template <std::size_t... Is>
-        using index_sequence = integer_sequence<std::size_t, Is...>;
-
-#if !defined(META_DOXYGEN_INVOKED) &&                                        \
-    ((defined(__clang__) && __clang_major__ >= 3 && __clang_minor__ >= 8) || \
-     (defined(_MSC_VER) && _MSC_FULL_VER >= 190023918))
-        // Implement make_integer_sequence and make_index_sequence with the
-        // __make_integer_seq builtin on compilers that provide it. (Redirect
-        // through decltype to workaround suspected clang bug.)
-        /// \cond
-        namespace detail
+        template <typename T, T, typename>
+        struct coerce_indices_
         {
-            template <class T, T N>
-            __make_integer_seq<integer_sequence, T, N> make_integer_sequence_();
-        }
-        /// \endcond
+        };
+    } // namespace detail
+    /// \endcond
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // integer_sequence
+#if !META_CXX_INTEGER_SEQUENCE
+    /// A container for a sequence of compile-time integer constants.
+    /// \ingroup integral
+    template <typename T, T... Is>
+    struct integer_sequence
+    {
+        using value_type = T;
+        /// \return `sizeof...(Is)`
+        static constexpr std::size_t size() noexcept { return sizeof...(Is); }
+    };
+#endif
 
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // index_sequence
+    /// A container for a sequence of compile-time integer constants of type
+    /// \c std::size_t
+    /// \ingroup integral
+    template <std::size_t... Is>
+    using index_sequence = integer_sequence<std::size_t, Is...>;
+
+#if META_HAS_MAKE_INTEGER_SEQ && !defined(META_DOXYGEN_INVOKED)
+    // Implement make_integer_sequence and make_index_sequence with the
+    // __make_integer_seq builtin on compilers that provide it. (Redirect
+    // through decltype to workaround suspected clang bug.)
+    /// \cond
+    namespace detail
+    {
         template <typename T, T N>
-        using make_integer_sequence = decltype(detail::make_integer_sequence_<T, N>());
+        __make_integer_seq<integer_sequence, T, N> make_integer_sequence_();
+    }
+    /// \endcond
 
-        template <std::size_t N>
-        using make_index_sequence = make_integer_sequence<std::size_t, N>;
-#else
-        /// Generate \c index_sequence containing integer constants [0,1,2,...,N-1].
-        /// \par Complexity
-        /// \f$ O(log(N)) \f$.
-        /// \ingroup integral
-        template <std::size_t N>
-        using make_index_sequence =
-            _t<detail::make_indices_<N, index_sequence<0>, detail::strategy_(1, N)>>;
+    template <typename T, T N>
+    using make_integer_sequence = decltype(detail::make_integer_sequence_<T, N>());
 
-        /// Generate \c integer_sequence containing integer constants [0,1,2,...,N-1].
-        /// \par Complexity
-        /// \f$ O(log(N)) \f$.
-        /// \ingroup integral
-        template <typename T, T N>
-        using make_integer_sequence =
-            _t<detail::coerce_indices_<T, 0, make_index_sequence<static_cast<std::size_t>(N)>>>;
+    template <std::size_t N>
+    using make_index_sequence = make_integer_sequence<std::size_t, N>;
+#else
+    /// Generate \c index_sequence containing integer constants [0,1,2,...,N-1].
+    /// \par Complexity
+    /// \f$ O(log(N)) \f$.
+    /// \ingroup integral
+    template <std::size_t N>
+    using make_index_sequence =
+        _t<detail::make_indices_<N, index_sequence<0>, detail::strategy_(1, N)>>;
+
+    /// Generate \c integer_sequence containing integer constants [0,1,2,...,N-1].
+    /// \par Complexity
+    /// \f$ O(log(N)) \f$.
+    /// \ingroup integral
+    template <typename T, T N>
+    using make_integer_sequence =
+        _t<detail::coerce_indices_<T, 0, make_index_sequence<static_cast<std::size_t>(N)>>>;
 #endif
 
-        ///////////////////////////////////////////////////////////////////////////////////////////////
-        // integer_range
-        /// Makes the integer sequence <tt>[From, To)</tt>.
-        /// \par Complexity
-        /// \f$ O(log(To - From)) \f$.
-        /// \ingroup integral
-        template <class T, T From, T To>
-        using integer_range =
-            _t<detail::coerce_indices_<T, From,
-                                       make_index_sequence<detail::range_distance_(From, To)>>>;
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // integer_range
+    /// Makes the integer sequence <tt>[From, To)</tt>.
+    /// \par Complexity
+    /// \f$ O(log(To - From)) \f$.
+    /// \ingroup integral
+    template <typename T, T From, T To>
+    using integer_range =
+        _t<detail::coerce_indices_<T, From,
+                                    make_index_sequence<detail::range_distance_(From, To)>>>;
 
-        /// \cond
-        namespace detail
+    /// \cond
+    namespace detail
+    {
+        template <typename, typename>
+        struct concat_indices_
         {
-            template <typename, typename>
-            struct concat_indices_
-            {
-            };
-
-            template <std::size_t... Is, std::size_t... Js>
-            struct concat_indices_<index_sequence<Is...>, index_sequence<Js...>>
-            {
-                using type = index_sequence<Is..., (Js + sizeof...(Is))...>;
-            };
-
-            template <>
-            struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
-            {
-                using type = index_sequence<>;
-            };
-
-            template <std::size_t End, std::size_t... Values>
-            struct make_indices_<End, index_sequence<Values...>, indices_strategy_::repeat>
-                : make_indices_<End, index_sequence<Values..., (Values + sizeof...(Values))...>,
-                                detail::strategy_(sizeof...(Values)*2, End)>
-            {
-            };
-
-            template <std::size_t End, std::size_t... Values>
-            struct make_indices_<End, index_sequence<Values...>, indices_strategy_::recurse>
-                : concat_indices_<index_sequence<Values...>,
-                                  make_index_sequence<End - sizeof...(Values)>>
-            {
-            };
-
-            template <typename T, T Offset, std::size_t... Values>
-            struct coerce_indices_<T, Offset, index_sequence<Values...>>
-            {
-                using type =
-                    integer_sequence<T, static_cast<T>(static_cast<T>(Values) + Offset)...>;
-            };
-        } // namespace detail
-        /// \endcond
-
-        /// Evaluate the Callable \p F with the arguments \p Args.
-        /// \ingroup invocation
-        template <typename F, typename... Args>
-        using invoke = typename F::template invoke<Args...>;
+        };
 
-        /// Lazy versions of meta actions
-        namespace lazy
+        template <std::size_t... Is, std::size_t... Js>
+        struct concat_indices_<index_sequence<Is...>, index_sequence<Js...>>
         {
-            /// \sa `meta::invoke`
-            /// \ingroup lazy_invocation
-            template <typename F, typename... Args>
-            using invoke = defer<invoke, F, Args...>;
-        }
+            using type = index_sequence<Is..., (Js + sizeof...(Is))...>;
+        };
 
-        /// A trait that always returns its argument \p T. Also, a Callable that always
-        /// returns
-        /// \p T.
-        /// \ingroup trait
-        /// \ingroup invocation
-        template <typename T>
-        struct id
+        template <>
+        struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
         {
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5 && !defined(META_DOXYGEN_INVOKED)
-            // Redirect through decltype for compilers that have not
-            // yet implemented CWG 1558:
-            // <http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1558>
-            static id impl(void *);
-
-            template <typename... Ts>
-            using invoke = _t<decltype(id::impl(static_cast<list<Ts...> *>(nullptr)))>;
-#else
-            template <typename...>
-            using invoke = T;
-#endif
+            using type = index_sequence<>;
+        };
 
-            using type = T;
+        template <std::size_t End, std::size_t... Values>
+        struct make_indices_<End, index_sequence<Values...>, indices_strategy_::repeat>
+          : make_indices_<End, index_sequence<Values..., (Values + sizeof...(Values))...>,
+                          detail::strategy_(sizeof...(Values) * 2, End)>
+        {
         };
 
-        /// An alias for type \p T. Useful in non-deduced contexts.
-        /// \ingroup trait
-        template <typename T>
-        using id_t = _t<id<T>>;
+        template <std::size_t End, std::size_t... Values>
+        struct make_indices_<End, index_sequence<Values...>, indices_strategy_::recurse>
+          : concat_indices_<index_sequence<Values...>,
+                            make_index_sequence<End - sizeof...(Values)>>
+        {
+        };
 
-        namespace lazy
+        template <typename T, T Offset, std::size_t... Values>
+        struct coerce_indices_<T, Offset, index_sequence<Values...>>
         {
-            /// \sa `meta::id`
-            /// \ingroup lazy_trait
-            /// \ingroup lazy_invocation
-            template <typename T>
-            using id = defer<id, T>;
-        }
+            using type =
+                integer_sequence<T, static_cast<T>(static_cast<T>(Values) + Offset)...>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Evaluate the invocable \p Fn with the arguments \p Args.
+    /// \ingroup invocation
+    template <META_TYPE_CONSTRAINT(invocable) Fn, typename... Args>
+    using invoke = typename Fn::template invoke<Args...>;
 
-        /// An alias for `void`.
-        /// \ingroup trait
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5 && !defined(META_DOXYGEN_INVOKED)
+    /// Lazy versions of meta actions
+    namespace lazy
+    {
+        /// \sa `meta::invoke`
+        /// \ingroup lazy_invocation
+        template <typename Fn, typename... Args>
+        using invoke = defer<invoke, Fn, Args...>;
+    } // namespace lazy
+
+    /// A trait that always returns its argument \p T. It is also an invocable
+    /// that always returns \p T.
+    /// \ingroup trait
+    /// \ingroup invocation
+    template <typename T>
+    struct id
+    {
+#if defined(META_WORKAROUND_CWG_1558) && !defined(META_DOXYGEN_INVOKED)
         // Redirect through decltype for compilers that have not
         // yet implemented CWG 1558:
-        // <http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1558>
+        static id impl(void *);
+
         template <typename... Ts>
-        using void_ = invoke<id<void>, Ts...>;
+        using invoke = _t<decltype(id::impl(static_cast<list<Ts...> *>(nullptr)))>;
 #else
         template <typename...>
-        using void_ = void;
+        using invoke = T;
 #endif
 
-        /// \cond
-        namespace detail
-        {
-            template <typename, typename = void>
-            struct is_trait_
-            {
-                using type = std::false_type;
-            };
-
-            template <typename T>
-            struct is_trait_<T, void_<typename T::type>>
-            {
-                using type = std::true_type;
-            };
-
-            template <typename, typename = void>
-            struct is_callable_
-            {
-                using type = std::false_type;
-            };
-
-            template <typename T>
-            struct is_callable_<T, void_<quote<T::template invoke>>>
-            {
-                using type = std::true_type;
-            };
+        using type = T;
+    };
 
-            template <template <typename...> class C, typename... Ts,
-                template <typename...> class D = C>
-            id<D<Ts...>> try_defer_(int);
-            template <template <typename...> class C, typename... Ts>
-            nil_ try_defer_(long);
+    /// An alias for type \p T. Useful in non-deduced contexts.
+    /// \ingroup trait
+    template <typename T>
+    using id_t = _t<id<T>>;
 
-            template <template <typename...> class C, typename... Ts>
-            using defer_ = decltype(detail::try_defer_<C, Ts...>(0));
+    namespace lazy
+    {
+        /// \sa `meta::id`
+        /// \ingroup lazy_trait
+        /// \ingroup lazy_invocation
+        template <typename T>
+        using id = defer<id, T>;
+    } // namespace lazy
+
+    /// An alias for `void`.
+    /// \ingroup trait
+#if defined(META_WORKAROUND_CWG_1558) && !defined(META_DOXYGEN_INVOKED)
+    // Redirect through decltype for compilers that have not
+    // yet implemented CWG 1558:
+    template <typename... Ts>
+    using void_ = invoke<id<void>, Ts...>;
+#else
+    template <typename...>
+    using void_ = void;
+#endif
 
-            template <typename T, template <T...> class C, T... Is,
-                template <T...> class D = C>
-            id<D<Is...>> try_defer_i_(int);
-            template <typename T, template <T...> class C, T... Is>
-            nil_ try_defer_i_(long);
+#if META_CXX_VARIABLE_TEMPLATES
+#ifdef META_CONCEPT
+    /// `true` if `T::type` exists and names a type; `false` otherwise.
+    /// \ingroup trait
+    template <typename T>
+    META_INLINE_VAR constexpr bool is_trait_v = trait<T>;
+
+    /// `true` if `T::invoke` exists and names a class template; `false` otherwise.
+    /// \ingroup trait
+    template <typename T>
+    META_INLINE_VAR constexpr bool is_callable_v = invocable<T>;
+#else   // ^^^ Concepts / No concepts vvv
+    /// \cond
+    namespace detail
+    {
+        template <typename, typename = void>
+        META_INLINE_VAR constexpr bool is_trait_ = false;
 
-            template <typename T, template <T...> class C, T... Is>
-            using defer_i_ = decltype(detail::try_defer_i_<T, C, Is...>(0));
+        template <typename T>
+        META_INLINE_VAR constexpr bool is_trait_<T, void_<typename T::type>> = true;
 
-            template <typename T>
-            using _t_t = _t<_t<T>>;
-        } // namespace detail
-        /// \endcond
+        template <typename, typename = void>
+        META_INLINE_VAR constexpr bool is_callable_ = false;
 
-        /// An alias for `std::true_type` if `T::type` exists and names a type;
-        /// otherwise, it's an alias for `std::false_type`.
-        /// \ingroup trait
         template <typename T>
-        using is_trait = _t<detail::is_trait_<T>>;
+        META_INLINE_VAR constexpr bool is_callable_<T, void_<quote<T::template invoke>>> = true;
+    } // namespace detail
+    /// \endcond
+
+    /// `true` if `T::type` exists and names a type; `false` otherwise.
+    /// \ingroup trait
+    template <typename T>
+    META_INLINE_VAR constexpr bool is_trait_v = detail::is_trait_<T>;
+
+    /// `true` if `T::invoke` exists and names a class template; `false` otherwise.
+    /// \ingroup trait
+    template <typename T>
+    META_INLINE_VAR constexpr bool is_callable_v = detail::is_callable_<T>;
+#endif  // Concepts vs. variable templates
+
+    /// An alias for `std::true_type` if `T::type` exists and names a type; otherwise, it's an
+    /// alias for `std::false_type`.
+    /// \ingroup trait
+    template <typename T>
+    using is_trait = bool_<is_trait_v<T>>;
+
+    /// An alias for `std::true_type` if `T::invoke` exists and names a class template;
+    /// otherwise, it's an alias for `std::false_type`.
+    /// \ingroup trait
+    template <typename T>
+    using is_callable = bool_<is_callable_v<T>>;
+#else   // ^^^ META_CXX_VARIABLE_TEMPLATES / !META_CXX_VARIABLE_TEMPLATES vvv
+    /// \cond
+    namespace detail
+    {
+        template <typename, typename = void>
+        struct is_trait_
+        {
+            using type = std::false_type;
+        };
 
-        /// An alias for `std::true_type` if `T::invoke` exists and names a class
-        /// template or alias template; otherwise, it's an alias for
-        /// `std::false_type`.
-        /// \ingroup trait
         template <typename T>
-        using is_callable = _t<detail::is_callable_<T>>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // defer
-        /// A wrapper that defers the instantiation of a template \p C with type
-        /// parameters \p Ts in a \c lambda or \c let expression.
-        ///
-        /// In the code below, the lambda would ideally be written as
-        /// `lambda<_a,_b,push_back<_a,_b>>`, however this fails since `push_back`
-        /// expects its first argument to be a list, not a placeholder. Instead,
-        /// we express it using \c defer as follows:
-        ///
-        /// \code
-        /// template <typename List>
-        /// using reverse = reverse_fold<List, list<>, lambda<_a, _b, defer<push_back,
-        /// _a, _b>>>;
-        /// \endcode
-        ///
-        /// \ingroup invocation
-        template <template <typename...> class C, typename... Ts>
-        struct defer : detail::defer_<C, Ts...>
+        struct is_trait_<T, void_<typename T::type>>
         {
+            using type = std::true_type;
         };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // defer_i
-        /// A wrapper that defers the instantiation of a template \p C with integral
-        /// constant parameters \p Is in a \c lambda or \c let expression.
-        /// \sa `defer`
-        /// \ingroup invocation
-        template <typename T, template <T...> class C, T... Is>
-        struct defer_i : detail::defer_i_<T, C, Is...>
+        template <typename, typename = void>
+        struct is_callable_
         {
+            using type = std::false_type;
         };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // defer_trait
-        /// A wrapper that defers the instantiation of a trait \p C with type parameters
-        /// \p Ts in a
-        /// \c lambda or \c let expression.
-        /// \sa `defer`
-        /// \ingroup invocation
-        template <template <typename...> class C, typename... Ts>
-        using defer_trait = defer<detail::_t_t, detail::defer_<C, Ts...>>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // defer_trait_i
-        /// A wrapper that defers the instantiation of a trait \p C with integral
-        /// constant
-        /// parameters \p Is in a \c lambda or \c let expression.
-        /// \sa `defer_i`
-        /// \ingroup invocation
-        template <typename T, template <T...> class C, T... Is>
-        using defer_trait_i =
-            defer<detail::_t_t, detail::defer_i_<T, C, Is...>>;
-
-        /// An alias that computes the size of the type \p T.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup trait
-        template <class T>
-        using sizeof_ = meta::size_t<sizeof(T)>;
-
-        /// An alias that computes the alignment required for any instance of the type
-        /// \p T.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup trait
-        template <class T>
-        using alignof_ = meta::size_t<alignof(T)>;
-
-        namespace lazy
-        {
-            /// \sa `meta::sizeof_`
-            /// \ingroup lazy_trait
-            template <typename T>
-            using sizeof_ = defer<sizeof_, T>;
-
-            /// \sa `meta::alignof_`
-            /// \ingroup lazy_trait
-            template <typename T>
-            using alignof_ = defer<alignof_, T>;
-        }
-
-        /// is
-        /// \cond
-        namespace detail
+        template <typename T>
+        struct is_callable_<T, void_<quote<T::template invoke>>>
         {
-            template <typename, template <typename...> class>
-            struct is_ : std::false_type
-            {
-            };
-
-            template <typename... Ts, template <typename...> class C>
-            struct is_<C<Ts...>, C> : std::true_type
-            {
-            };
-        }
-        /// \endcond
-
-        /// Test whether a type \c T is an instantiation of class
-        /// template \c C.
-        /// \ingroup trait
-        template <typename T, template <typename...> class C>
-        using is = _t<detail::is_<T, C>>;
+            using type = std::true_type;
+        };
+    } // namespace detail
+    /// \endcond
+
+    template <typename T>
+    using is_trait = _t<detail::is_trait_<T>>;
+
+    /// An alias for `std::true_type` if `T::invoke` exists and names a class
+    /// template or alias template; otherwise, it's an alias for
+    /// `std::false_type`.
+    /// \ingroup trait
+    template <typename T>
+    using is_callable = _t<detail::is_callable_<T>>;
+#endif
 
-        /// Compose the Callables \p Fs in the parameter pack \p Ts.
-        /// \ingroup composition
-        template <typename... Fs>
-        struct compose
+    /// \cond
+    namespace detail
+    {
+#ifdef META_CONCEPT
+        template <template <typename...> class, typename...>
+        struct defer_
         {
         };
 
-        template <typename F0>
-        struct compose<F0>
+        template <template <typename...> class C, typename... Ts>
+        requires valid<C, Ts...> struct defer_<C, Ts...>
         {
-            template <typename... Ts>
-            using invoke = invoke<F0, Ts...>;
+            using type = C<Ts...>;
         };
 
-        template <typename F0, typename... Fs>
-        struct compose<F0, Fs...>
+        template <typename T, template <T...> class, T...>
+        struct defer_i_
         {
-            template <typename... Ts>
-            using invoke = invoke<F0, invoke<compose<Fs...>, Ts...>>;
         };
 
-        namespace lazy
+        template <typename T, template <T...> class C, T... Is>
+        requires valid_i<T, C, Is...> struct defer_i_<T, C, Is...>
         {
-            /// \sa 'meta::compose'
-            /// \ingroup lazy_composition
-            template <typename... Fns>
-            using compose = defer<compose, Fns...>;
-        }
-
-        /// Turn a class template or alias template \p C into a Callable.
-        /// \ingroup composition
-        template <template <typename...> class C>
-        struct quote
+            using type = C<Is...>;
+        };
+#elif defined(META_WORKAROUND_MSVC_703656) // ^^^ Concepts / MSVC workaround vvv
+        template <typename, template <typename...> class, typename...>
+        struct _defer_
         {
-            // Indirection through defer here needed to avoid Core issue 1430
-            // http://open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1430
-            template <typename... Ts>
-            using invoke = _t<detail::defer_<C, Ts...>>;
         };
 
-        /// Turn a class template or alias template \p C taking literals of type \p T
-        /// into a Callable.
-        /// \ingroup composition
-        template <typename T, template <T...> class C>
-        struct quote_i
+        template <template <typename...> class C, typename... Ts>
+        struct _defer_<void_<C<Ts...>>, C, Ts...>
         {
-            // Indirection through defer_i here needed to avoid Core issue 1430
-            // http://open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1430
-            template <typename... Ts>
-            using invoke = _t<detail::defer_i_<T, C, Ts::type::value...>>;
+            using type = C<Ts...>;
         };
 
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 8 && !defined(META_DOXYGEN_INVOKED)
-        template <template <typename...> class C>
-        struct quote_trait
+        template <template <typename...> class C, typename... Ts>
+        using defer_ = _defer_<void, C, Ts...>;
+
+        template <typename, typename T, template <T...> class, T...>
+        struct _defer_i_
         {
-            template <typename... Ts>
-            using invoke = _t<invoke<quote<C>, Ts...>>;
         };
 
-        template <typename T, template <T...> class C>
-        struct quote_trait_i
+        template <typename T, template <T...> class C, T... Is>
+        struct _defer_i_<void_<C<Is...>>, T, C, Is...>
         {
-            template <typename... Ts>
-            using invoke = _t<invoke<quote_i<T, C>, Ts...>>;
+            using type = C<Is...>;
         };
-#else
-        // clang-format off
-        /// Turn a trait template \p C into a Callable.
-        /// \code
-        /// static_assert(std::is_same<invoke<quote_trait<std::add_const>, int>, int const>::value, "");
-        /// \endcode
-        /// \ingroup composition
-        template <template <typename...> class C>
-        using quote_trait = compose<quote<_t>, quote<C>>;
-
-        /// Turn a trait \p C taking literals of type \p T into a Callable.
-        /// \sa 'meta::quote_trait'
-        /// \ingroup composition
-        template <typename T, template <T...> class C>
-        using quote_trait_i = compose<quote<_t>, quote_i<T, C>>;
-// clang-format on
-#endif
 
-        /// A Callable that partially applies the Callable
-        /// \p F by binding the arguments \p Ts to the \e front of \p F.
-        /// \ingroup composition
-        template <typename F, typename... Ts>
-        struct bind_front
+        template <typename T, template <T...> class C, T... Is>
+        using defer_i_ = _defer_i_<void, T, C, Is...>;
+#else                             // ^^^ workaround ^^^ / vvv no workaround vvv
+        template <template <typename...> class C, typename... Ts,
+                    template <typename...> class D = C>
+        id<D<Ts...>> try_defer_(int);
+        template <template <typename...> class C, typename... Ts>
+        nil_ try_defer_(long);
+
+        template <template <typename...> class C, typename... Ts>
+        using defer_ = decltype(detail::try_defer_<C, Ts...>(0));
+
+        template <typename T, template <T...> class C, T... Is, template <T...> class D = C>
+        id<D<Is...>> try_defer_i_(int);
+        template <typename T, template <T...> class C, T... Is>
+        nil_ try_defer_i_(long);
+
+        template <typename T, template <T...> class C, T... Is>
+        using defer_i_ = decltype(detail::try_defer_i_<T, C, Is...>(0));
+#endif                            // Concepts vs. MSVC vs. Other
+
+        template <typename T>
+        using _t_t = _t<_t<T>>;
+    } // namespace detail
+    /// \endcond
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // defer
+    /// A wrapper that defers the instantiation of a template \p C with type parameters \p Ts in
+    /// a \c lambda or \c let expression.
+    ///
+    /// In the code below, the lambda would ideally be written as
+    /// `lambda<_a,_b,push_back<_a,_b>>`, however this fails since `push_back` expects its first
+    /// argument to be a list, not a placeholder. Instead, we express it using \c defer as
+    /// follows:
+    ///
+    /// \code
+    /// template <typename L>
+    /// using reverse = reverse_fold<L, list<>, lambda<_a, _b, defer<push_back, _a, _b>>>;
+    /// \endcode
+    ///
+    /// \ingroup invocation
+    template <template <typename...> class C, typename... Ts>
+    struct defer : detail::defer_<C, Ts...>
+    {
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // defer_i
+    /// A wrapper that defers the instantiation of a template \p C with integral constant
+    /// parameters \p Is in a \c lambda or \c let expression.
+    /// \sa `defer`
+    /// \ingroup invocation
+    template <typename T, template <T...> class C, T... Is>
+    struct defer_i : detail::defer_i_<T, C, Is...>
+    {
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // defer_trait
+    /// A wrapper that defers the instantiation of a trait \p C with type parameters \p Ts in a
+    /// \c lambda or \c let expression.
+    /// \sa `defer`
+    /// \ingroup invocation
+    template <template <typename...> class C, typename... Ts>
+    using defer_trait = defer<detail::_t_t, detail::defer_<C, Ts...>>;
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // defer_trait_i
+    /// A wrapper that defers the instantiation of a trait \p C with integral constant
+    /// parameters \p Is in a \c lambda or \c let expression.
+    /// \sa `defer_i`
+    /// \ingroup invocation
+    template <typename T, template <T...> class C, T... Is>
+    using defer_trait_i = defer<detail::_t_t, detail::defer_i_<T, C, Is...>>;
+
+    /// An alias that computes the size of the type \p T.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup trait
+    template <typename T>
+    using sizeof_ = meta::size_t<sizeof(T)>;
+
+    /// An alias that computes the alignment required for any instance of the type \p T.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup trait
+    template <typename T>
+    using alignof_ = meta::size_t<alignof(T)>;
+
+    namespace lazy
+    {
+        /// \sa `meta::sizeof_`
+        /// \ingroup lazy_trait
+        template <typename T>
+        using sizeof_ = defer<sizeof_, T>;
+
+        /// \sa `meta::alignof_`
+        /// \ingroup lazy_trait
+        template <typename T>
+        using alignof_ = defer<alignof_, T>;
+    } // namespace lazy
+
+#if META_CXX_VARIABLE_TEMPLATES
+    /// is
+    /// Test whether a type \p T is an instantiation of class
+    /// template \p C.
+    /// \ingroup trait
+    template <typename T, template <typename...> class C>
+    using is = bool_<is_v<T, C>>;
+#else
+    /// is
+    /// \cond
+    namespace detail
+    {
+        template <typename, template <typename...> class>
+        struct is_ : std::false_type
         {
-            template <typename... Us>
-            using invoke = invoke<F, Ts..., Us...>;
         };
 
-        /// A Callable that partially applies the Callable \p F by binding the
-        /// arguments \p Us to the \e back of \p F.
-        /// \ingroup composition
-        template <typename F, typename... Us>
-        struct bind_back
+        template <typename... Ts, template <typename...> class C>
+        struct is_<C<Ts...>, C> : std::true_type
         {
-            template <typename... Ts>
-            using invoke = invoke<F, Ts..., Us...>;
         };
+    } // namespace detail
+    /// \endcond
+
+    /// Test whether a type \c T is an instantiation of class
+    /// template \c C.
+    /// \ingroup trait
+    template <typename T, template <typename...> class C>
+    using is = _t<detail::is_<T, C>>;
+#endif
 
-        namespace lazy
-        {
-            /// \sa 'meta::bind_front'
-            /// \ingroup lazy_composition
-            template <typename Fn, typename... Ts>
-            using bind_front = defer<bind_front, Fn, Ts...>;
+    /// Compose the Invocables \p Fns in the parameter pack \p Ts.
+    /// \ingroup composition
+    template <META_TYPE_CONSTRAINT(invocable)... Fns>
+    struct compose_
+    {
+    };
 
-            /// \sa 'meta::bind_back'
-            /// \ingroup lazy_composition
-            template <typename Fn, typename... Ts>
-            using bind_back = defer<bind_back, Fn, Ts...>;
-        }
+    template <META_TYPE_CONSTRAINT(invocable) Fn0>
+    struct compose_<Fn0>
+    {
+        template <typename... Ts>
+        using invoke = invoke<Fn0, Ts...>;
+    };
 
-        /// Extend meta with your own datatypes.
-        namespace extension
-        {
-            /// A trait that unpacks the types in the type list \p List into the Callable
-            /// \p F.
-            /// \ingroup extension
-            template <typename F, typename List>
-            struct apply
-            {
-            };
+    template <META_TYPE_CONSTRAINT(invocable) Fn0, META_TYPE_CONSTRAINT(invocable)... Fns>
+    struct compose_<Fn0, Fns...>
+    {
+        template <typename... Ts>
+        using invoke = invoke<Fn0, invoke<compose_<Fns...>, Ts...>>;
+    };
 
-            template <typename F, typename Ret, typename... Args>
-            struct apply<F, Ret(Args...)> : lazy::invoke<F, Ret, Args...>
-            {
-            };
+    template <typename... Fns>
+    using compose = compose_<Fns...>;
 
-            template <typename F, template <typename...> class T, typename... Ts>
-            struct apply<F, T<Ts...>> : lazy::invoke<F, Ts...>
-            {
-            };
+    namespace lazy
+    {
+        /// \sa 'meta::compose'
+        /// \ingroup lazy_composition
+        template <typename... Fns>
+        using compose = defer<compose, Fns...>;
+    } // namespace lazy
+
+    /// Turn a template \p C into an invocable.
+    /// \ingroup composition
+    template <template <typename...> class C>
+    struct quote
+    {
+        // Indirection through defer here needed to avoid Core issue 1430
+        // https://wg21.link/cwg1430
+        template <typename... Ts>
+        using invoke = _t<defer<C, Ts...>>;
+    };
+
+    /// Turn a template \p C taking literals of type \p T into a
+    /// invocable.
+    /// \ingroup composition
+    template <typename T, template <T...> class C>
+    struct quote_i
+    {
+        // Indirection through defer_i here needed to avoid Core issue 1430
+        // https://wg21.link/cwg1430
+        template <META_TYPE_CONSTRAINT(integral)... Ts>
+        using invoke = _t<defer_i<T, C, Ts::type::value...>>;
+    };
+
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 8 && \
+!defined(META_DOXYGEN_INVOKED)
+    template <template <typename...> class C>
+    struct quote_trait
+    {
+        template <typename... Ts>
+        using invoke = _t<invoke<quote<C>, Ts...>>;
+    };
 
-            template <typename F, typename T, T... Is>
-            struct apply<F, integer_sequence<T, Is...>>
-                : lazy::invoke<F, std::integral_constant<T, Is>...>
-            {
-            };
-        }
+    template <typename T, template <T...> class C>
+    struct quote_trait_i
+    {
+        template <typename... Ts>
+        using invoke = _t<invoke<quote_i<T, C>, Ts...>>;
+    };
+#else
+    // clang-format off
+    /// Turn a trait template \p C into an invocable.
+    /// \code
+    /// static_assert(std::is_same_v<invoke<quote_trait<std::add_const>, int>, int const>, "");
+    /// \endcode
+    /// \ingroup composition
+    template <template <typename...> class C>
+    using quote_trait = compose<quote<_t>, quote<C>>;
+
+    /// Turn a trait template \p C taking literals of type \p T into an invocable.
+    /// \ingroup composition
+    template <typename T, template <T...> class C>
+    using quote_trait_i = compose<quote<_t>, quote_i<T, C>>;
+    // clang-format on
+#endif
 
-        /// Applies the Callable \p C using the types in the type list \p List as
-        /// arguments.
-        /// \ingroup invocation
-        template <typename C, typename List>
-        using apply = _t<extension::apply<C, List>>;
+    /// An invocable that partially applies the invocable
+    /// \p Fn by binding the arguments \p Ts to the \e front of \p Fn.
+    /// \ingroup composition
+    template <META_TYPE_CONSTRAINT(invocable) Fn, typename... Ts>
+    struct bind_front
+    {
+        template <typename... Us>
+        using invoke = invoke<Fn, Ts..., Us...>;
+    };
+
+    /// An invocable that partially applies the invocable \p Fn by binding the
+    /// arguments \p Us to the \e back of \p Fn.
+    /// \ingroup composition
+    template <META_TYPE_CONSTRAINT(invocable) Fn, typename... Us>
+    struct bind_back
+    {
+        template <typename... Ts>
+        using invoke = invoke<Fn, Ts..., Us...>;
+    };
 
-        namespace lazy
+    namespace lazy
+    {
+        /// \sa 'meta::bind_front'
+        /// \ingroup lazy_composition
+        template <typename Fn, typename... Ts>
+        using bind_front = defer<bind_front, Fn, Ts...>;
+
+        /// \sa 'meta::bind_back'
+        /// \ingroup lazy_composition
+        template <typename Fn, typename... Ts>
+        using bind_back = defer<bind_back, Fn, Ts...>;
+    } // namespace lazy
+
+    /// Extend meta with your own datatypes.
+    namespace extension
+    {
+        /// A trait that unpacks the types in the type list \p L into the invocable
+        /// \p Fn.
+        /// \ingroup extension
+        template <META_TYPE_CONSTRAINT(invocable) Fn, typename L>
+        struct apply
         {
-            template <typename F, typename List>
-            using apply = defer<apply, F, List>;
-        }
-
-        /// A Callable that takes a bunch of arguments, bundles them into a type list,
-        /// and
-        /// then calls the Callable \p F with the type list \p Q.
-        /// \ingroup composition
-        template <typename F, typename Q = quote<list>>
-        using curry = compose<F, Q>;
-
-        /// A Callable that takes a type list, unpacks the types, and then calls the
-        /// Callable \p F with the types.
-        /// \ingroup composition
-        template <typename F>
-        using uncurry = bind_front<quote<apply>, F>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::curry'
-            /// \ingroup lazy_composition
-            template <typename F, typename Q = quote<list>>
-            using curry = defer<curry, F, Q>;
-
-            /// \sa 'meta::uncurry'
-            /// \ingroup lazy_composition
-            template <typename F>
-            using uncurry = defer<uncurry, F>;
-        }
+        };
 
-        /// A Callable that reverses the order of the first two arguments.
-        /// \ingroup composition
-        template <typename F>
-        struct flip
+        template <META_TYPE_CONSTRAINT(invocable) Fn, typename Ret, typename... Args>
+        struct apply<Fn, Ret(Args...)> : lazy::invoke<Fn, Ret, Args...>
         {
-        private:
-            template <typename... Ts>
-            struct impl
-            {
-            };
-            template <typename A, typename B, typename... Ts>
-            struct impl<A, B, Ts...> : lazy::invoke<F, B, A, Ts...>
-            {
-            };
-
-        public:
-            template <typename... Ts>
-            using invoke = _t<impl<Ts...>>;
         };
 
-        namespace lazy
+        template <META_TYPE_CONSTRAINT(invocable) Fn, template <typename...> class T,
+                    typename... Ts>
+        struct apply<Fn, T<Ts...>> : lazy::invoke<Fn, Ts...>
         {
-            /// \sa 'meta::flip'
-            /// \ingroup lazy_composition
-            template <typename F>
-            using flip = defer<flip, F>;
-        }
+        };
 
-        /// \cond
-        namespace detail
-        {
-            template <typename...>
-            struct on_
-            {
-            };
-            template <typename F, typename... Gs>
-            struct on_<F, Gs...>
-            {
-                template <typename... Ts>
-                using invoke = invoke<F, invoke<compose<Gs...>, Ts>...>;
-            };
-        }
-        /// \endcond
-
-        /// Use as `on<F, Gs...>`. Creates an Callable that applies Callable \c F to the
-        /// result of applying Callable `compose<Gs...>` to all the arguments.
-        /// \ingroup composition
-        template <typename... Fs>
-        using on = detail::on_<Fs...>;
-
-        namespace lazy
+        template <META_TYPE_CONSTRAINT(invocable) Fn, typename T, T... Is>
+        struct apply<Fn, integer_sequence<T, Is...>>
+          : lazy::invoke<Fn, std::integral_constant<T, Is>...>
         {
-            /// \sa 'meta::on'
-            /// \ingroup lazy_composition
-            template <typename F, typename G>
-            using on = defer<on, F, G>;
-        }
+        };
+    } // namespace extension
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // if_
-        /// \cond
-        namespace detail
-        {
-        #ifdef __clang__
-            // Clang is faster with this implementation
-            template <typename, typename = bool>
-            struct _if_
-            {
-            };
+    /// Applies the invocable \p Fn using the types in the type list \p L as
+    /// arguments.
+    /// \ingroup invocation
+    template <META_TYPE_CONSTRAINT(invocable) Fn, typename L>
+    using apply = _t<extension::apply<Fn, L>>;
 
-            template <typename If>
-            struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_if<If::type::value>
-            {
-            };
+    namespace lazy
+    {
+        template <typename Fn, typename L>
+        using apply = defer<apply, Fn, L>;
+    }
 
-            template <typename If, typename Then>
-            struct _if_<list<If, Then>, decltype(bool(If::type::value))>
-                : std::enable_if<If::type::value, Then>
-            {
-            };
+    /// An invocable that takes a bunch of arguments, bundles them into a type
+    /// list, and then calls the invocable \p Fn with the type list \p Q.
+    /// \ingroup composition
+    template <META_TYPE_CONSTRAINT(invocable) Fn,
+                META_TYPE_CONSTRAINT(invocable) Q = quote<list>>
+    using curry = compose<Fn, Q>;
 
-            template <typename If, typename Then, typename Else>
-            struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
-                : std::conditional<If::type::value, Then, Else>
-            {
-            };
-        #else
-            // GCC seems to prefer this implementation
-            template <typename, typename = std::true_type>
-            struct _if_
-            {
-            };
+    /// An invocable that takes a type list, unpacks the types, and then
+    /// calls the invocable \p Fn with the types.
+    /// \ingroup composition
+    template <META_TYPE_CONSTRAINT(invocable) Fn>
+    using uncurry = bind_front<quote<apply>, Fn>;
 
-            template <typename If>
-            struct _if_<list<If>, bool_<If::type::value>>
-            {
-                using type = void;
-            };
+    namespace lazy
+    {
+        /// \sa 'meta::curry'
+        /// \ingroup lazy_composition
+        template <typename Fn, typename Q = quote<list>>
+        using curry = defer<curry, Fn, Q>;
+
+        /// \sa 'meta::uncurry'
+        /// \ingroup lazy_composition
+        template <typename Fn>
+        using uncurry = defer<uncurry, Fn>;
+    } // namespace lazy
+
+    /// An invocable that reverses the order of the first two arguments.
+    /// \ingroup composition
+    template <META_TYPE_CONSTRAINT(invocable) Fn>
+    struct flip
+    {
+    private:
+        template <typename... Ts>
+        struct impl
+        {
+        };
+        template <typename A, typename B, typename... Ts>
+        struct impl<A, B, Ts...> : lazy::invoke<Fn, B, A, Ts...>
+        {
+        };
 
-            template <typename If, typename Then>
-            struct _if_<list<If, Then>, bool_<If::type::value>>
-            {
-                using type = Then;
-            };
+    public:
+        template <typename... Ts>
+        using invoke = _t<impl<Ts...>>;
+    };
 
-            template <typename If, typename Then, typename Else>
-            struct _if_<list<If, Then, Else>, bool_<If::type::value>>
-            {
-                using type = Then;
-            };
+    namespace lazy
+    {
+        /// \sa 'meta::flip'
+        /// \ingroup lazy_composition
+        template <typename Fn>
+        using flip = defer<flip, Fn>;
+    } // namespace lazy
 
-            template <typename If, typename Then, typename Else>
-            struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
-            {
-                using type = Else;
-            };
-        #endif
-        } // namespace detail
-        /// \endcond
+    /// \cond
+    namespace detail
+    {
+        template <typename...>
+        struct on_
+        {
+        };
+        template <typename Fn, typename... Gs>
+        struct on_<Fn, Gs...>
+        {
+            template <typename... Ts>
+            using invoke = invoke<Fn, invoke<compose<Gs...>, Ts>...>;
+        };
+    } // namespace detail
+    /// \endcond
 
-        /// Select one type or another depending on a compile-time Boolean.
-        /// \ingroup logical
-        template <typename... Args>
-        using if_ = _t<detail::_if_<list<Args...>>>;
+    /// Use as `on<Fn, Gs...>`. Creates an invocable that applies invocable \c Fn to the
+    /// result of applying invocable `compose<Gs...>` to all the arguments.
+    /// \ingroup composition
+    template <META_TYPE_CONSTRAINT(invocable)... Fns>
+    using on_ = detail::on_<Fns...>;
 
-        /// Select one type or another depending on a compile-time Boolean.
-        /// \ingroup logical
-        template <bool If, typename... Args>
-        using if_c = _t<detail::_if_<list<bool_<If>, Args...>>>;
+    template <typename... Fns>
+    using on = on_<Fns...>;
 
-        namespace lazy
+    namespace lazy
+    {
+        /// \sa 'meta::on'
+        /// \ingroup lazy_composition
+        template <typename Fn, typename G>
+        using on = defer<on, Fn, G>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // if_
+    /// \cond
+    namespace detail
+    {
+#ifdef META_CONCEPT
+        template <typename...>
+        struct _if_
         {
-            /// \sa 'meta::if_'
-            /// \ingroup lazy_logical
-            template <typename... Args>
-            using if_ = defer<if_, Args...>;
-
-            /// \sa 'meta::if_c'
-            /// \ingroup lazy_logical
-            template <bool If, typename... Args>
-            using if_c = if_<bool_<If>, Args...>;
-        }
+        };
 
-        /// \cond
-        namespace detail
+        template <integral If>
+        struct _if_<If> : std::enable_if<_v<If>>
         {
-            template <bool>
-            struct _and_
-            {
-                template <class = void>
-                using invoke = std::true_type;
-            };
-
-            template <>
-            struct _and_<false>
-            {
-                template <typename Bool_, typename... Bools>
-                using invoke = invoke<
-                    if_c<!Bool_::type::value,
-                         id<std::false_type>,
-                         _and_<0==sizeof...(Bools)>>, Bools...>;
-            };
+        };
 
-            template <bool>
-            struct _or_
-            {
-                template <class = void>
-                using invoke = std::false_type;
-            };
+        template <integral If, typename Then>
+        struct _if_<If, Then> : std::enable_if<_v<If>, Then>
+        {
+        };
 
-            template <>
-            struct _or_<false>
-            {
-                template <typename Bool_, typename... Bools>
-                using invoke = invoke<
-                    if_c<Bool_::type::value,
-                         id<std::true_type>,
-                         _or_<0 == sizeof...(Bools)>>, Bools...>;
-            };
-        } // namespace detail
-        /// \endcond
+        template <integral If, typename Then, typename Else>
+        struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
+        {
+        };
+#elif defined(__clang__)
+        // Clang is faster with this implementation
+        template <typename, typename = bool>
+        struct _if_
+        {
+        };
 
-        /// Logically negate the Boolean parameter
-        /// \ingroup logical
-        template <bool Bool_>
-        using not_c = bool_<!Bool_>;
+        template <typename If>
+        struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_if<If::type::value>
+        {
+        };
 
-        /// Logically negate the integral constant-wrapped Boolean parameter.
-        /// \ingroup logical
-        template <typename Bool_>
-        using not_ = not_c<Bool_::type::value>;
+        template <typename If, typename Then>
+        struct _if_<list<If, Then>, decltype(bool(If::type::value))>
+          : std::enable_if<If::type::value, Then>
+        {
+        };
 
-/// Logically and together all the Boolean parameters
-/// \ingroup logical
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 5 && __GNUC_MINOR__ == 1
-        // Alternative formulation of and_c to workaround
-        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66405
-        template <bool... Bools>
-        using and_c = std::is_same<integer_sequence<bool, true, Bools...>,
-                                   integer_sequence<bool, Bools..., true>>;
+        template <typename If, typename Then, typename Else>
+        struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
+          : std::conditional<If::type::value, Then, Else>
+        {
+        };
 #else
-        template <bool... Bools>
-        using and_c = std::is_same<integer_sequence<bool, Bools...>,
-                                   integer_sequence<bool, (Bools || true)...>>;
-#endif
+        // GCC seems to prefer this implementation
+        template <typename, typename = std::true_type>
+        struct _if_
+        {
+        };
 
-        /// Logically and together all the integral constant-wrapped Boolean parameters,
-        /// \e without
-        /// doing short-circuiting.
-        /// \ingroup logical
-        template <typename... Bools>
-        using strict_and = and_c<Bools::type::value...>;
-
-        /// Logically and together all the integral constant-wrapped Boolean parameters,
-        /// \e with
-        /// short-circuiting.
-        /// \ingroup logical
-        // Make a trip through defer<> to avoid CWG1430
-        template <typename... Bools>
-        using and_ = _t<defer<detail::_and_<0 == sizeof...(Bools)>::template invoke, Bools...>>;
-
-        /// Logically or together all the Boolean parameters
-        /// \ingroup logical
-        template <bool... Bools>
-        using or_c = not_<std::is_same<integer_sequence<bool, Bools...>,
-                                       integer_sequence<bool, (Bools && false)...>>>;
-
-        /// Logically or together all the integral constant-wrapped Boolean parameters,
-        /// \e without
-        /// doing short-circuiting.
-        /// \ingroup logical
-        template <typename... Bools>
-        using strict_or = or_c<Bools::type::value...>;
-
-        /// Logically or together all the integral constant-wrapped Boolean parameters,
-        /// \e with
-        /// short-circuiting.
-        /// \ingroup logical
-        // Make a trip through defer<> to avoid CWG1430
-        template <typename... Bools>
-        using or_ = _t<defer<detail::_or_<0 == sizeof...(Bools)>:: template invoke, Bools...>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::and_'
-            /// \ingroup lazy_logical
-            template <typename... Bools>
-            using and_ = defer<and_, Bools...>;
-
-            /// \sa 'meta::or_'
-            /// \ingroup lazy_logical
-            template <typename... Bools>
-            using or_ = defer<or_, Bools...>;
-
-            /// \sa 'meta::not_'
-            /// \ingroup lazy_logical
-            template <typename Bool_>
-            using not_ = defer<not_, Bool_>;
-
-            /// \sa 'meta::strict_and'
-            /// \ingroup lazy_logical
-            template <typename... Bools>
-            using strict_and = defer<strict_and, Bools...>;
-
-            /// \sa 'meta::strict_or'
-            /// \ingroup lazy_logical
-            template <typename... Bools>
-            using strict_or = defer<strict_or, Bools...>;
-        }
+        template <typename If>
+        struct _if_<list<If>, bool_<If::type::value>>
+        {
+            using type = void;
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // fold
-        /// \cond
-        namespace detail
+        template <typename If, typename Then>
+        struct _if_<list<If, Then>, bool_<If::type::value>>
         {
-            template <typename Fun, typename T0>
-            struct compose1_
-            {
-                template <typename X>
-                using invoke = invoke<Fun, _t<X>, T0>;
-            };
+            using type = Then;
+        };
 
-            template <typename Fun, typename T0, typename T1, typename T2, typename T3, typename T4,
-                      typename T5, typename T6, typename T7, typename T8, typename T9>
-            struct compose10_
-            {
-                template <typename X, typename Y>
-                using F = invoke<Fun, X, Y>;
+        template <typename If, typename Then, typename Else>
+        struct _if_<list<If, Then, Else>, bool_<If::type::value>>
+        {
+            using type = Then;
+        };
 
-                template <typename S>
-                using invoke =
-                    F<F<F<F<F<F<F<F<F<F<_t<S>, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
-            };
+        template <typename If, typename Then, typename Else>
+        struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
+        {
+            using type = Else;
+        };
+#endif
+    } // namespace detail
+        /// \endcond
 
-            template <typename, typename, typename>
-            struct fold_
-            {
-            };
+    /// Select one type or another depending on a compile-time Boolean.
+    /// \ingroup logical
+#ifdef META_CONCEPT
+    template <typename... Args>
+    using if_ = _t<detail::_if_<Args...>>;
 
-            template <typename State, typename Fun>
-            struct fold_<list<>, State, Fun> : State
-            {
-            };
+    /// Select one type or another depending on a compile-time Boolean.
+    /// \ingroup logical
+    template <bool If, typename... Args>
+    using if_c = _t<detail::_if_<bool_<If>, Args...>>;
+#else
+    template <typename... Args>
+    using if_ = _t<detail::_if_<list<Args...>>>;
 
-            template <typename Head, typename... List, typename State, typename Fun>
-            struct fold_<list<Head, List...>, State, Fun>
-                : fold_<list<List...>, lazy::invoke<compose1_<Fun, Head>, State>, Fun>
-            {
-            };
+    template <bool If, typename... Args>
+    using if_c = _t<detail::_if_<list<bool_<If>, Args...>>>;
+#endif
 
-            template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
-                      typename T6, typename T7, typename T8, typename T9, typename... List,
-                      typename State, typename Fun>
-            struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, List...>, State, Fun>
-                : fold_<
-                      list<List...>,
-                      lazy::invoke<compose10_<Fun, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, State>,
-                      Fun>
-            {
-            };
-        } // namespace detail
-        /// \endcond
+    namespace lazy
+    {
+        /// \sa 'meta::if_'
+        /// \ingroup lazy_logical
+        template <typename... Args>
+        using if_ = defer<if_, Args...>;
 
-        /// Return a new \c meta::list constructed by doing a left fold of the list \p List using
-        /// binary Callable \p Fun and initial state \p State. That is, the \c State_N for the list
-        /// element \c A_N is computed by `Fun(State_N-1, A_N) -> State_N`.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List, typename State, typename Fun>
-        using fold = _t<detail::fold_<List, id<State>, Fun>>;
-
-        /// An alias for `meta::fold`.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List, typename State, typename Fun>
-        using accumulate = fold<List, State, Fun>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::foldl'
-            /// \ingroup lazy_transformation
-            template <typename List, typename State, typename Fun>
-            using fold = defer<fold, List, State, Fun>;
-
-            /// \sa 'meta::accumulate'
-            /// \ingroup lazy_transformation
-            template <typename List, typename State, typename Fun>
-            using accumulate = defer<accumulate, List, State, Fun>;
-        }
+        /// \sa 'meta::if_c'
+        /// \ingroup lazy_logical
+        template <bool If, typename... Args>
+        using if_c = if_<bool_<If>, Args...>;
+    } // namespace lazy
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // reverse_fold
-        /// \cond
-        namespace detail
+    /// \cond
+    namespace detail
+    {
+#ifdef META_CONCEPT
+        template <typename...>
+        struct _and_
         {
-            template <typename List, typename State, typename Fun>
-            struct reverse_fold_
-            {
-            };
-
-            template <typename State, typename Fun>
-            struct reverse_fold_<list<>, State, Fun>
-            {
-                using type = State;
-            };
+        };
 
-            template <typename Head, typename... List, typename State, typename Fun>
-            struct reverse_fold_<list<Head, List...>, State, Fun>
-                : lazy::invoke<compose1_<Fun, Head>, reverse_fold_<list<List...>, State, Fun>>
-            {
-            };
+        template <>
+        struct _and_<> : std::true_type
+        {
+        };
 
-            template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
-                      typename T6, typename T7, typename T8, typename T9, typename... List,
-                      typename State, typename Fun>
-            struct reverse_fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, List...>, State, Fun>
-                : lazy::invoke<compose10_<Fun, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>,
-                               reverse_fold_<list<List...>, State, Fun>>
-            {
-            };
-        }
-        /// \endcond
+        template <integral B, typename... Bs>
+        requires (bool(B::type::value)) struct _and_<B, Bs...> : _and_<Bs...>
+        {
+        };
 
-        /// Return a new \c meta::list constructed by doing a right fold of the list \p List using
-        /// binary Callable \p Fun and initial state \p State. That is, the \c State_N
-        /// for the list element \c A_N is computed by `Fun(A_N, State_N+1) -> State_N`.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List, typename State, typename Fun>
-        using reverse_fold = _t<detail::reverse_fold_<List, State, Fun>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::foldr'
-            /// \ingroup lazy_transformation
-            template <typename List, typename State, typename Fun>
-            using reverse_fold = defer<reverse_fold, List, State, Fun>;
-        }
+        template <integral B, typename... Bs>
+        requires (!bool(B::type::value)) struct _and_<B, Bs...> : std::false_type
+        {
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////////
-        // npos
-        /// A special value used to indicate no matches. It equals the maximum value
-        /// representable
-        /// by std::size_t.
-        /// \ingroup list
-        using npos = meta::size_t<std::size_t(-1)>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // list
-        /// A list of types.
-        /// \ingroup list
-        template <typename... Ts>
-        struct list
+        template <typename...>
+        struct _or_
         {
-            using type = list;
-            /// \return `sizeof...(Ts)`
-            static constexpr std::size_t size() noexcept { return sizeof...(Ts); }
         };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // size
-        /// An integral constant wrapper that is the size of the \c meta::list
-        /// \p List.
-        /// \ingroup list
-        template <typename List>
-        using size = meta::size_t<List::size()>;
+        template <>
+        struct _or_<> : std::false_type
+        {
+        };
 
-        namespace lazy
+        template <integral B, typename... Bs>
+        requires (bool(B::type::value)) struct _or_<B, Bs...> : std::true_type
         {
-            /// \sa 'meta::size'
-            /// \ingroup lazy_list
-            template <typename List>
-            using size = defer<size, List>;
-        }
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // concat
-        /// \cond
-        namespace detail
+        template <integral B, typename... Bs>
+        requires (!bool(B::type::value)) struct _or_<B, Bs...> : _or_<Bs...>
         {
-            template <typename... Lists>
-            struct concat_
-            {
-            };
+        };
+#else
+        template <bool>
+        struct _and_
+        {
+            template <typename...>
+            using invoke = std::true_type;
+        };
 
-            template <>
-            struct concat_<>
-            {
-                using type = list<>;
-            };
+        template <>
+        struct _and_<false>
+        {
+            template <typename B, typename... Bs>
+            using invoke = invoke<
+                if_c<!B::type::value, id<std::false_type>, _and_<0 == sizeof...(Bs)>>,
+                Bs...>;
+        };
 
-            template <typename... List1>
-            struct concat_<list<List1...>>
-            {
-                using type = list<List1...>;
-            };
+        template <bool>
+        struct _or_
+        {
+            template <typename = void>
+            using invoke = std::false_type;
+        };
 
-            template <typename... List1, typename... List2, typename... Rest>
-            struct concat_<list<List1...>, list<List2...>, Rest...>
-                : concat_<list<List1..., List2...>, Rest...>
-            {
-            };
+        template <>
+        struct _or_<false>
+        {
+            template <typename B, typename... Bs>
+            using invoke = invoke<
+                if_c<B::type::value, id<std::true_type>, _or_<0 == sizeof...(Bs)>>,
+                Bs...>;
+        };
+#endif
+    } // namespace detail
+    /// \endcond
+
+    /// Logically negate the Boolean parameter
+    /// \ingroup logical
+    template <bool B>
+    using not_c = bool_<!B>;
+
+    /// Logically negate the integral constant-wrapped Boolean parameter.
+    /// \ingroup logical
+    template <META_TYPE_CONSTRAINT(integral) B>
+    using not_ = not_c<B::type::value>;
+
+#if META_CXX_FOLD_EXPRESSIONS && !defined(META_WORKAROUND_GCC_UNKNOWN1)
+    template <bool... Bs>
+    META_INLINE_VAR constexpr bool and_v = (true && ... && Bs);
+
+    /// Logically AND together all the Boolean parameters
+    /// \ingroup logical
+    template <bool... Bs>
+#if defined(META_WORKAROUND_MSVC_756112) || defined(META_WORKAROUND_GCC_86356)
+    using and_c = bool_<and_v<Bs...>>;
+#else
+    using and_c = bool_<(true && ... && Bs)>;
+#endif
+#else
+#if defined(META_WORKAROUND_GCC_66405)
+    template <bool... Bs>
+    using and_c = meta::bool_<
+        META_IS_SAME(integer_sequence<bool, true, Bs...>,
+                     integer_sequence<bool, Bs..., true>)>;
+#else
+    template <bool... Bs>
+    struct and_c
+      : meta::bool_<
+            META_IS_SAME(integer_sequence<bool, Bs...>,
+                         integer_sequence<bool, (Bs || true)...>)>
+    {};
+#endif
+#if META_CXX_VARIABLE_TEMPLATES
+    template <bool... Bs>
+    META_INLINE_VAR constexpr bool and_v =
+        META_IS_SAME(integer_sequence<bool, Bs...>,
+                     integer_sequence<bool, (Bs || true)...>);
+#endif
+#endif
 
-            template <typename... List1, typename... List2, typename... List3, typename... List4,
-                      typename... List5, typename... List6, typename... List7, typename... List8,
-                      typename... List9, typename... List10, typename... Rest>
-            struct concat_<list<List1...>, list<List2...>, list<List3...>, list<List4...>,
-                           list<List5...>, list<List6...>, list<List7...>, list<List8...>,
-                           list<List9...>, list<List10...>, Rest...>
-                : concat_<list<List1..., List2..., List3..., List4..., List5..., List6..., List7...,
-                               List8..., List9..., List10...>,
-                          Rest...>
-            {
-            };
-        } // namespace detail
-        /// \endcond
+    /// Logically AND together all the integral constant-wrapped Boolean
+    /// parameters, \e without short-circuiting.
+    /// \ingroup logical
+    template <META_TYPE_CONSTRAINT(integral)... Bs>
+    using strict_and_ = and_c<Bs::type::value...>;
+
+    template <typename... Bs>
+    using strict_and = strict_and_<Bs...>;
+
+    /// Logically AND together all the integral constant-wrapped Boolean
+    /// parameters, \e with short-circuiting.
+    /// \ingroup logical
+    template <typename... Bs>
+#ifdef META_CONCEPT
+    using and_ = _t<detail::_and_<Bs...>>;
+#else
+    // Make a trip through defer<> to avoid CWG1430
+    // https://wg21.link/cwg1430
+    using and_ = _t<defer<detail::_and_<0 == sizeof...(Bs)>::template invoke, Bs...>>;
+#endif
 
-        /// Concatenates several lists into a single list.
-        /// \pre The parameters must all be instantiations of \c meta::list.
-        /// \par Complexity
-        /// \f$ O(L) \f$ where \f$ L \f$ is the number of lists in the list of lists.
-        /// \ingroup transformation
-        template <typename... Lists>
-        using concat = _t<detail::concat_<Lists...>>;
+    /// Logically OR together all the Boolean parameters
+    /// \ingroup logical
+#if META_CXX_FOLD_EXPRESSIONS && !defined(META_WORKAROUND_GCC_UNKNOWN1)
+    template <bool... Bs>
+    META_INLINE_VAR constexpr bool or_v = (false || ... || Bs);
 
-        namespace lazy
-        {
-            /// \sa 'meta::concat'
-            /// \ingroup lazy_transformation
-            template <typename... Lists>
-            using concat = defer<concat, Lists...>;
-        }
+    template <bool... Bs>
+#if defined(META_WORKAROUND_MSVC_756112) || defined(META_WORKAROUND_GCC_86356)
+    using or_c = bool_<or_v<Bs...>>;
+#else
+    using or_c = bool_<(false || ... || Bs)>;
+#endif
+#else
+    template <bool... Bs>
+    struct or_c
+      : meta::bool_<
+            !META_IS_SAME(integer_sequence<bool, Bs...>,
+                          integer_sequence<bool, (Bs && false)...>)>
+    {};
+#if META_CXX_VARIABLE_TEMPLATES
+    template <bool... Bs>
+    META_INLINE_VAR constexpr bool or_v =
+        !META_IS_SAME(integer_sequence<bool, Bs...>,
+                      integer_sequence<bool, (Bs && false)...>);
+#endif
+#endif
 
-        /// Joins a list of lists into a single list.
-        /// \pre The parameter must be an instantiation of \c meta::list\<T...\>
-        /// where each \c T is itself an instantiation of \c meta::list.
-        /// \par Complexity
-        /// \f$ O(L) \f$ where \f$ L \f$ is the number of lists in the list of
-        /// lists.
-        /// \ingroup transformation
-        template <typename ListOfLists>
-        using join = apply<quote<concat>, ListOfLists>;
+    /// Logically OR together all the integral constant-wrapped Boolean
+    /// parameters, \e without short-circuiting.
+    /// \ingroup logical
+    template <META_TYPE_CONSTRAINT(integral)... Bs>
+    using strict_or_ = or_c<Bs::type::value...>;
+
+    template <typename... Bs>
+    using strict_or = strict_or_<Bs...>;
+
+    /// Logically OR together all the integral constant-wrapped Boolean
+    /// parameters, \e with short-circuiting.
+    /// \ingroup logical
+    template <typename... Bs>
+#ifdef META_CONCEPT
+    using or_ = _t<detail::_or_<Bs...>>;
+#else
+    // Make a trip through defer<> to avoid CWG1430
+    // https://wg21.link/cwg1430
+    using or_ = _t<defer<detail::_or_<0 == sizeof...(Bs)>::template invoke, Bs...>>;
+#endif
 
-        namespace lazy
+    namespace lazy
+    {
+        /// \sa 'meta::and_'
+        /// \ingroup lazy_logical
+        template <typename... Bs>
+        using and_ = defer<and_, Bs...>;
+
+        /// \sa 'meta::or_'
+        /// \ingroup lazy_logical
+        template <typename... Bs>
+        using or_ = defer<or_, Bs...>;
+
+        /// \sa 'meta::not_'
+        /// \ingroup lazy_logical
+        template <typename B>
+        using not_ = defer<not_, B>;
+
+        /// \sa 'meta::strict_and'
+        /// \ingroup lazy_logical
+        template <typename... Bs>
+        using strict_and = defer<strict_and, Bs...>;
+
+        /// \sa 'meta::strict_or'
+        /// \ingroup lazy_logical
+        template <typename... Bs>
+        using strict_or = defer<strict_or, Bs...>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // fold
+    /// \cond
+    namespace detail
+    {
+        template <typename, typename, typename>
+        struct fold_
         {
-            /// \sa 'meta::join'
-            /// \ingroup lazy_transformation
-            template <typename ListOfLists>
-            using join = defer<join, ListOfLists>;
-        }
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // transform
-        /// \cond
-        namespace detail
+        template <typename Fn, typename T0, typename T1, typename T2, typename T3, typename T4,
+                    typename T5, typename T6, typename T7, typename T8, typename T9>
+        struct compose10_
         {
-            template <typename, typename = void>
-            struct transform_
-            {
-            };
+            template <typename X, typename Y>
+            using F = invoke<Fn, X, Y>;
 
-            template <typename... Ts, typename Fun>
-            struct transform_<list<list<Ts...>, Fun>, void_<invoke<Fun, Ts>...>>
-            {
-                using type = list<invoke<Fun, Ts>...>;
-            };
+            template <typename S>
+            using invoke =
+                F<F<F<F<F<F<F<F<F<F<_t<S>, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
+        };
 
-            template <typename... Ts0, typename... Ts1, typename Fun>
-            struct transform_<list<list<Ts0...>, list<Ts1...>, Fun>,
-                              void_<invoke<Fun, Ts0, Ts1>...>>
-            {
-                using type = list<invoke<Fun, Ts0, Ts1>...>;
-            };
-        } // namespace detail
-        /// \endcond
+#ifdef META_CONCEPT
+        template <typename Fn>
+        struct compose_
+        {
+            template <typename X, typename Y>
+            using F = invoke<Fn, X, Y>;
 
-        /// Return a new \c meta::list constructed by transforming all the elements in
-        /// \p List with
-        /// the unary Callable \p Fun. \c transform can also be called with two lists of
-        /// the same length and a binary Callable, in which case it returns a new list
-        /// constructed with the results of calling \c Fun with each element in the
-        /// lists,
-        /// pairwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename... Args>
-        using transform = _t<detail::transform_<list<Args...>>>;
+            template <typename T0, typename T1, typename T2, typename T3, typename T4,
+                        typename T5, typename T6, typename T7, typename T8, typename T9,
+                        typename State>
+            using invoke =
+                F<F<F<F<F<F<F<F<F<F<State, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
+        };
 
-        namespace lazy
+        template <typename State, typename Fn>
+        struct fold_<list<>, State, Fn>
         {
-            /// \sa 'meta::transform'
-            /// \ingroup lazy_transformation
-            template <typename... Args>
-            using transform = defer<transform, Args...>;
-        }
+            using type = State;
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // repeat_n
-        /// \cond
-        namespace detail
+        template <typename Head, typename... Tail, typename State, typename Fn>
+        requires valid<invoke, Fn, State, Head>
+        struct fold_<list<Head, Tail...>, State, Fn>
+          : fold_<list<Tail...>, invoke<Fn, State, Head>, Fn>
         {
-            template <typename T, std::size_t>
-            using first_ = T;
-
-            template <typename T, typename Ints>
-            struct repeat_n_c_
-            {
-            };
+        };
 
-            template <typename T, std::size_t... Is>
-            struct repeat_n_c_<T, index_sequence<Is...>>
-            {
-                using type = list<first_<T, Is>...>;
-            };
-        }
-        /// \endcond
+        template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+                    typename T6, typename T7, typename T8, typename T9, typename... Tail,
+                    typename State, typename Fn>
+        requires valid<invoke, compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>
+        struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
+          : fold_<list<Tail...>,
+                  invoke<compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>, Fn>
+        {
+        };
+#else   // ^^^ Concepts / no Concepts vvv
+        template <typename Fn, typename T0>
+        struct compose1_
+        {
+            template <typename X>
+            using invoke = invoke<Fn, _t<X>, T0>;
+        };
 
-        /// Generate `list<T,T,T...T>` of size \p N arguments.
-        /// \par Complexity
-        /// \f$ O(log N) \f$.
-        /// \ingroup list
-        template <std::size_t N, typename T = void>
-        using repeat_n_c = _t<detail::repeat_n_c_<T, make_index_sequence<N>>>;
+        template <typename State, typename Fn>
+        struct fold_<list<>, State, Fn> : State
+        {
+        };
 
-        /// Generate `list<T,T,T...T>` of size \p N arguments.
-        /// \par Complexity
-        /// \f$ O(log N) \f$.
-        /// \ingroup list
-        template <typename N, typename T = void>
-        using repeat_n = repeat_n_c<N::type::value, T>;
+        template <typename Head, typename... Tail, typename State, typename Fn>
+        struct fold_<list<Head, Tail...>, State, Fn>
+          : fold_<list<Tail...>, lazy::invoke<compose1_<Fn, Head>, State>, Fn>
+        {
+        };
 
-        namespace lazy
+        template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+                    typename T6, typename T7, typename T8, typename T9, typename... Tail,
+                    typename State, typename Fn>
+        struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
+          : fold_<list<Tail...>,
+                  lazy::invoke<compose10_<Fn, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, State>, Fn>
         {
-            /// \sa 'meta::repeat_n'
-            /// \ingroup lazy_list
-            template <typename N, typename T = void>
-            using repeat_n = defer<repeat_n, N, T>;
+        };
+#endif  // META_CONCEPT
+    } // namespace detail
+    /// \endcond
+
+    /// Return a new \c meta::list constructed by doing a left fold of the list \p L using
+    /// binary invocable \p Fn and initial state \p State. That is, the \c State_N for
+    /// the list element \c A_N is computed by `Fn(State_N-1, A_N) -> State_N`.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, typename State, META_TYPE_CONSTRAINT(invocable) Fn>
+#ifdef META_CONCEPT
+    using fold = _t<detail::fold_<L, State, Fn>>;
+#else
+    using fold = _t<detail::fold_<L, id<State>, Fn>>;
+#endif
 
-            /// \sa 'meta::repeat_n_c'
-            /// \ingroup lazy_list
-            template <std::size_t N, typename T = void>
-            using repeat_n_c = defer<repeat_n, meta::size_t<N>, T>;
-        }
+    /// An alias for `meta::fold`.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, typename State, META_TYPE_CONSTRAINT(invocable) Fn>
+    using accumulate = fold<L, State, Fn>;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // at
-        /// \cond
-        namespace detail
+    namespace lazy
+    {
+        /// \sa 'meta::foldl'
+        /// \ingroup lazy_transformation
+        template <typename L, typename State, typename Fn>
+        using fold = defer<fold, L, State, Fn>;
+
+        /// \sa 'meta::accumulate'
+        /// \ingroup lazy_transformation
+        template <typename L, typename State, typename Fn>
+        using accumulate = defer<accumulate, L, State, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // reverse_fold
+    /// \cond
+    namespace detail
+    {
+        template <typename, typename, typename>
+        struct reverse_fold_
         {
-            template <typename VoidPtrs>
-            struct at_impl_;
+        };
 
-            template <typename... VoidPtrs>
-            struct at_impl_<list<VoidPtrs...>>
-            {
-                static nil_ eval(...);
+        template <typename State, typename Fn>
+        struct reverse_fold_<list<>, State, Fn>
+        {
+            using type = State;
+        };
 
-                template <typename T, typename... Us>
-                static T eval(VoidPtrs..., T *, Us *...);
-            };
+#ifdef META_CONCEPT
+        template <typename Head, typename... L, typename State, typename Fn>
+        requires trait<reverse_fold_<list<L...>, State, Fn>> struct reverse_fold_<
+            list<Head, L...>, State, Fn>
+          : lazy::invoke<Fn, _t<reverse_fold_<list<L...>, State, Fn>>, Head>
+        {
+        };
+#else
+        template <typename Head, typename... Tail, typename State, typename Fn>
+        struct reverse_fold_<list<Head, Tail...>, State, Fn>
+          : lazy::invoke<compose1_<Fn, Head>, reverse_fold_<list<Tail...>, State, Fn>>
+        {
+        };
+#endif
 
-            template <typename List, typename N>
-            struct at_
-            {
-            };
+        template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+                    typename T6, typename T7, typename T8, typename T9, typename... Tail,
+                    typename State, typename Fn>
+        struct reverse_fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
+          : lazy::invoke<compose10_<Fn, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>,
+                            reverse_fold_<list<Tail...>, State, Fn>>
+        {
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Return a new \c meta::list constructed by doing a right fold of the list \p L using
+    /// binary invocable \p Fn and initial state \p State. That is, the \c State_N for the list
+    /// element \c A_N is computed by `Fn(A_N, State_N+1) -> State_N`.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, typename State, META_TYPE_CONSTRAINT(invocable) Fn>
+    using reverse_fold = _t<detail::reverse_fold_<L, State, Fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::foldr'
+        /// \ingroup lazy_transformation
+        template <typename L, typename State, typename Fn>
+        using reverse_fold = defer<reverse_fold, L, State, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // npos
+    /// A special value used to indicate no matches. It equals the maximum
+    /// value representable by std::size_t.
+    /// \ingroup list
+    using npos = meta::size_t<std::size_t(-1)>;
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // list
+    /// A list of types.
+    /// \ingroup list
+    template <typename... Ts>
+    struct list
+    {
+        using type = list;
+        /// \return `sizeof...(Ts)`
+        static constexpr std::size_t size() noexcept { return sizeof...(Ts); }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // size
+    /// An integral constant wrapper that is the size of the \c meta::list
+    /// \p L.
+    /// \ingroup list
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using size = meta::size_t<L::size()>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::size'
+        /// \ingroup lazy_list
+        template <typename L>
+        using size = defer<size, L>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // concat
+    /// \cond
+    namespace detail
+    {
+        template <typename... Lists>
+        struct concat_
+        {
+        };
 
-            template <typename... Ts, typename N>
-            struct at_<list<Ts...>, N>
-                : decltype(at_impl_<repeat_n<N, void *>>::eval(static_cast<id<Ts> *>(nullptr)...))
-            {
-            };
-        } // namespace detail
-        /// \endcond
+        template <>
+        struct concat_<>
+        {
+            using type = list<>;
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // at
-        /// Return the \p N th element in the \c meta::list \p List.
-        /// \par Complexity
-        /// Amortized \f$ O(1) \f$.
-        /// \ingroup list
-        template <typename List, typename N>
-        using at = _t<detail::at_<List, N>>;
-
-        /// Return the \p N th element in the \c meta::list \p List.
-        /// \par Complexity
-        /// Amortized \f$ O(1) \f$.
-        /// \ingroup list
-        template <typename List, std::size_t N>
-        using at_c = at<List, meta::size_t<N>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::at'
-            /// \ingroup lazy_list
-            template <typename List, typename N>
-            using at = defer<at, List, N>;
-        }
+        template <typename... L1>
+        struct concat_<list<L1...>>
+        {
+            using type = list<L1...>;
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // drop
-        /// \cond
-        namespace detail
+        template <typename... L1, typename... L2>
+        struct concat_<list<L1...>, list<L2...>>
         {
-            ///////////////////////////////////////////////////////////////////////////////////////
-            /// drop_impl_
-            template <typename VoidPtrs>
-            struct drop_impl_
-            {
-                static nil_ eval(...);
-            };
+            using type = list<L1..., L2...>;
+        };
 
-            template <typename... VoidPtrs>
-            struct drop_impl_<list<VoidPtrs...>>
-            {
-                static nil_ eval(...);
+        template <typename... L1, typename... L2, typename... L3>
+        struct concat_<list<L1...>, list<L2...>, list<L3...>>
+        {
+            using type = list<L1..., L2..., L3...>;
+        };
 
-                template <typename... Ts>
-                static id<list<Ts...>> eval(VoidPtrs..., id<Ts> *...);
-            };
+        template <typename... L1, typename... L2, typename... L3, typename... Rest>
+        struct concat_<list<L1...>, list<L2...>, list<L3...>, Rest...>
+          : concat_<list<L1..., L2..., L3...>, Rest...>
+        {
+        };
 
-            template <>
-            struct drop_impl_<list<>>
-            {
-                template <typename... Ts>
-                static id<list<Ts...>> eval(id<Ts> *...);
-            };
+        template <typename... L1, typename... L2, typename... L3, typename... L4,
+                    typename... L5, typename... L6, typename... L7, typename... L8,
+                    typename... L9, typename... L10, typename... Rest>
+        struct concat_<list<L1...>, list<L2...>, list<L3...>, list<L4...>, list<L5...>,
+                        list<L6...>, list<L7...>, list<L8...>, list<L9...>, list<L10...>,
+                        Rest...>
+          : concat_<list<L1..., L2..., L3..., L4..., L5..., L6..., L7..., L8..., L9..., L10...>,
+                    Rest...>
+        {
+        };
+    } // namespace detail
+    /// \endcond
 
-            template <typename List, typename N>
-            struct drop_
-            {
-            };
+    /// Concatenates several lists into a single list.
+    /// \pre The parameters must all be instantiations of \c meta::list.
+    /// \par Complexity
+    /// \f$ O(L) \f$ where \f$ L \f$ is the number of lists in the list of lists.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like)... Ls>
+    using concat_ = _t<detail::concat_<Ls...>>;
 
-            template <typename... Ts, typename N>
-            struct drop_<list<Ts...>, N>
-                : decltype(drop_impl_<repeat_n<N, void *>>::eval(detail::_nullptr_v<id<Ts>>()...))
-            {
-            };
-        } // namespace detail
-        /// \endcond
+    template <typename... Lists>
+    using concat = concat_<Lists...>;
 
-        /// Return a new \c meta::list by removing the first \p N elements from \p List.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup transformation
-        template <typename List, typename N>
-        using drop = _t<detail::drop_<List, N>>;
-
-        /// Return a new \c meta::list by removing the first \p N elements from \p List.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup transformation
-        template <typename List, std::size_t N>
-        using drop_c = _t<detail::drop_<List, meta::size_t<N>>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::drop'
-            /// \ingroup lazy_transformation
-            template <typename List, typename N>
-            using drop = defer<drop, List, N>;
-        }
+    namespace lazy
+    {
+        /// \sa 'meta::concat'
+        /// \ingroup lazy_transformation
+        template <typename... Lists>
+        using concat = defer<concat, Lists...>;
+    } // namespace lazy
+
+    /// Joins a list of lists into a single list.
+    /// \pre The parameter must be an instantiation of \c meta::list\<T...\>
+    /// where each \c T is itself an instantiation of \c meta::list.
+    /// \par Complexity
+    /// \f$ O(L) \f$ where \f$ L \f$ is the number of lists in the list of
+    /// lists.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
+    using join = apply<quote<concat>, ListOfLists>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::join'
+        /// \ingroup lazy_transformation
+        template <typename ListOfLists>
+        using join = defer<join, ListOfLists>;
+    } // namespace lazy
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // front
-        /// \cond
-        namespace detail
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // transform
+    /// \cond
+    namespace detail
+    {
+#ifdef META_CONCEPT
+        template <typename... Args>
+        struct transform_
         {
-            template <typename List>
-            struct front_
-            {
-            };
+        };
 
-            template <typename Head, typename... List>
-            struct front_<list<Head, List...>>
-            {
-                using type = Head;
-            };
-        } // namespace detail
+        template <typename... Ts, invocable Fn>
+        requires and_v<valid<invoke, Fn, Ts>...>
+        struct transform_<list<Ts...>, Fn>
+        {
+            using type = list<invoke<Fn, Ts>...>;
+        };
+
+        template <typename... Ts, typename... Us, invocable Fn>
+        requires and_v<valid<invoke, Fn, Ts, Us>...>
+        struct transform_<list<Ts...>, list<Us...>, Fn>
+        {
+            using type = list<invoke<Fn, Ts, Us>...>;
+        };
+#else
+        template <typename, typename = void>
+        struct transform_
+        {
+        };
+
+        template <typename... Ts, typename Fn>
+        struct transform_<list<list<Ts...>, Fn>, void_<invoke<Fn, Ts>...>>
+        {
+            using type = list<invoke<Fn, Ts>...>;
+        };
+
+        template <typename... Ts0, typename... Ts1, typename Fn>
+        struct transform_<list<list<Ts0...>, list<Ts1...>, Fn>,
+                            void_<invoke<Fn, Ts0, Ts1>...>>
+        {
+            using type = list<invoke<Fn, Ts0, Ts1>...>;
+        };
+#endif
+    } // namespace detail
         /// \endcond
 
-        /// Return the first element in \c meta::list \p List.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup list
-        template <typename List>
-        using front = _t<detail::front_<List>>;
+    /// Return a new \c meta::list constructed by transforming all the
+    /// elements in \p L with the unary invocable \p Fn. \c transform can
+    /// also be called with two lists of the same length and a binary
+    /// invocable, in which case it returns a new list constructed with the
+    /// results of calling \c Fn with each element in the lists, pairwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+#ifdef META_CONCEPT
+    template <typename... Args>
+    using transform = _t<detail::transform_<Args...>>;
+#else
+    template <typename... Args>
+    using transform = _t<detail::transform_<list<Args...>>>;
+#endif
+
+    namespace lazy
+    {
+        /// \sa 'meta::transform'
+        /// \ingroup lazy_transformation
+        template <typename... Args>
+        using transform = defer<transform, Args...>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // repeat_n
+    /// \cond
+    namespace detail
+    {
+        template <typename T, std::size_t>
+        using first_ = T;
 
-        namespace lazy
+        template <typename T, typename Ints>
+        struct repeat_n_c_
         {
-            /// \sa 'meta::front'
-            /// \ingroup lazy_list
-            template <typename List>
-            using front = defer<front, List>;
-        }
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // back
-        /// \cond
-        namespace detail
+        template <typename T, std::size_t... Is>
+        struct repeat_n_c_<T, index_sequence<Is...>>
         {
-            template <typename List>
-            struct back_
-            {
-            };
+            using type = list<first_<T, Is>...>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Generate `list<T,T,T...T>` of size \p N arguments.
+    /// \par Complexity
+    /// \f$ O(log N) \f$.
+    /// \ingroup list
+    template <std::size_t N, typename T = void>
+    using repeat_n_c = _t<detail::repeat_n_c_<T, make_index_sequence<N>>>;
+
+    /// Generate `list<T,T,T...T>` of size \p N arguments.
+    /// \par Complexity
+    /// \f$ O(log N) \f$.
+    /// \ingroup list
+    template <META_TYPE_CONSTRAINT(integral) N, typename T = void>
+    using repeat_n = repeat_n_c<N::type::value, T>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::repeat_n'
+        /// \ingroup lazy_list
+        template <typename N, typename T = void>
+        using repeat_n = defer<repeat_n, N, T>;
 
-            template <typename Head, typename... List>
-            struct back_<list<Head, List...>>
-            {
-                using type = at_c<list<Head, List...>, sizeof...(List)>;
-            };
-        } // namespace detail
-        /// \endcond
+        /// \sa 'meta::repeat_n_c'
+        /// \ingroup lazy_list
+        template <std::size_t N, typename T = void>
+        using repeat_n_c = defer<repeat_n, meta::size_t<N>, T>;
+    } // namespace lazy
 
-        /// Return the last element in \c meta::list \p List.
-        /// \par Complexity
-        /// Amortized \f$ O(1) \f$.
-        /// \ingroup list
-        template <typename List>
-        using back = _t<detail::back_<List>>;
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // at
+    /// \cond
+    namespace detail
+    {
+#if META_HAS_TYPE_PACK_ELEMENT && !defined(META_DOXYGEN_INVOKED)
+        template <typename L, std::size_t N, typename = void>
+        struct at_
+        {
+        };
 
-        namespace lazy
+        template <typename... Ts, std::size_t N>
+        struct at_<list<Ts...>, N, void_<__type_pack_element<N, Ts...>>>
         {
-            /// \sa 'meta::back'
-            /// \ingroup lazy_list
-            template <typename List>
-            using back = defer<back, List>;
-        }
+            using type = __type_pack_element<N, Ts...>;
+        };
+#else
+        template <typename VoidPtrs>
+        struct at_impl_;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // push_front
-        /// \cond
-        namespace detail
+        template <typename... VoidPtrs>
+        struct at_impl_<list<VoidPtrs...>>
         {
-            template <typename List, typename T>
-            struct push_front_
-            {
-            };
+            static nil_ eval(...);
 
-            template <typename... List, typename T>
-            struct push_front_<list<List...>, T>
-            {
-                using type = list<T, List...>;
-            };
-        } // namespace detail
-        /// \endcond
+            template <typename T, typename... Us>
+            static T eval(VoidPtrs..., T *, Us *...);
+        };
 
-        /// Return a new \c meta::list by adding the element \c T to the front of \p
-        /// List.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup transformation
-        template <typename List, typename T>
-        using push_front = _t<detail::push_front_<List, T>>;
+        template <typename L, std::size_t N>
+        struct at_
+        {
+        };
 
-        namespace lazy
+        template <typename... Ts, std::size_t N>
+        struct at_<list<Ts...>, N>
+          : decltype(at_impl_<repeat_n_c<N, void *>>::eval(static_cast<id<Ts> *>(nullptr)...))
         {
-            /// \sa 'meta::push_front'
-            /// \ingroup lazy_transformation
-            template <typename List, typename T>
-            using push_front = defer<push_front, List, T>;
-        }
+        };
+#endif    // META_HAS_TYPE_PACK_ELEMENT
+    } // namespace detail
+    /// \endcond
+
+    /// Return the \p N th element in the \c meta::list \p L.
+    /// \par Complexity
+    /// Amortized \f$ O(1) \f$.
+    /// \ingroup list
+    template <META_TYPE_CONSTRAINT(list_like) L, std::size_t N>
+    using at_c = _t<detail::at_<L, N>>;
+
+    /// Return the \p N th element in the \c meta::list \p L.
+    /// \par Complexity
+    /// Amortized \f$ O(1) \f$.
+    /// \ingroup list
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(integral) N>
+    using at = at_c<L, N::type::value>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::at'
+        /// \ingroup lazy_list
+        template <typename L, typename N>
+        using at = defer<at, L, N>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // drop
+    /// \cond
+    namespace detail
+    {
+        ///////////////////////////////////////////////////////////////////////////////////////
+        /// drop_impl_
+        template <typename VoidPtrs>
+        struct drop_impl_
+        {
+            static nil_ eval(...);
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // pop_front
-        /// \cond
-        namespace detail
+        template <typename... VoidPtrs>
+        struct drop_impl_<list<VoidPtrs...>>
         {
-            template <typename List>
-            struct pop_front_
-            {
-            };
+            static nil_ eval(...);
 
-            template <typename Head, typename... List>
-            struct pop_front_<list<Head, List...>>
-            {
-                using type = list<List...>;
-            };
-        } // namespace detail
-        /// \endcond
+            template <typename... Ts>
+            static id<list<Ts...>> eval(VoidPtrs..., id<Ts> *...);
+        };
 
-        /// Return a new \c meta::list by removing the first element from the front of
-        /// \p List.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup transformation
-        template <typename List>
-        using pop_front = _t<detail::pop_front_<List>>;
+        template <>
+        struct drop_impl_<list<>>
+        {
+            template <typename... Ts>
+            static id<list<Ts...>> eval(id<Ts> *...);
+        };
 
-        namespace lazy
+        template <typename L, std::size_t N>
+        struct drop_
         {
-            /// \sa 'meta::pop_front'
-            /// \ingroup lazy_transformation
-            template <typename List>
-            using pop_front = defer<pop_front, List>;
-        }
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // push_back
-        /// \cond
-        namespace detail
+        template <typename... Ts, std::size_t N>
+        struct drop_<list<Ts...>, N>
+#if META_CXX_VARIABLE_TEMPLATES
+          : decltype(drop_impl_<repeat_n_c<N, void *>>::eval(detail::nullptr_v<id<Ts>>...))
+#else
+          : decltype(drop_impl_<repeat_n_c<N, void *>>::eval(detail::_nullptr_v<id<Ts>>()...))
+#endif
         {
-            template <typename List, typename T>
-            struct push_back_
-            {
-            };
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Return a new \c meta::list by removing the first \p N elements from \p L.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, std::size_t N>
+    using drop_c = _t<detail::drop_<L, N>>;
+
+    /// Return a new \c meta::list by removing the first \p N elements from \p L.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(integral) N>
+    using drop = drop_c<L, N::type::value>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::drop'
+        /// \ingroup lazy_transformation
+        template <typename L, typename N>
+        using drop = defer<drop, L, N>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // front
+    /// \cond
+    namespace detail
+    {
+        template <typename L>
+        struct front_
+        {
+        };
 
-            template <typename... List, typename T>
-            struct push_back_<list<List...>, T>
-            {
-                using type = list<List..., T>;
-            };
-        } // namespace detail
-        /// \endcond
+        template <typename Head, typename... Tail>
+        struct front_<list<Head, Tail...>>
+        {
+            using type = Head;
+        };
+    } // namespace detail
+    /// \endcond
 
-        /// Return a new \c meta::list by adding the element \c T to the back of \p
-        /// List.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \note \c pop_back not provided because it cannot be made to meet the
-        /// complexity guarantees one would expect.
-        /// \ingroup transformation
-        template <typename List, typename T>
-        using push_back = _t<detail::push_back_<List, T>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::push_back'
-            /// \ingroup lazy_transformation
-            template <typename List, typename T>
-            using push_back = defer<push_back, List, T>;
-        }
+    /// Return the first element in \c meta::list \p L.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup list
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using front = _t<detail::front_<L>>;
 
-        /// \cond
-        namespace detail
+    namespace lazy
+    {
+        /// \sa 'meta::front'
+        /// \ingroup lazy_list
+        template <typename L>
+        using front = defer<front, L>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // back
+    /// \cond
+    namespace detail
+    {
+        template <typename L>
+        struct back_
         {
-            template <typename T, typename U>
-            using min_ = if_<less<U, T>, U, T>;
+        };
 
-            template <typename T, typename U>
-            using max_ = if_<less<U, T>, T, U>;
-        }
-        /// \endcond
+        template <typename Head, typename... Tail>
+        struct back_<list<Head, Tail...>>
+        {
+            using type = at_c<list<Head, Tail...>, sizeof...(Tail)>;
+        };
+    } // namespace detail
+    /// \endcond
 
-        /// An integral constant wrapper around the minimum of `Ts::type::value...`
-        /// \ingroup math
-        template <typename... Ts>
-        using min = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::min_>>;
+    /// Return the last element in \c meta::list \p L.
+    /// \par Complexity
+    /// Amortized \f$ O(1) \f$.
+    /// \ingroup list
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using back = _t<detail::back_<L>>;
 
-        /// An integral constant wrapper around the maximum of `Ts::type::value...`
-        /// \ingroup math
+    namespace lazy
+    {
+        /// \sa 'meta::back'
+        /// \ingroup lazy_list
+        template <typename L>
+        using back = defer<back, L>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // push_front
+    /// Return a new \c meta::list by adding the element \c T to the front of \p L.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, typename... Ts>
+    using push_front = apply<bind_front<quote<list>, Ts...>, L>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::push_front'
+        /// \ingroup lazy_transformation
         template <typename... Ts>
-        using max = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::max_>>;
+        using push_front = defer<push_front, Ts...>;
+    } // namespace lazy
 
-        namespace lazy
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // pop_front
+    /// \cond
+    namespace detail
+    {
+        template <typename L>
+        struct pop_front_
         {
-            /// \sa 'meta::min'
-            /// \ingroup lazy_math
-            template <typename... Ts>
-            using min = defer<min, Ts...>;
+        };
 
-            /// \sa 'meta::max'
-            /// \ingroup lazy_math
-            template <typename... Ts>
-            using max = defer<max, Ts...>;
-        }
+        template <typename Head, typename... L>
+        struct pop_front_<list<Head, L...>>
+        {
+            using type = list<L...>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Return a new \c meta::list by removing the first element from the
+    /// front of \p L.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using pop_front = _t<detail::pop_front_<L>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::pop_front'
+        /// \ingroup lazy_transformation
+        template <typename L>
+        using pop_front = defer<pop_front, L>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // push_back
+    /// Return a new \c meta::list by adding the element \c T to the back of \p L.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \note \c pop_back not provided because it cannot be made to meet the
+    /// complexity guarantees one would expect.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, typename... Ts>
+    using push_back = apply<bind_back<quote<list>, Ts...>, L>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::push_back'
+        /// \ingroup lazy_transformation
+        template <typename... Ts>
+        using push_back = defer<push_back, Ts...>;
+    } // namespace lazy
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // empty
-        /// An Boolean integral constant wrapper around \c true if \p List is an empty
-        /// type list; \c
-        /// false, otherwise.
-        /// \par Complexity
-        /// \f$ O(1) \f$.
-        /// \ingroup list
-        template <typename List>
-        using empty = bool_<0 == size<List>::type::value>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::empty'
-            /// \ingroup lazy_list
-            template <typename List>
-            using empty = defer<empty, List>;
-        }
+    /// \cond
+    namespace detail
+    {
+        template <typename T, typename U>
+        using min_ = if_<less<U, T>, U, T>;
+
+        template <typename T, typename U>
+        using max_ = if_<less<U, T>, T, U>;
+    } // namespace detail
+    /// \endcond
+
+    /// An integral constant wrapper around the minimum of `Ts::type::value...`
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral)... Ts>
+    using min_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::min_>>;
+
+    template <typename... Ts>
+    using min = min_<Ts...>;
+
+    /// An integral constant wrapper around the maximum of `Ts::type::value...`
+    /// \ingroup math
+    template <META_TYPE_CONSTRAINT(integral)... Ts>
+    using max_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::max_>>;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // pair
-        /// A list with exactly two elements
-        /// \ingroup list
-        template <typename F, typename S>
-        using pair = list<F, S>;
+    template <typename... Ts>
+    using max = max_<Ts...>;
 
-        /// Retrieve the first element of the \c pair \p Pair
-        /// \ingroup list
+    namespace lazy
+    {
+        /// \sa 'meta::min'
+        /// \ingroup lazy_math
+        template <typename... Ts>
+        using min = defer<min, Ts...>;
+
+        /// \sa 'meta::max'
+        /// \ingroup lazy_math
+        template <typename... Ts>
+        using max = defer<max, Ts...>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // empty
+    /// An Boolean integral constant wrapper around \c true if \p L is an
+    /// empty type list; \c false, otherwise.
+    /// \par Complexity
+    /// \f$ O(1) \f$.
+    /// \ingroup list
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using empty = bool_<0 == size<L>::type::value>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::empty'
+        /// \ingroup lazy_list
+        template <typename L>
+        using empty = defer<empty, L>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // pair
+    /// A list with exactly two elements
+    /// \ingroup list
+    template <typename F, typename S>
+    using pair = list<F, S>;
+
+    /// Retrieve the first element of the \c pair \p Pair
+    /// \ingroup list
+    template <typename Pair>
+    using first = front<Pair>;
+
+    /// Retrieve the first element of the \c pair \p Pair
+    /// \ingroup list
+    template <typename Pair>
+    using second = front<pop_front<Pair>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::first'
+        /// \ingroup lazy_list
         template <typename Pair>
-        using first = front<Pair>;
+        using first = defer<first, Pair>;
 
-        /// Retrieve the first element of the \c pair \p Pair
-        /// \ingroup list
+        /// \sa 'meta::second'
+        /// \ingroup lazy_list
         template <typename Pair>
-        using second = front<pop_front<Pair>>;
+        using second = defer<second, Pair>;
+    } // namespace lazy
 
-        namespace lazy
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // find_index
+    /// \cond
+    namespace detail
+    {
+        // With thanks to Peter Dimov:
+        constexpr std::size_t find_index_i_(bool const *const first, bool const *const last,
+                                            std::size_t N = 0)
         {
-            /// \sa 'meta::first'
-            /// \ingroup lazy_list
-            template <typename Pair>
-            using first = defer<first, Pair>;
-
-            /// \sa 'meta::second'
-            /// \ingroup lazy_list
-            template <typename Pair>
-            using second = defer<second, Pair>;
+            return first == last ? npos::value
+                                 : *first ? N : find_index_i_(first + 1, last, N + 1);
         }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // find_index
-        /// \cond
-        namespace detail
+        template <typename L, typename T>
+        struct find_index_
         {
-            // With thanks to Peter Dimov:
-            constexpr std::size_t find_index_i_(bool const *const first, bool const *const last,
-                                                std::size_t N = 0)
-            {
-                return first == last ? npos::value
-                                     : *first ? N : find_index_i_(first + 1, last, N + 1);
-            }
+        };
 
-            template <typename List, typename T>
-            struct find_index_
-            {
-            };
+        template <typename V>
+        struct find_index_<list<>, V>
+        {
+            using type = npos;
+        };
 
-            template <typename V>
-            struct find_index_<list<>, V>
-            {
-                using type = npos;
-            };
+        template <typename... T, typename V>
+        struct find_index_<list<T...>, V>
+        {
+#ifdef META_WORKAROUND_LLVM_28385
+            static constexpr bool s_v[sizeof...(T)] = {META_IS_SAME(T, V)...};
+#else
+            static constexpr bool s_v[] = {META_IS_SAME(T, V)...};
+#endif
+            using type = size_t<find_index_i_(s_v, s_v + sizeof...(T))>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Finds the index of the first occurrence of the type \p T within the list \p L.
+    /// Returns `#meta::npos` if the type \p T was not found.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    /// \sa `meta::npos`
+    template <META_TYPE_CONSTRAINT(list_like) L, typename T>
+    using find_index = _t<detail::find_index_<L, T>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::find_index'
+        /// \ingroup lazy_query
+        template <typename L, typename T>
+        using find_index = defer<find_index, L, T>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // reverse_find_index
+    /// \cond
+    namespace detail
+    {
+        // With thanks to Peter Dimov:
+        constexpr std::size_t reverse_find_index_i_(bool const *const first,
+                                                    bool const *const last, std::size_t N)
+        {
+            return first == last
+                ? npos::value
+                : *(last - 1) ? N - 1 : reverse_find_index_i_(first, last - 1, N - 1);
+        }
 
-            template <typename... T, typename V>
-            struct find_index_<list<T...>, V>
-            {
-                // Explicitly specify extent to avoid https://llvm.org/bugs/show_bug.cgi?id=28385
-                static constexpr bool s_v[sizeof...(T)] = {std::is_same<T, V>::value...};
-                using type = size_t<find_index_i_(s_v, s_v + sizeof...(T))>;
-            };
-        } // namespace detail
-        /// \endcond
+        template <typename L, typename T>
+        struct reverse_find_index_
+        {
+        };
 
-        /// Finds the index of the first occurrence of the type \p T within the list \p
-        /// List.
-        /// Returns `#meta::npos` if the type \p T was not found.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        /// \sa `meta::npos`
-        template <typename List, typename T>
-        using find_index = _t<detail::find_index_<List, T>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::find_index'
-            /// \ingroup lazy_query
-            template <typename List, typename T>
-            using find_index = defer<find_index, List, T>;
-        }
+        template <typename V>
+        struct reverse_find_index_<list<>, V>
+        {
+            using type = npos;
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // reverse_find_index
-        /// \cond
-        namespace detail
+        template <typename... T, typename V>
+        struct reverse_find_index_<list<T...>, V>
         {
-            // With thanks to Peter Dimov:
-            constexpr std::size_t reverse_find_index_i_(bool const *const first,
-                                                        bool const *const last, std::size_t N)
-            {
-                return first == last
-                           ? npos::value
-                           : *(last - 1) ? N - 1 : reverse_find_index_i_(first, last - 1, N - 1);
-            }
+#ifdef META_WORKAROUND_LLVM_28385
+            static constexpr bool s_v[sizeof...(T)] = {META_IS_SAME(T, V)...};
+#else
+            static constexpr bool s_v[] = {META_IS_SAME(T, V)...};
+#endif
+            using type = size_t<reverse_find_index_i_(s_v, s_v + sizeof...(T), sizeof...(T))>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Finds the index of the last occurrence of the type \p T within the
+    /// list \p L. Returns `#meta::npos` if the type \p T was not found.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    /// \sa `#meta::npos`
+    template <META_TYPE_CONSTRAINT(list_like) L, typename T>
+    using reverse_find_index = _t<detail::reverse_find_index_<L, T>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::reverse_find_index'
+        /// \ingroup lazy_query
+        template <typename L, typename T>
+        using reverse_find_index = defer<reverse_find_index, L, T>;
+    } // namespace lazy
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // find
+    /// Return the tail of the list \p L starting at the first occurrence of
+    /// \p T, if any such element exists; the empty list, otherwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, typename T>
+    using find = drop<L, min<find_index<L, T>, size<L>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::find'
+        /// \ingroup lazy_query
+        template <typename L, typename T>
+        using find = defer<find, L, T>;
+    } // namespace lazy
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // reverse_find
+    /// \cond
+    namespace detail
+    {
+        template <typename L, typename T, typename State = list<>>
+        struct reverse_find_
+        {
+        };
 
-            template <typename List, typename T>
-            struct reverse_find_index_
-            {
-            };
+        template <typename T, typename State>
+        struct reverse_find_<list<>, T, State>
+        {
+            using type = State;
+        };
 
-            template <typename V>
-            struct reverse_find_index_<list<>, V>
-            {
-                using type = npos;
-            };
+        template <typename Head, typename... L, typename T, typename State>
+        struct reverse_find_<list<Head, L...>, T, State> : reverse_find_<list<L...>, T, State>
+        {
+        };
 
-            template <typename... T, typename V>
-            struct reverse_find_index_<list<T...>, V>
-            {
-                // Explicitly specify extent to avoid https://llvm.org/bugs/show_bug.cgi?id=28385
-                static constexpr bool s_v[sizeof...(T)] = {std::is_same<T, V>::value...};
-                using type = size_t<reverse_find_index_i_(s_v, s_v + sizeof...(T), sizeof...(T))>;
-            };
-        } // namespace detail
-        /// \endcond
+        template <typename... L, typename T, typename State>
+        struct reverse_find_<list<T, L...>, T, State>
+          : reverse_find_<list<L...>, T, list<T, L...>>
+        {
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Return the tail of the list \p L starting at the last occurrence of \p T, if any such
+    /// element exists; the empty list, otherwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, typename T>
+    using reverse_find = drop<L, min<reverse_find_index<L, T>, size<L>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::rfind'
+        /// \ingroup lazy_query
+        template <typename L, typename T>
+        using reverse_find = defer<reverse_find, L, T>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // find_if
+    /// \cond
+    namespace detail
+    {
+#ifdef META_CONCEPT
+        template <typename L, typename Fn>
+        struct find_if_
+        {
+        };
 
-        /// Finds the index of the last occurrence of the type \p T within the list \p
-        /// List. Returns
-        /// `#meta::npos` if the type \p T was not found.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        /// \sa `#meta::npos`
-        template <typename List, typename T>
-        using reverse_find_index = _t<detail::reverse_find_index_<List, T>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::reverse_find_index'
-            /// \ingroup lazy_query
-            template <typename List, typename T>
-            using reverse_find_index = defer<reverse_find_index, List, T>;
-        }
+        template <typename Fn>
+        struct find_if_<list<>, Fn>
+        {
+            using type = list<>;
+        };
 
-        ////////////////////////////////////////////////////////////////////////////////////
-        // find
-        /// Return the tail of the list \p List starting at the first occurrence of \p
-        /// T, if any
-        /// such element exists; the empty list, otherwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename T>
-        using find = drop<List, min<find_index<List, T>, size<List>>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::find'
-            /// \ingroup lazy_query
-            template <typename List, typename T>
-            using find = defer<find, List, T>;
+        template <typename Head, typename... L, typename Fn>
+        requires integral<invoke<Fn, Head>>
+        struct find_if_<list<Head, L...>, Fn>
+          : if_<invoke<Fn, Head>, id<list<Head, L...>>, find_if_<list<L...>, Fn>>
+        {
+        };
+#else
+        constexpr bool const *find_if_i_(bool const *const begin, bool const *const end)
+        {
+            return begin == end || *begin ? begin : find_if_i_(begin + 1, end);
         }
 
-        ////////////////////////////////////////////////////////////////////////////////////
-        // reverse_find
-        /// Return the tail of the list \p List starting at the last occurrence of \p T,
-        /// if any such
-        /// element exists; the empty list, otherwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename T>
-        using reverse_find = drop<List, min<reverse_find_index<List, T>, size<List>>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::rfind'
-            /// \ingroup lazy_query
-            template <typename List, typename T>
-            using reverse_find = defer<reverse_find, List, T>;
-        }
+        template <typename L, typename Fn, typename = void>
+        struct find_if_
+        {
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // find_if
-        /// \cond
-        namespace detail
+        template <typename Fn>
+        struct find_if_<list<>, Fn>
         {
-            constexpr bool const *find_if_i_(bool const *const begin, bool const *const end)
-            {
-                return begin == end || *begin ? begin : find_if_i_(begin + 1, end);
-            }
+            using type = list<>;
+        };
 
-            template <typename List, typename Fun, typename = void>
-            struct find_if_
-            {
-            };
-
-            template <typename Fun>
-            struct find_if_<list<>, Fun>
-            {
-                using type = list<>;
-            };
-
-            template <typename... List, typename Fun>
-            struct find_if_<list<List...>, Fun,
-                            void_<integer_sequence<bool, bool(invoke<Fun, List>::type::value)...>>>
-            {
-                // Explicitly specify extent to avoid https://llvm.org/bugs/show_bug.cgi?id=28385
-                static constexpr bool s_v[sizeof...(List)] = {invoke<Fun, List>::type::value...};
-                using type =
-                    drop_c<list<List...>, detail::find_if_i_(s_v, s_v + sizeof...(List)) - s_v>;
-            };
-        } // namespace detail
-        /// \endcond
-
-        /// Return the tail of the list \p List starting at the first element `A` such
-        /// that
-        /// `invoke<Fun, A>::%value` is \c true, if any such element exists; the empty
-        /// list,
-        /// otherwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename Fun>
-        using find_if = _t<detail::find_if_<List, Fun>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::find_if'
-            /// \ingroup lazy_query
-            template <typename List, typename Fun>
-            using find_if = defer<find_if, List, Fun>;
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////
-        // reverse_find_if
-        /// \cond
-        namespace detail
+        template <typename... L, typename Fn>
+        struct find_if_<list<L...>, Fn,
+                        void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>>
         {
-            constexpr bool const *reverse_find_if_i_(bool const *const begin, bool const *const pos,
-                                                     bool const *const end)
-            {
-                return begin == pos
-                           ? end
-                           : *(pos - 1) ? pos - 1 : reverse_find_if_i_(begin, pos - 1, end);
-            }
-
-            template <typename List, typename Fun, typename = void>
-            struct reverse_find_if_
-            {
-            };
+#ifdef META_WORKAROUND_LLVM_28385
+            static constexpr bool s_v[sizeof...(L)] = {invoke<Fn, L>::type::value...};
+#else
+            static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
+#endif
+            using type =
+                drop_c<list<L...>, detail::find_if_i_(s_v, s_v + sizeof...(L)) - s_v>;
+        };
+#endif
+    } // namespace detail
+    /// \endcond
+
+    /// Return the tail of the list \p L starting at the first element `A`
+    /// such that `invoke<Fn, A>::%value` is \c true, if any such element
+    /// exists; the empty list, otherwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using find_if = _t<detail::find_if_<L, Fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::find_if'
+        /// \ingroup lazy_query
+        template <typename L, typename Fn>
+        using find_if = defer<find_if, L, Fn>;
+    } // namespace lazy
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // reverse_find_if
+    /// \cond
+    namespace detail
+    {
+#ifdef META_CONCEPT
+        template <typename L, typename Fn, typename State = list<>>
+        struct reverse_find_if_
+        {
+        };
 
-            template <typename Fun>
-            struct reverse_find_if_<list<>, Fun>
-            {
-                using type = list<>;
-            };
+        template <typename Fn, typename State>
+        struct reverse_find_if_<list<>, Fn, State>
+        {
+            using type = State;
+        };
 
-            template <typename... List, typename Fun>
-            struct reverse_find_if_<
-                list<List...>, Fun,
-                void_<integer_sequence<bool, bool(invoke<Fun, List>::type::value)...>>>
-            {
-                // Explicitly specify extent to avoid https://llvm.org/bugs/show_bug.cgi?id=28385
-                static constexpr bool s_v[sizeof...(List)] = {invoke<Fun, List>::type::value...};
-                using type =
-                  drop_c<list<List...>, detail::reverse_find_if_i_(s_v, s_v + sizeof...(List),
-                                                                   s_v + sizeof...(List)) - s_v>;
-            };
+        template <typename Head, typename... L, typename Fn, typename State>
+        requires integral<invoke<Fn, Head>>
+        struct reverse_find_if_<list<Head, L...>, Fn, State>
+          : reverse_find_if_<list<L...>, Fn, if_<invoke<Fn, Head>, list<Head, L...>, State>>
+        {
+        };
+#else
+        constexpr bool const *reverse_find_if_i_(bool const *const begin, bool const *const pos,
+                                                    bool const *const end)
+        {
+            return begin == pos
+                ? end
+                : *(pos - 1) ? pos - 1 : reverse_find_if_i_(begin, pos - 1, end);
         }
-        /// \endcond
 
-        /// Return the tail of the list \p List starting at the last element `A` such
-        /// that
-        /// `invoke<Fun, A>::%value` is \c true, if any such element exists; the empty
-        /// list,
-        /// otherwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename Fun>
-        using reverse_find_if = _t<detail::reverse_find_if_<List, Fun>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::rfind_if'
-            /// \ingroup lazy_query
-            template <typename List, typename Fun>
-            using reverse_find_if = defer<reverse_find_if, List, Fun>;
-        }
+        template <typename L, typename Fn, typename = void>
+        struct reverse_find_if_
+        {
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // replace
-        /// \cond
-        namespace detail
+        template <typename Fn>
+        struct reverse_find_if_<list<>, Fn>
         {
-            template <typename List, typename T, typename U>
-            struct replace_
-            {
-            };
+            using type = list<>;
+        };
 
-            template <typename... List, typename T, typename U>
-            struct replace_<list<List...>, T, U>
-            {
-                using type = list<if_<std::is_same<T, List>, U, List>...>;
-            };
-        } // namespace detail
-        /// \endcond
+        template <typename... L, typename Fn>
+        struct reverse_find_if_<
+            list<L...>, Fn,
+            void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>>
+        {
+#ifdef META_WORKAROUND_LLVM_28385
+            static constexpr bool s_v[sizeof...(L)] = {invoke<Fn, L>::type::value...};
+#else
+            static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
+#endif
+            using type =
+                drop_c<list<L...>, detail::reverse_find_if_i_(s_v, s_v + sizeof...(L),
+                                                                    s_v + sizeof...(L)) -
+                                            s_v>;
+        };
+#endif
+    } // namespace detail
+    /// \endcond
+
+    /// Return the tail of the list \p L starting at the last element `A`
+    /// such that `invoke<Fn, A>::%value` is \c true, if any such element
+    /// exists; the empty list, otherwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using reverse_find_if = _t<detail::reverse_find_if_<L, Fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::rfind_if'
+        /// \ingroup lazy_query
+        template <typename L, typename Fn>
+        using reverse_find_if = defer<reverse_find_if, L, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // replace
+    /// \cond
+    namespace detail
+    {
+        template <typename L, typename T, typename U>
+        struct replace_
+        {
+        };
 
-        /// Return a new \c meta::list where all instances of type \p T have been
-        /// replaced with
-        /// \p U.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List, typename T, typename U>
-        using replace = _t<detail::replace_<List, T, U>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::replace'
-            /// \ingroup lazy_transformation
-            template <typename List, typename T, typename U>
-            using replace = defer<replace, T, U>;
-        }
+        template <typename... L, typename T, typename U>
+        struct replace_<list<L...>, T, U>
+        {
+            using type = list<if_c<META_IS_SAME(T, L), U, L>...>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Return a new \c meta::list where all instances of type \p T have
+    /// been replaced with \p U.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, typename T, typename U>
+    using replace = _t<detail::replace_<L, T, U>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::replace'
+        /// \ingroup lazy_transformation
+        template <typename L, typename T, typename U>
+        using replace = defer<replace, T, U>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // replace_if
+    /// \cond
+    namespace detail
+    {
+#ifdef META_CONCEPT
+        template <typename L, typename C, typename U>
+        struct replace_if_
+        {
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // replace_if
-        /// \cond
-        namespace detail
+        template <typename... L, typename C, typename U>
+        requires and_v<integral<invoke<C, L>>...>
+        struct replace_if_<list<L...>, C, U>
         {
-            template <typename List, typename C, typename U, typename = void>
-            struct replace_if_
-            {
-            };
+            using type = list<if_<invoke<C, L>, U, L>...>;
+        };
+#else
+        template <typename L, typename C, typename U, typename = void>
+        struct replace_if_
+        {
+        };
 
-            template <typename... List, typename C, typename U>
-            struct replace_if_<list<List...>, C, U,
-                               void_<integer_sequence<bool, bool(invoke<C, List>::type::value)...>>>
-            {
-                using type = list<if_<invoke<C, List>, U, List>...>;
-            };
-        } // namespace detail
-        /// \endcond
+        template <typename... L, typename C, typename U>
+        struct replace_if_<list<L...>, C, U,
+                            void_<integer_sequence<bool, bool(invoke<C, L>::type::value)...>>>
+        {
+            using type = list<if_<invoke<C, L>, U, L>...>;
+        };
+#endif
+    } // namespace detail
+    /// \endcond
+
+    /// Return a new \c meta::list where all elements \c A of the list \p L
+    /// for which `invoke<C,A>::%value` is \c true have been replaced with
+    /// \p U.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, typename C, typename U>
+    using replace_if = _t<detail::replace_if_<L, C, U>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::replace_if'
+        /// \ingroup lazy_transformation
+        template <typename L, typename C, typename U>
+        using replace_if = defer<replace_if, C, U>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////
+    // count
+    namespace detail
+    {
+        template <typename, typename>
+        struct count_
+        {
+        };
 
-        /// Return a new \c meta::list where all elements \c A of the list \p List for
-        /// which
-        /// `invoke<C,A>::%value` is \c true have been replaced with \p U.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List, typename C, typename U>
-        using replace_if = _t<detail::replace_if_<List, C, U>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::replace_if'
-            /// \ingroup lazy_transformation
-            template <typename List, typename C, typename U>
-            using replace_if = defer<replace_if, C, U>;
+#if (defined(META_CONCEPT) || META_CXX_VARIABLE_TEMPLATES) && META_CXX_FOLD_EXPRESSIONS
+        template <typename... Ts, typename T>
+        struct count_<list<Ts...>, T>
+        {
+            using type = meta::size_t<((std::size_t)META_IS_SAME(T, Ts) + ...)>;
+        };
+#else
+        constexpr std::size_t count_i_(bool const *const begin, bool const *const end,
+                                       std::size_t n)
+        {
+            return begin == end ? n : detail::count_i_(begin + 1, end, n + *begin);
         }
 
-        ///////////////////////////////////////////////////////////////////////////////////////
-        // count
-        namespace detail
+        template <typename T>
+        struct count_<list<>, T>
         {
-            constexpr std::size_t count_i_(bool const *const begin, bool const *const end,
-                                           std::size_t n)
-            {
-                return begin == end ? n : detail::count_i_(begin + 1, end, n + *begin);
-            }
-
-            template <typename List, typename T, typename = void>
-            struct count_
-            {
-            };
+            using type = meta::size_t<0>;
+        };
 
-            template <typename T>
-            struct count_<list<>, T>
-            {
-                using type = meta::size_t<0>;
-            };
+        template <typename... L, typename T>
+        struct count_<list<L...>, T>
+        {
+#ifdef META_WORKAROUND_LLVM_28385
+            static constexpr bool s_v[sizeof...(L)] = {META_IS_SAME(T, L)...};
+#else
+            static constexpr bool s_v[] = {META_IS_SAME(T, L)...};
+#endif
+            using type = meta::size_t<detail::count_i_(s_v, s_v + sizeof...(L), 0u)>;
+        };
+#endif
+    } // namespace detail
 
-            template <typename... List, typename T>
-            struct count_<list<List...>, T>
-            {
-                // Explicitly specify extent to avoid https://llvm.org/bugs/show_bug.cgi?id=28385
-                static constexpr bool s_v[sizeof...(List)] = {std::is_same<T, List>::value...};
-                using type = meta::size_t<detail::count_i_(s_v, s_v + sizeof...(List), 0u)>;
-            };
-        }
+    /// Count the number of times a type \p T appears in the list \p L.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, typename T>
+    using count = _t<detail::count_<L, T>>;
 
-        /// Count the number of times a type \p T appears in the list \p List.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename T>
-        using count = _t<detail::count_<List, T>>;
+    namespace lazy
+    {
+        /// \sa `meta::count`
+        /// \ingroup lazy_query
+        template <typename L, typename T>
+        using count = defer<count, L, T>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////
+    // count_if
+    namespace detail
+    {
+#if defined(META_CONCEPT) && META_CXX_FOLD_EXPRESSIONS
+        template <typename, typename>
+        struct count_if_
+        {
+        };
 
-        namespace lazy
+        template <typename... Ts, typename Fn>
+        requires (integral<invoke<Fn, Ts>> && ...)
+        struct count_if_<list<Ts...>, Fn>
         {
-            /// \sa `meta::count`
-            /// \ingroup lazy_query
-            template <typename List, typename T>
-            using count = defer<count, List, T>;
-        }
+            using type = meta::size_t<((std::size_t)(bool)_v<invoke<Fn, Ts>> + ...)>;
+        };
+#else
+        template <typename L, typename Fn, typename = void>
+        struct count_if_
+        {
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////
-        // count_if
-        namespace detail
+        template <typename Fn>
+        struct count_if_<list<>, Fn>
         {
-            template <typename List, typename Fn, typename = void>
-            struct count_if_
-            {
-            };
+            using type = meta::size_t<0>;
+        };
 
-            template <typename Fn>
-            struct count_if_<list<>, Fn>
-            {
-                using type = meta::size_t<0>;
-            };
+        template <typename... L, typename Fn>
+        struct count_if_<list<L...>, Fn,
+                            void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>>
+        {
+#if META_CXX_FOLD_EXPRESSIONS
+            using type = meta::size_t<((std::size_t)(bool)invoke<Fn, L>::type::value + ...)>;
+#else
+#ifdef META_WORKAROUND_LLVM_28385
+            static constexpr bool s_v[sizeof...(L)] = {invoke<Fn, L>::type::value...};
+#else
+            static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
+#endif
+            using type = meta::size_t<detail::count_i_(s_v, s_v + sizeof...(L), 0u)>;
+#endif  // META_CXX_FOLD_EXPRESSIONS
+        };
+#endif  // META_CONCEPT
+    } // namespace detail
+
+    /// Count the number of times the predicate \p Fn evaluates to true for all the elements in
+    /// the list \p L.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using count_if = _t<detail::count_if_<L, Fn>>;
+
+    namespace lazy
+    {
+        /// \sa `meta::count_if`
+        /// \ingroup lazy_query
+        template <typename L, typename Fn>
+        using count_if = defer<count_if, L, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // filter
+    /// \cond
+    namespace detail
+    {
+        template <typename Pred>
+        struct filter_
+        {
+            template <typename A>
+            using invoke = if_c<invoke<Pred, A>::type::value, list<A>, list<>>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Returns a new meta::list where only those elements of \p L that satisfy the
+    /// Callable \p Pred such that `invoke<Pred,A>::%value` is \c true are present.
+    /// That is, those elements that don't satisfy the \p Pred are "removed".
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <typename L, typename Pred>
+    using filter = join<transform<L, detail::filter_<Pred>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::filter'
+        /// \ingroup lazy_transformation
+        template <typename L, typename Fn>
+        using filter = defer<filter, L, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // static_const
+    ///\cond
+    namespace detail
+    {
+        template <typename T>
+        struct static_const
+        {
+            static constexpr T value{};
+        };
 
-            template <typename... List, typename Fn>
-            struct count_if_<list<List...>, Fn,
-                             void_<integer_sequence<bool, bool(invoke<Fn, List>::type::value)...>>>
-            {
-                // Explicitly specify extent to avoid https://llvm.org/bugs/show_bug.cgi?id=28385
-                static constexpr bool s_v[sizeof...(List)] = {invoke<Fn, List>::type::value...};
-                using type = meta::size_t<detail::count_i_(s_v, s_v + sizeof...(List), 0u)>;
-            };
-        }
+        // Avoid potential ODR violations with global objects:
+        template <typename T>
+        constexpr T static_const<T>::value;
+    } // namespace detail
 
-        /// Count the number of times the predicate \p Fn evaluates to true for all the
-        /// elements in
-        /// the list \p List.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename Fn>
-        using count_if = _t<detail::count_if_<List, Fn>>;
-
-        namespace lazy
-        {
-            /// \sa `meta::count_if`
-            /// \ingroup lazy_query
-            template <typename List, typename Fn>
-            using count_if = defer<count_if, List, Fn>;
-        }
+    ///\endcond
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // filter
-        /// \cond
-        namespace detail
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // for_each
+    /// \cond
+    namespace detail
+    {
+        struct for_each_fn
         {
-            template <typename Pred>
-            struct filter_
+            template <class Fn, class... Args>
+            constexpr auto operator()(list<Args...>, Fn f) const -> Fn
             {
-                template <typename A>
-                using invoke = if_c<invoke<Pred, A>::type::value, list<A>, list<>>;
-            };
-        } // namespace detail
+                return (void)std::initializer_list<int>{((void)f(Args{}), 0)...}, f;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+#if META_CXX_INLINE_VARIABLES
+    /// `for_each(L, Fn)` calls the \p Fn for each
+    /// argument in the \p L.
+    /// \ingroup runtime
+    inline constexpr detail::for_each_fn for_each{};
+#else
+    ///\cond
+    namespace
+    {
         /// \endcond
 
-        /// Returns a new meta::list where only those elements of \p List that satisfy
-        /// the
-        /// Callable \p Pred such that `invoke<Pred,A>::%value` is \c true are present.
-        /// That is, those elements that don't satisfy the \p Pred are "removed".
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List, typename Pred>
-        using filter = join<transform<List, detail::filter_<Pred>>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::filter'
-            /// \ingroup lazy_transformation
-            template <typename List, typename Pred>
-            using filter = defer<filter, List, Pred>;
-        }
+        /// `for_each(List, UnaryFunction)` calls the \p UnaryFunction for each
+        /// argument in the \p List.
+        /// \ingroup runtime
+        constexpr auto &&for_each = detail::static_const<detail::for_each_fn>::value;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // static_const
-        ///\cond
-        namespace detail
-        {
-            template <typename T>
-            struct static_const
-            {
-                static constexpr T value{};
-            };
+        /// \cond
+    }
+    /// \endcond
+#endif
 
-            // Avoid potential ODR violations with global objects:
-            template <typename T>
-            constexpr T static_const<T>::value;
-        } // namespace detail
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // transpose
+    /// Given a list of lists of types \p ListOfLists, transpose the elements from the lists.
+    /// \par Complexity
+    /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
+    /// \f$ M \f$ is the size of the inner lists.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
+    using transpose = fold<ListOfLists, repeat_n<size<front<ListOfLists>>, list<>>,
+                            bind_back<quote<transform>, quote<push_back>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::transpose'
+        /// \ingroup lazy_transformation
+        template <typename ListOfLists>
+        using transpose = defer<transpose, ListOfLists>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // zip_with
+    /// Given a list of lists of types \p ListOfLists and an invocable \p Fn, construct a new
+    /// list by calling \p Fn with the elements from the lists pairwise.
+    /// \par Complexity
+    /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
+    /// \f$ M \f$ is the size of the inner lists.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(invocable) Fn, META_TYPE_CONSTRAINT(list_like) ListOfLists>
+    using zip_with = transform<transpose<ListOfLists>, uncurry<Fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::zip_with'
+        /// \ingroup lazy_transformation
+        template <typename Fn, typename ListOfLists>
+        using zip_with = defer<zip_with, Fn, ListOfLists>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // zip
+    /// Given a list of lists of types \p ListOfLists, construct a new list by grouping the
+    /// elements from the lists pairwise into `meta::list`s.
+    /// \par Complexity
+    /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and \f$ M \f$
+    /// is the size of the inner lists.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
+    using zip = transpose<ListOfLists>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::zip'
+        /// \ingroup lazy_transformation
+        template <typename ListOfLists>
+        using zip = defer<zip, ListOfLists>;
+    } // namespace lazy
 
-        ///\endcond
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // as_list
+    /// \cond
+    namespace detail
+    {
+        template <typename T>
+        using uncvref_t = _t<std::remove_cv<_t<std::remove_reference<T>>>>;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // for_each
-        /// \cond
-        namespace detail
+        // Indirection here needed to avoid Core issue 1430
+        // https://wg21.link/cwg1430
+        template <typename Sequence>
+        struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
         {
-            struct for_each_fn
-            {
-                template <class UnaryFunction, class... Args>
-                constexpr auto operator()(list<Args...>, UnaryFunction f) const -> UnaryFunction
-                {
-                    return (void)std::initializer_list<int>{((void)f(Args{}), 0)...}, f;
-                }
-            };
-        } // namespace detail
-        /// \endcond
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Turn a type into an instance of \c meta::list in a way determined by
+    /// \c meta::apply.
+    /// \ingroup list
+    template <typename Sequence>
+    using as_list = _t<detail::as_list_<detail::uncvref_t<Sequence>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::as_list'
+        /// \ingroup lazy_list
+        template <typename Sequence>
+        using as_list = defer<as_list, Sequence>;
+    } // namespace lazy
 
-        ///\cond
-        namespace
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // reverse
+    /// \cond
+    namespace detail
+    {
+        template <typename L, typename State = list<>>
+        struct reverse_ : lazy::fold<L, State, quote<push_front>>
         {
-            /// \endcond
+        };
 
-            /// `for_each(List, UnaryFunction)` calls the \p UnaryFunction for each
-            /// argument in the \p List.
-            /// \ingroup runtime
-            constexpr auto &&for_each = detail::static_const<detail::for_each_fn>::value;
+        template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
+                    typename T6, typename T7, typename T8, typename T9, typename... Ts,
+                    typename... Us>
+        struct reverse_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>, list<Us...>>
+          : reverse_<list<Ts...>, list<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0, Us...>>
+        {
+        };
+    }
+    /// \endcond
 
-            /// \cond
-        }
-        /// \endcond
+    /// Return a new \c meta::list by reversing the elements in the list \p L.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using reverse = _t<detail::reverse_<L>>;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // transpose
-        /// Given a list of lists of types \p ListOfLists, transpose the elements from
-        /// the lists.
-        /// \par Complexity
-        /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
-        /// \f$ M \f$ is the size of the inner lists.
-        /// \ingroup transformation
-        template <typename ListOfLists>
-        using transpose = fold<ListOfLists, repeat_n<size<front<ListOfLists>>, list<>>,
-                               bind_back<quote<transform>, quote<push_back>>>;
+    namespace lazy
+    {
+        /// \sa 'meta::reverse'
+        /// \ingroup lazy_transformation
+        template <typename L>
+        using reverse = defer<reverse, L>;
+    } // namespace lazy
+
+    /// Logically negate the result of invocable \p Fn.
+    /// \ingroup trait
+    template <META_TYPE_CONSTRAINT(invocable) Fn>
+    using not_fn = compose<quote<not_>, Fn>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::not_fn'
+        /// \ingroup lazy_trait
+        template <typename Fn>
+        using not_fn = defer<not_fn, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // all_of
+    /// A Boolean integral constant wrapper around \c true if `invoke<Fn, A>::%value` is \c true
+    /// for all elements \c A in \c meta::list \p L; \c false, otherwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using all_of = empty<find_if<L, not_fn<Fn>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::all_of'
+        /// \ingroup lazy_query
+        template <typename L, typename Fn>
+        using all_of = defer<all_of, L, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // any_of
+    /// A Boolean integral constant wrapper around \c true if `invoke<Fn, A>::%value` is
+    /// \c true for any element \c A in \c meta::list \p L; \c false, otherwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using any_of = not_<empty<find_if<L, Fn>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::any_of'
+        /// \ingroup lazy_query
+        template <typename L, typename Fn>
+        using any_of = defer<any_of, L, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // none_of
+    /// A Boolean integral constant wrapper around \c true if `invoke<Fn, A>::%value` is
+    /// \c false for all elements \c A in \c meta::list \p L; \c false, otherwise.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using none_of = empty<find_if<L, Fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::none_of'
+        /// \ingroup lazy_query
+        template <typename L, META_TYPE_CONSTRAINT(invocable) Fn>
+        using none_of = defer<none_of, L, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // in
+    /// A Boolean integral constant wrapper around \c true if there is at least one occurrence
+    /// of \p T in \p L.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup query
+    template <META_TYPE_CONSTRAINT(list_like) L, typename T>
+    using in = not_<empty<find<L, T>>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::in'
+        /// \ingroup lazy_query
+        template <typename L, typename T>
+        using in = defer<in, L, T>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // inherit
+    /// \cond
+    namespace detail
+    {
+        template <typename L>
+        struct inherit_
+        {
+        };
 
-        namespace lazy
+        template <typename... L>
+        struct inherit_<list<L...>> : L...
         {
-            /// \sa 'meta::transpose'
-            /// \ingroup lazy_transformation
-            template <typename ListOfLists>
-            using transpose = defer<transpose, ListOfLists>;
-        }
+            using type = inherit_;
+        };
+    } // namespace detail
+    /// \endcond
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // zip_with
-        /// Given a list of lists of types \p ListOfLists and a Callable \p Fun,
-        /// construct
-        /// a new list by calling \p Fun with the elements from the lists pairwise.
-        /// \par Complexity
-        /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
-        /// \f$ M \f$ is the size of the inner lists.
-        /// \ingroup transformation
-        template <typename Fun, typename ListOfLists>
-        using zip_with = transform<transpose<ListOfLists>, uncurry<Fun>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::zip_with'
-            /// \ingroup lazy_transformation
-            template <typename Fun, typename ListOfLists>
-            using zip_with = defer<zip_with, Fun, ListOfLists>;
-        }
+    /// A type that inherits from all the types in the list
+    /// \pre The types in the list must be unique
+    /// \pre All the types in the list must be non-final class types
+    /// \ingroup datatype
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using inherit = meta::_t<detail::inherit_<L>>;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // zip
-        /// Given a list of lists of types \p ListOfLists, construct a new list by
-        /// grouping the
-        /// elements from the lists pairwise into `meta::list`s.
-        /// \par Complexity
-        /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
-        /// \f$ M \f$
-        /// is the size of the inner lists.
-        /// \ingroup transformation
-        template <typename ListOfLists>
-        using zip = transpose<ListOfLists>;
+    namespace lazy
+    {
+        /// \sa 'meta::inherit'
+        /// \ingroup lazy_datatype
+        template <typename L>
+        using inherit = defer<inherit, L>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // unique
+    /// \cond
+    namespace detail
+    {
+        template <typename Set, typename T>
+        struct in_
+        {
+        };
 
-        namespace lazy
+        template <typename... Set, typename T>
+        struct in_<list<Set...>, T> : bool_<META_IS_BASE_OF(id<T>, inherit<list<id<Set>...>>)>
         {
-            /// \sa 'meta::zip'
-            /// \ingroup lazy_transformation
-            template <typename ListOfLists>
-            using zip = defer<zip, ListOfLists>;
-        }
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // as_list
-        /// \cond
-        namespace detail
+        template <typename Set, typename T>
+        struct insert_back_
         {
-            template <typename T>
-            using uncvref_t = _t<std::remove_cv<_t<std::remove_reference<T>>>>;
+        };
 
-            // Indirection here needed to avoid Core issue 1430
-            // http://open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1430
-            template <typename Sequence>
-            struct as_list_ : lazy::invoke<uncurry<curry<quote_trait<id>>>, uncvref_t<Sequence>>
+        template <typename... Set, typename T>
+        struct insert_back_<list<Set...>, T>
+        {
+            using type = if_<in_<list<Set...>, T>, list<Set...>, list<Set..., T>>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Return a new \c meta::list where all duplicate elements have been removed.
+    /// \par Complexity
+    /// \f$ O(N^2) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L>
+    using unique = fold<L, list<>, quote_trait<detail::insert_back_>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::unique'
+        /// \ingroup lazy_transformation
+        template <typename L>
+        using unique = defer<unique, L>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // partition
+    /// \cond
+    namespace detail
+    {
+        template <typename Fn>
+        struct partition_
+        {
+#ifdef META_CONCEPT
+            template <typename, typename>
+#else
+            template <typename, typename, typename = void>
+#endif
+            struct impl
             {
             };
-        } // namespace detail
-        /// \endcond
+            template <typename... Yes, typename... No, typename A>
+#ifdef META_CONCEPT
+            requires integral<invoke<Fn, A>>
+            struct impl<pair<list<Yes...>, list<No...>>, A>
+#else
+            struct impl<pair<list<Yes...>, list<No...>>, A,
+                        void_<bool_<invoke<Fn, A>::type::value>>>
+#endif
+            {
+                using type = if_<invoke<Fn, A>, pair<list<Yes..., A>, list<No...>>,
+                                    pair<list<Yes...>, list<No..., A>>>;
+            };
 
-        /// Turn a type into an instance of \c meta::list in a way determined by
-        /// \c meta::invoke.
-        /// \ingroup list
-        template <typename Sequence>
-        using as_list = _t<detail::as_list_<Sequence>>;
+            template <typename State, typename A>
+            using invoke = _t<impl<State, A>>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Returns a pair of lists, where the elements of \p L that satisfy the
+    /// invocable \p Fn such that `invoke<Fn,A>::%value` is \c true are present in the
+    /// first list and the rest are in the second.
+    /// \par Complexity
+    /// \f$ O(N) \f$.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using partition = fold<L, pair<list<>, list<>>, detail::partition_<Fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::partition'
+        /// \ingroup lazy_transformation
+        template <typename L, typename Fn>
+        using partition = defer<partition, L, Fn>;
+    } // namespace lazy
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // sort
+    /// \cond
+    namespace detail
+    {
+        template <META_TYPE_CONSTRAINT(invocable) Fn, typename A, typename B, typename... Ts>
+        using part_ = partition<list<B, Ts...>, bind_back<Fn, A>>;
+#ifdef META_CONCEPT
+        template <list_like L, invocable Fn>
+#else
+        template <typename, typename, typename = void>
+#endif
+        struct sort_
+        {
+        };
+        template <typename Fn>
+        struct sort_<list<>, Fn>
+        {
+            using type = list<>;
+        };
 
-        namespace lazy
+        template <typename A, typename Fn>
+        struct sort_<list<A>, Fn>
         {
-            /// \sa 'meta::as_list'
-            /// \ingroup lazy_list
-            template <typename Sequence>
-            using as_list = defer<as_list, Sequence>;
-        }
+            using type = list<A>;
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // reverse
-        /// \cond
-        namespace detail
+        template <typename A, typename B, typename... Ts, typename Fn>
+#ifdef META_CONCEPT
+        requires trait<sort_<first<part_<Fn, A, B, Ts...>>, Fn>> &&
+            trait<sort_<second<part_<Fn, A, B, Ts...>>, Fn>>
+        struct sort_<list<A, B, Ts...>, Fn>
+#else
+        struct sort_<
+            list<A, B, Ts...>, Fn,
+            void_<_t<sort_<first<part_<Fn, A, B, Ts...>>, Fn>>>>
+#endif
         {
-            template <typename List, typename State = list<>>
-            struct reverse_ : lazy::fold<List, State, quote<push_front>>
-            {
-            };
+            using P = part_<Fn, A, B, Ts...>;
+            using type = concat<_t<sort_<first<P>, Fn>>, list<A>, _t<sort_<second<P>, Fn>>>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    // clang-format off
+    /// Return a new \c meta::list that is sorted according to invocable predicate \p Fn.
+    /// \par Complexity
+    /// Expected: \f$ O(N log N) \f$
+    /// Worst case: \f$ O(N^2) \f$.
+    /// \code
+    /// using L0 = list<char[5], char[3], char[2], char[6], char[1], char[5], char[10]>;
+    /// using L1 = meta::sort<L0, lambda<_a, _b, lazy::less<lazy::sizeof_<_a>, lazy::sizeof_<_b>>>>;
+    /// static_assert(std::is_same_v<L1, list<char[1], char[2], char[3], char[5], char[5], char[6], char[10]>>, "");
+    /// \endcode
+    /// \ingroup transformation
+    // clang-format on
+    template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
+    using sort = _t<detail::sort_<L, Fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::sort'
+        /// \ingroup lazy_transformation
+        template <typename L, typename Fn>
+        using sort = defer<sort, L, Fn>;
+    } // namespace lazy
+
+    ////////////////////////////////////////////////////////////////////////////
+    // lambda_
+    /// \cond
+    namespace detail
+    {
+        template <typename T, int = 0>
+        struct protect_;
 
-            template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
-                      typename T6, typename T7, typename T8, typename T9, typename... Ts,
-                      typename... Us>
-            struct reverse_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>, list<Us...>>
-                : reverse_<list<Ts...>, list<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0, Us...>>
-            {
-            };
-        }
-        /// \endcond
+        template <typename, int = 0>
+        struct vararg_;
 
-        /// Return a new \c meta::list by reversing the elements in the list \p List.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List>
-        using reverse = _t<detail::reverse_<List>>;
+        template <typename T, int = 0>
+        struct is_valid_;
+
+        // Returns which branch to evaluate
+        template <typename If, typename... Ts>
+#ifdef META_CONCEPT
+        using lazy_if_ = lazy::_t<defer<_if_, If, protect_<Ts>...>>;
+#else
+        using lazy_if_ = lazy::_t<defer<_if_, list<If, protect_<Ts>...>>>;
+#endif
 
-        namespace lazy
+        template <typename A, typename T, typename Fn, typename Ts>
+        struct subst1_
+        {
+            using type = list<list<T>>;
+        };
+        template <typename T, typename Fn, typename Ts>
+        struct subst1_<Fn, T, Fn, Ts>
+        {
+            using type = list<>;
+        };
+        template <typename A, typename T, typename Fn, typename Ts>
+        struct subst1_<vararg_<A>, T, Fn, Ts>
         {
-            /// \sa 'meta::reverse'
-            /// \ingroup lazy_transformation
-            template <typename List>
-            using reverse = defer<reverse, List>;
-        }
+            using type = list<Ts>;
+        };
 
-        /// Logically negate the result of Callable \p F.
-        /// \ingroup trait
-        template <typename F>
-        using not_fn = compose<quote<not_>, F>;
+        template <typename As, typename Ts>
+        using substitutions_ = push_back<
+            join<transform<
+                concat<As, repeat_n_c<size<Ts>{} + 2 - size<As>{}, back<As>>>,
+                concat<Ts, repeat_n_c<2, back<As>>>,
+                bind_back<quote_trait<subst1_>, back<As>, drop_c<Ts, size<As>{} - 2>>>>,
+            list<back<As>>>;
+
+#if 0//def META_CONCEPT
+        template <list_like As, list_like Ts>
+        requires (_v<size<Ts>> + 2 >= _v<size<As>>)
+        using substitutions = substitutions_<As, Ts>;
+#else // ^^^ concepts / no concepts vvv
+        template <typename As, typename Ts>
+        using substitutions =
+#ifdef META_WORKAROUND_MSVC_702792
+            invoke<if_c<(size<Ts>::value + 2 >= size<As>::value), quote<substitutions_>>, As,
+                    Ts>;
+#else // ^^^ workaround ^^^ / vvv no workaround vvv
+            invoke<if_c<(size<Ts>{} + 2 >= size<As>{}), quote<substitutions_>>, As, Ts>;
+#endif // META_WORKAROUND_MSVC_702792
+#endif // META_CONCEPT
 
-        namespace lazy
+        template <typename T>
+        struct is_vararg_ : std::false_type
         {
-            /// \sa 'meta::not_fn'
-            /// \ingroup lazy_trait
-            template <typename F>
-            using not_fn = defer<not_fn, F>;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // all_of
-        /// A Boolean integral constant wrapper around \c true if `invoke<F, A>::%value`
-        /// is \c true
-        /// for all elements \c A in \c meta::list \p List; \c false, otherwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename F>
-        using all_of = empty<find_if<List, not_fn<F>>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::all_of'
-            /// \ingroup lazy_query
-            template <typename List, typename Fn>
-            using all_of = defer<all_of, List, Fn>;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // any_of
-        /// A Boolean integral constant wrapper around \c true if `invoke<F, A>::%value`
-        /// is
-        /// \c true for any element \c A in \c meta::list \p List; \c false, otherwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename F>
-        using any_of = not_<empty<find_if<List, F>>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::any_of'
-            /// \ingroup lazy_query
-            template <typename List, typename Fn>
-            using any_of = defer<any_of, List, Fn>;
-        }
+        };
+        template <typename T>
+        struct is_vararg_<vararg_<T>> : std::true_type
+        {
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // none_of
-        /// A Boolean integral constant wrapper around \c true if `invoke<F, A>::%value`
-        /// is
-        /// \c false for all elements \c A in \c meta::list \p List; \c false,
-        /// otherwise.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename F>
-        using none_of = empty<find_if<List, F>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::none_of'
-            /// \ingroup lazy_query
-            template <typename List, typename Fn>
-            using none_of = defer<none_of, List, Fn>;
-        }
+        template <META_TYPE_CONSTRAINT(list_like) Tags>
+        using is_variadic_ = is_vararg_<at<push_front<Tags, void>, dec<size<Tags>>>>;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // in
-        /// A Boolean integral constant wrapper around \c true if there is at least one
-        /// occurrence
-        /// of \p T in \p List.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup query
-        template <typename List, typename T>
-        using in = not_<empty<find<List, T>>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::in'
-            /// \ingroup lazy_query
-            template <typename List, typename T>
-            using in = defer<in, List, T>;
-        }
+        template <META_TYPE_CONSTRAINT(list_like) Tags, bool IsVariadic = is_variadic_<Tags>::value>
+        struct lambda_;
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // inherit
-        /// \cond
-        namespace detail
+        // Non-variadic lambda implementation
+        template <typename... As>
+        struct lambda_<list<As...>, false>
         {
-            template <typename List>
-            struct inherit_
+        private:
+            static constexpr std::size_t arity = sizeof...(As) - 1;
+            using Tags = list<As...>; // Includes the lambda body as the last arg!
+            using Fn = back<Tags>;
+            template <typename T, META_TYPE_CONSTRAINT(list_like) Args>
+            struct impl;
+            template <typename T, META_TYPE_CONSTRAINT(list_like) Args>
+            using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
+#if 0//def META_CONCEPT
+            template <typename, list_like>
+#else
+            template <typename, typename, typename = void>
+#endif
+            struct subst_
             {
             };
-
-            template <typename... List>
-            struct inherit_<list<List...>> : List...
+            template <template <typename...> class C, typename... Ts, typename Args>
+#if 0//def META_CONCEPT
+            requires valid<C, _t<impl<Ts, Args>>...> struct subst_<defer<C, Ts...>, Args>
+#else
+            struct subst_<defer<C, Ts...>, Args, void_<C<_t<impl<Ts, Args>>...>>>
+#endif
             {
-                using type = inherit_;
+                using type = C<_t<impl<Ts, Args>>...>;
             };
-        }
-        /// \endcond
-
-        /// A type that inherits from all the types in the list
-        /// \pre The types in the list must be unique
-        /// \pre All the types in the list must be non-final class types
-        /// \ingroup datatype
-        template <typename List>
-        using inherit = meta::_t<detail::inherit_<List>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::inherit'
-            /// \ingroup lazy_datatype
-            template <typename List>
-            using inherit = defer<inherit, List>;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // set
-        // Used to improve the performance of \c meta::unique.
-        /// \cond
-        namespace detail
-        {
-            template <typename Set, typename T>
-            struct in_
+            template <typename T, template <T...> class C, T... Is, typename Args>
+#if 0//def META_CONCEPT
+            requires valid_i<T, C, Is...> struct subst_<defer_i<T, C, Is...>, Args>
+#else
+            struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
+#endif
             {
+                using type = C<Is...>;
             };
-
-            template <typename... Set, typename T>
-            struct in_<list<Set...>, T> : std::is_base_of<id<T>, inherit<list<id<Set>...>>>
+            template <typename T, META_TYPE_CONSTRAINT(list_like) Args>
+            struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
+                                lazy::at<Args, reverse_find_index<Tags, T>>, id<T>>
             {
             };
-
-            template <typename Set, typename T>
-            struct insert_back_
+            template <typename T, typename Args>
+            struct impl<protect_<T>, Args>
             {
+                using type = T;
             };
-
-            template <typename... Set, typename T>
-            struct insert_back_<list<Set...>, T>
+            template <typename T, typename Args>
+            struct impl<is_valid_<T>, Args>
             {
-                using type = if_<in_<list<Set...>, T>, list<Set...>, list<Set..., T>>;
+                using type = is_trait<impl<T, Args>>;
             };
-        } // namespace detail
-        /// \endcond
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // unique
-        /// Return a new \c meta::list where all duplicate elements have been removed.
-        /// \par Complexity
-        /// \f$ O(N^2) \f$.
-        /// \ingroup transformation
-        template <typename List>
-        using unique = fold<List, list<>, quote_trait<detail::insert_back_>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::unique'
-            /// \ingroup lazy_transformation
-            template <typename List>
-            using unique = defer<unique, List>;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // partition
-        /// \cond
-        namespace detail
-        {
-            template <typename Pred>
-            struct partition_
+            template <typename If, typename... Ts, typename Args>
+            struct impl<defer<if_, If, Ts...>, Args> // Short-circuit if_
+              : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
             {
-                template <typename, typename, typename = void>
-                struct impl
-                {
-                };
-                template <typename... Yes, typename... No, typename A>
-                struct impl<pair<list<Yes...>, list<No...>>, A,
-                            void_<bool_<invoke<Pred, A>::type::value>>>
-                {
-                    using type = if_<invoke<Pred, A>, pair<list<Yes..., A>, list<No...>>,
-                                     pair<list<Yes...>, list<No..., A>>>;
-                };
-                template <typename State, typename A>
-                using invoke = _t<impl<State, A>>;
             };
-        } // namespace detail
-        /// \endcond
+            template <typename B, typename... Bs, typename Args>
+            struct impl<defer<and_, B, Bs...>, Args> // Short-circuit and_
+              : impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
+                     Args>
+            {
+            };
+            template <typename B, typename... Bs, typename Args>
+            struct impl<defer<or_, B, Bs...>, Args> // Short-circuit or_
+              : impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
+                     Args>
+            {
+            };
+            template <template <typename...> class C, typename... Ts, typename Args>
+            struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
+            {
+            };
+            template <typename T, template <T...> class C, T... Is, typename Args>
+            struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
+            {
+            };
+            template <template <typename...> class C, typename... Ts, typename Args>
+            struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
+            {
+            };
+            template <typename... Ts, typename Args>
+            struct impl<lambda_<list<Ts...>, false>, Args>
+            {
+                using type = compose<uncurry<lambda_<list<As..., Ts...>, false>>,
+                                        curry<bind_front<quote<concat>, Args>>>;
+            };
+            template <typename... Bs, typename Args>
+            struct impl<lambda_<list<Bs...>, true>, Args>
+            {
+                using type = compose<typename lambda_<list<As..., Bs...>, true>::thunk,
+                                        bind_front<quote<concat>, transform<Args, quote<list>>>,
+                                        curry<bind_front<quote<substitutions>, list<Bs...>>>>;
+            };
 
-        /// Returns a pair of lists, where the elements of \p List that satisfy the
-        /// Callable \p Pred such that `invoke<Pred,A>::%value` is \c true are present
-        /// in the
-        /// first list and the rest are in the second.
-        /// \par Complexity
-        /// \f$ O(N) \f$.
-        /// \ingroup transformation
-        template <typename List, typename Pred>
-        using partition = fold<List, pair<list<>, list<>>, detail::partition_<Pred>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::partition'
-            /// \ingroup lazy_transformation
-            template <typename List, typename Pred>
-            using partition = defer<partition, List, Pred>;
-        }
+        public:
+            template <typename... Ts>
+#ifdef META_CONCEPT
+                requires (sizeof...(Ts) == arity) using invoke = _t<impl<Fn, list<Ts..., Fn>>>;
+#else
+            using invoke = _t<if_c<sizeof...(Ts) == arity, impl<Fn, list<Ts..., Fn>>>>;
+#endif
+        };
 
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // sort
-        /// \cond
-        namespace detail
+        // Lambda with variadic placeholder (broken out due to less efficient compile-time
+        // resource usage)
+        template <typename... As>
+        struct lambda_<list<As...>, true>
         {
+        private:
+            template <META_TYPE_CONSTRAINT(list_like) T, bool IsVar>
+            friend struct lambda_;
+            using Tags = list<As...>; // Includes the lambda body as the last arg!
+            template <typename T, META_TYPE_CONSTRAINT(list_like) Args>
+            struct impl;
+            template <META_TYPE_CONSTRAINT(list_like) Args>
+            using eval_impl_ = bind_back<quote_trait<impl>, Args>;
+            template <typename T, META_TYPE_CONSTRAINT(list_like) Args>
+            using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
+            template <template <typename...> class C, META_TYPE_CONSTRAINT(list_like) Args,
+                        META_TYPE_CONSTRAINT(list_like) Ts>
+            using try_subst_ = apply<quote<C>, join<transform<Ts, eval_impl_<Args>>>>;
+#if 0//def META_CONCEPT
+            template <typename, list_like>
+#else
             template <typename, typename, typename = void>
-            struct sort_
+#endif
+            struct subst_
             {
             };
-
-            template <typename Pred>
-            struct sort_<list<>, Pred>
+            template <template <typename...> class C, typename... Ts, typename Args>
+#if 0//def META_CONCEPT
+            requires is_true<try_subst_<C, Args, list<Ts...>>> struct subst_<defer<C, Ts...>, Args>
+#else
+            struct subst_<defer<C, Ts...>, Args, void_<try_subst_<C, Args, list<Ts...>>>>
+#endif
             {
-                using type = list<>;
+                using type = list<try_subst_<C, Args, list<Ts...>>>;
             };
-
-            template <typename A, typename Pred>
-            struct sort_<list<A>, Pred>
+            template <typename T, template <T...> class C, T... Is, typename Args>
+#if 0//def META_CONCEPT
+            requires valid_i<T, C, Is...> struct subst_<defer_i<T, C, Is...>, Args>
+#else
+            struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
+#endif
             {
-                using type = list<A>;
+                using type = list<C<Is...>>;
             };
-
-            template <typename A, typename B, typename... List, typename Pred>
-            struct sort_<
-                list<A, B, List...>, Pred,
-                void_<_t<sort_<first<partition<list<B, List...>, bind_back<Pred, A>>>, Pred>>>>
+            template <typename T, META_TYPE_CONSTRAINT(list_like) Args>
+            struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
+                                lazy::at<Args, reverse_find_index<Tags, T>>, id<list<T>>>
             {
-                using P = partition<list<B, List...>, bind_back<Pred, A>>;
-                using type = concat<_t<sort_<first<P>, Pred>>, list<A>, _t<sort_<second<P>, Pred>>>;
             };
-        }
-        /// \endcond
-
-        // clang-format off
-        /// Return a new \c meta::list that is sorted according to Callable predicate \p Pred.
-        /// \par Complexity
-        /// Expected: \f$ O(N log N) \f$
-        /// Worst case: \f$ O(N^2) \f$.
-        /// \code
-        /// using L0 = list<char[5], char[3], char[2], char[6], char[1], char[5], char[10]>;
-        /// using L1 = meta::sort<L0, lambda<_a, _b, lazy::less<lazy::sizeof_<_a>, lazy::sizeof_<_b>>>>;
-        /// static_assert(std::is_same<L1, list<char[1], char[2], char[3], char[5], char[5], char[6], char[10]>>::value, "");
-        /// \endcode
-        /// \ingroup transformation
-        // clang-format on
-        template <typename List, typename Pred>
-        using sort = _t<detail::sort_<List, Pred>>;
-
-        namespace lazy
-        {
-            /// \sa 'meta::sort'
-            /// \ingroup lazy_transformation
-            template <typename List, typename Pred>
-            using sort = defer<sort, List, Pred>;
-        }
-
-        ////////////////////////////////////////////////////////////////////////////
-        // lambda_
-        /// \cond
-        namespace detail
-        {
-            template <typename T, int = 0>
-            struct protect_;
-
-            template <typename, int = 0>
-            struct vararg_;
-
-            template <typename T, int = 0>
-            struct is_valid_;
-
-            // Returns which branch to evaluate
-            template <typename If, typename... Ts>
-            using lazy_if_ = lazy::_t<defer<_if_, list<If, protect_<Ts>...>>>;
-
-            template <typename A, typename T, typename F, typename Ts>
-            struct subst1_
+            template <typename T, typename Args>
+            struct impl<protect_<T>, Args>
             {
-                using type = list<list<T>>;
+                using type = list<T>;
             };
-            template <typename T, typename F, typename Ts>
-            struct subst1_<F, T, F, Ts>
+            template <typename T, typename Args>
+            struct impl<is_valid_<T>, Args>
             {
-                using type = list<>;
+                using type = list<is_trait<impl<T, Args>>>;
             };
-            template <typename A, typename T, typename F, typename Ts>
-            struct subst1_<vararg_<A>, T, F, Ts>
+            template <typename If, typename... Ts, typename Args>
+            struct impl<defer<if_, If, Ts...>, Args> // Short-circuit if_
+              : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
             {
-                using type = list<Ts>;
             };
-
-            template <typename As, typename Ts>
-            using substitutions_ = push_back<
-                join<transform<
-                    concat<As, repeat_n_c<size<Ts>{} + 2 - size<As>{}, back<As>>>,
-                    concat<Ts, repeat_n_c<2, back<As>>>,
-                    bind_back<quote_trait<subst1_>, back<As>, drop_c<Ts, size<As>{} - 2>>>>,
-                list<back<As>>>;
-
-            template <typename As, typename Ts>
-            using substitutions =
-                invoke<if_c<(size<Ts>{} + 2 >= size<As>{}), quote<substitutions_>>, As, Ts>;
-
-            template <typename T>
-            struct is_vararg_ : std::false_type
+            template <typename B, typename... Bs, typename Args>
+            struct impl<defer<and_, B, Bs...>, Args> // Short-circuit and_
+              : impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
+                     Args>
             {
             };
-            template <typename T>
-            struct is_vararg_<vararg_<T>> : std::true_type
+            template <typename B, typename... Bs, typename Args>
+            struct impl<defer<or_, B, Bs...>, Args> // Short-circuit or_
+              : impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
+                     Args>
             {
             };
-
-            template <typename Tags>
-            using is_variadic_ = is_vararg_<at<push_front<Tags, void>, dec<size<Tags>>>>;
-
-            template <typename Tags, bool IsVariadic = is_variadic_<Tags>::value>
-            struct lambda_;
-
-            // Non-variadic lambda implementation
-            template <typename... As>
-            struct lambda_<list<As...>, false>
+            template <template <typename...> class C, typename... Ts, typename Args>
+            struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
             {
-            private:
-                static constexpr std::size_t arity = sizeof...(As)-1;
-                using Tags = list<As...>; // Includes the lambda body as the last arg!
-                using F = back<Tags>;
-                template <typename T, typename Args>
-                struct impl;
-                template <typename T, typename Args>
-                using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
-                template <typename, typename, typename = void>
-                struct subst_
-                {
-                };
-                template <template <typename...> class C, typename... Ts, typename Args>
-                struct subst_<defer<C, Ts...>, Args, void_<C<_t<impl<Ts, Args>>...>>>
-                {
-                    using type = C<_t<impl<Ts, Args>>...>;
-                };
-                template <typename T, template <T...> class C, T... Is, typename Args>
-                struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
-                {
-                    using type = C<Is...>;
-                };
-                template <typename T, typename Args>
-                struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
-                                   lazy::at<Args, reverse_find_index<Tags, T>>, id<T>>
-                {
-                };
-                template <typename T, typename Args>
-                struct impl<protect_<T>, Args>
-                {
-                    using type = T;
-                };
-                template <typename T, typename Args>
-                struct impl<is_valid_<T>, Args>
-                {
-                    using type = is_trait<impl<T, Args>>;
-                };
-                template <typename If, typename... Ts, typename Args>
-                struct impl<defer<if_, If, Ts...>, Args> // Short-circuit if_
-                    : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
-                {
-                };
-                template <typename Bool_, typename... Ts, typename Args>
-                struct impl<defer<and_, Bool_, Ts...>, Args> // Short-circuit and_
-                    : impl<lazy_impl_<lazy_if_<Bool_, lazy::and_<Ts...>, protect_<std::false_type>>,
-                                      Args>,
-                           Args>
-                {
-                };
-                template <typename Bool_, typename... Ts, typename Args>
-                struct impl<defer<or_, Bool_, Ts...>, Args> // Short-circuit or_
-                    : impl<lazy_impl_<lazy_if_<Bool_, protect_<std::true_type>, lazy::or_<Ts...>>,
-                                      Args>,
-                           Args>
-                {
-                };
-                template <template <typename...> class C, typename... Ts, typename Args>
-                struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
-                {
-                };
-                template <typename T, template <T...> class C, T... Is, typename Args>
-                struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
-                {
-                };
-                template <template <typename...> class C, typename... Ts, typename Args>
-                struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
-                {
-                };
-                template <typename... Ts, typename Args>
-                struct impl<lambda_<list<Ts...>, false>, Args>
-                {
-                    using type = compose<uncurry<lambda_<list<As..., Ts...>, false>>,
-                                         curry<bind_front<quote<concat>, Args>>>;
-                };
-                template <typename... Bs, typename Args>
-                struct impl<lambda_<list<Bs...>, true>, Args>
-                {
-                    using type = compose<typename lambda_<list<As..., Bs...>, true>::thunk,
-                                         bind_front<quote<concat>, transform<Args, quote<list>>>,
-                                         curry<bind_front<quote<substitutions>, list<Bs...>>>>;
-                };
-
-            public:
-                template <typename... Ts>
-                using invoke = _t<if_c<sizeof...(Ts) == arity, impl<F, list<Ts..., F>>>>;
             };
-
-            // Lambda with variadic placeholder (broken out due to less efficient
-            // compile-time
-            // resource usage)
-            template <typename... As>
-            struct lambda_<list<As...>, true>
+            template <typename T, template <T...> class C, T... Is, typename Args>
+            struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
             {
-            private:
-                template <typename T, bool IsVar>
-                friend struct lambda_;
-                using Tags = list<As...>; // Includes the lambda body as the last arg!
-                template <typename T, typename Args>
-                struct impl;
-                template <typename Args>
-                using eval_impl_ = bind_back<quote_trait<impl>, Args>;
-                template <typename T, typename Args>
-                using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
-                template <template <typename...> class C, typename Args, typename Ts>
-                using try_subst_ = apply<quote<C>, join<transform<Ts, eval_impl_<Args>>>>;
-                template <typename, typename, typename = void>
-                struct subst_
-                {
-                };
-                template <template <typename...> class C, typename... Ts, typename Args>
-                struct subst_<defer<C, Ts...>, Args, void_<try_subst_<C, Args, list<Ts...>>>>
-                {
-                    using type = list<try_subst_<C, Args, list<Ts...>>>;
-                };
-                template <typename T, template <T...> class C, T... Is, typename Args>
-                struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
-                {
-                    using type = list<C<Is...>>;
-                };
-                template <typename T, typename Args>
-                struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
-                                   lazy::at<Args, reverse_find_index<Tags, T>>, id<list<T>>>
-                {
-                };
-                template <typename T, typename Args>
-                struct impl<protect_<T>, Args>
-                {
-                    using type = list<T>;
-                };
-                template <typename T, typename Args>
-                struct impl<is_valid_<T>, Args>
-                {
-                    using type = list<is_trait<impl<T, Args>>>;
-                };
-                template <typename If, typename... Ts, typename Args>
-                struct impl<defer<if_, If, Ts...>, Args> // Short-circuit if_
-                    : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
-                {
-                };
-                template <typename Bool_, typename... Ts, typename Args>
-                struct impl<defer<and_, Bool_, Ts...>, Args> // Short-circuit and_
-                    : impl<lazy_impl_<lazy_if_<Bool_, lazy::and_<Ts...>, protect_<std::false_type>>,
-                                      Args>,
-                           Args>
-                {
-                };
-                template <typename Bool_, typename... Ts, typename Args>
-                struct impl<defer<or_, Bool_, Ts...>, Args> // Short-circuit or_
-                    : impl<lazy_impl_<lazy_if_<Bool_, protect_<std::true_type>, lazy::or_<Ts...>>,
-                                      Args>,
-                           Args>
-                {
-                };
-                template <template <typename...> class C, typename... Ts, typename Args>
-                struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
-                {
-                };
-                template <typename T, template <T...> class C, T... Is, typename Args>
-                struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
-                {
-                };
-                template <template <typename...> class C, typename... Ts, typename Args>
-                struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
-                {
-                };
-                template <typename... Bs, bool IsVar, typename Args>
-                struct impl<lambda_<list<Bs...>, IsVar>, Args>
-                {
-                    using type =
-                        list<compose<typename lambda_<list<As..., Bs...>, true>::thunk,
-                                     bind_front<quote<concat>, Args>,
-                                     curry<bind_front<quote<substitutions>, list<Bs...>>>>>;
-                };
-                struct thunk
-                {
-                    template <typename S, typename R = _t<impl<back<Tags>, S>>>
-                    using invoke = if_c<size<R>{} == 1, front<R>>;
-                };
-
-            public:
-                template <typename... Ts>
-                using invoke = invoke<thunk, substitutions<Tags, list<Ts...>>>;
             };
-        }
-        /// \endcond
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // lambda
-        /// For creating anonymous Callables.
-        /// \code
-        /// using L = lambda<_a, _b, std::pair<_b, std::pair<_a, _a>>>;
-        /// using P = invoke<L, int, short>;
-        /// static_assert(std::is_same<P, std::pair<short, std::pair<int, int>>>::value,
-        /// "");
-        /// \endcode
-        /// \ingroup trait
-        template <typename... Ts>
-        using lambda = if_c<(sizeof...(Ts) > 0), detail::lambda_<list<Ts...>>>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // is_valid
-        /// For testing whether a deferred computation will succeed in a \c let or a \c
-        /// lambda.
-        /// \ingroup trait
-        template <typename T>
-        using is_valid = detail::is_valid_<T>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // vararg
-        /// For defining variadic placeholders.
-        template <typename T>
-        using vararg = detail::vararg_<T>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // protect
-        /// For preventing the evaluation of a nested `defer`ed computation in a \c let
-        /// or
-        /// \c lambda expression.
-        template <typename T>
-        using protect = detail::protect_<T>;
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // var
-        /// For use when defining local variables in \c meta::let expressions
-        /// \sa `meta::let`
-        template <typename Tag, typename Value>
-        struct var;
-
-        /// \cond
-        namespace detail
-        {
-            template <typename... As>
-            struct let_
+            template <template <typename...> class C, typename... Ts, typename Args>
+            struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
             {
             };
-            template <typename Fn>
-            struct let_<Fn>
+            template <typename... Bs, bool IsVar, typename Args>
+            struct impl<lambda_<list<Bs...>, IsVar>, Args>
             {
-                using type = lazy::invoke<lambda<Fn>>;
+                using type =
+                    list<compose<typename lambda_<list<As..., Bs...>, true>::thunk,
+                                    bind_front<quote<concat>, Args>,
+                                    curry<bind_front<quote<substitutions>, list<Bs...>>>>>;
             };
-            template <typename Tag, typename Value, typename... Rest>
-            struct let_<var<Tag, Value>, Rest...>
+            struct thunk
             {
-                using type = lazy::invoke<lambda<Tag, _t<let_<Rest...>>>, Value>;
+                template <typename S, typename R = _t<impl<back<Tags>, S>>>
+#ifdef META_CONCEPT
+                    requires (_v<size<R>> == 1) using invoke = front<R>;
+#else
+                using invoke = if_c<size<R>{} == 1, front<R>>;
+#endif
             };
-        }
-        /// \endcond
 
-        /// A lexically scoped expression with local variables.
-        ///
-        /// \code
-        /// template <typename T, typename List>
-        /// using find_index_ = let<
-        ///     var<_a, List>,
-        ///     var<_b, lazy::find<_a, T>>,
-        ///     lazy::if_<
-        ///         std::is_same<_b, list<>>,
-        ///         meta::npos,
-        ///         lazy::minus<lazy::size<_a>, lazy::size<_b>>>>;
-        /// static_assert(find_index_<int, list<short, int, float>>{} == 1, "");
-        /// static_assert(find_index_<double, list<short, int, float>>{} ==
-        /// meta::npos{}, "");
-        /// \endcode
-        /// \ingroup trait
-        template <typename... As>
-        using let = _t<_t<detail::let_<As...>>>;
+        public:
+            template <typename... Ts>
+            using invoke = invoke<thunk, substitutions<Tags, list<Ts...>>>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // lambda
+    /// For creating anonymous Invocables.
+    /// \code
+    /// using L = lambda<_a, _b, std::pair<_b, std::pair<_a, _a>>>;
+    /// using P = invoke<L, int, short>;
+    /// static_assert(std::is_same_v<P, std::pair<short, std::pair<int, int>>>, "");
+    /// \endcode
+    /// \ingroup trait
+    template <typename... Ts>
+#ifdef META_CONCEPT
+        requires (sizeof...(Ts) > 0) using lambda = detail::lambda_<list<Ts...>>;
+#else
+    using lambda = if_c<(sizeof...(Ts) > 0), detail::lambda_<list<Ts...>>>;
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // is_valid
+    /// For testing whether a deferred computation will succeed in a \c let or a \c lambda.
+    /// \ingroup trait
+    template <typename T>
+    using is_valid = detail::is_valid_<T>;
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // vararg
+    /// For defining variadic placeholders.
+    template <typename T>
+    using vararg = detail::vararg_<T>;
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // protect
+    /// For preventing the evaluation of a nested `defer`ed computation in a \c let or
+    /// \c lambda expression.
+    template <typename T>
+    using protect = detail::protect_<T>;
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // var
+    /// For use when defining local variables in \c meta::let expressions
+    /// \sa `meta::let`
+    template <typename Tag, typename Value>
+    struct var;
 
-        namespace lazy
+    /// \cond
+    namespace detail
+    {
+        template <typename...>
+        struct let_
         {
-            /// \sa `meta::let`
-            /// \ingroup lazy_trait
-            template <typename... As>
-            using let = defer<let, As...>;
-        }
+        };
+        template <typename Fn>
+        struct let_<Fn>
+        {
+            using type = lazy::invoke<lambda<Fn>>;
+        };
+        template <typename Tag, typename Value, typename... Rest>
+        struct let_<var<Tag, Value>, Rest...>
+        {
+            using type = lazy::invoke<lambda<Tag, _t<let_<Rest...>>>, Value>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// A lexically scoped expression with local variables.
+    ///
+    /// \code
+    /// template <typename T, typename L>
+    /// using find_index_ = let<
+    ///     var<_a, L>,
+    ///     var<_b, lazy::find<_a, T>>,
+    ///     lazy::if_<
+    ///         std::is_same<_b, list<>>,
+    ///         meta::npos,
+    ///         lazy::minus<lazy::size<_a>, lazy::size<_b>>>>;
+    /// static_assert(find_index_<int, list<short, int, float>>{} == 1, "");
+    /// static_assert(find_index_<double, list<short, int, float>>{} == meta::npos{}, "");
+    /// \endcode
+    /// \ingroup trait
+    template <typename... As>
+    using let = _t<_t<detail::let_<As...>>>;
+
+    namespace lazy
+    {
+        /// \sa `meta::let`
+        /// \ingroup lazy_trait
+        template <typename... As>
+        using let = defer<let, As...>;
+    } // namespace lazy
 
-        // Some argument placeholders for use in \c lambda expressions.
-        /// \ingroup trait
-        inline namespace placeholders
-        {
-            // regular placeholders:
-            struct _a;
-            struct _b;
-            struct _c;
-            struct _d;
-            struct _e;
-            struct _f;
-            struct _g;
-            struct _h;
-            struct _i;
-
-            // variadic placeholders:
-            using _args = vararg<void>;
-            using _args_a = vararg<_a>;
-            using _args_b = vararg<_b>;
-            using _args_c = vararg<_c>;
-        } // namespace placeholders
-
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // cartesian_product
-        /// \cond
-        namespace detail
+    // Some argument placeholders for use in \c lambda expressions.
+    /// \ingroup trait
+    inline namespace placeholders
+    {
+        // regular placeholders:
+        struct _a;
+        struct _b;
+        struct _c;
+        struct _d;
+        struct _e;
+        struct _f;
+        struct _g;
+        struct _h;
+        struct _i;
+
+        // variadic placeholders:
+        using _args = vararg<void>;
+        using _args_a = vararg<_a>;
+        using _args_b = vararg<_b>;
+        using _args_c = vararg<_c>;
+    } // namespace placeholders
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // cartesian_product
+    /// \cond
+    namespace detail
+    {
+        template <typename M2, typename M>
+        struct cartesian_product_fn
         {
-            template <typename M2, typename M>
-            struct cartesian_product_fn
+            template <typename X>
+            struct lambda0
             {
-                template <typename X>
-                struct lambda0
-                {
-                    template <typename Xs>
-                    using lambda1 = list<push_front<Xs, X>>;
-                    using type = join<transform<M2, quote<lambda1>>>;
-                };
-                using type = join<transform<M, quote_trait<lambda0>>>;
+                template <typename Xs>
+                using lambda1 = list<push_front<Xs, X>>;
+                using type = join<transform<M2, quote<lambda1>>>;
             };
-        } // namespace detail
-        /// \endcond
-
-        /// Given a list of lists \p ListOfLists, return a new list of lists that is the
-        /// Cartesian
-        /// Product. Like the `sequence` function from the Haskell Prelude.
-        /// \par Complexity
-        /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
-        /// \f$ M \f$ is the size of the inner lists.
-        /// \ingroup transformation
+            using type = join<transform<M, quote_trait<lambda0>>>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// Given a list of lists \p ListOfLists, return a new list of lists that is the Cartesian
+    /// Product. Like the `sequence` function from the Haskell Prelude.
+    /// \par Complexity
+    /// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
+    /// \f$ M \f$ is the size of the inner lists.
+    /// \ingroup transformation
+    template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
+    using cartesian_product =
+        reverse_fold<ListOfLists, list<list<>>, quote_trait<detail::cartesian_product_fn>>;
+
+    namespace lazy
+    {
+        /// \sa 'meta::cartesian_product'
+        /// \ingroup lazy_transformation
         template <typename ListOfLists>
-        using cartesian_product =
-            reverse_fold<ListOfLists, list<list<>>, quote_trait<detail::cartesian_product_fn>>;
+        using cartesian_product = defer<cartesian_product, ListOfLists>;
+    } // namespace lazy
 
-        namespace lazy
+    /// \cond
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // add_const_if
+    namespace detail
+    {
+        template <bool>
+        struct add_const_if
         {
-            /// \sa 'meta::cartesian_product'
-            /// \ingroup lazy_transformation
-            template <typename ListOfLists>
-            using cartesian_product = defer<cartesian_product, ListOfLists>;
-        }
-
-        /// \cond
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // add_const_if
-        namespace detail
+            template <typename T>
+            using invoke = T const;
+        };
+        template <>
+        struct add_const_if<false>
         {
-            template <bool>
-            struct add_const_if
-            {
-                template <typename T>
-                using invoke = T const;
-            };
-            template <>
-            struct add_const_if<false>
-            {
-                template <typename T>
-                using invoke = T;
-            };
-        } // namespace detail
-        template <bool If>
-        using add_const_if_c = detail::add_const_if<If>;
-        template <typename If>
-        using add_const_if = add_const_if_c<If::type::value>;
-        /// \endcond
+            template <typename T>
+            using invoke = T;
+        };
+    } // namespace detail
+    template <bool If>
+    using add_const_if_c = detail::add_const_if<If>;
+    template <META_TYPE_CONSTRAINT(integral) If>
+    using add_const_if = add_const_if_c<If::type::value>;
+    /// \endcond
 
-        /// \cond
-        ///////////////////////////////////////////////////////////////////////////////////////////
-        // const_if
-        template <bool If, typename T>
-        using const_if_c = invoke<add_const_if_c<If>, T>;
-        template <typename If, typename T>
-        using const_if = invoke<add_const_if<If>, T>;
-        /// \endcond
+    /// \cond
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // const_if
+    template <bool If, typename T>
+    using const_if_c = typename add_const_if_c<If>::template invoke<T>;
+    template <typename If, typename T>
+    using const_if = typename add_const_if<If>::template invoke<T>;
+    /// \endcond
 
-        /// \cond
-        namespace detail
-        {
-            template <typename State, typename Ch>
-            using atoi_ = if_c<(Ch::value >= '0' && Ch::value <= '9'),
-                               std::integral_constant<typename State::value_type,
-                                                      State::value * 10 + (Ch::value - '0')>>;
-        }
-        /// \endcond
+    /// \cond
+    namespace detail
+    {
+        template <typename State, typename Ch>
+        using atoi_ = if_c<(Ch::value >= '0' && Ch::value <= '9'),
+                            std::integral_constant<typename State::value_type,
+                                                    State::value * 10 + (Ch::value - '0')>>;
+    }
+    /// \endcond
 
-        inline namespace literals
+    inline namespace literals
+    {
+        /// A user-defined literal that generates objects of type \c meta::size_t.
+        /// \ingroup integral
+        template <char... Chs>
+        constexpr fold<list<char_<Chs>...>, meta::size_t<0>, quote<detail::atoi_>>
+            operator"" _z()
         {
-            /// A user-defined literal that generates objects of type \c meta::size_t.
-            /// \ingroup integral
-            template <char... Chs>
-            constexpr fold<list<char_<Chs>...>, meta::size_t<0>, quote<detail::atoi_>>
-                operator"" _z()
-            {
-                return {};
-            }
+            return {};
         }
-        /// \cond
-    } // namespace v1
-      /// \endcond
+    } // namespace literals
 } // namespace meta
 
 /// \cond
-#if defined(__clang__) && defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 1101
-
-_LIBCPP_BEGIN_NAMESPACE_STD
+// Non-portable forward declarations of standard containers
+#ifndef META_NO_STD_FORWARD_DECLARATIONS
+#if defined(__apple_build_version__) || (defined(__clang__) && __clang_major__ < 6)
+META_BEGIN_NAMESPACE_STD
+META_BEGIN_NAMESPACE_VERSION
 template <class>
-class _LIBCPP_TYPE_VIS_ONLY allocator;
+class META_TEMPLATE_VIS allocator;
 template <class, class>
-struct _LIBCPP_TYPE_VIS_ONLY pair;
+struct META_TEMPLATE_VIS pair;
 template <class>
-struct _LIBCPP_TYPE_VIS_ONLY hash;
+struct META_TEMPLATE_VIS hash;
 template <class>
-struct _LIBCPP_TYPE_VIS_ONLY less;
+struct META_TEMPLATE_VIS less;
 template <class>
-struct _LIBCPP_TYPE_VIS_ONLY equal_to;
+struct META_TEMPLATE_VIS equal_to;
 template <class>
-struct _LIBCPP_TYPE_VIS_ONLY char_traits;
+struct META_TEMPLATE_VIS char_traits;
+#if defined(_GLIBCXX_USE_CXX11_ABI) && _GLIBCXX_USE_CXX11_ABI
+inline namespace __cxx11 {
+#endif
+template <class, class, class>
+class META_TEMPLATE_VIS basic_string;
+#if defined(_GLIBCXX_USE_CXX11_ABI) && _GLIBCXX_USE_CXX11_ABI
+}
+#endif
+META_END_NAMESPACE_VERSION
+META_BEGIN_NAMESPACE_CONTAINER
+#if defined(__GLIBCXX__)
+inline namespace __cxx11 {
+#endif
 template <class, class>
-class _LIBCPP_TYPE_VIS_ONLY list;
+class META_TEMPLATE_VIS list;
+#if defined(__GLIBCXX__)
+}
+#endif
 template <class, class>
-class _LIBCPP_TYPE_VIS_ONLY forward_list;
+class META_TEMPLATE_VIS forward_list;
 template <class, class>
-class _LIBCPP_TYPE_VIS_ONLY vector;
+class META_TEMPLATE_VIS vector;
 template <class, class>
-class _LIBCPP_TYPE_VIS_ONLY deque;
-template <class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY basic_string;
+class META_TEMPLATE_VIS deque;
 template <class, class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY map;
+class META_TEMPLATE_VIS map;
 template <class, class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY multimap;
+class META_TEMPLATE_VIS multimap;
 template <class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY set;
+class META_TEMPLATE_VIS set;
 template <class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY multiset;
+class META_TEMPLATE_VIS multiset;
 template <class, class, class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY unordered_map;
+class META_TEMPLATE_VIS unordered_map;
 template <class, class, class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
+class META_TEMPLATE_VIS unordered_multimap;
 template <class, class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY unordered_set;
+class META_TEMPLATE_VIS unordered_set;
 template <class, class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY unordered_multiset;
+class META_TEMPLATE_VIS unordered_multiset;
 template <class, class>
-class _LIBCPP_TYPE_VIS_ONLY queue;
+class META_TEMPLATE_VIS queue;
 template <class, class, class>
-class _LIBCPP_TYPE_VIS_ONLY priority_queue;
+class META_TEMPLATE_VIS priority_queue;
 template <class, class>
-class _LIBCPP_TYPE_VIS_ONLY stack;
-_LIBCPP_END_NAMESPACE_STD
+class META_TEMPLATE_VIS stack;
+META_END_NAMESPACE_CONTAINER
+META_END_NAMESPACE_STD
 
 namespace meta
 {
-    inline namespace v1
-    {
-        namespace detail
-        {
-            template <typename T, typename A = std::allocator<T>>
-            using std_list = std::list<T, A>;
-            template <typename T, typename A = std::allocator<T>>
-            using std_forward_list = std::forward_list<T, A>;
-            template <typename T, typename A = std::allocator<T>>
-            using std_vector = std::vector<T, A>;
-            template <typename T, typename A = std::allocator<T>>
-            using std_deque = std::deque<T, A>;
-            template <typename T, typename C = std::char_traits<T>, typename A = std::allocator<T>>
-            using std_basic_string = std::basic_string<T, C, A>;
-            template <typename K, typename V, typename C = std::less<K>,
-                      typename A = std::allocator<std::pair<K const, V>>>
-            using std_map = std::map<K, V, C, A>;
-            template <typename K, typename V, typename C = std::less<K>,
-                      typename A = std::allocator<std::pair<K const, V>>>
-            using std_multimap = std::multimap<K, V, C, A>;
-            template <typename K, typename C = std::less<K>, typename A = std::allocator<K>>
-            using std_set = std::set<K, C, A>;
-            template <typename K, typename C = std::less<K>, typename A = std::allocator<K>>
-            using std_multiset = std::multiset<K, C, A>;
-            template <typename K, typename V, typename H = std::hash<K>,
-                      typename C = std::equal_to<K>,
-                      typename A = std::allocator<std::pair<K const, V>>>
-            using std_unordered_map = std::unordered_map<K, V, H, C, A>;
-            template <typename K, typename V, typename H = std::hash<K>,
-                      typename C = std::equal_to<K>,
-                      typename A = std::allocator<std::pair<K const, V>>>
-            using std_unordered_multimap = std::unordered_multimap<K, V, H, C, A>;
-            template <typename K, typename H = std::hash<K>, typename C = std::equal_to<K>,
-                      typename A = std::allocator<K>>
-            using std_unordered_set = std::unordered_set<K, H, C, A>;
-            template <typename K, typename H = std::hash<K>, typename C = std::equal_to<K>,
-                      typename A = std::allocator<K>>
-            using std_unordered_multiset = std::unordered_multiset<K, H, C, A>;
-            template <typename T, typename C = std_deque<T>>
-            using std_queue = std::queue<T, C>;
-            template <typename T, typename C = std_vector<T>,
-                      class D = std::less<typename C::value_type>>
-            using std_priority_queue = std::priority_queue<T, C, D>;
-            template <typename T, typename C = std_deque<T>>
-            using std_stack = std::stack<T, C>;
-        }
-
-        template <>
-        struct quote<::std::list> : quote<detail::std_list>
-        {
-        };
-        template <>
-        struct quote<::std::deque> : quote<detail::std_deque>
-        {
-        };
-        template <>
-        struct quote<::std::forward_list> : quote<detail::std_forward_list>
-        {
-        };
-        template <>
-        struct quote<::std::vector> : quote<detail::std_vector>
-        {
-        };
-        template <>
-        struct quote<::std::basic_string> : quote<detail::std_basic_string>
-        {
-        };
-        template <>
-        struct quote<::std::map> : quote<detail::std_map>
-        {
-        };
-        template <>
-        struct quote<::std::multimap> : quote<detail::std_multimap>
-        {
-        };
-        template <>
-        struct quote<::std::set> : quote<detail::std_set>
-        {
-        };
-        template <>
-        struct quote<::std::multiset> : quote<detail::std_multiset>
-        {
-        };
-        template <>
-        struct quote<::std::unordered_map> : quote<detail::std_unordered_map>
-        {
-        };
-        template <>
-        struct quote<::std::unordered_multimap> : quote<detail::std_unordered_multimap>
-        {
-        };
-        template <>
-        struct quote<::std::unordered_set> : quote<detail::std_unordered_set>
-        {
-        };
-        template <>
-        struct quote<::std::unordered_multiset> : quote<detail::std_unordered_multiset>
-        {
-        };
-        template <>
-        struct quote<::std::queue> : quote<detail::std_queue>
-        {
-        };
-        template <>
-        struct quote<::std::priority_queue> : quote<detail::std_priority_queue>
-        {
-        };
-        template <>
-        struct quote<::std::stack> : quote<detail::std_stack>
-        {
-        };
-    }
-}
+    namespace detail
+    {
+        template <typename T, typename A = std::allocator<T>>
+        using std_list = std::list<T, A>;
+        template <typename T, typename A = std::allocator<T>>
+        using std_forward_list = std::forward_list<T, A>;
+        template <typename T, typename A = std::allocator<T>>
+        using std_vector = std::vector<T, A>;
+        template <typename T, typename A = std::allocator<T>>
+        using std_deque = std::deque<T, A>;
+        template <typename T, typename C = std::char_traits<T>, typename A = std::allocator<T>>
+        using std_basic_string = std::basic_string<T, C, A>;
+        template <typename K, typename V, typename C = std::less<K>,
+                    typename A = std::allocator<std::pair<K const, V>>>
+        using std_map = std::map<K, V, C, A>;
+        template <typename K, typename V, typename C = std::less<K>,
+                    typename A = std::allocator<std::pair<K const, V>>>
+        using std_multimap = std::multimap<K, V, C, A>;
+        template <typename K, typename C = std::less<K>, typename A = std::allocator<K>>
+        using std_set = std::set<K, C, A>;
+        template <typename K, typename C = std::less<K>, typename A = std::allocator<K>>
+        using std_multiset = std::multiset<K, C, A>;
+        template <typename K, typename V, typename H = std::hash<K>,
+                    typename C = std::equal_to<K>,
+                    typename A = std::allocator<std::pair<K const, V>>>
+        using std_unordered_map = std::unordered_map<K, V, H, C, A>;
+        template <typename K, typename V, typename H = std::hash<K>,
+                    typename C = std::equal_to<K>,
+                    typename A = std::allocator<std::pair<K const, V>>>
+        using std_unordered_multimap = std::unordered_multimap<K, V, H, C, A>;
+        template <typename K, typename H = std::hash<K>, typename C = std::equal_to<K>,
+                    typename A = std::allocator<K>>
+        using std_unordered_set = std::unordered_set<K, H, C, A>;
+        template <typename K, typename H = std::hash<K>, typename C = std::equal_to<K>,
+                    typename A = std::allocator<K>>
+        using std_unordered_multiset = std::unordered_multiset<K, H, C, A>;
+        template <typename T, typename C = std_deque<T>>
+        using std_queue = std::queue<T, C>;
+        template <typename T, typename C = std_vector<T>,
+                    class D = std::less<typename C::value_type>>
+        using std_priority_queue = std::priority_queue<T, C, D>;
+        template <typename T, typename C = std_deque<T>>
+        using std_stack = std::stack<T, C>;
+    } // namespace detail
+
+    template <>
+    struct quote<::std::list> : quote<detail::std_list>
+    {
+    };
+    template <>
+    struct quote<::std::deque> : quote<detail::std_deque>
+    {
+    };
+    template <>
+    struct quote<::std::forward_list> : quote<detail::std_forward_list>
+    {
+    };
+    template <>
+    struct quote<::std::vector> : quote<detail::std_vector>
+    {
+    };
+    template <>
+    struct quote<::std::basic_string> : quote<detail::std_basic_string>
+    {
+    };
+    template <>
+    struct quote<::std::map> : quote<detail::std_map>
+    {
+    };
+    template <>
+    struct quote<::std::multimap> : quote<detail::std_multimap>
+    {
+    };
+    template <>
+    struct quote<::std::set> : quote<detail::std_set>
+    {
+    };
+    template <>
+    struct quote<::std::multiset> : quote<detail::std_multiset>
+    {
+    };
+    template <>
+    struct quote<::std::unordered_map> : quote<detail::std_unordered_map>
+    {
+    };
+    template <>
+    struct quote<::std::unordered_multimap> : quote<detail::std_unordered_multimap>
+    {
+    };
+    template <>
+    struct quote<::std::unordered_set> : quote<detail::std_unordered_set>
+    {
+    };
+    template <>
+    struct quote<::std::unordered_multiset> : quote<detail::std_unordered_multiset>
+    {
+    };
+    template <>
+    struct quote<::std::queue> : quote<detail::std_queue>
+    {
+    };
+    template <>
+    struct quote<::std::priority_queue> : quote<detail::std_priority_queue>
+    {
+    };
+    template <>
+    struct quote<::std::stack> : quote<detail::std_stack>
+    {
+    };
+} // namespace meta
 
+#endif
 #endif
 /// \endcond
 
-#if defined(__clang__)
+#ifdef __clang__
 #pragma GCC diagnostic pop
 #endif
 #endif
diff --git a/inst/include/meta/meta_fwd.hpp b/inst/include/meta/meta_fwd.hpp
index 71bbe63..a2f5e6f 100644
--- a/inst/include/meta/meta_fwd.hpp
+++ b/inst/include/meta/meta_fwd.hpp
@@ -15,63 +15,345 @@
 #ifndef META_FWD_HPP
 #define META_FWD_HPP
 
+#include <type_traits>
 #include <utility>
 
-#ifndef META_DISABLE_DEPRECATED_WARNINGS
-#ifdef __cpp_attribute_deprecated
-#define META_DEPRECATED(MSG) [[deprecated(MSG)]]
+#ifdef __clang__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-variable-declarations"
+#endif
+
+#define META_CXX_STD_14 201402L
+#define META_CXX_STD_17 201703L
+
+#if defined(_MSVC_LANG) && _MSVC_LANG > __cplusplus // Older clangs define _MSVC_LANG < __cplusplus
+#define META_CXX_VER _MSVC_LANG
 #else
-#if defined(__clang__) || defined(__GNUC__)
-#define META_DEPRECATED(MSG) __attribute__((deprecated(MSG)))
+#define META_CXX_VER __cplusplus
+#endif
+
+#if defined(__apple_build_version__) || defined(__clang__)
+#if defined(__apple_build_version__) || (defined(__clang__) && __clang_major__ < 6)
+#define META_WORKAROUND_LLVM_28385 // https://llvm.org/bugs/show_bug.cgi?id=28385
+#endif
+
 #elif defined(_MSC_VER)
-#define META_DEPRECATED(MSG) __declspec(deprecated(MSG))
+#define META_HAS_MAKE_INTEGER_SEQ 1
+#if _MSC_VER < 1920
+#define META_WORKAROUND_MSVC_702792 // Bogus C4018 comparing constant expressions with dependent type
+#define META_WORKAROUND_MSVC_703656 // ICE with pack expansion inside decltype in alias template
+#endif
+
+#if _MSC_VER < 1921
+#define META_WORKAROUND_MSVC_756112 // fold expression + alias templates in template argument
+#endif
+
+#elif defined(__GNUC__)
+#define META_WORKAROUND_GCC_86356 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86356
+#if __GNUC__ < 8
+#define META_WORKAROUND_GCC_UNKNOWN1 // Older GCCs don't like fold + debug + -march=native
+#endif
+#if __GNUC__ == 5 && __GNUC_MINOR__ == 1
+#define META_WORKAROUND_GCC_66405 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66405
+#endif
+#if __GNUC__ < 5
+#define META_WORKAROUND_CWG_1558 // https://wg21.link/cwg1558
+#endif
+#endif
+
+#ifndef META_CXX_VARIABLE_TEMPLATES
+#ifdef __cpp_variable_templates
+#define META_CXX_VARIABLE_TEMPLATES __cpp_variable_templates
+#else
+#define META_CXX_VARIABLE_TEMPLATES (META_CXX_VER >= META_CXX_STD_14)
+#endif
+#endif
+
+#ifndef META_CXX_INLINE_VARIABLES
+#ifdef __cpp_inline_variables
+#define META_CXX_INLINE_VARIABLES __cpp_inline_variables
+#else
+#define META_CXX_INLINE_VARIABLES (META_CXX_VER >= META_CXX_STD_17)
+#endif
+#endif
+
+#ifndef META_INLINE_VAR
+#if META_CXX_INLINE_VARIABLES
+#define META_INLINE_VAR inline
+#else
+#define META_INLINE_VAR
+#endif
+#endif
+
+#ifndef META_CXX_INTEGER_SEQUENCE
+#ifdef __cpp_lib_integer_sequence
+#define META_CXX_INTEGER_SEQUENCE __cpp_lib_integer_sequence
 #else
-#define META_DEPRECATED(MSG)
+#define META_CXX_INTEGER_SEQUENCE (META_CXX_VER >= META_CXX_STD_14)
+#endif
+#endif
+
+#ifndef META_HAS_MAKE_INTEGER_SEQ
+#ifdef __has_builtin
+#if __has_builtin(__make_integer_seq)
+#define META_HAS_MAKE_INTEGER_SEQ 1
+#endif
+#endif
+#endif
+#ifndef META_HAS_MAKE_INTEGER_SEQ
+#define META_HAS_MAKE_INTEGER_SEQ 0
+#endif
+
+#ifndef META_HAS_TYPE_PACK_ELEMENT
+#ifdef __has_builtin
+#if __has_builtin(__type_pack_element)
+#define META_HAS_TYPE_PACK_ELEMENT 1
+#endif
+#endif
 #endif
+#ifndef META_HAS_TYPE_PACK_ELEMENT
+#define META_HAS_TYPE_PACK_ELEMENT 0
 #endif
+
+#if !defined(META_DEPRECATED) && !defined(META_DISABLE_DEPRECATED_WARNINGS)
+#if defined(__cpp_attribute_deprecated) || META_CXX_VER >= META_CXX_STD_14
+#define META_DEPRECATED(...) [[deprecated(__VA_ARGS__)]]
+#elif defined(__clang__) || defined(__GNUC__)
+#define META_DEPRECATED(...) __attribute__((deprecated(__VA_ARGS__)))
+#endif
+#endif
+#ifndef META_DEPRECATED
+#define META_DEPRECATED(...)
+#endif
+
+#ifndef META_CXX_FOLD_EXPRESSIONS
+#ifdef __cpp_fold_expressions
+#define META_CXX_FOLD_EXPRESSIONS __cpp_fold_expressions
 #else
-#define META_DEPRECATED(MSG)
+#define META_CXX_FOLD_EXPRESSIONS (META_CXX_VER >= META_CXX_STD_17)
+#endif
 #endif
 
+#if META_CXX_FOLD_EXPRESSIONS
+#if !META_CXX_VARIABLE_TEMPLATES
+#error Fold expressions, but no variable templates?
+#endif
+#endif
+
+#if defined(__cpp_concepts) && __cpp_concepts > 0
+#if !META_CXX_VARIABLE_TEMPLATES
+#error Concepts, but no variable templates?
+#endif
+#if __cpp_concepts <= 201507L
+#define META_CONCEPT concept bool
+// TS concepts subsumption barrier for atomic expressions
+#define META_CONCEPT_BARRIER(...) ::meta::detail::barrier<__VA_ARGS__>
+#else
+#define META_CONCEPT concept
+#define META_CONCEPT_BARRIER(...) __VA_ARGS__
+#endif
+#define META_TYPE_CONSTRAINT(...) __VA_ARGS__
+#else
+#define META_TYPE_CONSTRAINT(...) typename
+#endif
+
+#if (defined(__cpp_lib_type_trait_variable_templates) && \
+    __cpp_lib_type_trait_variable_templates > 0)
+#define META_CXX_TRAIT_VARIABLE_TEMPLATES 1
+#else
+#define META_CXX_TRAIT_VARIABLE_TEMPLATES 0
+#endif
+
+#if defined(__clang__)
+#define META_IS_SAME(...) __is_same(__VA_ARGS__)
+#elif defined(__GNUC__) && __GNUC__ >= 6
+#define META_IS_SAME(...) __is_same_as(__VA_ARGS__)
+#elif META_CXX_TRAIT_VARIABLE_TEMPLATES
+#define META_IS_SAME(...) std::is_same_v<__VA_ARGS__>
+#else
+#define META_IS_SAME(...) std::is_same<__VA_ARGS__>::value
+#endif
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+#define META_IS_BASE_OF(...) __is_base_of(__VA_ARGS__)
+#elif META_CXX_TRAIT_VARIABLE_TEMPLATES
+#define META_IS_BASE_OF(...) std::is_base_of_v<__VA_ARGS__>
+#else
+#define META_IS_BASE_OF(...) std::is_base_of<__VA_ARGS__>::value
+#endif
+
+#if defined(__clang__) || defined(_MSC_VER) || \
+    (defined(__GNUC__) && __GNUC__ >= 8)
+#define META_IS_CONSTRUCTIBLE(...) __is_constructible(__VA_ARGS__)
+#elif META_CXX_TRAIT_VARIABLE_TEMPLATES
+#define META_IS_CONSTRUCTIBLE(...) std::is_constructible_v<__VA_ARGS__>
+#else
+#define META_IS_CONSTRUCTIBLE(...) std::is_constructible<__VA_ARGS__>::value
+#endif
+
+/// \cond
+// Non-portable forward declarations of standard containers
+#ifdef _LIBCPP_VERSION
+#define META_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
+#define META_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
+#elif defined(_MSVC_STL_VERSION)
+#define META_BEGIN_NAMESPACE_STD _STD_BEGIN
+#define META_END_NAMESPACE_STD _STD_END
+#else
+#define META_BEGIN_NAMESPACE_STD namespace std {
+#define META_END_NAMESPACE_STD }
+#endif
+
+#if defined(__GLIBCXX__)
+#define META_BEGIN_NAMESPACE_VERSION _GLIBCXX_BEGIN_NAMESPACE_VERSION
+#define META_END_NAMESPACE_VERSION _GLIBCXX_END_NAMESPACE_VERSION
+#define META_BEGIN_NAMESPACE_CONTAINER _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+#define META_END_NAMESPACE_CONTAINER _GLIBCXX_END_NAMESPACE_CONTAINER
+#else
+#define META_BEGIN_NAMESPACE_VERSION
+#define META_END_NAMESPACE_VERSION
+#define META_BEGIN_NAMESPACE_CONTAINER
+#define META_END_NAMESPACE_CONTAINER
+#endif
+
+#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION >= 4000
+#define META_TEMPLATE_VIS _LIBCPP_TEMPLATE_VIS
+#elif defined(_LIBCPP_VERSION)
+#define META_TEMPLATE_VIS _LIBCPP_TYPE_VIS_ONLY
+#else
+#define META_TEMPLATE_VIS
+#endif
+/// \endcond
+
 namespace meta
 {
-    inline namespace v1
-    {
-#ifdef __cpp_lib_integer_sequence
-        using std::integer_sequence;
+#if META_CXX_INTEGER_SEQUENCE
+    using std::integer_sequence;
 #else
-        template <typename T, T...>
-        struct integer_sequence;
+    template <typename T, T...>
+    struct integer_sequence;
 #endif
 
-        template <typename... Ts>
-        struct list;
+    template <typename... Ts>
+    struct list;
 
-        template <typename T>
-        struct id;
+    template <typename T>
+    struct id;
 
-        template <template <typename...> class>
-        struct quote;
+    template <template <typename...> class>
+    struct quote;
 
-        template <typename T, template <T...> class F>
-        struct quote_i;
+    template <typename T, template <T...> class F>
+    struct quote_i;
 
-        template <typename... Fs>
-        struct compose;
+    template <template <typename...> class C, typename... Ts>
+    struct defer;
 
-        template <template <typename...> class C, typename... Ts>
-        struct defer;
+    template <typename T, template <T...> class C, T... Is>
+    struct defer_i;
 
-        template <typename T, template <T...> class C, T... Is>
-        struct defer_i;
+#if META_CXX_VARIABLE_TEMPLATES || defined(META_DOXYGEN_INVOKED)
+    /// is_v
+    /// Test whether a type \p T is an instantiation of class
+    /// template \p C.
+    /// \ingroup trait
+    template <typename, template <typename...> class>
+    META_INLINE_VAR constexpr bool is_v = false;
+    template <typename... Ts, template <typename...> class C>
+    META_INLINE_VAR constexpr bool is_v<C<Ts...>, C> = true;
+#endif
 
-        namespace extension
-        {
-            template <typename F, typename List>
-            struct apply;
-        }
+#ifdef META_CONCEPT
+    namespace detail
+    {
+        template <bool B>
+        META_INLINE_VAR constexpr bool barrier = B;
+
+        template <class T, T> struct require_constant; // not defined
+    }
+
+    template <typename...>
+    META_CONCEPT is_true = META_CONCEPT_BARRIER(true);
+
+    template <typename T, typename U>
+    META_CONCEPT same_as =
+        META_CONCEPT_BARRIER(META_IS_SAME(T, U));
+
+    template <template <typename...> class C, typename... Ts>
+    META_CONCEPT valid = requires
+    {
+        typename C<Ts...>;
+    };
+
+    template <typename T, template <T...> class C, T... Is>
+    META_CONCEPT valid_i = requires
+    {
+        typename C<Is...>;
+    };
+
+    template <typename T>
+    META_CONCEPT trait = requires
+    {
+        typename T::type;
+    };
+
+    template <typename T>
+    META_CONCEPT invocable = requires
+    {
+        typename quote<T::template invoke>;
+    };
+
+    template <typename T>
+    META_CONCEPT list_like = is_v<T, list>;
 
-    } // inline namespace v1
+    // clang-format off
+    template <typename T>
+    META_CONCEPT integral = requires
+    {
+        typename T::type;
+        typename T::value_type;
+        typename T::type::value_type;
+    }
+    && same_as<typename T::value_type, typename T::type::value_type>
+#if META_CXX_TRAIT_VARIABLE_TEMPLATES
+    && std::is_integral_v<typename T::value_type>
+#else
+    && std::is_integral<typename T::value_type>::value
+#endif
+
+    && requires
+    {
+        // { T::value } -> same_as<const typename T::value_type&>;
+        T::value;
+        requires same_as<decltype(T::value), const typename T::value_type>;
+        typename detail::require_constant<decltype(T::value), T::value>;
+
+        // { T::type::value } -> same_as<const typename T::value_type&>;
+        T::type::value;
+        requires same_as<decltype(T::type::value), const typename T::value_type>;
+        typename detail::require_constant<decltype(T::type::value), T::type::value>;
+        requires T::value == T::type::value;
+
+        // { T{}() } -> same_as<typename T::value_type>;
+        T{}();
+        requires same_as<decltype(T{}()), typename T::value_type>;
+        typename detail::require_constant<decltype(T{}()), T{}()>;
+        requires T{}() == T::value;
+
+        { T{} } -> typename T::value_type;
+    };
+    // clang-format on
+#endif // META_CONCEPT
+
+    namespace extension
+    {
+        template <META_TYPE_CONSTRAINT(invocable) F, typename L>
+        struct apply;
+    }
 } // namespace meta
 
+#ifdef __clang__
+#pragma GCC diagnostic pop
+#endif
+
 #endif
diff --git a/inst/include/range/v3/#getlines.hpp# b/inst/include/range/v3/#getlines.hpp#
new file mode 100644
index 0000000..bb7f109
--- /dev/null
+++ b/inst/include/range/v3/#getlines.hpp#
@@ -0,0 +1,94 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_GETLINES_HPP
+#define RANGES_V3_GETLINES_HPP
+
+#include <string>
+#include <istream>
+#include <range/v3/range_fwd.hpp>
+#include <range/v3/view_facade.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+
+namespace ranges
+{
+    inline namespace v3
+    {
+        /// \addtogroup group-core
+        /// @{
+        struct getlines_range
+          : view_facade<getlines_range, unknown>
+        {
+        private:
+            friend range_access;
+            std::istream *sin_;
+            std::string str_;
+            char delim_;
+            struct cursor
+            {
+            private:
+                getlines_range *rng_;
+            public:
+                cursor() = default;
+                explicit cursor(getlines_range &rng)
+                  : rng_(&rng)
+                {}
+                void next()
+                {
+                    rng_->next();
+                }
+                std::string &read() const noexcept
+                {
+                    return rng_->str_;
+                }
+                bool equal(default_sentinel) const
+                {
+                    return !*rng_->sin_;
+                }
+            };
+            void next()
+            {
+                std::getline(*sin_, str_, delim_);
+            }
+            cursor begin_cursor()
+            {
+                return cursor{*this};
+            }
+        public:
+            getlines_range() = default;
+            getlines_range(std::istream &sin, char delim = '\n')
+              : sin_(&sin), str_{}, delim_(delim)
+            {
+                this->next(); // prime the pump
+            }
+            std::string & cached() noexcept
+            {
+                return str_;
+            }
+        };
+
+        struct getlines_fn
+        {
+            getlines_range operator()(std::istream & sin, char delim = '\n') const
+            {
+                return getlines_range{sin, delim};
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(getlines_fn, getlines)
+        /// @}
+    }
+}
+
+#endif
diff --git a/inst/include/range/v3/action.hpp b/inst/include/range/v3/action.hpp
new file mode 100644
index 0000000..6f2befd
--- /dev/null
+++ b/inst/include/range/v3/action.hpp
@@ -0,0 +1,42 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_HPP
+#define RANGES_V3_ACTION_HPP
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/adjacent_remove_if.hpp>
+#include <range/v3/action/concepts.hpp>
+#include <range/v3/action/drop.hpp>
+#include <range/v3/action/drop_while.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/action/insert.hpp>
+#include <range/v3/action/join.hpp>
+#include <range/v3/action/push_back.hpp>
+#include <range/v3/action/push_front.hpp>
+#include <range/v3/action/remove_if.hpp>
+#include <range/v3/action/reverse.hpp>
+#include <range/v3/action/shuffle.hpp>
+#include <range/v3/action/slice.hpp>
+#include <range/v3/action/sort.hpp>
+#include <range/v3/action/split.hpp>
+#include <range/v3/action/split_when.hpp>
+#include <range/v3/action/stable_sort.hpp>
+#include <range/v3/action/stride.hpp>
+#include <range/v3/action/take.hpp>
+#include <range/v3/action/take_while.hpp>
+#include <range/v3/action/transform.hpp>
+#include <range/v3/action/unique.hpp>
+#include <range/v3/action/unstable_remove_if.hpp>
+
+#endif
diff --git a/inst/include/range/v3/action/action.hpp b/inst/include/range/v3/action/action.hpp
new file mode 100644
index 0000000..9a06431
--- /dev/null
+++ b/inst/include/range/v3/action/action.hpp
@@ -0,0 +1,216 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_CONTAINER_ACTION_HPP
+#define RANGES_V3_CONTAINER_ACTION_HPP
+
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/concepts.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/pipeable.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    struct make_action_closure_fn
+    {
+        template<typename Fun>
+        constexpr actions::action_closure<Fun> operator()(Fun fun) const
+        {
+            return actions::action_closure<Fun>{static_cast<Fun &&>(fun)};
+        }
+    };
+
+    /// \sa make_view_fn
+    RANGES_INLINE_VARIABLE(make_action_closure_fn, make_action_closure)
+
+    namespace actions
+    {
+        struct RANGES_STRUCT_WITH_ADL_BARRIER(action_closure_base)
+        {
+            // Piping requires things are passed by value.
+            CPP_template(typename Rng, typename ActionFn)(                        //
+                requires(!defer::is_true<std::is_lvalue_reference<Rng>::value> && //
+                         defer::range<Rng> && defer::invocable<ActionFn, Rng &>)) //
+                friend constexpr auto
+                operator|(Rng && rng, action_closure<ActionFn> act)
+            {
+                return aux::move(static_cast<ActionFn &&>(act)(rng));
+            }
+
+#ifndef RANGES_WORKAROUND_CLANG_43400
+            template<typename Rng, typename ActionFn>   // ******************************
+            friend constexpr auto                       // ******************************
+            operator|(Rng &,                            // ********* READ THIS **********
+                      action_closure<ActionFn> const &) // ****** IF YOUR COMPILE *******
+                -> CPP_broken_friend_ret(Rng)(          // ******** BREAKS HERE *********
+                    requires range<Rng>) = delete;      // ******************************
+            // **************************************************************************
+            // *    When piping a range into an action, the range must be moved in.     *
+            // **************************************************************************
+#endif // RANGES_WORKAROUND_CLANG_43400
+
+            template<typename ActionFn, typename Pipeable>
+            friend constexpr auto operator|(action_closure<ActionFn> act, Pipeable pipe)
+                -> CPP_broken_friend_ret(action_closure<composed<Pipeable, ActionFn>>)(
+                    requires(is_pipeable_v<Pipeable>))
+            {
+                return make_action_closure(compose(static_cast<Pipeable &&>(pipe),
+                                                   static_cast<ActionFn &&>(act)));
+            }
+
+            template<typename Rng, typename ActionFn>
+            friend constexpr auto operator|=(Rng & rng, action_closure<ActionFn> act) //
+                -> CPP_broken_friend_ret(Rng &)(                                      //
+                    requires range<Rng> && invocable<ActionFn, Rng &>)
+            {
+                static_cast<ActionFn &&>(act)(rng);
+                return rng;
+            }
+        };
+
+#ifdef RANGES_WORKAROUND_CLANG_43400
+        namespace RANGES_ADL_BARRIER_FOR(action_closure_base)
+        {
+            template<typename Rng, typename ActionFn>   // ******************************
+            constexpr auto                              // ******************************
+            operator|(Rng &,                            // ********* READ THIS **********
+                      action_closure<ActionFn> const &) // ****** IF YOUR COMPILE *******
+                ->CPP_ret(Rng)(                         // ******** BREAKS HERE *********
+                    requires range<Rng>) = delete;      // ******************************
+            // **************************************************************************
+            // *    When piping a range into an action, the range must be moved in.     *
+            // **************************************************************************
+        } // namespace )
+#endif    // RANGES_WORKAROUND_CLANG_43400
+
+        template<typename ActionFn>
+        struct RANGES_EMPTY_BASES action_closure
+          : action_closure_base
+          , ActionFn
+        {
+            action_closure() = default;
+
+            constexpr explicit action_closure(ActionFn fn)
+              : ActionFn(static_cast<ActionFn &&>(fn))
+            {}
+        };
+
+        /// \cond
+        /// DEPRECATED STUFF
+        struct action_access_
+        {
+            template<typename Action>
+            struct impl
+            {
+                // clang-format off
+                template<typename... Ts, typename A = Action>
+                static constexpr auto CPP_auto_fun(bind)(Ts &&... ts)
+                (
+                    return A::bind(static_cast<Ts &&>(ts)...)
+                )
+                // clang-format on
+            };
+        };
+
+        using action_access RANGES_DEPRECATED(
+            "action_access and actions::action<> are deprecated. Please "
+            "replace action<> with action_closure<> and discontinue use of "
+            "action_access.") = action_access_;
+
+        template<typename>
+        struct old_action_;
+
+        struct make_action_fn_
+        {
+            template<typename Fun>
+            constexpr old_action_<Fun> operator()(Fun fun) const
+            {
+                return old_action_<Fun>{static_cast<Fun &&>(fun)};
+            }
+        };
+        using make_action_fn RANGES_DEPRECATED(
+            "make_action_fn is deprecated. Please use "
+            "make_action_closure instead.") = make_action_fn_;
+
+        namespace
+        {
+            RANGES_DEPRECATED(
+                "make_action and actions::action<> has been deprecated. Please switch to "
+                "make_action_closure and action::action_closure.")
+            RANGES_INLINE_VAR constexpr auto & make_action =
+                static_const<make_action_fn_>::value;
+        } // namespace
+
+        template<typename Action>
+        struct old_action_ : pipeable_base
+        {
+        private:
+            Action act_;
+            friend pipeable_access;
+
+        public:
+            old_action_() = default;
+
+            constexpr explicit old_action_(Action a) noexcept(
+                std::is_nothrow_move_constructible<Action>::value)
+              : act_(detail::move(a))
+            {}
+
+            // Calling directly requires things are passed by reference.
+            template<typename Rng, typename... Rest>
+            auto operator()(Rng & rng, Rest &&... rest) const
+                -> CPP_ret(invoke_result_t<Action const &, Rng &, Rest...>)( //
+                    requires range<Rng> && invocable<Action const &, Rng &, Rest...>)
+            {
+                return invoke(act_, rng, static_cast<Rest &&>(rest)...);
+            }
+
+            // Currying overload.
+            // clang-format off
+            CPP_template(typename... Rest, typename A = Action)(
+                requires(sizeof...(Rest) != 0))
+            auto CPP_auto_fun(operator())(Rest &&... rest)(const)
+            (
+                return make_action_fn_{}(
+                    action_access_::impl<A>::bind(act_,
+                                                  static_cast<Rest &&>(rest)...))
+            )
+            // clang-format on
+        };
+
+        template<typename Action>
+        using action RANGES_DEPRECATED(
+            "The actions::action<> template is deprecated. Please switch to "
+            "action_closure") = old_action_<Action>;
+        /// \endcond
+    } // namespace actions
+
+    template<typename ActionFn>
+    RANGES_INLINE_VAR constexpr bool is_pipeable_v<actions::action_closure<ActionFn>> =
+        true;
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/adjacent_remove_if.hpp b/inst/include/range/v3/action/adjacent_remove_if.hpp
new file mode 100644
index 0000000..fef2350
--- /dev/null
+++ b/inst/include/range/v3/action/adjacent_remove_if.hpp
@@ -0,0 +1,66 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler
+//  Copyright Christopher Di Bella
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ACTION_ADJACENT_REMOVE_IF_HPP
+#define RANGES_V3_ACTION_ADJACENT_REMOVE_IF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/algorithm/adjacent_remove_if.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct adjacent_remove_if_fn
+        {
+            template<typename Pred, typename Proj = identity>
+            constexpr auto CPP_fun(operator())(Pred pred,
+                                               Proj proj = {})(const //
+                                                               requires(!range<Pred>))
+            {
+                return make_action_closure(
+                    bind_back(adjacent_remove_if_fn{}, std::move(pred), std::move(proj)));
+            }
+
+            template<typename Rng, typename Pred, typename Proj = identity>
+            auto operator()(Rng && rng, Pred pred, Proj proj = {}) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> &&
+                        erasable_range<Rng, iterator_t<Rng>, sentinel_t<Rng>> &&
+                            indirect_relation<Pred, projected<iterator_t<Rng>, Proj>> &&
+                                permutable<iterator_t<Rng>>)
+            {
+                auto i = adjacent_remove_if(rng, std::move(pred), std::move(proj));
+                erase(rng, std::move(i), end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::adjacent_remove_if_fn
+        RANGES_INLINE_VARIABLE(adjacent_remove_if_fn, adjacent_remove_if)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ACTION_ADJACENT_REMOVE_IF_HPP
diff --git a/inst/include/range/v3/action/concepts.hpp b/inst/include/range/v3/action/concepts.hpp
new file mode 100644
index 0000000..2ef32c4
--- /dev/null
+++ b/inst/include/range/v3/action/concepts.hpp
@@ -0,0 +1,163 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_CONCEPTS_HPP
+#define RANGES_V3_ACTION_CONCEPTS_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        struct movable_input_iterator
+        {
+            using iterator_category = std::input_iterator_tag;
+            using value_type = T;
+            using difference_type = std::ptrdiff_t;
+            using pointer = T *;
+            using reference = T &&;
+
+            movable_input_iterator() = default;
+            movable_input_iterator & operator++();
+            movable_input_iterator operator++(int);
+            bool operator==(movable_input_iterator const &) const;
+            bool operator!=(movable_input_iterator const &) const;
+            T && operator*() const;
+        };
+    } // namespace detail
+      /// \endcond
+
+    /// \addtogroup group-range
+    /// @{
+
+    // std::array is a semi_container, native arrays are not.
+    // clang-format off
+    CPP_def
+    (
+        template(typename T)
+        concept semi_container,
+            forward_range<T> && default_constructible<uncvref_t<T>> &&
+            movable<uncvref_t<T>> &&
+            !view_<T>
+    );
+
+    // std::vector is a container, std::array is not
+    CPP_def
+    (
+        template(typename T)
+        concept container,
+            semi_container<T> &&
+            constructible_from<
+                uncvref_t<T>,
+                detail::movable_input_iterator<range_value_t<T>>,
+                detail::movable_input_iterator<range_value_t<T>>>
+    );
+
+    CPP_def
+    (
+        template(typename C)
+        concept reservable,
+            requires (C &c, C const &cc, range_size_t<C> s)
+            (
+                c.reserve(s),
+                cc.capacity(),
+                cc.max_size(),
+                concepts::requires_<same_as<decltype(cc.capacity()), range_size_t<C>>>,
+                concepts::requires_<same_as<decltype(cc.max_size()), range_size_t<C>>>
+            ) &&
+            container<C> && sized_range<C>
+    );
+
+    CPP_def
+    (
+        template(typename C, typename I)
+        concept reservable_with_assign,
+            requires (C &c, I i)
+            (
+                c.assign(i, i)
+            ) &&
+            reservable<C> && input_iterator<I>
+    );
+
+    CPP_def
+    (
+        template(typename C)
+        concept random_access_reservable,
+            reservable<C> && random_access_range<C>
+    );
+    // clang-format on
+
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        auto is_lvalue_container_like(T &) noexcept -> CPP_ret(std::true_type)( //
+            requires container<T>)
+        {
+            return {};
+        }
+
+        template<typename T>
+        auto is_lvalue_container_like(reference_wrapper<T>) noexcept
+            -> CPP_ret(meta::not_<std::is_rvalue_reference<T>>)( //
+                requires container<T>)
+        {
+            return {};
+        }
+
+        template<typename T>
+        auto is_lvalue_container_like(std::reference_wrapper<T>) noexcept
+            -> CPP_ret(std::true_type)( //
+                requires container<T>)
+        {
+            return {};
+        }
+
+        template<typename T>
+        auto is_lvalue_container_like(ref_view<T>) noexcept -> CPP_ret(std::true_type)( //
+            requires container<T>)
+        {
+            return {};
+        }
+
+        template<typename T>
+        using is_lvalue_container_like_t =
+            decltype(detail::is_lvalue_container_like(std::declval<T>()));
+
+    } // namespace detail
+    /// \endcond
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename T)
+        concept lvalue_container_like,
+            implicitly_convertible_to<detail::is_lvalue_container_like_t<T>,
+                                      std::true_type> &&
+            forward_range<T>
+    );
+    // clang-format on
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/drop.hpp b/inst/include/range/v3/action/drop.hpp
new file mode 100644
index 0000000..fb2cfcc
--- /dev/null
+++ b/inst/include/range/v3/action/drop.hpp
@@ -0,0 +1,62 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_DROP_HPP
+#define RANGES_V3_ACTION_DROP_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct drop_fn
+        {
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                RANGES_EXPECT(n >= Int(0));
+                return make_action_closure(bind_back(drop_fn{}, n));
+            }
+
+            template<typename Rng>
+            auto operator()(Rng && rng, range_difference_t<Rng> n) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> &&
+                        erasable_range<Rng &, iterator_t<Rng>, iterator_t<Rng>>)
+            {
+                RANGES_EXPECT(n >= 0);
+                ranges::actions::erase(
+                    rng, begin(rng), ranges::next(begin(rng), n, end(rng)));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::drop_fn
+        RANGES_INLINE_VARIABLE(drop_fn, drop)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/drop_while.hpp b/inst/include/range/v3/action/drop_while.hpp
new file mode 100644
index 0000000..005f32b
--- /dev/null
+++ b/inst/include/range/v3/action/drop_while.hpp
@@ -0,0 +1,60 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_DROP_WHILE_HPP
+#define RANGES_V3_ACTION_DROP_WHILE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct drop_while_fn
+        {
+            template<typename Fun>
+            constexpr auto CPP_fun(operator())(Fun fun)(const //
+                                                        requires(!range<Fun>))
+            {
+                return make_action_closure(bind_back(drop_while_fn{}, std::move(fun)));
+            }
+
+            template<typename Rng, typename Fun>
+            auto operator()(Rng && rng, Fun fun) const -> CPP_ret(Rng)( //
+                requires forward_range<Rng> &&
+                    indirect_unary_predicate<Fun, iterator_t<Rng>> &&
+                        erasable_range<Rng &, iterator_t<Rng>, iterator_t<Rng>>)
+            {
+                ranges::actions::erase(
+                    rng, begin(rng), find_if_not(begin(rng), end(rng), std::move(fun)));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::drop_while_fn
+        RANGES_INLINE_VARIABLE(drop_while_fn, drop_while)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/erase.hpp b/inst/include/range/v3/action/erase.hpp
new file mode 100644
index 0000000..59ba5bd
--- /dev/null
+++ b/inst/include/range/v3/action/erase.hpp
@@ -0,0 +1,76 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_ERASE_HPP
+#define RANGES_V3_ACTION_ERASE_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/insert.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace adl_erase_detail
+    {
+        template<typename Cont, typename I, typename S>
+        auto erase(Cont && cont, I first, S last)                            //
+            -> CPP_ret(decltype(unwrap_reference(cont).erase(first, last)))( //
+                requires lvalue_container_like<Cont> && forward_iterator<I> &&
+                    sentinel_for<S, I>)
+        {
+            return unwrap_reference(cont).erase(first, last);
+        }
+
+        struct erase_fn
+        {
+            template<typename Rng, typename I, typename S>
+            auto operator()(Rng && rng, I first, S last) const
+                -> CPP_ret(decltype(erase((Rng &&) rng, first, last)))( //
+                    requires range<Rng> && forward_iterator<I> && sentinel_for<S, I>)
+            {
+                return erase(static_cast<Rng &&>(rng), first, last);
+            }
+        };
+    } // namespace adl_erase_detail
+    /// \endcond
+
+    /// \ingroup group-actions
+    RANGES_INLINE_VARIABLE(adl_erase_detail::erase_fn, erase)
+
+    namespace actions
+    {
+        using ranges::erase;
+    }
+
+    /// \addtogroup group-range
+    /// @{
+    // clang-format off
+    CPP_def
+    (
+        template(typename Rng, typename I, typename S)
+        concept erasable_range,
+            requires (Rng &&rng, I first, S last)
+            (
+                ranges::erase(static_cast<Rng &&>(rng), first, last)
+            ) &&
+            range<Rng>
+    );
+    // clang-format on
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/insert.hpp b/inst/include/range/v3/action/insert.hpp
new file mode 100644
index 0000000..5ed3a07
--- /dev/null
+++ b/inst/include/range/v3/action/insert.hpp
@@ -0,0 +1,301 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_INSERT_HPP
+#define RANGES_V3_ACTION_INSERT_HPP
+
+#include <initializer_list>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/concepts.hpp>
+#include <range/v3/algorithm/max.hpp>
+#include <range/v3/iterator/common_iterator.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace adl_insert_detail
+    {
+        template<typename Cont, typename... Args>
+        using insert_result_t = decltype(
+            unwrap_reference(std::declval<Cont>()).insert(std::declval<Args>()...));
+
+        template<typename Cont, typename T>
+        auto insert(Cont && cont, T && t) -> CPP_ret(insert_result_t<Cont &, T>)( //
+            requires lvalue_container_like<Cont> &&
+            (!range<T> && constructible_from<range_value_t<Cont>, T>))
+        {
+            return unwrap_reference(cont).insert(static_cast<T &&>(t));
+        }
+
+        template<typename Cont, typename I, typename S>
+        auto insert(Cont && cont, I i, S j)
+            -> CPP_ret(insert_result_t<Cont &, detail::cpp17_iterator_t<I, S>,
+                                       detail::cpp17_iterator_t<I, S>>)( //
+                requires lvalue_container_like<Cont> && sentinel_for<S, I> && (!range<S>))
+        {
+            return unwrap_reference(cont).insert(detail::cpp17_iterator_t<I, S>{i},
+                                                 detail::cpp17_iterator_t<I, S>{j});
+        }
+
+        template<typename Cont, typename Rng>
+        auto insert(Cont && cont, Rng && rng)
+            -> CPP_ret(insert_result_t<Cont &, detail::range_cpp17_iterator_t<Rng>,
+                                       detail::range_cpp17_iterator_t<Rng>>)( //
+                requires lvalue_container_like<Cont> && range<Rng>)
+        {
+            return unwrap_reference(cont).insert(
+                detail::range_cpp17_iterator_t<Rng>{ranges::begin(rng)},
+                detail::range_cpp17_iterator_t<Rng>{ranges::end(rng)});
+        }
+
+        template<typename Cont, typename I, typename T>
+        auto insert(Cont && cont, I p, T && t)
+            -> CPP_ret(insert_result_t<Cont &, I, T>)( //
+                requires lvalue_container_like<Cont> && input_iterator<I> &&
+                (!range<T> && constructible_from<range_value_t<Cont>, T>))
+        {
+            return unwrap_reference(cont).insert(p, static_cast<T &&>(t));
+        }
+
+        template<typename Cont, typename I, typename N, typename T>
+        auto insert(Cont && cont, I p, N n, T && t)
+            -> CPP_ret(insert_result_t<Cont &, I, N, T>)( //
+                requires lvalue_container_like<Cont> && input_iterator<I> &&
+                    integral<N> && constructible_from<range_value_t<Cont>, T>)
+        {
+            return unwrap_reference(cont).insert(p, n, static_cast<T &&>(t));
+        }
+
+        /// \cond
+        namespace detail
+        {
+            using ranges::detail::cpp17_iterator_t;
+            using ranges::detail::range_cpp17_iterator_t;
+
+            template<typename Cont, typename P>
+            auto insert_reserve_helper(Cont & cont, P const p,
+                                       range_size_t<Cont> const delta)
+                -> CPP_ret(iterator_t<Cont>)( //
+                    requires container<Cont> && input_iterator<P> &&
+                        random_access_reservable<Cont>)
+            {
+                auto const old_size = ranges::size(cont);
+                auto const max_size = cont.max_size();
+                RANGES_EXPECT(delta <= max_size - old_size);
+                auto const new_size = old_size + delta;
+                auto const old_capacity = cont.capacity();
+                auto const index = p - ranges::begin(cont);
+                if(old_capacity < new_size)
+                {
+                    auto const new_capacity =
+                        (old_capacity <= max_size / 3 * 2)
+                            ? ranges::max(old_capacity + old_capacity / 2, new_size)
+                            : max_size;
+                    cont.reserve(new_capacity);
+                }
+                return ranges::begin(cont) + index;
+            }
+
+            template<typename Cont, typename P, typename I, typename S>
+            auto insert_impl(Cont && cont, P p, I i, S j, std::false_type)
+                -> CPP_ret(decltype(unwrap_reference(cont).insert(
+                    p, cpp17_iterator_t<I, S>{i}, cpp17_iterator_t<I, S>{j})))( //
+                    requires sentinel_for<S, I> && (!range<S>))
+            {
+                using C = cpp17_iterator_t<I, S>;
+                return unwrap_reference(cont).insert(p, C{i}, C{j});
+            }
+
+            template<typename Cont, typename P, typename I, typename S>
+            auto insert_impl(Cont && cont_, P p, I i, S j, std::true_type)
+                -> CPP_ret(decltype(unwrap_reference(cont_).insert(
+                    ranges::begin(unwrap_reference(cont_)), cpp17_iterator_t<I, S>{i},
+                    cpp17_iterator_t<I, S>{j})))( //
+                    requires sized_sentinel_for<S, I> && random_access_reservable<Cont> &&
+                    (!range<S>))
+            {
+                using C = cpp17_iterator_t<I, S>;
+                auto && cont = unwrap_reference(cont_);
+                auto const delta = static_cast<range_size_t<Cont>>(j - i);
+                auto pos = insert_reserve_helper(cont, std::move(p), delta);
+                return cont.insert(pos, C{std::move(i)}, C{std::move(j)});
+            }
+
+            template<typename Cont, typename I, typename Rng>
+            auto insert_impl(Cont && cont, I p, Rng && rng, std::false_type)
+                -> CPP_ret(decltype(unwrap_reference(cont).insert(
+                    p, range_cpp17_iterator_t<Rng>{ranges::begin(rng)},
+                    range_cpp17_iterator_t<Rng>{ranges::end(rng)})))( //
+                    requires range<Rng>)
+            {
+                using C = range_cpp17_iterator_t<Rng>;
+                return unwrap_reference(cont).insert(
+                    p, C{ranges::begin(rng)}, C{ranges::end(rng)});
+            }
+
+            template<typename Cont, typename I, typename Rng>
+            auto insert_impl(Cont && cont_, I p, Rng && rng, std::true_type)
+                -> CPP_ret(decltype(unwrap_reference(cont_).insert(
+                    begin(unwrap_reference(cont_)),
+                    range_cpp17_iterator_t<Rng>{ranges::begin(rng)},
+                    range_cpp17_iterator_t<Rng>{ranges::end(rng)})))( //
+                    requires random_access_reservable<Cont> && sized_range<Rng>)
+            {
+                using C = range_cpp17_iterator_t<Rng>;
+                auto && cont = unwrap_reference(cont_);
+                auto const delta = static_cast<range_size_t<Cont>>(ranges::size(rng));
+                auto pos = insert_reserve_helper(cont, std::move(p), delta);
+                return cont.insert(pos, C{ranges::begin(rng)}, C{ranges::end(rng)});
+            }
+        } // namespace detail
+        /// \endcond
+
+        template<typename Cont, typename P, typename I, typename S>
+        auto insert(Cont && cont, P p, I i, S j) -> CPP_ret(decltype(detail::insert_impl(
+            static_cast<Cont &&>(cont), std::move(p), std::move(i), std::move(j),
+            meta::bool_<random_access_reservable<Cont> &&
+                        sized_sentinel_for<S, I>>{})))( //
+            requires lvalue_container_like<Cont> && input_iterator<P> &&
+                sentinel_for<S, I> &&
+            (!range<S>))
+        {
+            return detail::insert_impl(static_cast<Cont &&>(cont),
+                                       std::move(p),
+                                       std::move(i),
+                                       std::move(j),
+                                       meta::bool_ < random_access_reservable<Cont> &&
+                                           sized_sentinel_for<S, I> > {});
+        }
+
+        template<typename Cont, typename I, typename Rng>
+        auto insert(Cont && cont, I p, Rng && rng)
+            -> CPP_ret(decltype(detail::insert_impl(
+                static_cast<Cont &&>(cont), std::move(p), static_cast<Rng &&>(rng),
+                meta::bool_<random_access_reservable<Cont> && sized_range<Rng>>{})))( //
+                requires lvalue_container_like<Cont> && input_iterator<I> && range<Rng>)
+        {
+            return detail::insert_impl(static_cast<Cont &&>(cont),
+                                       std::move(p),
+                                       static_cast<Rng &&>(rng),
+                                       meta::bool_ < random_access_reservable<Cont> &&
+                                           sized_range<Rng> > {});
+        }
+
+        struct insert_fn
+        {
+            template<typename Rng, typename... Args>
+            using insert_result_t =
+                decltype(insert(std::declval<Rng>(), std::declval<Args>()...));
+
+            template<typename Rng, typename T>
+            auto operator()(Rng && rng, T && t) const
+                -> CPP_ret(insert_result_t<Rng, T>)( //
+                    requires range<Rng> &&
+                    (!range<T>)&&constructible_from<range_value_t<Rng>, T>)
+            {
+                return insert(static_cast<Rng &&>(rng), static_cast<T &&>(t));
+            }
+
+            template<typename Rng, typename Rng2>
+            auto operator()(Rng && rng, Rng2 && rng2) const
+                -> CPP_ret(insert_result_t<Rng, Rng2>)( //
+                    requires range<Rng> && range<Rng2>)
+            {
+                static_assert(!is_infinite<Rng>::value,
+                              "Attempting to insert an infinite range into a container");
+                return insert(static_cast<Rng &&>(rng), static_cast<Rng2 &&>(rng2));
+            }
+
+            template<typename Rng, typename T>
+            auto operator()(Rng && rng, std::initializer_list<T> rng2) const
+                -> CPP_ret(insert_result_t<Rng, std::initializer_list<T> &>)( //
+                    requires range<Rng>)
+            {
+                return insert(static_cast<Rng &&>(rng), rng2);
+            }
+
+            template<typename Rng, typename I, typename S>
+            auto operator()(Rng && rng, I i, S j) const
+                -> CPP_ret(insert_result_t<Rng, I, S>)( //
+                    requires range<Rng> && sentinel_for<S, I> && (!range<S>))
+            {
+                return insert(static_cast<Rng &&>(rng), std::move(i), std::move(j));
+            }
+
+            template<typename Rng, typename I, typename T>
+            auto operator()(Rng && rng, I p, T && t) const
+                -> CPP_ret(insert_result_t<Rng, I, T>)( //
+                    requires range<Rng> && input_iterator<I> &&
+                    (!range<T>)&&constructible_from<range_value_t<Rng>, T>)
+            {
+                return insert(
+                    static_cast<Rng &&>(rng), std::move(p), static_cast<T &&>(t));
+            }
+
+            template<typename Rng, typename I, typename Rng2>
+            auto operator()(Rng && rng, I p, Rng2 && rng2) const
+                -> CPP_ret(insert_result_t<Rng, I, Rng2>)( //
+                    requires range<Rng> && input_iterator<I> && range<Rng2>)
+            {
+                static_assert(!is_infinite<Rng>::value,
+                              "Attempting to insert an infinite range into a container");
+                return insert(
+                    static_cast<Rng &&>(rng), std::move(p), static_cast<Rng2 &&>(rng2));
+            }
+
+            template<typename Rng, typename I, typename T>
+            auto operator()(Rng && rng, I p, std::initializer_list<T> rng2) const
+                -> CPP_ret(insert_result_t<Rng, I, std::initializer_list<T> &>)( //
+                    requires range<Rng> && input_iterator<I>)
+            {
+                return insert(static_cast<Rng &&>(rng), std::move(p), rng2);
+            }
+
+            template<typename Rng, typename I, typename N, typename T>
+            auto operator()(Rng && rng, I p, N n, T && t) const
+                -> CPP_ret(insert_result_t<Rng, I, N, T>)( //
+                    requires range<Rng> && input_iterator<I> && integral<N> &&
+                    (!range<T>)&&constructible_from<range_value_t<Rng>, T>)
+            {
+                return insert(
+                    static_cast<Rng &&>(rng), std::move(p), n, static_cast<T &&>(t));
+            }
+
+            template<typename Rng, typename P, typename I, typename S>
+            auto operator()(Rng && rng, P p, I i, S j) const
+                -> CPP_ret(insert_result_t<Rng, P, I, S>)( //
+                    requires range<Rng> && input_iterator<P> && sentinel_for<S, I> &&
+                    (!range<S>))
+            {
+                return insert(
+                    static_cast<Rng &&>(rng), std::move(p), std::move(i), std::move(j));
+            }
+        };
+    } // namespace adl_insert_detail
+    /// \endcond
+
+    /// \ingroup group-actions
+    RANGES_INLINE_VARIABLE(adl_insert_detail::insert_fn, insert)
+
+    namespace actions
+    {
+        using ranges::insert;
+    }
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/join.hpp b/inst/include/range/v3/action/join.hpp
new file mode 100644
index 0000000..bdc54dc
--- /dev/null
+++ b/inst/include/range/v3/action/join.hpp
@@ -0,0 +1,64 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_JOIN_HPP
+#define RANGES_V3_ACTION_JOIN_HPP
+
+#include <vector>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/concepts.hpp>
+#include <range/v3/action/push_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        template<typename Rng>
+        using join_action_value_t_ =
+            meta::if_c<(bool)ranges::container<range_value_t<Rng>>, //
+                       range_value_t<Rng>,                          //
+                       std::vector<range_value_t<range_value_t<Rng>>>>;
+
+        struct join_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(join_action_value_t_<Rng>)( //
+                requires input_range<Rng> && input_range<range_value_t<Rng>> &&
+                    semiregular<join_action_value_t_<Rng>>)
+            {
+                join_action_value_t_<Rng> ret;
+                auto last = ranges::end(rng);
+                for(auto it = begin(rng); it != last; ++it)
+                    push_back(ret, *it);
+                return ret;
+            }
+        };
+
+        /// \relates actions::join_fn
+        /// \sa action_closure
+        RANGES_INLINE_VARIABLE(action_closure<join_fn>, join)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/push_back.hpp b/inst/include/range/v3/action/push_back.hpp
new file mode 100644
index 0000000..56b8d4c
--- /dev/null
+++ b/inst/include/range/v3/action/push_back.hpp
@@ -0,0 +1,157 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_PUSH_BACK_HPP
+#define RANGES_V3_ACTION_PUSH_BACK_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/insert.hpp>
+#include <range/v3/detail/with_braced_init_args.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+
+    /// \cond
+    namespace adl_push_back_detail
+    {
+        template<typename Cont, typename T>
+        using push_back_t = decltype(static_cast<void>(
+            unwrap_reference(std::declval<Cont &>()).push_back(std::declval<T>())));
+
+        template<typename Cont, typename Rng>
+        using insert_t = decltype(static_cast<void>(
+            ranges::insert(std::declval<Cont &>(), std::declval<sentinel_t<Cont>>(),
+                           std::declval<Rng>())));
+
+        template<typename Cont, typename T>
+        auto push_back(Cont && cont, T && t) -> CPP_ret(push_back_t<Cont, T>)( //
+            requires lvalue_container_like<Cont> &&
+            (!range<T>)&&constructible_from<range_value_t<Cont>, T>)
+        {
+            unwrap_reference(cont).push_back(static_cast<T &&>(t));
+        }
+
+        template<typename Cont, typename Rng>
+        auto push_back(Cont && cont, Rng && rng) -> CPP_ret(insert_t<Cont, Rng>)( //
+            requires lvalue_container_like<Cont> && range<Rng>)
+        {
+            ranges::insert(cont, end(cont), static_cast<Rng &&>(rng));
+        }
+
+        /// \cond
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng, typename T)
+            concept can_push_back_,
+                requires (Rng &&rng, T &&t)
+                (
+                    push_back(rng, (T &&) t)
+                )
+        );
+        // clang-format on
+        /// \endcond
+
+        struct push_back_fn
+        {
+#ifdef RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+        private:
+            template<typename T, std::size_t N>
+            struct lamduh
+            {
+                T (&val_)[N];
+
+                template<typename Rng>
+                auto operator()(Rng && rng) const
+                    -> invoke_result_t<push_back_fn, Rng, T (&)[N]>
+                {
+                    return push_back_fn{}(static_cast<Rng &&>(rng), val_);
+                }
+            };
+
+        public:
+            template<typename T, std::size_t N>
+            constexpr auto operator()(T (&val)[N]) const
+            {
+                return make_action_closure(lamduh<T, N>{val});
+            }
+#else  // ^^^ workaround / no workaround vvv
+            template<typename T, std::size_t N>
+            constexpr auto operator()(T (&val)[N]) const
+            {
+                return make_action_closure(
+                    [&val](auto && rng)
+                        -> invoke_result_t<push_back_fn, decltype(rng), T(&)[N]> {
+                        return push_back_fn{}(static_cast<decltype(rng)>(rng), val);
+                    });
+            }
+#endif // RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+
+            template<typename T>
+            constexpr auto operator()(T && val) const
+            {
+                return make_action_closure(
+                    bind_back(push_back_fn{}, static_cast<T &&>(val)));
+            }
+
+            template<typename T>
+            constexpr auto operator()(std::initializer_list<T> val) const
+            {
+                return make_action_closure(bind_back(push_back_fn{}, val));
+            }
+
+            template<typename Rng, typename T>
+            auto operator()(Rng && rng, T && t) const //
+                -> CPP_ret(Rng)(                      //
+                    requires input_range<Rng> && can_push_back_<Rng, T> &&
+                    (range<T> || constructible_from<range_value_t<Rng>, T>))
+            {
+                push_back(rng, static_cast<T &&>(t));
+                return static_cast<Rng &&>(rng);
+            }
+
+            template<typename Rng, typename T>
+            auto operator()(Rng && rng, std::initializer_list<T> t) const //
+                -> CPP_ret(Rng)(                                          //
+                    requires input_range<Rng> &&                          //
+                        can_push_back_<Rng, std::initializer_list<T>> &&  //
+                            constructible_from<range_value_t<Rng>, T const &>)
+            {
+                push_back(rng, t);
+                return static_cast<Rng &&>(rng);
+            }
+        };
+    } // namespace adl_push_back_detail
+    /// \endcond
+
+    namespace actions
+    {
+        RANGES_INLINE_VARIABLE(adl_push_back_detail::push_back_fn, push_back)
+    } // namespace actions
+
+    using actions::push_back;
+
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/push_front.hpp b/inst/include/range/v3/action/push_front.hpp
new file mode 100644
index 0000000..eae9dae
--- /dev/null
+++ b/inst/include/range/v3/action/push_front.hpp
@@ -0,0 +1,155 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_PUSH_FRONT_HPP
+#define RANGES_V3_ACTION_PUSH_FRONT_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/insert.hpp>
+#include <range/v3/detail/with_braced_init_args.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+
+    /// \cond
+    namespace adl_push_front_detail
+    {
+        template<typename Cont, typename T>
+        using push_front_t = decltype(static_cast<void>(
+            unwrap_reference(std::declval<Cont &>()).push_front(std::declval<T>())));
+
+        template<typename Cont, typename Rng>
+        using insert_t = decltype(static_cast<void>(
+            ranges::insert(std::declval<Cont &>(), std::declval<iterator_t<Cont>>(),
+                           std::declval<Rng>())));
+
+        template<typename Cont, typename T>
+        auto push_front(Cont && cont, T && t) -> CPP_ret(push_front_t<Cont, T>)( //
+            requires lvalue_container_like<Cont> &&
+            (!range<T>)&&constructible_from<range_value_t<Cont>, T>)
+        {
+            unwrap_reference(cont).push_front(static_cast<T &&>(t));
+        }
+
+        template<typename Cont, typename Rng>
+        auto push_front(Cont && cont, Rng && rng) -> CPP_ret(insert_t<Cont, Rng>)( //
+            requires lvalue_container_like<Cont> && range<Rng>)
+        {
+            ranges::insert(cont, begin(cont), static_cast<Rng &&>(rng));
+        }
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng, typename T)
+            concept can_push_front_,
+                requires (Rng &&rng, T &&t)
+                (
+                    push_front(rng, (T &&) t)
+                )
+        );
+        // clang-format on
+
+        struct push_front_fn
+        {
+#ifdef RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+        private:
+            template<typename T, std::size_t N>
+            struct lamduh
+            {
+                T (&val_)[N];
+
+                template<typename Rng>
+                auto operator()(Rng && rng) const
+                    -> invoke_result_t<push_front_fn, Rng, T (&)[N]>
+                {
+                    return push_front_fn{}(static_cast<Rng &&>(rng), val_);
+                }
+            };
+
+        public:
+            template<typename T, std::size_t N>
+            constexpr auto operator()(T (&val)[N]) const
+            {
+                return make_action_closure(lamduh<T, N>{val});
+            }
+#else  // ^^^ workaround / no workaround vvv
+            template<typename T, std::size_t N>
+            constexpr auto operator()(T (&val)[N]) const
+            {
+                return make_action_closure(
+                    [&val](auto && rng)
+                        -> invoke_result_t<push_front_fn, decltype(rng), T(&)[N]> {
+                        return push_front_fn{}(static_cast<decltype(rng)>(rng), val);
+                    });
+            }
+#endif // RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+
+            template<typename T>
+            constexpr auto operator()(T && val) const
+            {
+                return make_action_closure(
+                    bind_back(push_front_fn{}, static_cast<T &&>(val)));
+            }
+
+            template<typename T>
+            constexpr auto operator()(std::initializer_list<T> val) const
+            {
+                return make_action_closure(bind_back(push_front_fn{}, val));
+            }
+
+            template<typename Rng, typename T>
+            auto operator()(Rng && rng, T && t) const //
+                -> CPP_ret(Rng)(                      //
+                    requires input_range<Rng> && can_push_front_<Rng, T> &&
+                    (range<T> || constructible_from<range_value_t<Rng>, T>))
+            {
+                push_front(rng, static_cast<T &&>(t));
+                return static_cast<Rng &&>(rng);
+            }
+
+            template<typename Rng, typename T>
+            auto operator()(Rng && rng, std::initializer_list<T> t) const //
+                -> CPP_ret(Rng)(                                          //
+                    requires input_range<Rng> &&                          //
+                        can_push_front_<Rng, std::initializer_list<T>> &&
+                            constructible_from<range_value_t<Rng>, T const &>)
+            {
+                push_front(rng, t);
+                return static_cast<Rng &&>(rng);
+            }
+        };
+    } // namespace adl_push_front_detail
+    /// \endcond
+
+    namespace actions
+    {
+        RANGES_INLINE_VARIABLE(adl_push_front_detail::push_front_fn, push_front)
+    } // namespace actions
+
+    using actions::push_front;
+
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/remove.hpp b/inst/include/range/v3/action/remove.hpp
new file mode 100644
index 0000000..387669f
--- /dev/null
+++ b/inst/include/range/v3/action/remove.hpp
@@ -0,0 +1,71 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrey Diduh 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ACTION_REMOVE_HPP
+#define RANGES_V3_ACTION_REMOVE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/algorithm/remove.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct remove_fn
+        {
+            template<typename V, typename P>
+            constexpr auto CPP_fun(operator())(V && value, P proj)(const //
+                                                                   requires(!range<V>))
+            {
+                return make_action_closure(
+                    bind_back(remove_fn{}, static_cast<V &&>(value), std::move(proj)));
+            }
+
+            template<typename V>
+            constexpr auto operator()(V && value) const
+            {
+                return make_action_closure(
+                    bind_back(remove_fn{}, static_cast<V &&>(value), identity{}));
+            }
+
+            template<typename Rng, typename V, typename P = identity>
+            auto operator()(Rng && rng, V const & value, P proj = {}) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> && permutable<iterator_t<Rng>> &&
+                        erasable_range<Rng, iterator_t<Rng>, sentinel_t<Rng>> &&
+                            indirect_relation<equal_to, projected<iterator_t<Rng>, P>,
+                                              V const *>)
+            {
+                auto it = ranges::remove(rng, value, std::move(proj));
+                ranges::erase(rng, it, ranges::end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::remove_fn
+        RANGES_INLINE_VARIABLE(remove_fn, remove)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/action/remove_if.hpp b/inst/include/range/v3/action/remove_if.hpp
new file mode 100644
index 0000000..900a4ad
--- /dev/null
+++ b/inst/include/range/v3/action/remove_if.hpp
@@ -0,0 +1,66 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_REMOVE_IF_HPP
+#define RANGES_V3_ACTION_REMOVE_IF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/algorithm/remove_if.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    // TODO Look at all the special cases handled by erase_if in Library Fundamentals 2
+
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct remove_if_fn
+        {
+            template<typename C, typename P = identity>
+            constexpr auto CPP_fun(operator())(C pred, P proj = P{})(const //
+                                                                     requires(!range<C>))
+            {
+                return make_action_closure(
+                    bind_back(remove_if_fn{}, std::move(pred), std::move(proj)));
+            }
+
+            template<typename Rng, typename C, typename P = identity>
+            auto operator()(Rng && rng, C pred, P proj = P{}) const -> CPP_ret(Rng)( //
+                requires forward_range<Rng> &&
+                    erasable_range<Rng &, iterator_t<Rng>, iterator_t<Rng>> &&
+                        permutable<iterator_t<Rng>> &&
+                            indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>)
+            {
+                auto it = ranges::remove_if(rng, std::move(pred), std::move(proj));
+                ranges::erase(rng, it, ranges::end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::remove_if_fn
+        RANGES_INLINE_VARIABLE(remove_if_fn, remove_if)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/reverse.hpp b/inst/include/range/v3/action/reverse.hpp
new file mode 100644
index 0000000..0a4b284
--- /dev/null
+++ b/inst/include/range/v3/action/reverse.hpp
@@ -0,0 +1,51 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_REVERSE_HPP
+#define RANGES_V3_ACTION_REVERSE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/algorithm/reverse.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        /// Reversed the source range in-place.
+        struct reverse_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(Rng)( //
+                requires bidirectional_range<Rng> && permutable<iterator_t<Rng>>)
+            {
+                ranges::reverse(rng);
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::reverse_fn
+        /// \sa action_closure
+        RANGES_INLINE_VARIABLE(action_closure<reverse_fn>, reverse)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/shuffle.hpp b/inst/include/range/v3/action/shuffle.hpp
new file mode 100644
index 0000000..7cf7c4e
--- /dev/null
+++ b/inst/include/range/v3/action/shuffle.hpp
@@ -0,0 +1,100 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Filip Matzner 2015
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_SHUFFLE_HPP
+#define RANGES_V3_ACTION_SHUFFLE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/algorithm/shuffle.hpp>
+#include <range/v3/functional/bind.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct shuffle_fn
+        {
+#ifdef RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+        private:
+            template<typename Gen>
+            struct lamduh
+            {
+                Gen & gen_;
+
+                template<typename Rng>
+                auto operator()(Rng && rng) const
+                    -> invoke_result_t<shuffle_fn, Rng, Gen &>
+                {
+                    return shuffle_fn{}(static_cast<Rng &&>(rng), gen_);
+                }
+            };
+
+        public:
+            template<typename Gen>
+            constexpr auto CPP_fun(operator())(Gen & gen)(
+                const //
+                requires uniform_random_bit_generator<Gen>)
+            {
+                return make_action_closure(lamduh<Gen>{gen});
+            }
+#else  // ^^^ workaround / no workaround vvv
+            template<typename Gen>
+            constexpr auto CPP_fun(operator())(Gen & gen)(
+                const //
+                requires uniform_random_bit_generator<Gen>)
+            {
+                return make_action_closure(
+                    [&gen](auto && rng)
+                        -> invoke_result_t<shuffle_fn, decltype(rng), Gen &> {
+                        return shuffle_fn{}(static_cast<decltype(rng)>(rng), gen);
+                    });
+            }
+#endif // RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+
+            template<typename Gen>
+            constexpr auto CPP_fun(operator())(Gen && gen)(
+                const //
+                requires uniform_random_bit_generator<Gen>)
+            {
+                return make_action_closure(
+                    bind_back(shuffle_fn{}, static_cast<Gen &&>(gen)));
+            }
+
+            template<typename Rng, typename Gen>
+            auto operator()(Rng && rng, Gen && gen) const -> CPP_ret(Rng)( //
+                requires random_access_range<Rng> && permutable<iterator_t<Rng>> &&
+                    uniform_random_bit_generator<std::remove_reference_t<Gen>> &&
+                        convertible_to<invoke_result_t<Gen &>, range_difference_t<Rng>>)
+            {
+                ranges::shuffle(rng, static_cast<Gen &&>(gen));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::shuffle_fn
+        /// \sa `action_closure`
+        RANGES_INLINE_VARIABLE(shuffle_fn, shuffle)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/slice.hpp b/inst/include/range/v3/action/slice.hpp
new file mode 100644
index 0000000..0262fba
--- /dev/null
+++ b/inst/include/range/v3/action/slice.hpp
@@ -0,0 +1,153 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_SLICE_HPP
+#define RANGES_V3_ACTION_SLICE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/interface.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct slice_fn
+        {
+        private:
+            template<typename D>
+            using diff_t = range_difference_t<D>;
+
+        public:
+            // Overloads for the pipe syntax: rng | actions::slice(from, to)
+            template<typename D>
+            constexpr auto CPP_fun(operator())(D from, D to)(const //
+                                                             requires integral<D>)
+            {
+                return make_action_closure(bind_back(slice_fn{}, from, to));
+            }
+            template<typename D>
+            constexpr auto CPP_fun(operator())(D from, detail::from_end_<D> to)(
+                const //
+                requires integral<D>)
+            {
+                return make_action_closure(bind_back(slice_fn{}, from, to));
+            }
+            template<typename D>
+            constexpr auto CPP_fun(operator())(detail::from_end_<D> from,
+                                               detail::from_end_<D> to)(
+                const //
+                requires integral<D>)
+            {
+                return make_action_closure(bind_back(slice_fn{}, from, to));
+            }
+            template<typename D>
+            constexpr auto CPP_fun(operator())(D from,
+                                               end_fn const & to)(const //
+                                                                  requires integral<D>)
+            {
+                return make_action_closure(bind_back(slice_fn{}, from, to));
+            }
+            template<typename D>
+            constexpr auto CPP_fun(operator())(detail::from_end_<D> from,
+                                               end_fn const & to)(const //
+                                                                  requires integral<D>)
+            {
+                return make_action_closure(bind_back(slice_fn{}, from, to));
+            }
+
+            template<typename Rng, typename I = iterator_t<Rng>>
+            auto operator()(Rng && rng, diff_t<Rng> from, diff_t<Rng> to) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> && erasable_range<Rng &, I, I>)
+            {
+                RANGES_EXPECT(0 <= from && 0 <= to && from <= to);
+                RANGES_EXPECT(!sized_range<Rng> || to <= distance(rng));
+                ranges::actions::erase(rng, begin(rng), next(begin(rng), from));
+                ranges::actions::erase(rng, next(begin(rng), to - from), end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+
+            template<typename Rng, typename I = iterator_t<Rng>>
+            auto operator()(Rng && rng, diff_t<Rng> from,
+                            detail::from_end_<diff_t<Rng>> to) const -> CPP_ret(Rng)( //
+                requires bidirectional_range<Rng> && erasable_range<Rng &, I, I>)
+            {
+                RANGES_EXPECT(0 <= from && to.dist_ <= 0);
+                RANGES_EXPECT(!sized_range<Rng> || from - to.dist_ <= distance(rng));
+                ranges::actions::erase(rng, begin(rng), next(begin(rng), from));
+                if(to.dist_ != 0)
+                {
+                    auto const last = next(begin(rng), end(rng));
+                    ranges::actions::erase(rng, prev(last, -to.dist_), last);
+                }
+                return static_cast<Rng &&>(rng);
+            }
+
+            template<typename Rng, typename I = iterator_t<Rng>>
+            auto operator()(Rng && rng, detail::from_end_<diff_t<Rng>> from,
+                            detail::from_end_<diff_t<Rng>> to) const -> CPP_ret(Rng)( //
+                requires bidirectional_range<Rng> && erasable_range<Rng &, I, I>)
+            {
+                RANGES_EXPECT(from.dist_ <= 0 && to.dist_ <= 0 && from.dist_ <= to.dist_);
+                RANGES_EXPECT(!sized_range<Rng> || 0 <= distance(rng) + from.dist_);
+                auto last = next(begin(rng), end(rng));
+                ranges::actions::erase(rng, prev(last, -to.dist_), last);
+                last = next(begin(rng), end(rng));
+                ranges::actions::erase(
+                    rng, begin(rng), prev(last, to.dist_ - from.dist_));
+                return static_cast<Rng &&>(rng);
+            }
+
+            template<typename Rng, typename I = iterator_t<Rng>>
+            auto operator()(Rng && rng, diff_t<Rng> from, end_fn const &) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> && erasable_range<Rng &, I, I>)
+            {
+                RANGES_EXPECT(0 <= from);
+                RANGES_EXPECT(!sized_range<Rng> || from <= distance(rng));
+                ranges::actions::erase(rng, begin(rng), next(begin(rng), from));
+                return static_cast<Rng &&>(rng);
+            }
+
+            template<typename Rng, typename I = iterator_t<Rng>>
+            auto operator()(Rng && rng, detail::from_end_<diff_t<Rng>> from,
+                            end_fn const &) const -> CPP_ret(Rng)( //
+                requires bidirectional_range<Rng> && erasable_range<Rng &, I, I>)
+            {
+                RANGES_EXPECT(from.dist_ <= 0);
+                RANGES_EXPECT(!sized_range<Rng> || 0 <= distance(rng) + from.dist_);
+                auto const last = next(begin(rng), end(rng));
+                ranges::actions::erase(rng, begin(rng), prev(last, -from.dist_));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::slice_fn
+        RANGES_INLINE_VARIABLE(slice_fn, slice)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/sort.hpp b/inst/include/range/v3/action/sort.hpp
new file mode 100644
index 0000000..23d2f61
--- /dev/null
+++ b/inst/include/range/v3/action/sort.hpp
@@ -0,0 +1,61 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_SORT_HPP
+#define RANGES_V3_ACTION_SORT_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/algorithm/sort.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct sort_fn
+        {
+            template<typename C, typename P = identity>
+            constexpr auto CPP_fun(operator())(C pred, P proj = {})(const //
+                                                                    requires(!range<C>))
+            {
+                return make_action_closure(
+                    bind_back(sort_fn{}, std::move(pred), std::move(proj)));
+            }
+
+            template<typename Rng, typename C = less, typename P = identity>
+            auto operator()(Rng && rng, C pred = {}, P proj = {}) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+            {
+                ranges::sort(rng, std::move(pred), std::move(proj));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::sort_fn
+        /// \sa action_closure
+        RANGES_INLINE_VARIABLE(action_closure<sort_fn>, sort)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/split.hpp b/inst/include/range/v3/action/split.hpp
new file mode 100644
index 0000000..5de8614
--- /dev/null
+++ b/inst/include/range/v3/action/split.hpp
@@ -0,0 +1,115 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_SPLIT_HPP
+#define RANGES_V3_ACTION_SPLIT_HPP
+
+#include <vector>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/concepts.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/split.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct split_fn
+        {
+            template<typename Rng>
+            using split_value_t =
+                meta::if_c<(bool)ranges::container<Rng>, //
+                           uncvref_t<Rng>, std::vector<range_value_t<Rng>>>;
+
+#ifdef RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+        private:
+            template<typename T, std::size_t N>
+            struct lamduh
+            {
+                T (&val_)[N];
+
+                template<class Rng>
+                constexpr auto operator()(Rng && rng)
+                    -> decltype(split_fn{}(std::declval<Rng>(), val_))
+                {
+                    return split_fn{}(static_cast<Rng &&>(rng), val_);
+                }
+            };
+
+        public:
+            template<typename T, std::size_t N>
+            constexpr auto operator()(T (&val)[N]) const
+            {
+                return make_action_closure(lamduh<T, N>{val});
+            }
+#else  // ^^^ workaround / no workaround vvv
+            template<typename T, std::size_t N>
+            constexpr auto operator()(T (&val)[N]) const
+            {
+                return make_action_closure(
+                    [&val](auto && rng)
+                        -> invoke_result_t<split_fn, decltype(rng), T(&)[N]> {
+                        return split_fn{}(static_cast<decltype(rng)>(rng), val);
+                    });
+            }
+#endif // RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+
+            template<typename T>
+            constexpr auto operator()(T && t) const
+            {
+                return make_action_closure(bind_back(split_fn{}, static_cast<T &&>(t)));
+            }
+
+            // BUGBUG something is not right with the actions. It should be possible
+            // to move a container into a split and have elements moved into the result.
+            template<typename Rng>
+            auto operator()(Rng && rng, range_value_t<Rng> val) const
+                -> CPP_ret(std::vector<split_value_t<Rng>>)( //
+                    requires input_range<Rng> && indirectly_comparable<
+                        iterator_t<Rng>, range_value_t<Rng> const *, ranges::equal_to>)
+            {
+                return views::split(rng, std::move(val)) |
+                       to<std::vector<split_value_t<Rng>>>();
+            }
+
+            template<typename Rng, typename Pattern>
+            auto operator()(Rng && rng, Pattern && pattern) const
+                -> CPP_ret(std::vector<split_value_t<Rng>>)( //
+                    requires input_range<Rng> && viewable_range<Pattern> &&
+                        forward_range<Pattern> && indirectly_comparable<
+                            iterator_t<Rng>, iterator_t<Pattern>, ranges::equal_to> &&
+                    (forward_range<Rng> || detail::tiny_range<Pattern>))
+            {
+                return views::split(rng, static_cast<Pattern &&>(pattern)) |
+                       to<std::vector<split_value_t<Rng>>>();
+            }
+        };
+
+        /// \relates actions::split_fn
+        RANGES_INLINE_VARIABLE(split_fn, split)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/split_when.hpp b/inst/include/range/v3/action/split_when.hpp
new file mode 100644
index 0000000..5d2ed97
--- /dev/null
+++ b/inst/include/range/v3/action/split_when.hpp
@@ -0,0 +1,88 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_SPLIT_WHEN_HPP
+#define RANGES_V3_ACTION_SPLIT_WHEN_HPP
+
+#include <vector>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/concepts.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/split_when.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct split_when_fn
+        {
+            template<typename Rng>
+            using split_value_t =
+                meta::if_c<(bool)ranges::container<Rng>, //
+                           uncvref_t<Rng>, std::vector<range_value_t<Rng>>>;
+
+            template<typename Fun>
+            constexpr auto operator()(Fun fun) const
+            {
+                return make_action_closure(
+                    bind_back(split_when_fn{}, static_cast<Fun &&>(fun)));
+            }
+
+            // BUGBUG something is not right with the actions. It should be possible
+            // to move a container into a split and have elements moved into the result.
+            template<typename Rng, typename Fun>
+            auto operator()(Rng && rng, Fun fun) const                        //
+                -> CPP_ret(std::vector<split_value_t<Rng>>)(                  //
+                    requires forward_range<Rng> &&                            //
+                        invocable<Fun &, iterator_t<Rng>, sentinel_t<Rng>> && //
+                            invocable<Fun &, iterator_t<Rng>, iterator_t<Rng>> &&
+                                copy_constructible<Fun> &&
+                                    convertible_to<invoke_result_t<Fun &, iterator_t<Rng>,
+                                                                   sentinel_t<Rng>>,
+                                                   std::pair<bool, iterator_t<Rng>>>)
+            {
+                return views::split_when(rng, std::move(fun)) |
+                       to<std::vector<split_value_t<Rng>>>();
+            }
+
+            template<typename Rng, typename Fun>
+            auto operator()(Rng && rng, Fun fun) const
+                -> CPP_ret(std::vector<split_value_t<Rng>>)(              //
+                    requires forward_range<Rng> &&                        //
+                        predicate<Fun const &, range_reference_t<Rng>> && //
+                            copy_constructible<Fun>)
+            {
+                return views::split_when(rng, std::move(fun)) |
+                       to<std::vector<split_value_t<Rng>>>();
+            }
+        };
+
+        /// \relates actions::split_when_fn
+        RANGES_INLINE_VARIABLE(split_when_fn, split_when)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/stable_sort.hpp b/inst/include/range/v3/action/stable_sort.hpp
new file mode 100644
index 0000000..9c81079
--- /dev/null
+++ b/inst/include/range/v3/action/stable_sort.hpp
@@ -0,0 +1,61 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_STABLE_SORT_HPP
+#define RANGES_V3_ACTION_STABLE_SORT_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/algorithm/stable_sort.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct stable_sort_fn
+        {
+            template<typename C, typename P = identity>
+            constexpr auto CPP_fun(operator())(C pred, P proj = P{})(const //
+                                                                     requires(!range<C>))
+            {
+                return make_action_closure(
+                    bind_back(stable_sort_fn{}, std::move(pred), std::move(proj)));
+            }
+
+            template<typename Rng, typename C = less, typename P = identity>
+            auto operator()(Rng && rng, C pred = C{}, P proj = P{}) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+            {
+                ranges::stable_sort(rng, std::move(pred), std::move(proj));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::stable_sort_fn
+        /// \sa action_closure
+        RANGES_INLINE_VARIABLE(action_closure<stable_sort_fn>, stable_sort)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/stride.hpp b/inst/include/range/v3/action/stride.hpp
new file mode 100644
index 0000000..3e9cad8
--- /dev/null
+++ b/inst/include/range/v3/action/stride.hpp
@@ -0,0 +1,76 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_STRIDE_HPP
+#define RANGES_V3_ACTION_STRIDE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct stride_fn
+        {
+            template<typename D>
+            constexpr auto CPP_fun(operator())(D step)(const //
+                                                       requires detail::integer_like_<D>)
+            {
+                return make_action_closure(bind_back(stride_fn{}, step));
+            }
+
+            template<typename Rng, typename D = range_difference_t<Rng>>
+            auto operator()(Rng && rng, range_difference_t<Rng> const step) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> &&
+                        erasable_range<Rng &, iterator_t<Rng>, sentinel_t<Rng>> &&
+                            permutable<iterator_t<Rng>>)
+            {
+                using I = iterator_t<Rng>;
+                using S = sentinel_t<Rng>;
+                RANGES_EXPECT(0 < step);
+                if(1 < step)
+                {
+                    I first = ranges::begin(rng);
+                    S const last = ranges::end(rng);
+                    if(first != last)
+                    {
+                        for(I i = ranges::next(++first, step - 1, last); i != last;
+                            advance(i, step, last), ++first)
+                        {
+                            *first = iter_move(i);
+                        }
+                    }
+                    ranges::actions::erase(rng, first, last);
+                }
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::stride_fn
+        RANGES_INLINE_VARIABLE(stride_fn, stride)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/take.hpp b/inst/include/range/v3/action/take.hpp
new file mode 100644
index 0000000..3591d31
--- /dev/null
+++ b/inst/include/range/v3/action/take.hpp
@@ -0,0 +1,61 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_TAKE_HPP
+#define RANGES_V3_ACTION_TAKE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct take_fn
+        {
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_action_closure(bind_back(take_fn{}, n));
+            }
+
+            template<typename Rng>
+            auto operator()(Rng && rng, range_difference_t<Rng> n) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> &&
+                        erasable_range<Rng &, iterator_t<Rng>, sentinel_t<Rng>>)
+            {
+                RANGES_EXPECT(n >= 0);
+                ranges::actions::erase(
+                    rng, ranges::next(begin(rng), n, end(rng)), end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::take_fn
+        RANGES_INLINE_VARIABLE(take_fn, take)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/take_while.hpp b/inst/include/range/v3/action/take_while.hpp
new file mode 100644
index 0000000..17f0ba9
--- /dev/null
+++ b/inst/include/range/v3/action/take_while.hpp
@@ -0,0 +1,60 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_TAKE_WHILE_HPP
+#define RANGES_V3_ACTION_TAKE_WHILE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct take_while_fn
+        {
+            template<typename Fun>
+            constexpr auto CPP_fun(operator())(Fun fun)(const //
+                                                        requires(!range<Fun>))
+            {
+                return make_action_closure(bind_back(take_while_fn{}, std::move(fun)));
+            }
+
+            template<typename Rng, typename Fun>
+            auto operator()(Rng && rng, Fun fun) const -> CPP_ret(Rng)( //
+                requires forward_range<Rng> &&
+                    erasable_range<Rng &, iterator_t<Rng>, sentinel_t<Rng>> &&
+                        indirect_unary_predicate<Fun, iterator_t<Rng>>)
+            {
+                ranges::actions::erase(
+                    rng, find_if_not(begin(rng), end(rng), std::move(fun)), end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::take_while_fn
+        RANGES_INLINE_VARIABLE(take_while_fn, take_while)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/transform.hpp b/inst/include/range/v3/action/transform.hpp
new file mode 100644
index 0000000..10f1cee
--- /dev/null
+++ b/inst/include/range/v3/action/transform.hpp
@@ -0,0 +1,60 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_TRANSFORM_HPP
+#define RANGES_V3_ACTION_TRANSFORM_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/algorithm/transform.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct transform_fn
+        {
+            template<typename F, typename P = identity>
+            constexpr auto CPP_fun(operator())(F fun, P proj = P{})(const //
+                                                                    requires(!range<F>))
+            {
+                return make_action_closure(
+                    bind_back(transform_fn{}, std::move(fun), std::move(proj)));
+            }
+
+            template<typename Rng, typename F, typename P = identity>
+            auto operator()(Rng && rng, F fun, P proj = P{}) const -> CPP_ret(Rng)( //
+                requires input_range<Rng> && copy_constructible<F> &&
+                    writable<iterator_t<Rng>,
+                             indirect_result_t<F &, projected<iterator_t<Rng>, P>>>)
+            {
+                ranges::transform(rng, begin(rng), std::move(fun), std::move(proj));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates actions::transform_fn
+        RANGES_INLINE_VARIABLE(transform_fn, transform)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/unique.hpp b/inst/include/range/v3/action/unique.hpp
new file mode 100644
index 0000000..56c48c1
--- /dev/null
+++ b/inst/include/range/v3/action/unique.hpp
@@ -0,0 +1,65 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ACTION_UNIQUE_HPP
+#define RANGES_V3_ACTION_UNIQUE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/algorithm/unique.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct unique_fn
+        {
+            template<typename C, typename P = identity>
+            constexpr auto CPP_fun(operator())(C pred, P proj = P{})(const //
+                                                                     requires(!range<C>))
+            {
+                return make_action_closure(
+                    bind_back(unique_fn{}, std::move(pred), std::move(proj)));
+            }
+
+            template<typename Rng, typename C = equal_to, typename P = identity>
+            auto operator()(Rng && rng, C pred = C{}, P proj = P{}) const
+                -> CPP_ret(Rng)( //
+                    requires forward_range<Rng> &&
+                        erasable_range<Rng &, iterator_t<Rng>, sentinel_t<Rng>> &&
+                            sortable<iterator_t<Rng>, C, P>)
+            {
+                auto it = ranges::unique(rng, std::move(pred), std::move(proj));
+                ranges::erase(rng, it, end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \relates detail::unique_fn
+        /// \sa action_closure
+        RANGES_INLINE_VARIABLE(action_closure<unique_fn>, unique)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/action/unstable_remove_if.hpp b/inst/include/range/v3/action/unstable_remove_if.hpp
new file mode 100644
index 0000000..b1d09d7
--- /dev/null
+++ b/inst/include/range/v3/action/unstable_remove_if.hpp
@@ -0,0 +1,69 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrey Diduh 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ACTION_UNSTABLE_REMOVE_IF_HPP
+#define RANGES_V3_ACTION_UNSTABLE_REMOVE_IF_HPP
+
+#include <utility>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/action.hpp>
+#include <range/v3/action/erase.hpp>
+#include <range/v3/algorithm/unstable_remove_if.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-actions
+    /// @{
+    namespace actions
+    {
+        struct unstable_remove_if_fn
+        {
+            template<typename C, typename P = identity>
+            constexpr auto CPP_fun(operator())(C pred, P proj = P{})(const //
+                                                                     requires(!range<C>))
+            {
+                return make_action_closure(
+                    bind_back(unstable_remove_if_fn{}, std::move(pred), std::move(proj)));
+            }
+
+            template<typename Rng, typename C, typename P = identity>
+            auto operator()(Rng && rng, C pred, P proj = P{}) const -> CPP_ret(Rng)( //
+                requires bidirectional_range<Rng> && common_range<Rng> &&
+                    permutable<iterator_t<Rng>> &&
+                        indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> &&
+                            erasable_range<Rng, iterator_t<Rng>, iterator_t<Rng>>)
+            {
+                auto it = ranges::unstable_remove_if(ranges::begin(rng),
+                                                     ranges::end(rng),
+                                                     std::move(pred),
+                                                     std::move(proj));
+                ranges::erase(rng, it, ranges::end(rng));
+                return static_cast<Rng &&>(rng);
+            }
+        };
+
+        /// \sa `actions::unstable_remove_if_fn`
+        RANGES_INLINE_VARIABLE(unstable_remove_if_fn, unstable_remove_if)
+    } // namespace actions
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ACTION_UNSTABLE_REMOVE_IF_HPP
diff --git a/inst/include/range/v3/algorithm.hpp b/inst/include/range/v3/algorithm.hpp
new file mode 100644
index 0000000..cf31b8e
--- /dev/null
+++ b/inst/include/range/v3/algorithm.hpp
@@ -0,0 +1,108 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ALGORITHM_HPP
+#define RANGES_V3_ALGORITHM_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DISABLE_WARNINGS
+
+#include <range/v3/algorithm/adjacent_find.hpp>
+#include <range/v3/algorithm/adjacent_remove_if.hpp>
+#include <range/v3/algorithm/all_of.hpp>
+#include <range/v3/algorithm/any_of.hpp>
+#include <range/v3/algorithm/binary_search.hpp>
+#include <range/v3/algorithm/copy.hpp>
+#include <range/v3/algorithm/copy_backward.hpp>
+#include <range/v3/algorithm/copy_if.hpp>
+#include <range/v3/algorithm/copy_n.hpp>
+#include <range/v3/algorithm/count.hpp>
+#include <range/v3/algorithm/count_if.hpp>
+#include <range/v3/algorithm/ends_with.hpp>
+#include <range/v3/algorithm/equal.hpp>
+#include <range/v3/algorithm/equal_range.hpp>
+#include <range/v3/algorithm/fill.hpp>
+#include <range/v3/algorithm/fill_n.hpp>
+#include <range/v3/algorithm/find.hpp>
+#include <range/v3/algorithm/find_end.hpp>
+#include <range/v3/algorithm/find_first_of.hpp>
+#include <range/v3/algorithm/find_if.hpp>
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/algorithm/for_each.hpp>
+#include <range/v3/algorithm/for_each_n.hpp>
+#include <range/v3/algorithm/generate.hpp>
+#include <range/v3/algorithm/generate_n.hpp>
+#include <range/v3/algorithm/heap_algorithm.hpp>
+#include <range/v3/algorithm/inplace_merge.hpp>
+#include <range/v3/algorithm/is_partitioned.hpp>
+#include <range/v3/algorithm/is_sorted.hpp>
+#include <range/v3/algorithm/is_sorted_until.hpp>
+#include <range/v3/algorithm/lexicographical_compare.hpp>
+#include <range/v3/algorithm/lower_bound.hpp>
+#include <range/v3/algorithm/max.hpp>
+#include <range/v3/algorithm/max_element.hpp>
+#include <range/v3/algorithm/merge.hpp>
+#include <range/v3/algorithm/min.hpp>
+#include <range/v3/algorithm/min_element.hpp>
+#include <range/v3/algorithm/minmax.hpp>
+#include <range/v3/algorithm/minmax_element.hpp>
+#include <range/v3/algorithm/mismatch.hpp>
+#include <range/v3/algorithm/move.hpp>
+#include <range/v3/algorithm/move_backward.hpp>
+#include <range/v3/algorithm/none_of.hpp>
+#include <range/v3/algorithm/nth_element.hpp>
+#include <range/v3/algorithm/partial_sort.hpp>
+#include <range/v3/algorithm/partial_sort_copy.hpp>
+#include <range/v3/algorithm/partition.hpp>
+#include <range/v3/algorithm/partition_copy.hpp>
+#include <range/v3/algorithm/partition_point.hpp>
+#include <range/v3/algorithm/permutation.hpp>
+#include <range/v3/algorithm/remove.hpp>
+#include <range/v3/algorithm/remove_copy.hpp>
+#include <range/v3/algorithm/remove_copy_if.hpp>
+#include <range/v3/algorithm/remove_if.hpp>
+#include <range/v3/algorithm/replace.hpp>
+#include <range/v3/algorithm/replace_copy.hpp>
+#include <range/v3/algorithm/replace_copy_if.hpp>
+#include <range/v3/algorithm/replace_if.hpp>
+#include <range/v3/algorithm/reverse.hpp>
+#include <range/v3/algorithm/reverse_copy.hpp>
+#include <range/v3/algorithm/rotate.hpp>
+#include <range/v3/algorithm/rotate_copy.hpp>
+#include <range/v3/algorithm/sample.hpp>
+#include <range/v3/algorithm/search.hpp>
+#include <range/v3/algorithm/search_n.hpp>
+#include <range/v3/algorithm/set_algorithm.hpp>
+#include <range/v3/algorithm/shuffle.hpp>
+#include <range/v3/algorithm/sort.hpp>
+#include <range/v3/algorithm/stable_partition.hpp>
+#include <range/v3/algorithm/stable_sort.hpp>
+#include <range/v3/algorithm/starts_with.hpp>
+#include <range/v3/algorithm/swap_ranges.hpp>
+#include <range/v3/algorithm/transform.hpp>
+#include <range/v3/algorithm/unique.hpp>
+#include <range/v3/algorithm/unique_copy.hpp>
+#include <range/v3/algorithm/unstable_remove_if.hpp>
+#include <range/v3/algorithm/upper_bound.hpp>
+
+// BUGBUG
+#include <range/v3/algorithm/aux_/equal_range_n.hpp>
+#include <range/v3/algorithm/aux_/lower_bound_n.hpp>
+#include <range/v3/algorithm/aux_/merge_n.hpp>
+#include <range/v3/algorithm/aux_/merge_n_with_buffer.hpp>
+#include <range/v3/algorithm/aux_/sort_n_with_buffer.hpp>
+#include <range/v3/algorithm/aux_/upper_bound_n.hpp>
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/algorithm/adjacent_find.hpp b/inst/include/range/v3/algorithm/adjacent_find.hpp
new file mode 100644
index 0000000..9b8822e
--- /dev/null
+++ b/inst/include/range/v3/algorithm/adjacent_find.hpp
@@ -0,0 +1,72 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_ADJACENT_FIND_HPP
+#define RANGES_V3_ALGORITHM_ADJACENT_FIND_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(adjacent_find)
+        /// \brief function template \c adjacent_find
+        ///
+        /// range-based version of the \c adjacent_find std algorithm
+        ///
+        /// \pre `Rng` is a model of the `Range` concept
+        /// \pre `C` is a model of the `BinaryPredicate` concept
+        template<typename I, typename S, typename C = equal_to, typename P = identity>
+        auto RANGES_FUNC(adjacent_find)(I first, S last, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                                            //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_relation<C, projected<I, P>>)
+        {
+            if(first == last)
+                return first;
+            auto inext = first;
+            for(; ++inext != last; first = inext)
+                if(invoke(pred, invoke(proj, *first), invoke(proj, *inext)))
+                    return first;
+            return inext;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = equal_to, typename P = identity>
+        auto RANGES_FUNC(adjacent_find)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                    //
+                requires forward_range<Rng> &&
+                indirect_relation<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+    RANGES_FUNC_END(adjacent_find)
+
+    namespace cpp20
+    {
+        using ranges::adjacent_find;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // RANGE_ALGORITHM_ADJACENT_FIND_HPP
diff --git a/inst/include/range/v3/algorithm/adjacent_remove_if.hpp b/inst/include/range/v3/algorithm/adjacent_remove_if.hpp
new file mode 100644
index 0000000..9c04213
--- /dev/null
+++ b/inst/include/range/v3/algorithm/adjacent_remove_if.hpp
@@ -0,0 +1,90 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler
+//  Copyright Christopher Di Bella
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_ADJACENT_REMOVE_IF_HPP
+#define RANGES_V3_ALGORITHM_ADJACENT_REMOVE_IF_HPP
+
+#include <functional>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/adjacent_find.hpp>
+#include <range/v3/algorithm/move.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(adjacent_remove_if)
+        /// \brief function \c adjacent_remove_if
+        ///
+        /// range-based version of the \c adjacent_remove_if algorithm
+        ///
+        /// \pre `Rng` is a model of the `forward_range` concept.
+        /// \pre `Pred` is a model of the `BinaryPredicate` concept.
+        template<typename I, typename S, typename Pred, typename Proj = identity>
+        auto RANGES_FUNC(adjacent_remove_if)(
+            I first, S last, Pred pred = {}, Proj proj = {})
+            ->CPP_ret(I)( //
+                requires permutable<I> && sentinel_for<S, I> &&
+                indirect_relation<Pred, projected<I, Proj>>)
+        {
+            first = adjacent_find(std::move(first), last, std::ref(pred), std::ref(proj));
+            if(first == last)
+                return first;
+
+            auto i = first;
+            for(auto j = ++i; ++j != last; ++i)
+            {
+                if(!invoke(pred, invoke(proj, *i), invoke(proj, *j)))
+                {
+                    *first = iter_move(i);
+                    ++first;
+                }
+            }
+
+            *first = iter_move(i);
+            ++first;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename Pred, typename Proj = identity>
+        auto RANGES_FUNC(adjacent_remove_if)(Rng && rng, Pred pred, Proj proj = {}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                        //
+                requires forward_range<Rng> &&
+                indirect_relation<Pred, projected<iterator_t<Rng>, Proj>> &&
+                permutable<iterator_t<Rng>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+    RANGES_FUNC_END(adjacent_remove_if)
+
+    namespace cpp20
+    {
+        using ranges::adjacent_remove_if;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ALGORITHM_ADJACENT_REMOVE_IF_HPP
diff --git a/inst/include/range/v3/algorithm/all_of.hpp b/inst/include/range/v3/algorithm/all_of.hpp
new file mode 100644
index 0000000..279a4de
--- /dev/null
+++ b/inst/include/range/v3/algorithm/all_of.hpp
@@ -0,0 +1,67 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrew Sutton 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_ALL_OF_HPP
+#define RANGES_V3_ALGORITHM_ALL_OF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(all_of)
+
+        /// \brief function template \c all_of
+        template<typename I, typename S, typename F, typename P = identity>
+        auto RANGES_FUNC(all_of)(I first, S last, F pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                            //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<F, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+                if(!invoke(pred, invoke(proj, *first)))
+                    break;
+            return first == last;
+        }
+
+        /// \overload
+        template<typename Rng, typename F, typename P = identity>
+        auto RANGES_FUNC(all_of)(Rng && rng, F pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                       //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(all_of)
+
+    namespace cpp20
+    {
+        using ranges::all_of;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/any_of.hpp b/inst/include/range/v3/algorithm/any_of.hpp
new file mode 100644
index 0000000..3293333
--- /dev/null
+++ b/inst/include/range/v3/algorithm/any_of.hpp
@@ -0,0 +1,68 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrew Sutton 2014
+//  Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_ANY_OF_HPP
+#define RANGES_V3_ALGORITHM_ANY_OF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(any_of)
+
+        /// \brief function template \c any_of
+        template<typename I, typename S, typename F, typename P = identity>
+        auto RANGES_FUNC(any_of)(I first, S last, F pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                            //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<F, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+                if(invoke(pred, invoke(proj, *first)))
+                    return true;
+            return false;
+        }
+
+        /// \overload
+        template<typename Rng, typename F, typename P = identity>
+        auto RANGES_FUNC(any_of)(Rng && rng, F pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                       //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(any_of)
+
+    namespace cpp20
+    {
+        using ranges::any_of;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/aux_/equal_range_n.hpp b/inst/include/range/v3/algorithm/aux_/equal_range_n.hpp
new file mode 100644
index 0000000..7648224
--- /dev/null
+++ b/inst/include/range/v3/algorithm/aux_/equal_range_n.hpp
@@ -0,0 +1,84 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_AUX_EQUAL_RANGE_N_HPP
+#define RANGES_V3_ALGORITHM_AUX_EQUAL_RANGE_N_HPP
+
+#include <functional>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/lower_bound_n.hpp>
+#include <range/v3/algorithm/aux_/upper_bound_n.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    namespace aux
+    {
+        struct equal_range_n_fn
+        {
+            template<typename I, typename V, typename R = less, typename P = identity>
+            auto operator()(I first, iter_difference_t<I> dist, V const & val,
+                            R pred = R{}, P proj = P{}) const -> CPP_ret(subrange<I>)( //
+                requires forward_iterator<I> &&
+                    indirect_strict_weak_order<R, V const *, projected<I, P>>)
+            {
+                if(0 < dist)
+                {
+                    do
+                    {
+                        auto half = dist / 2;
+                        auto middle = ranges::next(first, half);
+                        auto && v = *middle;
+                        auto && pv = invoke(proj, (decltype(v) &&)v);
+                        if(invoke(pred, pv, val))
+                        {
+                            first = std::move(++middle);
+                            dist -= half + 1;
+                        }
+                        else if(invoke(pred, val, pv))
+                        {
+                            dist = half;
+                        }
+                        else
+                        {
+                            return {lower_bound_n(std::move(first),
+                                                  half,
+                                                  val,
+                                                  std::ref(pred),
+                                                  std::ref(proj)),
+                                    upper_bound_n(ranges::next(middle),
+                                                  dist - (half + 1),
+                                                  val,
+                                                  std::ref(pred),
+                                                  std::ref(proj))};
+                        }
+                    } while(0 != dist);
+                }
+                return {first, first};
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(equal_range_n_fn, equal_range_n)
+    } // namespace aux
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/aux_/lower_bound_n.hpp b/inst/include/range/v3/algorithm/aux_/lower_bound_n.hpp
new file mode 100644
index 0000000..de29a5c
--- /dev/null
+++ b/inst/include/range/v3/algorithm/aux_/lower_bound_n.hpp
@@ -0,0 +1,75 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_AUX_LOWER_BOUND_N_HPP
+#define RANGES_V3_ALGORITHM_AUX_LOWER_BOUND_N_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/partition_point_n.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // [&](auto&& i){ return invoke(pred, i, val); }
+        template<typename Pred, typename Val>
+        struct lower_bound_predicate
+        {
+            Pred & pred_;
+            Val & val_;
+
+            template<typename T>
+            bool operator()(T && t) const
+            {
+                return invoke(pred_, static_cast<T &&>(t), val_);
+            }
+        };
+
+        template<typename Pred, typename Val>
+        lower_bound_predicate<Pred, Val> make_lower_bound_predicate(Pred & pred,
+                                                                    Val & val)
+        {
+            return {pred, val};
+        }
+    } // namespace detail
+    /// \endcond
+
+    namespace aux
+    {
+        struct lower_bound_n_fn
+        {
+            template<typename I, typename V, typename C = less, typename P = identity>
+            auto operator()(I first, iter_difference_t<I> d, V const & val, C pred = C{},
+                            P proj = P{}) const -> CPP_ret(I)( //
+                requires forward_iterator<I> &&
+                    indirect_strict_weak_order<C, V const *, projected<I, P>>)
+            {
+                return partition_point_n(std::move(first),
+                                         d,
+                                         detail::make_lower_bound_predicate(pred, val),
+                                         std::move(proj));
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(lower_bound_n_fn, lower_bound_n)
+    } // namespace aux
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/aux_/merge_n.hpp b/inst/include/range/v3/algorithm/aux_/merge_n.hpp
new file mode 100644
index 0000000..ba65a07
--- /dev/null
+++ b/inst/include/range/v3/algorithm/aux_/merge_n.hpp
@@ -0,0 +1,106 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Copyright (c) 2009 Alexander Stepanov and Paul McJones
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without
+// fee, provided that the above copyright notice appear in all copies
+// and that both that copyright notice and this permission notice
+// appear in supporting documentation. The authors make no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+//
+// Algorithms from
+// Elements of Programming
+// by Alexander Stepanov and Paul McJones
+// Addison-Wesley Professional, 2009
+#ifndef RANGES_V3_ALGORITHM_AUX_MERGE_N_HPP
+#define RANGES_V3_ALGORITHM_AUX_MERGE_N_HPP
+
+#include <tuple>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/copy_n.hpp>
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    namespace aux
+    {
+        template<typename I0, typename I1, typename O>
+        using merge_n_result = detail::in1_in2_out_result<I0, I1, O>;
+
+        struct merge_n_fn
+        {
+            template<typename I0, typename I1, typename O, typename C = less,
+                     typename P0 = identity, typename P1 = identity>
+            auto operator()(I0 begin0, iter_difference_t<I0> n0, I1 begin1,
+                            iter_difference_t<I1> n1, O out, C r = C{}, P0 p0 = P0{},
+                            P1 p1 = P1{}) const -> CPP_ret(merge_n_result<I0, I1, O>)( //
+                requires mergeable<I0, I1, O, C, P0, P1>)
+            {
+                using T = merge_n_result<I0, I1, O>;
+                auto n0orig = n0;
+                auto n1orig = n1;
+                auto b0 = uncounted(begin0);
+                auto b1 = uncounted(begin1);
+                while(true)
+                {
+                    if(0 == n0)
+                    {
+                        auto res = copy_n(b1, n1, out);
+                        begin0 = recounted(begin0, b0, n0orig);
+                        begin1 = recounted(begin1, res.in, n1orig);
+                        return T{begin0, begin1, res.out};
+                    }
+                    if(0 == n1)
+                    {
+                        auto res = copy_n(b0, n0, out);
+                        begin0 = recounted(begin0, res.in, n0orig);
+                        begin1 = recounted(begin1, b1, n1orig);
+                        return T{begin0, begin1, res.out};
+                    }
+                    if(invoke(r, invoke(p1, *b1), invoke(p0, *b0)))
+                    {
+                        *out = *b1;
+                        ++b1;
+                        ++out;
+                        --n1;
+                    }
+                    else
+                    {
+                        *out = *b0;
+                        ++b0;
+                        ++out;
+                        --n0;
+                    }
+                }
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(merge_n_fn, merge_n)
+    } // namespace aux
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/aux_/merge_n_with_buffer.hpp b/inst/include/range/v3/algorithm/aux_/merge_n_with_buffer.hpp
new file mode 100644
index 0000000..2babb29
--- /dev/null
+++ b/inst/include/range/v3/algorithm/aux_/merge_n_with_buffer.hpp
@@ -0,0 +1,66 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Copyright (c) 2009 Alexander Stepanov and Paul McJones
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without
+// fee, provided that the above copyright notice appear in all copies
+// and that both that copyright notice and this permission notice
+// appear in supporting documentation. The authors make no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+//
+// Algorithms from
+// Elements of Programming
+// by Alexander Stepanov and Paul McJones
+// Addison-Wesley Professional, 2009
+#ifndef RANGES_V3_ALGORITHM_AUX_MERGE_N_WITH_BUFFER_HPP
+#define RANGES_V3_ALGORITHM_AUX_MERGE_N_WITH_BUFFER_HPP
+
+#include <tuple>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/merge_n.hpp>
+#include <range/v3/algorithm/copy_n.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    namespace aux
+    {
+        struct merge_n_with_buffer_fn
+        {
+            template<typename I, typename B, typename C = less, typename P = identity>
+            auto operator()(I begin0, iter_difference_t<I> n0, I begin1,
+                            iter_difference_t<I> n1, B buff, C r = C{}, P p = P{}) const
+                -> CPP_ret(I)( //
+                    requires same_as<iter_common_reference_t<I>,
+                                     iter_common_reference_t<B>> &&
+                        indirectly_copyable<I, B> && mergeable<B, I, I, C, P, P>)
+            {
+                copy_n(begin0, n0, buff);
+                return merge_n(buff, n0, begin1, n1, begin0, r, p, p).out;
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(merge_n_with_buffer_fn, merge_n_with_buffer)
+    } // namespace aux
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/aux_/partition_point_n.hpp b/inst/include/range/v3/algorithm/aux_/partition_point_n.hpp
new file mode 100644
index 0000000..16701e0
--- /dev/null
+++ b/inst/include/range/v3/algorithm/aux_/partition_point_n.hpp
@@ -0,0 +1,60 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_AUX_PARTITION_POINT_N_HPP
+#define RANGES_V3_ALGORITHM_AUX_PARTITION_POINT_N_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    namespace aux
+    {
+        struct partition_point_n_fn
+        {
+            template<typename I, typename C, typename P = identity>
+            auto operator()(I first, iter_difference_t<I> d, C pred,
+                            P proj = P{}) const //
+                -> CPP_ret(I)(                  //
+                    requires forward_iterator<I> &&
+                        indirect_unary_predicate<C, projected<I, P>>)
+            {
+                if(0 < d)
+                {
+                    do
+                    {
+                        auto half = d / 2;
+                        auto middle = next(uncounted(first), half);
+                        if(invoke(pred, invoke(proj, *middle)))
+                        {
+                            first = recounted(first, std::move(++middle), half + 1);
+                            d -= half + 1;
+                        }
+                        else
+                            d = half;
+                    } while(0 != d);
+                }
+                return first;
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(partition_point_n_fn, partition_point_n)
+    } // namespace aux
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/aux_/sort_n_with_buffer.hpp b/inst/include/range/v3/algorithm/aux_/sort_n_with_buffer.hpp
new file mode 100644
index 0000000..3f8ca48
--- /dev/null
+++ b/inst/include/range/v3/algorithm/aux_/sort_n_with_buffer.hpp
@@ -0,0 +1,69 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Copyright (c) 2009 Alexander Stepanov and Paul McJones
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without
+// fee, provided that the above copyright notice appear in all copies
+// and that both that copyright notice and this permission notice
+// appear in supporting documentation. The authors make no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+//
+// Algorithms from
+// Elements of Programming
+// by Alexander Stepanov and Paul McJones
+// Addison-Wesley Professional, 2009
+#ifndef RANGES_V3_ALGORITHM_AUX_SORT_N_WITH_BUFFER_HPP
+#define RANGES_V3_ALGORITHM_AUX_SORT_N_WITH_BUFFER_HPP
+
+#include <tuple>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/merge_n_with_buffer.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    namespace aux
+    {
+        struct sort_n_with_buffer_fn
+        {
+            template<typename I, typename B, typename C = less, typename P = identity>
+            auto operator()(I first, iter_difference_t<I> n, B buff, C r = C{},
+                            P p = P{}) const -> CPP_ret(I)( //
+                requires same_as<iter_common_reference_t<I>,
+                                 iter_common_reference_t<B>> &&
+                    indirectly_copyable<I, B> && mergeable<B, I, I, C, P, P>)
+            {
+                auto half = n / 2;
+                if(0 == half)
+                    return next(first, n);
+                I m = (*this)(first, half, buff, r, p);
+                (*this)(m, n - half, buff, r, p);
+                return merge_n_with_buffer(first, half, m, n - half, buff, r, p);
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(sort_n_with_buffer_fn, sort_n_with_buffer)
+    } // namespace aux
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/aux_/upper_bound_n.hpp b/inst/include/range/v3/algorithm/aux_/upper_bound_n.hpp
new file mode 100644
index 0000000..6b75019
--- /dev/null
+++ b/inst/include/range/v3/algorithm/aux_/upper_bound_n.hpp
@@ -0,0 +1,80 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_AUX_UPPER_BOUND_N_HPP
+#define RANGES_V3_ALGORITHM_AUX_UPPER_BOUND_N_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/partition_point_n.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // [&](auto&& i){ return !invoke(pred, val, i); }
+        template<typename Pred, typename Val>
+        struct upper_bound_predicate
+        {
+            Pred * pred_;
+            Val * val_;
+
+            template<typename T>
+            bool operator()(T && t) const
+            {
+                return !invoke(*pred_, *val_, static_cast<T &&>(t));
+            }
+        };
+
+        template<typename Pred, typename Val>
+        upper_bound_predicate<Pred, Val> make_upper_bound_predicate(Pred & pred,
+                                                                    Val & val)
+        {
+            return {&pred, &val};
+        }
+    } // namespace detail
+    /// \endcond
+
+    namespace aux
+    {
+        struct upper_bound_n_fn
+        {
+            /// \brief template function upper_bound
+            ///
+            /// range-based version of the `upper_bound` std algorithm
+            ///
+            /// \pre `Rng` is a model of the `Range` concept
+            template<typename I, typename V, typename C = less, typename P = identity>
+            auto operator()(I first, iter_difference_t<I> d, V const & val, C pred = C{},
+                            P proj = P{}) const -> CPP_ret(I)( //
+                requires forward_iterator<I> &&
+                    indirect_strict_weak_order<C, V const *, projected<I, P>>)
+            {
+                return partition_point_n(std::move(first),
+                                         d,
+                                         detail::make_upper_bound_predicate(pred, val),
+                                         std::move(proj));
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(upper_bound_n_fn, upper_bound_n)
+    } // namespace aux
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/binary_search.hpp b/inst/include/range/v3/algorithm/binary_search.hpp
new file mode 100644
index 0000000..9af819b
--- /dev/null
+++ b/inst/include/range/v3/algorithm/binary_search.hpp
@@ -0,0 +1,79 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_BINARY_SEARCH_HPP
+#define RANGES_V3_ALGORITHM_BINARY_SEARCH_HPP
+
+#include <functional>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/lower_bound.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(binary_search)
+        /// \brief function template \c binary_search
+        ///
+        /// range-based version of the \c binary_search std algorithm
+        ///
+        /// \pre `Rng` is a model of the `Range` concept
+        template<typename I,
+                 typename S,
+                 typename V,
+                 typename C = less,
+                 typename P = identity>
+        auto RANGES_FUNC(binary_search)(
+            I first, S last, V const & val, C pred = C{}, P proj = P{})
+            ->CPP_ret(bool)( //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, V const *, projected<I, P>>)
+        {
+            first =
+                lower_bound(std::move(first), last, val, std::ref(pred), std::ref(proj));
+            return first != last && !invoke(pred, val, invoke(proj, *first));
+        }
+
+        /// \overload
+        template<typename Rng, typename V, typename C = less, typename P = identity>
+        auto RANGES_FUNC(binary_search)(
+            Rng && rng, V const & val, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                       //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>)
+        {
+            static_assert(!is_infinite<Rng>::value,
+                          "Trying to binary search an infinite range");
+            return (*this)(begin(rng), end(rng), val, std::move(pred), std::move(proj));
+        }
+    RANGES_FUNC_END(binary_search)
+
+    namespace cpp20
+    {
+        using ranges::binary_search;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/copy.hpp b/inst/include/range/v3/algorithm/copy.hpp
new file mode 100644
index 0000000..2338c56
--- /dev/null
+++ b/inst/include/range/v3/algorithm/copy.hpp
@@ -0,0 +1,86 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_COPY_HPP
+#define RANGES_V3_ALGORITHM_COPY_HPP
+
+#include <functional>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/copy.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using copy_result = detail::in_out_result<I, O>;
+
+    RANGES_HIDDEN_DETAIL(namespace _copy CPP_PP_LBRACE())
+    RANGES_FUNC_BEGIN(copy)
+
+        /// \brief function template \c copy
+        template<typename I, typename S, typename O>
+        constexpr auto RANGES_FUNC(copy)(I first, S last, O out) //
+            ->CPP_ret(copy_result<I, O>)(                        //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && indirectly_copyable<I, O>)
+        {
+            for(; first != last; ++first, ++out)
+                *out = *first;
+            return {first, out};
+        } // namespace ranges
+
+        /// \overload
+        template<typename Rng, typename O>
+        constexpr auto RANGES_FUNC(copy)(Rng && rng, O out)  //
+            ->CPP_ret(copy_result<safe_iterator_t<Rng>, O>)( //
+                requires input_range<Rng> && weakly_incrementable<O> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(out));
+        }
+
+    RANGES_FUNC_END(copy)
+    RANGES_HIDDEN_DETAIL(CPP_PP_RBRACE())
+
+#ifndef RANGES_DOXYGEN_INVOKED
+    struct copy_fn
+      : aux::copy_fn
+      , _copy::copy_fn
+    {
+        using aux::copy_fn::operator();
+        using _copy::copy_fn::operator();
+    };
+    RANGES_INLINE_VARIABLE(copy_fn, copy)
+#endif
+
+    namespace cpp20
+    {
+        using ranges::copy_result;
+        using ranges::RANGES_HIDDEN_DETAIL(_copy::) copy;
+    } // namespace cpp20
+
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/copy_backward.hpp b/inst/include/range/v3/algorithm/copy_backward.hpp
new file mode 100644
index 0000000..3bc25f0
--- /dev/null
+++ b/inst/include/range/v3/algorithm/copy_backward.hpp
@@ -0,0 +1,71 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_COPY_BACKWARD_HPP
+#define RANGES_V3_ALGORITHM_COPY_BACKWARD_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using copy_backward_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(copy_backward)
+
+        /// \brief function template \c copy_backward
+        template<typename I, typename S, typename O>
+        auto RANGES_FUNC(copy_backward)(I first, S end_, O out)
+            ->CPP_ret(copy_backward_result<I, O>)( //
+                requires bidirectional_iterator<I> && sentinel_for<S, I> &&
+                bidirectional_iterator<O> && indirectly_copyable<I, O>)
+        {
+            I i = ranges::next(first, end_), last = i;
+            while(first != i)
+                *--out = *--i;
+            return {last, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O>
+        auto RANGES_FUNC(copy_backward)(Rng && rng, O out)
+            ->CPP_ret(copy_backward_result<safe_iterator_t<Rng>, O>)( //
+                requires bidirectional_range<Rng> && bidirectional_iterator<O> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(out));
+        }
+    RANGES_FUNC_END(copy_backward)
+
+    namespace cpp20
+    {
+        using ranges::copy_backward;
+        using ranges::copy_backward_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/copy_if.hpp b/inst/include/range/v3/algorithm/copy_if.hpp
new file mode 100644
index 0000000..b76cb5f
--- /dev/null
+++ b/inst/include/range/v3/algorithm/copy_if.hpp
@@ -0,0 +1,83 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_COPY_IF_HPP
+#define RANGES_V3_ALGORITHM_COPY_IF_HPP
+
+#include <functional>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using copy_if_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(copy_if)
+
+        /// \brief function template \c copy_if
+        template<typename I, typename S, typename O, typename F, typename P = identity>
+        auto RANGES_FUNC(copy_if)(I first, S last, O out, F pred, P proj = P{}) //
+            ->CPP_ret(copy_if_result<I, O>)(                                    //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && indirect_unary_predicate<F, projected<I, P>> &&
+                indirectly_copyable<I, O>)
+        {
+            for(; first != last; ++first)
+            {
+                auto && x = *first;
+                if(invoke(pred, invoke(proj, x)))
+                {
+                    *out = (decltype(x) &&)x;
+                    ++out;
+                }
+            }
+            return {first, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename F, typename P = identity>
+        auto RANGES_FUNC(copy_if)(Rng && rng, O out, F pred, P proj = P{})
+            ->CPP_ret(copy_if_result<safe_iterator_t<Rng>, O>)( //
+                requires input_range<Rng> && weakly_incrementable<O> &&
+                indirect_unary_predicate<F, projected<iterator_t<Rng>, P>> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(
+                begin(rng), end(rng), std::move(out), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(copy_if)
+
+    namespace cpp20
+    {
+        using ranges::copy_if;
+        using ranges::copy_if_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/copy_n.hpp b/inst/include/range/v3/algorithm/copy_n.hpp
new file mode 100644
index 0000000..7bd77a2
--- /dev/null
+++ b/inst/include/range/v3/algorithm/copy_n.hpp
@@ -0,0 +1,66 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_COPY_N_HPP
+#define RANGES_V3_ALGORITHM_COPY_N_HPP
+
+#include <functional>
+#include <tuple>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using copy_n_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(copy_n)
+
+        /// \brief function template \c copy_n
+        template<typename I, typename O, typename P = identity>
+        auto RANGES_FUNC(copy_n)(I first, iter_difference_t<I> n, O out)
+            ->CPP_ret(copy_n_result<I, O>)( //
+                requires input_iterator<I> && weakly_incrementable<O> &&
+                indirectly_copyable<I, O>)
+        {
+            RANGES_EXPECT(0 <= n);
+            auto norig = n;
+            auto b = uncounted(first);
+            for(; n != 0; ++b, ++out, --n)
+                *out = *b;
+            return {recounted(first, b, norig), out};
+        }
+
+    RANGES_FUNC_END(copy_n)
+
+    namespace cpp20
+    {
+        using ranges::copy_n;
+        using ranges::copy_n_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/count.hpp b/inst/include/range/v3/algorithm/count.hpp
new file mode 100644
index 0000000..ae00b35
--- /dev/null
+++ b/inst/include/range/v3/algorithm/count.hpp
@@ -0,0 +1,68 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_COUNT_HPP
+#define RANGES_V3_ALGORITHM_COUNT_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(count)
+
+        /// \brief function template \c count
+        template<typename I, typename S, typename V, typename P = identity>
+        auto RANGES_FUNC(count)(I first, S last, V const & val, P proj = P{})
+            ->CPP_ret(iter_difference_t<I>)( //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_relation<equal_to, projected<I, P>, V const *>)
+        {
+            iter_difference_t<I> n = 0;
+            for(; first != last; ++first)
+                if(invoke(proj, *first) == val)
+                    ++n;
+            return n;
+        }
+
+        /// \overload
+        template<typename Rng, typename V, typename P = identity>
+        auto RANGES_FUNC(count)(Rng && rng, V const & val, P proj = P{})
+            ->CPP_ret(iter_difference_t<iterator_t<Rng>>)( //
+                requires input_range<Rng> &&
+                indirect_relation<equal_to, projected<iterator_t<Rng>, P>, V const *>)
+        {
+            return (*this)(begin(rng), end(rng), val, std::move(proj));
+        }
+
+    RANGES_FUNC_END(count)
+
+    namespace cpp20
+    {
+        using ranges::count;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/count_if.hpp b/inst/include/range/v3/algorithm/count_if.hpp
new file mode 100644
index 0000000..74965d8
--- /dev/null
+++ b/inst/include/range/v3/algorithm/count_if.hpp
@@ -0,0 +1,68 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_COUNT_IF_HPP
+#define RANGES_V3_ALGORITHM_COUNT_IF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(count_if)
+
+        /// \brief function template \c count_if
+        template<typename I, typename S, typename R, typename P = identity>
+        auto RANGES_FUNC(count_if)(I first, S last, R pred, P proj = P{})
+            ->CPP_ret(iter_difference_t<I>)( //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<R, projected<I, P>>)
+        {
+            iter_difference_t<I> n = 0;
+            for(; first != last; ++first)
+                if(invoke(pred, invoke(proj, *first)))
+                    ++n;
+            return n;
+        }
+
+        /// \overload
+        template<typename Rng, typename R, typename P = identity>
+        auto RANGES_FUNC(count_if)(Rng && rng, R pred, P proj = P{})
+            ->CPP_ret(iter_difference_t<iterator_t<Rng>>)( //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<R, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(count_if)
+
+    namespace cpp20
+    {
+        using ranges::count_if;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/ends_with.hpp b/inst/include/range/v3/algorithm/ends_with.hpp
new file mode 100644
index 0000000..4a1b2ba
--- /dev/null
+++ b/inst/include/range/v3/algorithm/ends_with.hpp
@@ -0,0 +1,99 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Johel Guerrero 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 0.0. (See accompanying
+//  file LICENSE_0_0.txt or copy at
+//  http://www.boost.org/LICENSE_0_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_ENDS_WITH_HPP
+#define RANGES_V3_ALGORITHM_ENDS_WITH_HPP
+
+#include <utility>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/algorithm/equal.hpp>
+#include <range/v3/detail/config.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(ends_with)
+
+        /// \brief function template \c ends_with
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename S1,
+                 typename C = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        constexpr auto RANGES_FUNC(ends_with)(I0 begin0,
+                                              S0 end0,
+                                              I1 begin1,
+                                              S1 end1,
+                                              C pred = C{},
+                                              P0 proj0 = P0{},
+                                              P1 proj1 = P1{}) //
+            ->CPP_ret(bool)(                                   //
+                requires((forward_iterator<I0> && sentinel_for<S0, I0>) ||
+                         (input_iterator<I0> && sized_sentinel_for<S0, I0>)) &&
+                ((forward_iterator<I1> && sentinel_for<S1, I1>) ||
+                 (input_iterator<I1> && sized_sentinel_for<S1, I1>)) &&
+                indirectly_comparable<I0, I1, C, P0, P1>)
+        {
+            const auto drop = distance(begin0, end0) - distance(begin1, end1);
+            if(drop < 0)
+                return false;
+            return equal(next(std::move(begin0), drop),
+                         std::move(end0),
+                         std::move(begin1),
+                         std::move(end1),
+                         std::move(pred),
+                         std::move(proj0),
+                         std::move(proj1));
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename Rng1,
+                 typename C = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        constexpr auto RANGES_FUNC(ends_with)(
+            Rng0 && rng0, Rng1 && rng1, C pred = C{}, P0 proj0 = P0{}, P1 proj1 = P1{}) //
+            ->CPP_ret(bool)(                                                            //
+                requires(forward_range<Rng0> ||
+                         (input_range<Rng0> && sized_range<Rng0>)) &&
+                (forward_range<Rng1> || (input_range<Rng1> && sized_range<Rng1>)) &&
+                indirectly_comparable<iterator_t<Rng0>, iterator_t<Rng1>, C, P0, P1>)
+        {
+            const auto drop = distance(rng0) - distance(rng1);
+            if(drop < 0)
+                return false;
+            return equal(next(begin(rng0), drop),
+                         end(rng0),
+                         begin(rng1),
+                         end(rng1),
+                         std::move(pred),
+                         std::move(proj0),
+                         std::move(proj1));
+        }
+
+    RANGES_FUNC_END(ends_with)
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/equal.hpp b/inst/include/range/v3/algorithm/equal.hpp
new file mode 100644
index 0000000..3f95708
--- /dev/null
+++ b/inst/include/range/v3/algorithm/equal.hpp
@@ -0,0 +1,175 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 0.0. (See accompanying
+//  file LICENSE_0_0.txt or copy at
+//  http://www.boost.org/LICENSE_0_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_EQUAL_HPP
+#define RANGES_V3_ALGORITHM_EQUAL_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I0, typename S0, typename I1, typename S1, typename C,
+                 typename P0, typename P1>
+        constexpr bool equal_nocheck(I0 begin0, S0 end0, I1 begin1, S1 end1, C pred,
+                                     P0 proj0, P1 proj1)
+        {
+            for(; begin0 != end0 && begin1 != end1; ++begin0, ++begin1)
+                if(!invoke(pred, invoke(proj0, *begin0), invoke(proj1, *begin1)))
+                    return false;
+            return begin0 == end0 && begin1 == end1;
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(equal)
+
+        /// \brief function template \c equal
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename C = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::equal that takes an upper bound for "
+            "both sequences")
+        constexpr auto RANGES_FUNC(equal)(I0 begin0,
+                                          S0 end0,
+                                          I1 begin1,
+                                          C pred = C{},
+                                          P0 proj0 = P0{},
+                                          P1 proj1 = P1{}) //
+            ->CPP_ret(bool)(                               //
+                requires input_iterator<I0> && sentinel_for<S0, I0> &&
+                input_iterator<I1> && indirectly_comparable<I0, I1, C, P0, P1>)
+        {
+            for(; begin0 != end0; ++begin0, ++begin1)
+                if(!invoke(pred, invoke(proj0, *begin0), invoke(proj1, *begin1)))
+                    return false;
+            return true;
+        }
+
+        /// \overload
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename S1,
+                 typename C = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        constexpr auto RANGES_FUNC(equal)(I0 begin0,
+                                          S0 end0,
+                                          I1 begin1,
+                                          S1 end1,
+                                          C pred = C{},
+                                          P0 proj0 = P0{},
+                                          P1 proj1 = P1{}) //
+            ->CPP_ret(bool)(                               //
+                requires input_iterator<I0> && sentinel_for<S0, I0> &&
+                input_iterator<I1> && sentinel_for<S1, I1> &&
+                indirectly_comparable<I0, I1, C, P0, P1>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_sentinel_for<S0, I0> &&
+                                   sized_sentinel_for<S1, I1>))
+                if(distance(begin0, end0) != distance(begin1, end1))
+                    return false;
+            return detail::equal_nocheck(std::move(begin0),
+                                         std::move(end0),
+                                         std::move(begin1),
+                                         std::move(end1),
+                                         std::move(pred),
+                                         std::move(proj0),
+                                         std::move(proj1));
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename I1Ref,
+                 typename C = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::equal that takes an upper bound for "
+            "both sequences")
+        constexpr auto RANGES_FUNC(equal)(Rng0 && rng0,
+                                          I1Ref && begin1,
+                                          C pred = C{},
+                                          P0 proj0 = P0{},
+                                          P1 proj1 = P1{}) //
+            ->CPP_ret(bool)(                               //
+                requires input_range<Rng0> && input_iterator<uncvref_t<I1Ref>> &&
+                indirectly_comparable<iterator_t<Rng0>, uncvref_t<I1Ref>, C, P0, P1>)
+        {
+            RANGES_DIAGNOSTIC_PUSH
+            RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+            return (*this)(begin(rng0),
+                           end(rng0),
+                           (I1Ref &&) begin1,
+                           std::move(pred),
+                           std::move(proj0),
+                           std::move(proj1));
+            RANGES_DIAGNOSTIC_POP
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename Rng1,
+                 typename C = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        constexpr auto RANGES_FUNC(equal)(
+            Rng0 && rng0, Rng1 && rng1, C pred = C{}, P0 proj0 = P0{}, P1 proj1 = P1{}) //
+            ->CPP_ret(bool)(                                                            //
+                requires input_range<Rng0> && input_range<Rng1> &&
+                indirectly_comparable<iterator_t<Rng0>, iterator_t<Rng1>, C, P0, P1>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_range<Rng0> && sized_range<Rng1>))
+                if(distance(rng0) != distance(rng1))
+                    return false;
+            return detail::equal_nocheck(begin(rng0),
+                                         end(rng0),
+                                         begin(rng1),
+                                         end(rng1),
+                                         std::move(pred),
+                                         std::move(proj0),
+                                         std::move(proj1));
+        }
+
+    RANGES_FUNC_END(equal)
+
+    namespace cpp20
+    {
+        using ranges::equal;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/equal_range.hpp b/inst/include/range/v3/algorithm/equal_range.hpp
new file mode 100644
index 0000000..65e57eb
--- /dev/null
+++ b/inst/include/range/v3/algorithm/equal_range.hpp
@@ -0,0 +1,128 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_EQUAL_RANGE_HPP
+#define RANGES_V3_ALGORITHM_EQUAL_RANGE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/equal_range_n.hpp>
+#include <range/v3/algorithm/aux_/lower_bound_n.hpp>
+#include <range/v3/algorithm/upper_bound.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(equal_range)
+
+        /// \brief function template \c equal_range
+        template<typename I,
+                 typename S,
+                 typename V,
+                 typename C = less,
+                 typename P = identity>
+        auto RANGES_FUNC(equal_range)(
+            I first, S last, V const & val, C pred = C{}, P proj = P{})
+            ->CPP_ret(subrange<I>)( //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, V const *, projected<I, P>>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_sentinel_for<S, I>))
+            {
+                auto const len = distance(first, last);
+                return aux::equal_range_n(
+                    std::move(first), len, val, std::move(pred), std::move(proj));
+            }
+
+            // Probe exponentially for either end-of-range, an iterator that
+            // is past the equal range (i.e., denotes an element greater
+            // than val), or is in the equal range (denotes an element equal
+            // to val).
+            auto dist = iter_difference_t<I>{1};
+            while(true)
+            {
+                auto mid = first;
+                auto d = advance(mid, dist, last);
+                if(d || mid == last)
+                {
+                    // at the end of the input range
+                    dist -= d;
+                    return aux::equal_range_n(
+                        std::move(first), dist, val, std::ref(pred), std::ref(proj));
+                }
+                // if val < *mid, mid is after the target range.
+                auto && v = *mid;
+                auto && pv = invoke(proj, (decltype(v) &&)v);
+                if(invoke(pred, val, pv))
+                {
+                    return aux::equal_range_n(
+                        std::move(first), dist, val, std::ref(pred), std::ref(proj));
+                }
+                else if(!invoke(pred, pv, val))
+                {
+                    // *mid == val: the lower bound is <= mid, and the upper bound is >
+                    // mid.
+                    return {
+                        aux::lower_bound_n(
+                            std::move(first), dist, val, std::ref(pred), std::ref(proj)),
+                        upper_bound(std::move(mid),
+                                    std::move(last),
+                                    val,
+                                    std::ref(pred),
+                                    std::ref(proj))};
+                }
+                // *mid < val, mid is before the target range.
+                first = std::move(mid);
+                ++first;
+                dist *= 2;
+            }
+        }
+
+        /// \overload
+        template<typename Rng, typename V, typename C = less, typename P = identity>
+        auto RANGES_FUNC(equal_range)(
+            Rng && rng, V const & val, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_subrange_t<Rng>)(                       //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_range<Rng>))
+            {
+                auto const len = distance(rng);
+                return aux::equal_range_n(
+                    begin(rng), len, val, std::move(pred), std::move(proj));
+            }
+
+            return (*this)(begin(rng), end(rng), val, std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(equal_range)
+
+    namespace cpp20
+    {
+        using ranges::equal_range;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/fill.hpp b/inst/include/range/v3/algorithm/fill.hpp
new file mode 100644
index 0000000..e9c4777
--- /dev/null
+++ b/inst/include/range/v3/algorithm/fill.hpp
@@ -0,0 +1,60 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FILL_HPP
+#define RANGES_V3_ALGORITHM_FILL_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(fill)
+
+        /// \brief function template \c fill
+        template<typename O, typename S, typename V>
+        auto RANGES_FUNC(fill)(O first, S last, V const & val) //
+            ->CPP_ret(O)(                                      //
+                requires output_iterator<O, V const &> && sentinel_for<S, O>)
+        {
+            for(; first != last; ++first)
+                *first = val;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename V>
+        auto RANGES_FUNC(fill)(Rng && rng, V const & val)
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires output_range<Rng, V const &>)
+        {
+            return (*this)(begin(rng), end(rng), val);
+        }
+
+    RANGES_FUNC_END(fill)
+
+    namespace cpp20
+    {
+        using ranges::fill;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/fill_n.hpp b/inst/include/range/v3/algorithm/fill_n.hpp
new file mode 100644
index 0000000..0a2131d
--- /dev/null
+++ b/inst/include/range/v3/algorithm/fill_n.hpp
@@ -0,0 +1,56 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FILL_N_HPP
+#define RANGES_V3_ALGORITHM_FILL_N_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(fill_n)
+
+        /// \brief function template \c equal
+        template<typename O, typename V>
+        auto RANGES_FUNC(fill_n)(O first, iter_difference_t<O> n, V const & val)
+            ->CPP_ret(O)( //
+                requires output_iterator<O, V const &>)
+        {
+            RANGES_EXPECT(n >= 0);
+            auto norig = n;
+            auto b = uncounted(first);
+            for(; n != 0; ++b, --n)
+                *b = val;
+            return recounted(first, b, norig);
+        }
+
+    RANGES_FUNC_END(fill_n)
+
+    namespace cpp20
+    {
+        using ranges::fill_n;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/find.hpp b/inst/include/range/v3/algorithm/find.hpp
new file mode 100644
index 0000000..061b471
--- /dev/null
+++ b/inst/include/range/v3/algorithm/find.hpp
@@ -0,0 +1,75 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FIND_HPP
+#define RANGES_V3_ALGORITHM_FIND_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(find)
+        /// \brief template function \c find
+        ///
+        /// range-based version of the \c find std algorithm
+        ///
+        /// \pre `Rng` is a model of the `Range` concept
+        /// \pre `I` is a model of the `input_iterator` concept
+        /// \pre `S` is a model of the `sentinel_for<I>` concept
+        /// \pre `P` is a model of the `invocable<iter_common_reference_t<I>>` concept
+        /// \pre The ResultType of `P` is equality_comparable with V
+        template<typename I, typename S, typename V, typename P = identity>
+        auto RANGES_FUNC(find)(I first, S last, V const & val, P proj = P{})
+            ->CPP_ret(I)( //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_relation<equal_to, projected<I, P>, V const *>)
+        {
+            for(; first != last; ++first)
+                if(invoke(proj, *first) == val)
+                    break;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename V, typename P = identity>
+        auto RANGES_FUNC(find)(Rng && rng, V const & val, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires input_range<Rng> &&
+                indirect_relation<equal_to, projected<iterator_t<Rng>, P>, V const *>)
+        {
+            return (*this)(begin(rng), end(rng), val, std::move(proj));
+        }
+
+    RANGES_FUNC_END(find)
+
+    namespace cpp20
+    {
+        using ranges::find;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/find_end.hpp b/inst/include/range/v3/algorithm/find_end.hpp
new file mode 100644
index 0000000..b64f79d
--- /dev/null
+++ b/inst/include/range/v3/algorithm/find_end.hpp
@@ -0,0 +1,235 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FIND_END_HPP
+#define RANGES_V3_ALGORITHM_FIND_END_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S>
+        auto next_to_if(I i, S s, std::true_type) -> CPP_ret(I)( //
+            requires input_iterator<I> && sentinel_for<S, I>)
+        {
+            return ranges::next(i, s);
+        }
+
+        template<typename I, typename S>
+        auto next_to_if(I, S s, std::false_type) -> CPP_ret(S)( //
+            requires input_iterator<I> && sentinel_for<S, I>)
+        {
+            return s;
+        }
+
+        template<bool B, typename I, typename S>
+        auto next_to_if(I i, S s) -> CPP_ret(meta::if_c<B, I, S>)( //
+            requires input_iterator<I> && sentinel_for<S, I>)
+        {
+            return detail::next_to_if(std::move(i), std::move(s), meta::bool_<B>{});
+        }
+
+        template<typename I1, typename S1, typename I2, typename S2, typename R,
+                 typename P>
+        subrange<I1> find_end_impl(I1 begin1, S1 end1, I2 begin2, S2 end2, R pred, P proj,
+                                   std::forward_iterator_tag, std::forward_iterator_tag)
+        {
+            bool found = false;
+            I1 res_begin, res_end;
+            if(begin2 == end2)
+            {
+                auto e1 = ranges::next(begin1, end1);
+                return {e1, e1};
+            }
+            while(true)
+            {
+                while(true)
+                {
+                    if(begin1 == end1)
+                        return {(found ? res_begin : begin1), (found ? res_end : begin1)};
+                    if(invoke(pred, invoke(proj, *begin1), *begin2))
+                        break;
+                    ++begin1;
+                }
+                auto tmp1 = begin1;
+                auto tmp2 = begin2;
+                while(true)
+                {
+                    if(++tmp2 == end2)
+                    {
+                        res_begin = begin1++;
+                        res_end = ++tmp1;
+                        found = true;
+                        break;
+                    }
+                    if(++tmp1 == end1)
+                        return {(found ? res_begin : tmp1), (found ? res_end : tmp1)};
+                    if(!invoke(pred, invoke(proj, *tmp1), *tmp2))
+                    {
+                        ++begin1;
+                        break;
+                    }
+                }
+            }
+        }
+
+        template<typename I1, typename I2, typename R, typename P>
+        subrange<I1> find_end_impl(I1 begin1, I1 end1, I2 begin2, I2 end2, R pred, P proj,
+                                   std::bidirectional_iterator_tag,
+                                   std::bidirectional_iterator_tag)
+        {
+            // modeled after search algorithm (in reverse)
+            if(begin2 == end2)
+                return {end1, end1}; // Everything matches an empty sequence
+            I1 l1 = end1;
+            I2 l2 = end2;
+            --l2;
+            while(true)
+            {
+                // Find end element in sequence 1 that matches *(end2-1), with a mininum
+                // of loop checks
+                do
+                    // return {end1,end1} if no element matches *begin2
+                    if(begin1 == l1)
+                        return {end1, end1};
+                while(!invoke(pred, invoke(proj, *--l1), *l2));
+                // *l1 matches *l2, now match elements before here
+                I1 m1 = l1;
+                I2 m2 = l2;
+                do
+                    // If pattern exhausted, {m1,++l1} is the answer
+                    // (works for 1 element pattern)
+                    if(m2 == begin2)
+                        return {m1, ++l1};
+                    // Otherwise if source exhausted, pattern not found
+                    else if(m1 == begin1)
+                        return {end1, end1};
+                // if there is a mismatch, restart with a new l1
+                // else there is a match, check next elements
+                while(invoke(pred, invoke(proj, *--m1), *--m2));
+            }
+        }
+
+        template<typename I1, typename I2, typename R, typename P>
+        subrange<I1> find_end_impl(I1 begin1, I1 end1, I2 begin2, I2 end2, R pred, P proj,
+                                   std::random_access_iterator_tag,
+                                   std::random_access_iterator_tag)
+        {
+            // Take advantage of knowing source and pattern lengths.  Stop short when
+            // source is smaller than pattern
+            auto len2 = end2 - begin2;
+            if(len2 == 0)
+                return {end1, end1};
+            auto len1 = end1 - begin1;
+            if(len1 < len2)
+                return {end1, end1};
+            I1 const start =
+                begin1 + (len2 - 1); // End of pattern match can't go before here
+            I1 l1 = end1;
+            I2 l2 = end2;
+            --l2;
+            while(true)
+            {
+                do
+                    if(start == l1)
+                        return {end1, end1};
+                while(!invoke(pred, invoke(proj, *--l1), *l2));
+                I1 m1 = l1;
+                I2 m2 = l2;
+                do
+                    if(m2 == begin2)
+                        return {m1, ++l1};
+                // no need to check range on m1 because s guarantees we have enough source
+                while(invoke(pred, invoke(proj, *--m1), *--m2));
+            }
+        }
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(find_end)
+
+        /// \brief function template \c find_end
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename R = equal_to,
+                 typename P = identity>
+        auto RANGES_FUNC(find_end)(
+            I1 begin1, S1 end1, I2 begin2, S2 end2, R pred = R{}, P proj = P{}) //
+            ->CPP_ret(subrange<I1>)(                                            //
+                requires forward_iterator<I1> && sentinel_for<S1, I1> &&
+                forward_iterator<I2> && sentinel_for<S2, I2> &&
+                indirect_relation<R, projected<I1, P>, I2>)
+        {
+            constexpr bool Bidi =
+                bidirectional_iterator<I1> && bidirectional_iterator<I2>;
+            return detail::find_end_impl(begin1,
+                                         detail::next_to_if<Bidi>(begin1, end1),
+                                         begin2,
+                                         detail::next_to_if<Bidi>(begin2, end2),
+                                         std::move(pred),
+                                         std::move(proj),
+                                         iterator_tag_of<I1>(),
+                                         iterator_tag_of<I2>());
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename R = equal_to,
+                 typename P = identity>
+        auto RANGES_FUNC(find_end)(
+            Rng1 && rng1, Rng2 && rng2, R pred = R{}, P proj = P{}) //
+            ->CPP_ret(safe_subrange_t<Rng1>)(                       //
+                requires forward_range<Rng1> && forward_range<Rng2> &&
+                indirect_relation<R, projected<iterator_t<Rng1>, P>, iterator_t<Rng2>>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(pred),
+                           std::move(proj));
+        }
+
+    RANGES_FUNC_END(find_end)
+
+    namespace cpp20
+    {
+        using ranges::find_end;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/find_first_of.hpp b/inst/include/range/v3/algorithm/find_first_of.hpp
new file mode 100644
index 0000000..d6576aa
--- /dev/null
+++ b/inst/include/range/v3/algorithm/find_first_of.hpp
@@ -0,0 +1,101 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 0.0. (See accompanying
+//  file LICENSE_0_0.txt or copy at
+//  http://www.boost.org/LICENSE_0_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FIND_FIRST_OF_HPP
+#define RANGES_V3_ALGORITHM_FIND_FIRST_OF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(find_first_of)
+        // Rationale: return I0 instead of pair<I0,I1> because find_first_of need
+        // not actually compute the end of [I1,S0); therefore, it is not necessarily
+        // losing information. E.g., if begin0 == end0, we can return begin0 immediately.
+        // If we returned pair<I0,I1>, we would need to do an O(N) scan to find the
+        // end position.
+
+        /// \brief function template \c find_first_of
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename S1,
+                 typename R = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        constexpr auto RANGES_FUNC(find_first_of)(I0 begin0,
+                                                  S0 end0,
+                                                  I1 begin1,
+                                                  S1 end1,
+                                                  R pred = R{},
+                                                  P0 proj0 = P0{},
+                                                  P1 proj1 = P1{}) //
+            ->CPP_ret(I0)(                                         //
+                requires input_iterator<I0> && sentinel_for<S0, I0> &&
+                forward_iterator<I1> && sentinel_for<S1, I1> &&
+                indirect_relation<R, projected<I0, P0>, projected<I1, P1>>)
+        {
+            for(; begin0 != end0; ++begin0)
+                for(auto tmp = begin1; tmp != end1; ++tmp)
+                    if(invoke(pred, invoke(proj0, *begin0), invoke(proj1, *tmp)))
+                        return begin0;
+            return begin0;
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename Rng1,
+                 typename R = equal_to,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        constexpr auto RANGES_FUNC(find_first_of)(
+            Rng0 && rng0, Rng1 && rng1, R pred = R{}, P0 proj0 = P0{}, P1 proj1 = P1{}) //
+            ->CPP_ret(safe_iterator_t<Rng0>)(                                           //
+                requires input_range<Rng0> && forward_range<Rng1> &&
+                indirect_relation<R,
+                                  projected<iterator_t<Rng0>, P0>,
+                                  projected<iterator_t<Rng1>, P1>>)
+        {
+            return (*this)(begin(rng0),
+                           end(rng0),
+                           begin(rng1),
+                           end(rng1),
+                           std::move(pred),
+                           std::move(proj0),
+                           std::move(proj1));
+        }
+
+    RANGES_FUNC_END(find_first_of)
+
+    namespace cpp20
+    {
+        using ranges::find_first_of;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/find_if.hpp b/inst/include/range/v3/algorithm/find_if.hpp
new file mode 100644
index 0000000..a71cbfd
--- /dev/null
+++ b/inst/include/range/v3/algorithm/find_if.hpp
@@ -0,0 +1,77 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FIND_IF_HPP
+#define RANGES_V3_ALGORITHM_FIND_IF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(find_if)
+        /// \brief template function \c find
+        ///
+        /// range-based version of the \c find std algorithm
+        ///
+        /// \pre `Rng` is a model of the `Range` concept
+        /// \pre `I` is a model of the `input_iterator` concept
+        /// \pre `S` is a model of the `sentinel_for<I>` concept
+        /// \pre `P` is a model of the `invocable<V>` concept, where `V` is the
+        ///      value type of I.
+        /// \pre `F` models `predicate<X>`, where `X` is the result type
+        ///      of `invocable<P, V>`
+        template<typename I, typename S, typename F, typename P = identity>
+        auto RANGES_FUNC(find_if)(I first, S last, F pred, P proj = P{}) //
+            ->CPP_ret(I)(                                                //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<F, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+                if(invoke(pred, invoke(proj, *first)))
+                    break;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename F, typename P = identity>
+        auto RANGES_FUNC(find_if)(Rng && rng, F pred, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(find_if)
+
+    namespace cpp20
+    {
+        using ranges::find_if;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/find_if_not.hpp b/inst/include/range/v3/algorithm/find_if_not.hpp
new file mode 100644
index 0000000..5f9fe11
--- /dev/null
+++ b/inst/include/range/v3/algorithm/find_if_not.hpp
@@ -0,0 +1,77 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FIND_IF_NOT_HPP
+#define RANGES_V3_ALGORITHM_FIND_IF_NOT_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(find_if_not)
+        /// \brief template function \c find_if_not
+        ///
+        /// range-based version of the \c find_if_not std algorithm
+        ///
+        /// \pre `Rng` is a model of the `Range` concept
+        /// \pre `I` is a model of the `input_iterator` concept
+        /// \pre `S` is a model of the `sentinel_for<I>` concept
+        /// \pre `P` is a model of the `invocable<V>` concept, where `V` is the
+        ///      value type of I.
+        /// \pre `F` models `predicate<X>`, where `X` is the result type
+        ///      of `invocable<P, V>`
+        template<typename I, typename S, typename F, typename P = identity>
+        auto RANGES_FUNC(find_if_not)(I first, S last, F pred, P proj = P{}) //
+            ->CPP_ret(I)(                                                    //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<F, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+                if(!invoke(pred, invoke(proj, *first)))
+                    break;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename F, typename P = identity>
+        auto RANGES_FUNC(find_if_not)(Rng && rng, F pred, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(find_if_not)
+
+    namespace cpp20
+    {
+        using ranges::find_if_not;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/for_each.hpp b/inst/include/range/v3/algorithm/for_each.hpp
new file mode 100644
index 0000000..f734455
--- /dev/null
+++ b/inst/include/range/v3/algorithm/for_each.hpp
@@ -0,0 +1,75 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FOR_EACH_HPP
+#define RANGES_V3_ALGORITHM_FOR_EACH_HPP
+
+#include <functional>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/reference_wrapper.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename F>
+    using for_each_result = detail::in_fun_result<I, F>;
+
+    RANGES_FUNC_BEGIN(for_each)
+
+        /// \brief function template \c for_each
+        template<typename I, typename S, typename F, typename P = identity>
+        auto RANGES_FUNC(for_each)(I first, S last, F fun, P proj = P{})
+            ->CPP_ret(for_each_result<I, F>)( //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirectly_unary_invocable<F, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+            {
+                invoke(fun, invoke(proj, *first));
+            }
+            return {detail::move(first), detail::move(fun)};
+        }
+
+        /// \overload
+        template<typename Rng, typename F, typename P = identity>
+        auto RANGES_FUNC(for_each)(Rng && rng, F fun, P proj = P{})
+            ->CPP_ret(for_each_result<safe_iterator_t<Rng>, F>)( //
+                requires input_range<Rng> &&
+                indirectly_unary_invocable<F, projected<iterator_t<Rng>, P>>)
+        {
+            return {(*this)(begin(rng), end(rng), ref(fun), detail::move(proj)).in,
+                    detail::move(fun)};
+        }
+
+    RANGES_FUNC_END(for_each)
+
+    namespace cpp20
+    {
+        using ranges::for_each;
+        using ranges::for_each_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/for_each_n.hpp b/inst/include/range/v3/algorithm/for_each_n.hpp
new file mode 100644
index 0000000..754c2cf
--- /dev/null
+++ b/inst/include/range/v3/algorithm/for_each_n.hpp
@@ -0,0 +1,77 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Rostislav Khlebnikov 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_FOR_EACH_N_HPP
+#define RANGES_V3_ALGORITHM_FOR_EACH_N_HPP
+
+#include <functional>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(for_each_n)
+
+        /// \brief function template \c for_each_n
+        template<typename I, typename F, typename P = identity>
+        auto RANGES_FUNC(for_each_n)(
+            I first, iter_difference_t<I> n, F fun, P proj = P{}) //
+            ->CPP_ret(I)(                                         //
+                requires input_iterator<I> &&
+                indirectly_unary_invocable<F, projected<I, P>>)
+        {
+            RANGES_EXPECT(0 <= n);
+            auto norig = n;
+            auto b = uncounted(first);
+            for(; 0 < n; ++b, --n)
+                invoke(fun, invoke(proj, *b));
+            return recounted(first, b, norig);
+        }
+
+        /// \overload
+        template<typename Rng, typename F, typename P = identity>
+        auto RANGES_FUNC(for_each_n)(
+            Rng && rng, range_difference_t<Rng> n, F fun, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires input_range<Rng> &&
+                indirectly_unary_invocable<F, projected<iterator_t<Rng>, P>>)
+        {
+            if(sized_range<Rng>)
+                RANGES_EXPECT(n <= distance(rng));
+
+            return (*this)(begin(rng), n, detail::move(fun), detail::move(proj));
+        }
+
+    RANGES_FUNC_END(for_each_n)
+
+    // Not yet!
+    //  namespace cpp20
+    // {
+    //     using ranges::for_each_n;
+    // }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/generate.hpp b/inst/include/range/v3/algorithm/generate.hpp
new file mode 100644
index 0000000..94103c5
--- /dev/null
+++ b/inst/include/range/v3/algorithm/generate.hpp
@@ -0,0 +1,70 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_GENERATE_HPP
+#define RANGES_V3_ALGORITHM_GENERATE_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/reference_wrapper.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename O, typename F>
+    using generate_result = detail::out_fun_result<O, F>;
+
+    RANGES_FUNC_BEGIN(generate)
+
+        /// \brief function template \c generate_n
+        template<typename O, typename S, typename F>
+        auto RANGES_FUNC(generate)(O first, S last, F fun) //
+            ->CPP_ret(generate_result<O, F>)(              //
+                requires invocable<F &> && output_iterator<O, invoke_result_t<F &>> &&
+                sentinel_for<S, O>)
+        {
+            for(; first != last; ++first)
+                *first = invoke(fun);
+            return {detail::move(first), detail::move(fun)};
+        }
+
+        /// \overload
+        template<typename Rng, typename F>
+        auto RANGES_FUNC(generate)(Rng && rng, F fun)
+            ->CPP_ret(generate_result<safe_iterator_t<Rng>, F>)( //
+                requires invocable<F &> && output_range<Rng, invoke_result_t<F &>>)
+        {
+            return {(*this)(begin(rng), end(rng), ref(fun)).out, detail::move(fun)};
+        }
+
+    RANGES_FUNC_END(generate)
+
+    namespace cpp20
+    {
+        using ranges::generate;
+        using ranges::generate_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/generate_n.hpp b/inst/include/range/v3/algorithm/generate_n.hpp
new file mode 100644
index 0000000..22a54aa
--- /dev/null
+++ b/inst/include/range/v3/algorithm/generate_n.hpp
@@ -0,0 +1,63 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_GENERATE_N_HPP
+#define RANGES_V3_ALGORITHM_GENERATE_N_HPP
+
+#include <tuple>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename O, typename F>
+    using generate_n_result = detail::out_fun_result<O, F>;
+
+    RANGES_FUNC_BEGIN(generate_n)
+
+        /// \brief function template \c generate_n
+        template<typename O, typename F>
+        auto RANGES_FUNC(generate_n)(O first, iter_difference_t<O> n, F fun)
+            ->CPP_ret(generate_n_result<O, F>)( //
+                requires invocable<F &> && output_iterator<O, invoke_result_t<F &>>)
+        {
+            RANGES_EXPECT(n >= 0);
+            auto norig = n;
+            auto b = uncounted(first);
+            for(; 0 != n; ++b, --n)
+                *b = invoke(fun);
+            return {recounted(first, b, norig), detail::move(fun)};
+        }
+
+    RANGES_FUNC_END(generate_n)
+
+    namespace cpp20
+    {
+        using ranges::generate_n;
+        using ranges::generate_n_result;
+    } // namespace cpp20
+    // @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/heap_algorithm.hpp b/inst/include/range/v3/algorithm/heap_algorithm.hpp
new file mode 100644
index 0000000..3e65c91
--- /dev/null
+++ b/inst/include/range/v3/algorithm/heap_algorithm.hpp
@@ -0,0 +1,428 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_HEAP_ALGORITHM_HPP
+#define RANGES_V3_ALGORITHM_HEAP_ALGORITHM_HPP
+
+#include <functional>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        struct is_heap_until_n_fn
+        {
+            template<typename I, typename C = less, typename P = identity>
+            auto operator()(I const begin_, iter_difference_t<I> const n_, C pred = C{},
+                            P proj = P{}) const -> CPP_ret(I)( //
+                requires random_access_iterator<I> &&
+                    indirect_strict_weak_order<C, projected<I, P>>)
+            {
+                RANGES_EXPECT(0 <= n_);
+                iter_difference_t<I> p = 0, c = 1;
+                I pp = begin_;
+                while(c < n_)
+                {
+                    I cp = begin_ + c;
+                    if(invoke(pred, invoke(proj, *pp), invoke(proj, *cp)))
+                        return cp;
+                    ++c;
+                    ++cp;
+                    if(c == n_ || invoke(pred, invoke(proj, *pp), invoke(proj, *cp)))
+                        return cp;
+                    ++p;
+                    ++pp;
+                    c = 2 * p + 1;
+                }
+                return begin_ + n_;
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(is_heap_until_n_fn, is_heap_until_n)
+
+        struct is_heap_n_fn
+        {
+            template<typename I, typename C = less, typename P = identity>
+            auto operator()(I first, iter_difference_t<I> n, C pred = C{},
+                            P proj = P{}) const -> CPP_ret(bool)( //
+                requires random_access_iterator<I> &&
+                    indirect_strict_weak_order<C, projected<I, P>>)
+            {
+                return is_heap_until_n(first, n, std::move(pred), std::move(proj)) ==
+                       first + n;
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(is_heap_n_fn, is_heap_n)
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(is_heap_until)
+
+        /// \brief function template \c is_heap_until
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(is_heap_until)(I first, S last, C pred = C{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires random_access_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, projected<I, P>>)
+        {
+            return detail::is_heap_until_n(std::move(first),
+                                           distance(first, last),
+                                           std::move(pred),
+                                           std::move(proj));
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(is_heap_until)(Rng && rng, C pred = C{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires random_access_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>)
+        {
+            return detail::is_heap_until_n(
+                begin(rng), distance(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(is_heap_until)
+
+    namespace cpp20
+    {
+        using ranges::is_heap_until;
+    }
+
+    RANGES_FUNC_BEGIN(is_heap)
+
+        /// \brief function template \c is_heap
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(is_heap)(I first, S last, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                                   //
+                requires random_access_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, projected<I, P>>)
+        {
+            return detail::is_heap_n(std::move(first),
+                                     distance(first, last),
+                                     std::move(pred),
+                                     std::move(proj));
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(is_heap)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                              //
+                requires random_access_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>)
+        {
+            return detail::is_heap_n(
+                begin(rng), distance(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(is_heap)
+
+    namespace cpp20
+    {
+        using ranges::is_heap;
+    }
+    /// @}
+
+    /// \cond
+    namespace detail
+    {
+        struct sift_up_n_fn
+        {
+            template<typename I, typename C = less, typename P = identity>
+            void operator()(I first, iter_difference_t<I> len, C pred = C{},
+                            P proj = P{}) const
+            {
+                if(len > 1)
+                {
+                    I last = first + len;
+                    len = (len - 2) / 2;
+                    I i = first + len;
+                    if(invoke(pred, invoke(proj, *i), invoke(proj, *--last)))
+                    {
+                        iter_value_t<I> v = iter_move(last);
+                        do
+                        {
+                            *last = iter_move(i);
+                            last = i;
+                            if(len == 0)
+                                break;
+                            len = (len - 1) / 2;
+                            i = first + len;
+                        } while(invoke(pred, invoke(proj, *i), invoke(proj, v)));
+                        *last = std::move(v);
+                    }
+                }
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(sift_up_n_fn, sift_up_n)
+
+        struct sift_down_n_fn
+        {
+            template<typename I, typename C = less, typename P = identity>
+            void operator()(I first, iter_difference_t<I> len, I start, C pred = C{},
+                            P proj = P{}) const
+            {
+                // left-child of start is at 2 * start + 1
+                // right-child of start is at 2 * start + 2
+                auto child = start - first;
+
+                if(len < 2 || (len - 2) / 2 < child)
+                    return;
+
+                child = 2 * child + 1;
+                I child_i = first + child;
+
+                if((child + 1) < len &&
+                   invoke(pred, invoke(proj, *child_i), invoke(proj, *(child_i + 1))))
+                {
+                    // right-child exists and is greater than left-child
+                    ++child_i;
+                    ++child;
+                }
+
+                // check if we are in heap-order
+                if(invoke(pred, invoke(proj, *child_i), invoke(proj, *start)))
+                    // we are, start is larger than it's largest child
+                    return;
+
+                iter_value_t<I> top = iter_move(start);
+                do
+                {
+                    // we are not in heap-order, swap the parent with it's largest child
+                    *start = iter_move(child_i);
+                    start = child_i;
+
+                    if((len - 2) / 2 < child)
+                        break;
+
+                    // recompute the child based off of the updated parent
+                    child = 2 * child + 1;
+                    child_i = first + child;
+
+                    if((child + 1) < len &&
+                       invoke(pred, invoke(proj, *child_i), invoke(proj, *(child_i + 1))))
+                    {
+                        // right-child exists and is greater than left-child
+                        ++child_i;
+                        ++child;
+                    }
+
+                    // check if we are in heap-order
+                } while(!invoke(pred, invoke(proj, *child_i), invoke(proj, top)));
+                *start = std::move(top);
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(sift_down_n_fn, sift_down_n)
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(push_heap)
+
+        /// \brief function template \c push_heap
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(push_heap)(I first, S last, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                                        //
+                requires random_access_iterator<I> && sentinel_for<S, I> &&
+                sortable<I, C, P>)
+        {
+            auto n = distance(first, last);
+            detail::sift_up_n(first, n, std::move(pred), std::move(proj));
+            return first + n;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(push_heap)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                //
+                requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+        {
+            iterator_t<Rng> first = ranges::begin(rng);
+            auto n = distance(rng);
+            detail::sift_up_n(first, n, std::move(pred), std::move(proj));
+            return first + n;
+        }
+
+    RANGES_FUNC_END(push_heap)
+
+    namespace cpp20
+    {
+        using ranges::push_heap;
+    }
+    /// @}
+
+    /// \cond
+    namespace detail
+    {
+        struct pop_heap_n_fn
+        {
+            template<typename I, typename C = less, typename P = identity>
+            auto operator()(I first, iter_difference_t<I> len, C pred = C{},
+                            P proj = P{}) const -> CPP_ret(void)( //
+                requires random_access_iterator<I> && sortable<I, C, P>)
+            {
+                if(len > 1)
+                {
+                    ranges::iter_swap(first, first + (len - 1));
+                    detail::sift_down_n(
+                        first, len - 1, first, std::move(pred), std::move(proj));
+                }
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(pop_heap_n_fn, pop_heap_n)
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(pop_heap)
+
+        /// \brief function template \c pop_heap
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(pop_heap)(I first, S last, C pred = C{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires random_access_iterator<I> && sentinel_for<S, I> &&
+                sortable<I, C, P>)
+        {
+            auto n = distance(first, last);
+            detail::pop_heap_n(first, n, std::move(pred), std::move(proj));
+            return first + n;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(pop_heap)(Rng && rng, C pred = C{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+        {
+            iterator_t<Rng> first = ranges::begin(rng);
+            auto n = distance(rng);
+            detail::pop_heap_n(first, n, std::move(pred), std::move(proj));
+            return first + n;
+        }
+
+    RANGES_FUNC_END(pop_heap)
+
+    namespace cpp20
+    {
+        using ranges::pop_heap;
+    }
+
+    RANGES_FUNC_BEGIN(make_heap)
+
+        /// \brief function template \c make_heap
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(make_heap)(I first, S last, C pred = C{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires random_access_iterator<I> && sentinel_for<S, I> &&
+                sortable<I, C, P>)
+        {
+            iter_difference_t<I> const n = distance(first, last);
+            if(n > 1)
+                // start from the first parent, there is no need to consider children
+                for(auto start = (n - 2) / 2; start >= 0; --start)
+                    detail::sift_down_n(
+                        first, n, first + start, std::ref(pred), std::ref(proj));
+            return first + n;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(make_heap)(Rng && rng, C pred = C{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+        {
+            iterator_t<Rng> first = ranges::begin(rng);
+            auto const n = distance(rng);
+            if(n > 1)
+                // start from the first parent, there is no need to consider children
+                for(auto start = (n - 2) / 2; start >= 0; --start)
+                    detail::sift_down_n(
+                        first, n, first + start, std::ref(pred), std::ref(proj));
+            return first + n;
+        }
+
+    RANGES_FUNC_END(make_heap)
+
+    namespace cpp20
+    {
+        using ranges::make_heap;
+    }
+
+    RANGES_FUNC_BEGIN(sort_heap)
+
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(sort_heap)(I first, S last, C pred = C{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires random_access_iterator<I> && sentinel_for<S, I> &&
+                sortable<I, C, P>)
+        {
+            iter_difference_t<I> const n = distance(first, last);
+            for(auto i = n; i > 1; --i)
+                detail::pop_heap_n(first, i, std::ref(pred), std::ref(proj));
+            return first + n;
+        }
+
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(sort_heap)(Rng && rng, C pred = C{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires random_access_range<Rng &> && sortable<iterator_t<Rng>, C, P>)
+        {
+            iterator_t<Rng> first = ranges::begin(rng);
+            auto const n = distance(rng);
+            for(auto i = n; i > 1; --i)
+                detail::pop_heap_n(first, i, std::ref(pred), std::ref(proj));
+            return first + n;
+        }
+
+    RANGES_FUNC_END(sort_heap)
+
+    namespace cpp20
+    {
+        using ranges::sort_heap;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/inplace_merge.hpp b/inst/include/range/v3/algorithm/inplace_merge.hpp
new file mode 100644
index 0000000..0ca6391
--- /dev/null
+++ b/inst/include/range/v3/algorithm/inplace_merge.hpp
@@ -0,0 +1,303 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_INPLACE_MERGE_HPP
+#define RANGES_V3_ALGORITHM_INPLACE_MERGE_HPP
+
+#include <functional>
+#include <memory>
+#include <new>
+#include <type_traits>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/lower_bound.hpp>
+#include <range/v3/algorithm/merge.hpp>
+#include <range/v3/algorithm/min.hpp>
+#include <range/v3/algorithm/move.hpp>
+#include <range/v3/algorithm/rotate.hpp>
+#include <range/v3/algorithm/upper_bound.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/not_fn.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/move_iterators.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/reverse_iterator.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/memory.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        struct merge_adaptive_fn
+        {
+        private:
+            template<typename I, typename C, typename P>
+            static void impl(I first, I middle, I last, iter_difference_t<I> len1,
+                             iter_difference_t<I> len2, iter_value_t<I> * const buf,
+                             C & pred, P & proj)
+            {
+                auto tmpbuf = make_raw_buffer(buf);
+                if(len1 <= len2)
+                {
+                    auto p = ranges::move(first, middle, tmpbuf.begin()).out;
+                    merge(make_move_iterator(buf),
+                          make_move_iterator(p.base().base()),
+                          make_move_iterator(std::move(middle)),
+                          make_move_iterator(std::move(last)),
+                          std::move(first),
+                          std::ref(pred),
+                          std::ref(proj),
+                          std::ref(proj));
+                }
+                else
+                {
+                    auto p = ranges::move(middle, last, tmpbuf.begin()).out;
+                    using RBi = ranges::reverse_iterator<I>;
+                    using Rv = ranges::reverse_iterator<iter_value_t<I> *>;
+                    merge(make_move_iterator(RBi{std::move(middle)}),
+                          make_move_iterator(RBi{std::move(first)}),
+                          make_move_iterator(Rv{p.base().base()}),
+                          make_move_iterator(Rv{buf}),
+                          RBi{std::move(last)},
+                          not_fn(std::ref(pred)),
+                          std::ref(proj),
+                          std::ref(proj));
+                }
+            }
+
+        public:
+            template<typename I, typename C = less, typename P = identity>
+            auto operator()(I first, I middle, I last, iter_difference_t<I> len1,
+                            iter_difference_t<I> len2, iter_value_t<I> * buf,
+                            std::ptrdiff_t buf_size, C pred = C{}, P proj = P{}) const
+                -> CPP_ret(void)( //
+                    requires bidirectional_iterator<I> && sortable<I, C, P>)
+            {
+                using D = iter_difference_t<I>;
+                while(true)
+                {
+                    // if middle == last, we're done
+                    if(len2 == 0)
+                        return;
+                    // shrink [first, middle) as much as possible (with no moves),
+                    // returning if it shrinks to 0
+                    for(; true; ++first, --len1)
+                    {
+                        if(len1 == 0)
+                            return;
+                        if(invoke(pred, invoke(proj, *middle), invoke(proj, *first)))
+                            break;
+                    }
+                    if(len1 <= buf_size || len2 <= buf_size)
+                    {
+                        merge_adaptive_fn::impl(std::move(first),
+                                                std::move(middle),
+                                                std::move(last),
+                                                len1,
+                                                len2,
+                                                buf,
+                                                pred,
+                                                proj);
+                        return;
+                    }
+                    // first < middle < end
+                    // *first > *middle
+                    // partition [first, m1) [m1, middle) [middle, m2) [m2, last) such
+                    // that
+                    //     all elements in:
+                    //         [first, m1)  <= [middle, m2)
+                    //         [middle, m2) <  [m1, middle)
+                    //         [m1, middle) <= [m2, last)
+                    //     and m1 or m2 is in the middle of its range
+                    I m1;    // "median" of [first, middle)
+                    I m2;    // "median" of [middle, last)
+                    D len11; // distance(first, m1)
+                    D len21; // distance(middle, m2)
+                    // binary search smaller range
+                    if(len1 < len2)
+                    { // len >= 1, len2 >= 2
+                        len21 = len2 / 2;
+                        m2 = next(middle, len21);
+                        m1 = upper_bound(first,
+                                         middle,
+                                         invoke(proj, *m2),
+                                         std::ref(pred),
+                                         std::ref(proj));
+                        len11 = distance(first, m1);
+                    }
+                    else
+                    {
+                        if(len1 == 1)
+                        { // len1 >= len2 && len2 > 0, therefore len2 == 1
+                            // It is known *first > *middle
+                            ranges::iter_swap(first, middle);
+                            return;
+                        }
+                        // len1 >= 2, len2 >= 1
+                        len11 = len1 / 2;
+                        m1 = next(first, len11);
+                        m2 = lower_bound(middle,
+                                         last,
+                                         invoke(proj, *m1),
+                                         std::ref(pred),
+                                         std::ref(proj));
+                        len21 = distance(middle, m2);
+                    }
+                    D len12 = len1 - len11; // distance(m1, middle)
+                    D len22 = len2 - len21; // distance(m2, last)
+                    // [first, m1) [m1, middle) [middle, m2) [m2, last)
+                    // swap middle two partitions
+                    middle = rotate(m1, std::move(middle), m2).begin();
+                    // len12 and len21 now have swapped meanings
+                    // merge smaller range with recursive call and larger with tail
+                    // recursion elimination
+                    if(len11 + len21 < len12 + len22)
+                    {
+                        (*this)(std::move(first),
+                                std::move(m1),
+                                middle,
+                                len11,
+                                len21,
+                                buf,
+                                buf_size,
+                                std::ref(pred),
+                                std::ref(proj));
+                        first = std::move(middle);
+                        middle = std::move(m2);
+                        len1 = len12;
+                        len2 = len22;
+                    }
+                    else
+                    {
+                        (*this)(middle,
+                                std::move(m2),
+                                std::move(last),
+                                len12,
+                                len22,
+                                buf,
+                                buf_size,
+                                std::ref(pred),
+                                std::ref(proj));
+                        last = std::move(middle);
+                        middle = std::move(m1);
+                        len1 = len11;
+                        len2 = len21;
+                    }
+                }
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(merge_adaptive_fn, merge_adaptive)
+
+        struct inplace_merge_no_buffer_fn
+        {
+            template<typename I, typename C = less, typename P = identity>
+            auto operator()(I first, I middle, I last, iter_difference_t<I> len1,
+                            iter_difference_t<I> len2, C pred = C{}, P proj = P{}) const
+                -> CPP_ret(void)( //
+                    requires bidirectional_iterator<I> && sortable<I, C, P>)
+            {
+                merge_adaptive(std::move(first),
+                               std::move(middle),
+                               std::move(last),
+                               len1,
+                               len2,
+                               static_cast<iter_value_t<I> *>(nullptr),
+                               0,
+                               std::move(pred),
+                               std::move(proj));
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(inplace_merge_no_buffer_fn, inplace_merge_no_buffer)
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(inplace_merge)
+
+        // TODO reimplement to only need forward iterators
+
+        /// \brief function template \c inplace_merge
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(inplace_merge)(
+            I first, I middle, S last, C pred = C{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires bidirectional_iterator<I> && sortable<I, C, P>)
+        {
+            using value_type = iter_value_t<I>;
+            auto len1 = distance(first, middle);
+            auto len2_and_end = enumerate(middle, last);
+            auto buf_size = ranges::min(len1, len2_and_end.first);
+            std::pair<value_type *, std::ptrdiff_t> buf{nullptr, 0};
+            std::unique_ptr<value_type, detail::return_temporary_buffer> h;
+            if(detail::is_trivially_copy_assignable<value_type>::value && 8 < buf_size)
+            {
+                buf = detail::get_temporary_buffer<value_type>(buf_size);
+                h.reset(buf.first);
+            }
+            detail::merge_adaptive(std::move(first),
+                                   std::move(middle),
+                                   len2_and_end.second,
+                                   len1,
+                                   len2_and_end.first,
+                                   buf.first,
+                                   buf.second,
+                                   std::move(pred),
+                                   std::move(proj));
+            return len2_and_end.second;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(inplace_merge)(
+            Rng && rng, iterator_t<Rng> middle, C pred = C{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires bidirectional_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+        {
+            return (*this)(begin(rng),
+                           std::move(middle),
+                           end(rng),
+                           std::move(pred),
+                           std::move(proj));
+        }
+
+    RANGES_FUNC_END(inplace_merge)
+
+    namespace cpp20
+    {
+        using ranges::inplace_merge;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/is_partitioned.hpp b/inst/include/range/v3/algorithm/is_partitioned.hpp
new file mode 100644
index 0000000..01a851e
--- /dev/null
+++ b/inst/include/range/v3/algorithm/is_partitioned.hpp
@@ -0,0 +1,78 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===-------------------------- algorithm ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_IS_PARTITIONED_HPP
+#define RANGES_V3_ALGORITHM_IS_PARTITIONED_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(is_partitioned)
+
+        /// \brief function template \c is_partitioned
+        template<typename I, typename S, typename C, typename P = identity>
+        auto RANGES_FUNC(is_partitioned)(I first, S last, C pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                                    //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<C, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+                if(!invoke(pred, invoke(proj, *first)))
+                    break;
+            for(; first != last; ++first)
+                if(invoke(pred, invoke(proj, *first)))
+                    return false;
+            return true;
+        }
+
+        /// \overload
+        template<typename Rng, typename C, typename P = identity>
+        auto RANGES_FUNC(is_partitioned)(Rng && rng, C pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                               //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(is_partitioned)
+
+    namespace cpp20
+    {
+        using ranges::is_partitioned;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/is_sorted.hpp b/inst/include/range/v3/algorithm/is_sorted.hpp
new file mode 100644
index 0000000..e50cf7b
--- /dev/null
+++ b/inst/include/range/v3/algorithm/is_sorted.hpp
@@ -0,0 +1,75 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Implementation based on the code in libc++
+//   http://http://libcxx.llvm.org/
+#ifndef RANGES_V3_ALGORITHM_IS_SORTED_HPP
+#define RANGES_V3_ALGORITHM_IS_SORTED_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/is_sorted_until.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(is_sorted)
+        /// \brief template function \c is_sorted
+        ///
+        /// range-based version of the \c is_sorted std algorithm
+        ///
+        /// Works on forward_ranges
+        ///
+        /// \pre `Rng` is a model of the `forward_range` concept
+        /// \pre `I` is a model of the `forward_iterator` concept
+        /// \pre `S` and `I` model the `sentinel_for<S, I>` concept
+        /// \pre `R` and `projected<I, P>` model the `indirect_strict_weak_order<R,
+        /// projected<I, P>>` concept
+        ///
+        template<typename I, typename S, typename R = less, typename P = identity>
+        auto RANGES_FUNC(is_sorted)(I first, S last, R rel = R{}, P proj = P{})
+            ->CPP_ret(bool)( //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<R, projected<I, P>>)
+        {
+            return is_sorted_until(
+                       std::move(first), last, std::move(rel), std::move(proj)) == last;
+        }
+
+        /// \overload
+        template<typename Rng, typename R = less, typename P = identity>
+        auto RANGES_FUNC(is_sorted)(Rng && rng, R rel = R{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                               //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<R, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(rel), std::move(proj));
+        }
+
+    RANGES_FUNC_END(is_sorted)
+
+    namespace cpp20
+    {
+        using ranges::is_sorted;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/is_sorted_until.hpp b/inst/include/range/v3/algorithm/is_sorted_until.hpp
new file mode 100644
index 0000000..1fc4d68
--- /dev/null
+++ b/inst/include/range/v3/algorithm/is_sorted_until.hpp
@@ -0,0 +1,86 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Implementation based on the code in libc++
+//   http://http://libcxx.llvm.org/
+#ifndef RANGES_V3_ALGORITHM_IS_SORTED_UNTIL_HPP
+#define RANGES_V3_ALGORITHM_IS_SORTED_UNTIL_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(is_sorted_until)
+        /// \brief template function \c is_sorted_until
+        ///
+        /// range-based version of the \c is_sorted_until std algorithm
+        ///
+        /// Works on forward_ranges
+        ///
+        /// \pre `Rng` is a model of the `forward_range` concept
+        /// \pre `I` is a model of the `forward_iterator` concept
+        /// \pre `S` and `I` model the `sentinel_for<S, I>` concept
+        /// \pre `R` and `projected<I, P>` model the `indirect_strict_weak_order<R,
+        /// projected<I, P>>` concept
+        ///
+        template<typename I, typename S, typename R = less, typename P = identity>
+        auto RANGES_FUNC(is_sorted_until)(I first, S last, R pred = R{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<R, projected<I, P>>)
+        {
+            auto i = first;
+            if(first != last)
+            {
+                while(++i != last)
+                {
+                    if(invoke(pred, invoke(proj, *i), invoke(proj, *first)))
+                        return i;
+                    first = i;
+                }
+            }
+            return i;
+        }
+
+        /// \overload
+        template<typename Rng, typename R = less, typename P = identity>
+        auto RANGES_FUNC(is_sorted_until)(Rng && rng, R pred = R{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<R, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(is_sorted_until)
+
+    namespace cpp20
+    {
+        using ranges::is_sorted_until;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/lexicographical_compare.hpp b/inst/include/range/v3/algorithm/lexicographical_compare.hpp
new file mode 100644
index 0000000..3c4e3e3
--- /dev/null
+++ b/inst/include/range/v3/algorithm/lexicographical_compare.hpp
@@ -0,0 +1,97 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_LEXICOGRAPHICAL_COMPARE_HPP
+#define RANGES_V3_ALGORITHM_LEXICOGRAPHICAL_COMPARE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(lexicographical_compare)
+
+        /// \brief function template \c lexicographical_compare
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename S1,
+                 typename C = less,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        auto RANGES_FUNC(lexicographical_compare)(I0 begin0,
+                                                  S0 end0,
+                                                  I1 begin1,
+                                                  S1 end1,
+                                                  C pred = C{},
+                                                  P0 proj0 = P0{},
+                                                  P1 proj1 = P1{})
+            ->CPP_ret(bool)( //
+                requires input_iterator<I0> && sentinel_for<S0, I0> &&
+                input_iterator<I1> && sentinel_for<S1, I1> &&
+                indirect_strict_weak_order<C, projected<I0, P0>, projected<I1, P1>>)
+        {
+            for(; begin1 != end1; ++begin0, ++begin1)
+            {
+                if(begin0 == end0 ||
+                   invoke(pred, invoke(proj0, *begin0), invoke(proj1, *begin1)))
+                    return true;
+                if(invoke(pred, invoke(proj1, *begin1), invoke(proj0, *begin0)))
+                    return false;
+            }
+            return false;
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename Rng1,
+                 typename C = less,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        auto RANGES_FUNC(lexicographical_compare)(
+            Rng0 && rng0, Rng1 && rng1, C pred = C{}, P0 proj0 = P0{}, P1 proj1 = P1{}) //
+            ->CPP_ret(bool)(                                                            //
+                requires input_range<Rng0> && input_range<Rng1> &&
+                indirect_strict_weak_order<C,
+                                           projected<iterator_t<Rng0>, P0>,
+                                           projected<iterator_t<Rng1>, P1>>)
+        {
+            return (*this)(begin(rng0),
+                           end(rng0),
+                           begin(rng1),
+                           end(rng1),
+                           std::move(pred),
+                           std::move(proj0),
+                           std::move(proj1));
+        }
+
+    RANGES_FUNC_END(lexicographical_compare)
+
+    namespace cpp20
+    {
+        using ranges::lexicographical_compare;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/lower_bound.hpp b/inst/include/range/v3/algorithm/lower_bound.hpp
new file mode 100644
index 0000000..ed56faf
--- /dev/null
+++ b/inst/include/range/v3/algorithm/lower_bound.hpp
@@ -0,0 +1,76 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_LOWER_BOUND_HPP
+#define RANGES_V3_ALGORITHM_LOWER_BOUND_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/lower_bound_n.hpp>
+#include <range/v3/algorithm/partition_point.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(lower_bound)
+
+        /// \brief function template \c lower_bound
+        template<typename I,
+                 typename S,
+                 typename V,
+                 typename C = less,
+                 typename P = identity>
+        auto RANGES_FUNC(lower_bound)(
+            I first, S last, V const & val, C pred = C{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, V const *, projected<I, P>>)
+        {
+            return partition_point(std::move(first),
+                                   std::move(last),
+                                   detail::make_lower_bound_predicate(pred, val),
+                                   std::move(proj));
+        }
+
+        /// \overload
+        template<typename Rng, typename V, typename C = less, typename P = identity>
+        auto RANGES_FUNC(lower_bound)(
+            Rng && rng, V const & val, C pred = C{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>)
+        {
+            return partition_point(
+                rng, detail::make_lower_bound_predicate(pred, val), std::move(proj));
+        }
+
+    RANGES_FUNC_END(lower_bound)
+
+    namespace cpp20
+    {
+        using ranges::lower_bound;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/max.hpp b/inst/include/range/v3/algorithm/max.hpp
new file mode 100644
index 0000000..db63b59
--- /dev/null
+++ b/inst/include/range/v3/algorithm/max.hpp
@@ -0,0 +1,88 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2015
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MAX_HPP
+#define RANGES_V3_ALGORITHM_MAX_HPP
+
+#include <initializer_list>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(max)
+
+        /// \brief function template \c max
+        template<typename T, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(max)(
+            T const & a, T const & b, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(T const &)(                                 //
+                requires indirect_strict_weak_order<C, projected<T const *, P>>)
+        {
+            return invoke(pred, invoke(proj, b), invoke(proj, a)) ? a : b;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(max)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(range_value_t<Rng>)(                                      //
+                requires input_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> &&
+                indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>)
+        {
+            auto first = ranges::begin(rng);
+            auto last = ranges::end(rng);
+            RANGES_EXPECT(first != last);
+            range_value_t<Rng> result = *first;
+            while(++first != last)
+            {
+                auto && tmp = *first;
+                if(invoke(pred, invoke(proj, result), invoke(proj, tmp)))
+                    result = (decltype(tmp) &&)tmp;
+            }
+            return result;
+        }
+
+        /// \overload
+        template<typename T, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(max)(
+            std::initializer_list<T> const && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(T)(                                                      //
+                requires copyable<T> &&
+                indirect_strict_weak_order<C, projected<T const *, P>>)
+        {
+            return (*this)(rng, std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(max)
+
+    namespace cpp20
+    {
+        using ranges::max;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/max_element.hpp b/inst/include/range/v3/algorithm/max_element.hpp
new file mode 100644
index 0000000..23fea4b
--- /dev/null
+++ b/inst/include/range/v3/algorithm/max_element.hpp
@@ -0,0 +1,69 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MAX_ELEMENT_HPP
+#define RANGES_V3_ALGORITHM_MAX_ELEMENT_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(max_element)
+
+        /// \brief function template \c max_element
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(max_element)(I first, S last, C pred = C{}, P proj = P{})
+            ->CPP_ret(I)( //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, projected<I, P>>)
+        {
+            if(first != last)
+                for(auto tmp = next(first); tmp != last; ++tmp)
+                    if(invoke(pred, invoke(proj, *first), invoke(proj, *tmp)))
+                        first = tmp;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(max_element)(Rng && rng, C pred = C{}, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(max_element)
+
+    namespace cpp20
+    {
+        using ranges::max_element;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/merge.hpp b/inst/include/range/v3/algorithm/merge.hpp
new file mode 100644
index 0000000..5f4aea0
--- /dev/null
+++ b/inst/include/range/v3/algorithm/merge.hpp
@@ -0,0 +1,133 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Copyright (c) 2009 Alexander Stepanov and Paul McJones
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without
+// fee, provided that the above copyright notice appear in all copies
+// and that both that copyright notice and this permission notice
+// appear in supporting documentation. The authors make no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+//
+// Algorithms from
+// Elements of Programming
+// by Alexander Stepanov and Paul McJones
+// Addison-Wesley Professional, 2009
+
+#ifndef RANGES_V3_ALGORITHM_MERGE_HPP
+#define RANGES_V3_ALGORITHM_MERGE_HPP
+
+#include <tuple>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/copy.hpp>
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I0, typename I1, typename O>
+    using merge_result = detail::in1_in2_out_result<I0, I1, O>;
+
+    RANGES_FUNC_BEGIN(merge)
+
+        /// \brief function template \c merge
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename S1,
+                 typename O,
+                 typename C = less,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        auto RANGES_FUNC(merge)(I0 begin0,
+                                S0 end0,
+                                I1 begin1,
+                                S1 end1,
+                                O out,
+                                C pred = C{},
+                                P0 proj0 = P0{},
+                                P1 proj1 = P1{}) //
+            ->CPP_ret(merge_result<I0, I1, O>)(  //
+                requires sentinel_for<S0, I0> && sentinel_for<S1, I1> &&
+                mergeable<I0, I1, O, C, P0, P1>)
+        {
+            for(; begin0 != end0 && begin1 != end1; ++out)
+            {
+                if(invoke(pred, invoke(proj1, *begin1), invoke(proj0, *begin0)))
+                {
+                    *out = *begin1;
+                    ++begin1;
+                }
+                else
+                {
+                    *out = *begin0;
+                    ++begin0;
+                }
+            }
+            auto t0 = ranges::copy(begin0, end0, out);
+            auto t1 = ranges::copy(begin1, end1, t0.out);
+            return {t0.in, t1.in, t1.out};
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename Rng1,
+                 typename O,
+                 typename C = less,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        auto RANGES_FUNC(merge)(Rng0 && rng0,
+                                Rng1 && rng1,
+                                O out,
+                                C pred = C{},
+                                P0 proj0 = P0{},
+                                P1 proj1 = P1{})
+            ->CPP_ret(merge_result<safe_iterator_t<Rng0>, safe_iterator_t<Rng1>, O>)( //
+                requires range<Rng0> && range<Rng1> &&
+                mergeable<iterator_t<Rng0>, iterator_t<Rng1>, O, C, P0, P1>)
+        {
+            return (*this)(begin(rng0),
+                           end(rng0),
+                           begin(rng1),
+                           end(rng1),
+                           std::move(out),
+                           std::move(pred),
+                           std::move(proj0),
+                           std::move(proj1));
+        }
+
+    RANGES_FUNC_END(merge)
+
+    namespace cpp20
+    {
+        using ranges::merge;
+        using ranges::merge_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/min.hpp b/inst/include/range/v3/algorithm/min.hpp
new file mode 100644
index 0000000..3a314ea
--- /dev/null
+++ b/inst/include/range/v3/algorithm/min.hpp
@@ -0,0 +1,88 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2015
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MIN_HPP
+#define RANGES_V3_ALGORITHM_MIN_HPP
+
+#include <initializer_list>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(min)
+
+        /// \brief function template \c min
+        template<typename T, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(min)(
+            T const & a, T const & b, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(T const &)(                                 //
+                requires indirect_strict_weak_order<C, projected<T const *, P>>)
+        {
+            return invoke(pred, invoke(proj, b), invoke(proj, a)) ? b : a;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(min)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(range_value_t<Rng>)(                                      //
+                requires input_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> &&
+                indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>)
+        {
+            auto first = ranges::begin(rng);
+            auto last = ranges::end(rng);
+            RANGES_EXPECT(first != last);
+            range_value_t<Rng> result = *first;
+            while(++first != last)
+            {
+                auto && tmp = *first;
+                if(invoke(pred, invoke(proj, tmp), invoke(proj, result)))
+                    result = (decltype(tmp) &&)tmp;
+            }
+            return result;
+        }
+
+        /// \overload
+        template<typename T, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(min)(
+            std::initializer_list<T> const && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(T)(                                                      //
+                requires copyable<T> &&
+                indirect_strict_weak_order<C, projected<T const *, P>>)
+        {
+            return (*this)(rng, std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(min)
+
+    namespace cpp20
+    {
+        using ranges::min;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/min_element.hpp b/inst/include/range/v3/algorithm/min_element.hpp
new file mode 100644
index 0000000..c5379f7
--- /dev/null
+++ b/inst/include/range/v3/algorithm/min_element.hpp
@@ -0,0 +1,69 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MIN_ELEMENT_HPP
+#define RANGES_V3_ALGORITHM_MIN_ELEMENT_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(min_element)
+
+        /// \brief function template \c min_element
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(min_element)(I first, S last, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                                          //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, projected<I, P>>)
+        {
+            if(first != last)
+                for(auto tmp = next(first); tmp != last; ++tmp)
+                    if(invoke(pred, invoke(proj, *tmp), invoke(proj, *first)))
+                        first = tmp;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(min_element)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                  //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(min_element)
+
+    namespace cpp20
+    {
+        using ranges::min_element;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/minmax.hpp b/inst/include/range/v3/algorithm/minmax.hpp
new file mode 100644
index 0000000..c167ba0
--- /dev/null
+++ b/inst/include/range/v3/algorithm/minmax.hpp
@@ -0,0 +1,128 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2015
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MINMAX_HPP
+#define RANGES_V3_ALGORITHM_MINMAX_HPP
+
+#include <initializer_list>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename T>
+    using minmax_result = detail::min_max_result<T, T>;
+
+    RANGES_FUNC_BEGIN(minmax)
+
+        /// \brief function template \c minmax
+        template<typename T, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(minmax)(
+            T const & a, T const & b, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(minmax_result<T const &>)(                  //
+                requires indirect_strict_weak_order<C, projected<T const *, P>>)
+        {
+            using R = minmax_result<T const &>;
+            return invoke(pred, invoke(proj, b), invoke(proj, a)) ? R{b, a} : R{a, b};
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(minmax)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(minmax_result<range_value_t<Rng>>)(                          //
+                requires input_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> &&
+                indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>)
+        {
+            using R = minmax_result<range_value_t<Rng>>;
+            auto first = ranges::begin(rng);
+            auto last = ranges::end(rng);
+            RANGES_EXPECT(first != last);
+            auto result = R{*first, *first};
+            if(++first != last)
+            {
+                {
+                    auto && tmp = *first;
+                    if(invoke(pred, invoke(proj, tmp), invoke(proj, result.min)))
+                        result.min = (decltype(tmp) &&)tmp;
+                    else
+                        result.max = (decltype(tmp) &&)tmp;
+                }
+                while(++first != last)
+                {
+                    range_value_t<Rng> tmp1 = *first;
+                    if(++first == last)
+                    {
+                        if(invoke(pred, invoke(proj, tmp1), invoke(proj, result.min)))
+                            result.min = std::move(tmp1);
+                        else if(!invoke(
+                                    pred, invoke(proj, tmp1), invoke(proj, result.max)))
+                            result.max = std::move(tmp1);
+                        break;
+                    }
+
+                    auto && tmp2 = *first;
+                    if(invoke(pred, invoke(proj, tmp2), invoke(proj, tmp1)))
+                    {
+                        if(invoke(pred, invoke(proj, tmp2), invoke(proj, result.min)))
+                            result.min = (decltype(tmp2) &&)tmp2;
+                        if(!invoke(pred, invoke(proj, tmp1), invoke(proj, result.max)))
+                            result.max = std::move(tmp1);
+                    }
+                    else
+                    {
+                        if(invoke(pred, invoke(proj, tmp1), invoke(proj, result.min)))
+                            result.min = std::move(tmp1);
+                        if(!invoke(pred, invoke(proj, tmp2), invoke(proj, result.max)))
+                            result.max = (decltype(tmp2) &&)tmp2;
+                    }
+                }
+            }
+            return result;
+        }
+
+        /// \overload
+        template<typename T, typename C = less, typename P = identity>
+        constexpr auto RANGES_FUNC(minmax)(
+            std::initializer_list<T> const && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(minmax_result<T>)(                                       //
+                requires copyable<T> &&
+                indirect_strict_weak_order<C, projected<T const *, P>>)
+        {
+            return (*this)(rng, std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(minmax)
+
+    namespace cpp20
+    {
+        using ranges::minmax;
+        using ranges::minmax_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/minmax_element.hpp b/inst/include/range/v3/algorithm/minmax_element.hpp
new file mode 100644
index 0000000..b603544
--- /dev/null
+++ b/inst/include/range/v3/algorithm/minmax_element.hpp
@@ -0,0 +1,108 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Implementation based on the code in libc++
+//   http://http://libcxx.llvm.org/
+
+#ifndef RANGES_V3_ALGORITHM_MINMAX_ELEMENT_HPP
+#define RANGES_V3_ALGORITHM_MINMAX_ELEMENT_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I>
+    using minmax_element_result = detail::min_max_result<I, I>;
+
+    RANGES_FUNC_BEGIN(minmax_element)
+
+        /// \brief function template \c minmax_element
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(minmax_element)(I first, S last, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(minmax_element_result<I>)(                                      //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, projected<I, P>>)
+        {
+            minmax_element_result<I> result{first, first};
+            if(first == last || ++first == last)
+                return result;
+            if(invoke(pred, invoke(proj, *first), invoke(proj, *result.min)))
+                result.min = first;
+            else
+                result.max = first;
+            while(++first != last)
+            {
+                I tmp = first;
+                if(++first == last)
+                {
+                    if(invoke(pred, invoke(proj, *tmp), invoke(proj, *result.min)))
+                        result.min = tmp;
+                    else if(!invoke(pred, invoke(proj, *tmp), invoke(proj, *result.max)))
+                        result.max = tmp;
+                    break;
+                }
+                else
+                {
+                    if(invoke(pred, invoke(proj, *first), invoke(proj, *tmp)))
+                    {
+                        if(invoke(pred, invoke(proj, *first), invoke(proj, *result.min)))
+                            result.min = first;
+                        if(!invoke(pred, invoke(proj, *tmp), invoke(proj, *result.max)))
+                            result.max = tmp;
+                    }
+                    else
+                    {
+                        if(invoke(pred, invoke(proj, *tmp), invoke(proj, *result.min)))
+                            result.min = tmp;
+                        if(!invoke(pred, invoke(proj, *first), invoke(proj, *result.max)))
+                            result.max = first;
+                    }
+                }
+            }
+            return result;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(minmax_element)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(minmax_element_result<safe_iterator_t<Rng>>)(              //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(minmax_element)
+
+    namespace cpp20
+    {
+        using ranges::minmax_element;
+        using ranges::minmax_element_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/mismatch.hpp b/inst/include/range/v3/algorithm/mismatch.hpp
new file mode 100644
index 0000000..aec9dc9
--- /dev/null
+++ b/inst/include/range/v3/algorithm/mismatch.hpp
@@ -0,0 +1,170 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MISMATCH_HPP
+#define RANGES_V3_ALGORITHM_MISMATCH_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I1, typename I2>
+    using mismatch_result = detail::in1_in2_result<I1, I2>;
+
+    RANGES_FUNC_BEGIN(mismatch)
+
+        /// \brief function template \c mismatch
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::mismatch that takes an upper bound for "
+            "both sequences")
+        auto RANGES_FUNC(mismatch)(I1 begin1,
+                                   S1 end1,
+                                   I2 begin2,
+                                   C pred = C{},
+                                   P1 proj1 = P1{},
+                                   P2 proj2 = P2{}) //
+            ->CPP_ret(mismatch_result<I1, I2>)(     //
+                requires input_iterator<I1> && sentinel_for<S1, I1> &&
+                input_iterator<I2> &&
+                indirect_relation<C, projected<I1, P1>, projected<I2, P2>>)
+        {
+            for(; begin1 != end1; ++begin1, ++begin2)
+                if(!invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                    break;
+            return {begin1, begin2};
+        }
+
+        /// \overload
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(mismatch)(I1 begin1,
+                                   S1 end1,
+                                   I2 begin2,
+                                   S2 end2,
+                                   C pred = C{},
+                                   P1 proj1 = P1{},
+                                   P2 proj2 = P2{}) //
+            ->CPP_ret(mismatch_result<I1, I2>)(     //
+                requires input_iterator<I1> && sentinel_for<S1, I1> &&
+                input_iterator<I2> && sentinel_for<S2, I2> &&
+                indirect_relation<C, projected<I1, P1>, projected<I2, P2>>)
+        {
+            for(; begin1 != end1 && begin2 != end2; ++begin1, ++begin2)
+                if(!invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                    break;
+            return {begin1, begin2};
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename I2Ref,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::mismatch that takes an upper bound for "
+            "both sequences")
+        auto RANGES_FUNC(mismatch)(Rng1 && rng1,
+                                   I2Ref && begin2,
+                                   C pred = C{}, // see below [*]
+                                   P1 proj1 = P1{},
+                                   P2 proj2 = P2{})                              //
+            ->CPP_ret(mismatch_result<safe_iterator_t<Rng1>, uncvref_t<I2Ref>>)( //
+                requires input_range<Rng1> && input_iterator<uncvref_t<I2Ref>> &&
+                indirect_relation<C,
+                                  projected<iterator_t<Rng1>, P1>,
+                                  projected<uncvref_t<I2Ref>, P2>>)
+        {
+            RANGES_DIAGNOSTIC_PUSH
+            RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           static_cast<uncvref_t<I2Ref> &&>(begin2),
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+            RANGES_DIAGNOSTIC_POP
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(mismatch)(
+            Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{}, P2 proj2 = P2{}) //
+            ->CPP_ret(mismatch_result<safe_iterator_t<Rng1>, safe_iterator_t<Rng2>>)(   //
+                requires input_range<Rng1> && input_range<Rng2> &&
+                indirect_relation<C,
+                                  projected<iterator_t<Rng1>, P1>,
+                                  projected<iterator_t<Rng2>, P2>>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+    RANGES_FUNC_END(mismatch)
+
+    namespace cpp20
+    {
+        using ranges::mismatch;
+        using ranges::mismatch_result;
+    } // namespace cpp20
+
+    // [*] In this case, the 'begin2' iterator is taken by universal reference. Why? So
+    // that we can properly distinguish this case:
+    //   int x[] = {1,2,3,4};
+    //   int y[] = {1,2,3,4};
+    //   mismatch(x, y);
+    // Had 'begin2' been taken by value as is customary, this call could match as either
+    // two ranges, or a range and an iterator, where the iterator is the array, decayed
+    // to a pointer. Yuk!
+
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/move.hpp b/inst/include/range/v3/algorithm/move.hpp
new file mode 100644
index 0000000..81f8ae2
--- /dev/null
+++ b/inst/include/range/v3/algorithm/move.hpp
@@ -0,0 +1,85 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MOVE_HPP
+#define RANGES_V3_ALGORITHM_MOVE_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using move_result = detail::in_out_result<I, O>;
+
+    RANGES_HIDDEN_DETAIL(namespace _move CPP_PP_LBRACE())
+    RANGES_FUNC_BEGIN(move)
+
+        /// \brief function template \c move
+        template<typename I, typename S, typename O>
+        auto RANGES_FUNC(move)(I first, S last, O out) //
+            ->CPP_ret(move_result<I, O>)(              //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && indirectly_movable<I, O>)
+        {
+            for(; first != last; ++first, ++out)
+                *out = iter_move(first);
+            return {first, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O>
+        auto RANGES_FUNC(move)(Rng && rng, O out)            //
+            ->CPP_ret(move_result<safe_iterator_t<Rng>, O>)( //
+                requires input_range<Rng> && weakly_incrementable<O> &&
+                indirectly_movable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(out));
+        }
+
+    RANGES_FUNC_END(move)
+    RANGES_HIDDEN_DETAIL(CPP_PP_RBRACE())
+
+#ifndef RANGES_DOXYGEN_INVOKED
+    struct RANGES_EMPTY_BASES move_fn
+      : aux::move_fn
+      , _move::move_fn
+    {
+        using aux::move_fn::operator();
+        using _move::move_fn::operator();
+    };
+
+    RANGES_INLINE_VARIABLE(move_fn, move)
+#endif
+
+    namespace cpp20
+    {
+        using ranges::move_result;
+        using ranges::RANGES_HIDDEN_DETAIL(_move::) move;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/move_backward.hpp b/inst/include/range/v3/algorithm/move_backward.hpp
new file mode 100644
index 0000000..16b90ea
--- /dev/null
+++ b/inst/include/range/v3/algorithm/move_backward.hpp
@@ -0,0 +1,72 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_MOVE_BACKWARD_HPP
+#define RANGES_V3_ALGORITHM_MOVE_BACKWARD_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using move_backward_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(move_backward)
+
+        /// \brief function template \c move_backward
+        template<typename I, typename S, typename O>
+        auto RANGES_FUNC(move_backward)(I first, S end_, O out) //
+            ->CPP_ret(move_backward_result<I, O>)(              //
+                requires bidirectional_iterator<I> && sentinel_for<S, I> &&
+                bidirectional_iterator<O> && indirectly_movable<I, O>)
+        {
+            I i = ranges::next(first, end_), last = i;
+            while(first != i)
+                *--out = iter_move(--i);
+            return {last, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O>
+        auto RANGES_FUNC(move_backward)(Rng && rng, O out)            //
+            ->CPP_ret(move_backward_result<safe_iterator_t<Rng>, O>)( //
+                requires bidirectional_range<Rng> && bidirectional_iterator<O> &&
+                indirectly_movable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(out));
+        }
+
+    RANGES_FUNC_END(move_backward)
+
+    namespace cpp20
+    {
+        using ranges::move_backward;
+        using ranges::move_backward_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/none_of.hpp b/inst/include/range/v3/algorithm/none_of.hpp
new file mode 100644
index 0000000..400af6f
--- /dev/null
+++ b/inst/include/range/v3/algorithm/none_of.hpp
@@ -0,0 +1,68 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrew Sutton 2014
+//  Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_NONE_OF_HPP
+#define RANGES_V3_ALGORITHM_NONE_OF_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(none_of)
+
+        /// \brief function template \c none_of
+        template<typename I, typename S, typename F, typename P = identity>
+        auto RANGES_FUNC(none_of)(I first, S last, F pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                             //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<F, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+                if(invoke(pred, invoke(proj, *first)))
+                    return false;
+            return true;
+        }
+
+        /// \overload
+        template<typename Rng, typename F, typename P = identity>
+        auto RANGES_FUNC(none_of)(Rng && rng, F pred, P proj = P{}) //
+            ->CPP_ret(bool)(                                        //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(none_of)
+
+    namespace cpp20
+    {
+        using ranges::none_of;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/nth_element.hpp b/inst/include/range/v3/algorithm/nth_element.hpp
new file mode 100644
index 0000000..4a1c137
--- /dev/null
+++ b/inst/include/range/v3/algorithm/nth_element.hpp
@@ -0,0 +1,329 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef RANGES_V3_ALGORITHM_NTH_ELEMENT_HPP
+#define RANGES_V3_ALGORITHM_NTH_ELEMENT_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/min_element.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // stable, 2-3 compares, 0-2 swaps
+
+        template<typename I, typename C, typename P>
+        auto sort3(I x, I y, I z, C & pred, P & proj) -> CPP_ret(unsigned)( //
+            requires forward_iterator<I> && indirect_relation<C, projected<I, P>>)
+        {
+            unsigned r = 0;
+            if(!invoke(pred, invoke(proj, *y), invoke(proj, *x))) // if x <= y
+            {
+                if(!invoke(pred, invoke(proj, *z), invoke(proj, *y))) // if y <= z
+                    return r;                                         // x <= y && y <= z
+                                                                      // x <= y && y > z
+                ranges::iter_swap(y, z);                              // x <= z && y < z
+                r = 1;
+                if(invoke(pred, invoke(proj, *y), invoke(proj, *x))) // if x > y
+                {
+                    ranges::iter_swap(x, y); // x < y && y <= z
+                    r = 2;
+                }
+                return r; // x <= y && y < z
+            }
+            if(invoke(pred, invoke(proj, *z), invoke(proj, *y))) // x > y, if y > z
+            {
+                ranges::iter_swap(x, z); // x < y && y < z
+                r = 1;
+                return r;
+            }
+            ranges::iter_swap(x, y);                             // x > y && y <= z
+            r = 1;                                               // x < y && x <= z
+            if(invoke(pred, invoke(proj, *z), invoke(proj, *y))) // if y > z
+            {
+                ranges::iter_swap(y, z); // x <= y && y < z
+                r = 2;
+            }
+            return r;
+        } // x <= y && y <= z
+
+        template<typename I, typename C, typename P>
+        auto selection_sort(I first, I last, C & pred, P & proj) -> CPP_ret(void)( //
+            requires bidirectional_iterator<I> && indirect_relation<C, projected<I, P>>)
+        {
+            RANGES_EXPECT(first != last);
+            for(I lm1 = ranges::prev(last); first != lm1; ++first)
+            {
+                I i = ranges::min_element(first, last, std::ref(pred), std::ref(proj));
+                if(i != first)
+                    ranges::iter_swap(first, i);
+            }
+        }
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(nth_element)
+
+        /// \brief function template \c nth_element
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(nth_element)(
+            I first, I nth, S end_, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                       //
+                requires random_access_iterator<I> && sortable<I, C, P>)
+        {
+            I last = ranges::next(nth, end_), end_orig = last;
+            // C is known to be a reference type
+            using difference_type = iter_difference_t<I>;
+            difference_type const limit = 7;
+            while(true)
+            {
+            restart:
+                if(nth == last)
+                    return end_orig;
+                difference_type len = last - first;
+                switch(len)
+                {
+                case 0:
+                case 1:
+                    return end_orig;
+                case 2:
+                    if(invoke(pred, invoke(proj, *--last), invoke(proj, *first)))
+                        ranges::iter_swap(first, last);
+                    return end_orig;
+                case 3:
+                {
+                    I m = first;
+                    detail::sort3(first, ++m, --last, pred, proj);
+                    return end_orig;
+                }
+                }
+                if(len <= limit)
+                {
+                    detail::selection_sort(first, last, pred, proj);
+                    return end_orig;
+                }
+                // len > limit >= 3
+                I m = first + len / 2;
+                I lm1 = last;
+                unsigned n_swaps = detail::sort3(first, m, --lm1, pred, proj);
+                // *m is median
+                // partition [first, m) < *m and *m <= [m, last)
+                //(this inhibits tossing elements equivalent to m around unnecessarily)
+                I i = first;
+                I j = lm1;
+                // j points beyond range to be tested, *lm1 is known to be <= *m
+                // The search going up is known to be guarded but the search coming down
+                // isn't. Prime the downward search with a guard.
+                if(!invoke(pred, invoke(proj, *i), invoke(proj, *m))) // if *first == *m
+                {
+                    // *first == *m, *first doesn't go in first part
+                    // manually guard downward moving j against i
+                    while(true)
+                    {
+                        if(i == --j)
+                        {
+                            // *first == *m, *m <= all other elements
+                            // Parition instead into [first, i) == *first and *first < [i,
+                            // last)
+                            ++i; // first + 1
+                            j = last;
+                            if(!invoke(
+                                   pred,
+                                   invoke(proj, *first),
+                                   invoke(
+                                       proj,
+                                       *--j))) // we need a guard if *first == *(last-1)
+                            {
+                                while(true)
+                                {
+                                    if(i == j)
+                                        return end_orig; // [first, last) all equivalent
+                                                         // elements
+                                    if(invoke(
+                                           pred, invoke(proj, *first), invoke(proj, *i)))
+                                    {
+                                        ranges::iter_swap(i, j);
+                                        ++n_swaps;
+                                        ++i;
+                                        break;
+                                    }
+                                    ++i;
+                                }
+                            }
+                            // [first, i) == *first and *first < [j, last) and j == last -
+                            // 1
+                            if(i == j)
+                                return end_orig;
+                            while(true)
+                            {
+                                while(
+                                    !invoke(pred, invoke(proj, *first), invoke(proj, *i)))
+                                    ++i;
+                                while(invoke(
+                                    pred, invoke(proj, *first), invoke(proj, *--j)))
+                                    ;
+                                if(i >= j)
+                                    break;
+                                ranges::iter_swap(i, j);
+                                ++n_swaps;
+                                ++i;
+                            }
+                            // [first, i) == *first and *first < [i, last)
+                            // The first part is sorted,
+                            if(nth < i)
+                                return end_orig;
+                            // nth_element the second part
+                            // nth_element<C>(i, nth, last, pred);
+                            first = i;
+                            goto restart;
+                        }
+                        if(invoke(pred, invoke(proj, *j), invoke(proj, *m)))
+                        {
+                            ranges::iter_swap(i, j);
+                            ++n_swaps;
+                            break; // found guard for downward moving j, now use unguarded
+                                   // partition
+                        }
+                    }
+                }
+                ++i;
+                // j points beyond range to be tested, *lm1 is known to be <= *m
+                // if not yet partitioned...
+                if(i < j)
+                {
+                    // known that *(i - 1) < *m
+                    while(true)
+                    {
+                        // m still guards upward moving i
+                        while(invoke(pred, invoke(proj, *i), invoke(proj, *m)))
+                            ++i;
+                        // It is now known that a guard exists for downward moving j
+                        while(!invoke(pred, invoke(proj, *--j), invoke(proj, *m)))
+                            ;
+                        if(i >= j)
+                            break;
+                        ranges::iter_swap(i, j);
+                        ++n_swaps;
+                        // It is known that m != j
+                        // If m just moved, follow it
+                        if(m == i)
+                            m = j;
+                        ++i;
+                    }
+                }
+                // [first, i) < *m and *m <= [i, last)
+                if(i != m && invoke(pred, invoke(proj, *m), invoke(proj, *i)))
+                {
+                    ranges::iter_swap(i, m);
+                    ++n_swaps;
+                }
+                // [first, i) < *i and *i <= [i+1, last)
+                if(nth == i)
+                    return end_orig;
+                if(n_swaps == 0)
+                {
+                    // We were given a perfectly partitioned sequence.  Coincidence?
+                    if(nth < i)
+                    {
+                        // Check for [first, i) already sorted
+                        j = m = first;
+                        while(++j != i)
+                        {
+                            if(invoke(pred, invoke(proj, *j), invoke(proj, *m)))
+                                // not yet sorted, so sort
+                                goto not_sorted;
+                            m = j;
+                        }
+                        // [first, i) sorted
+                        return end_orig;
+                    }
+                    else
+                    {
+                        // Check for [i, last) already sorted
+                        j = m = i;
+                        while(++j != last)
+                        {
+                            if(invoke(pred, invoke(proj, *j), invoke(proj, *m)))
+                                // not yet sorted, so sort
+                                goto not_sorted;
+                            m = j;
+                        }
+                        // [i, last) sorted
+                        return end_orig;
+                    }
+                }
+            not_sorted:
+                // nth_element on range containing nth
+                if(nth < i)
+                {
+                    // nth_element<C>(first, nth, i, pred);
+                    last = i;
+                }
+                else
+                {
+                    // nth_element<C>(i+1, nth, last, pred);
+                    first = ++i;
+                }
+            }
+            return end_orig;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(nth_element)(
+            Rng && rng, iterator_t<Rng> nth, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                             //
+                requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+        {
+            return (*this)(
+                begin(rng), std::move(nth), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(nth_element)
+
+    namespace cpp20
+    {
+        using ranges::nth_element;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/partial_sort.hpp b/inst/include/range/v3/algorithm/partial_sort.hpp
new file mode 100644
index 0000000..900b9a6
--- /dev/null
+++ b/inst/include/range/v3/algorithm/partial_sort.hpp
@@ -0,0 +1,85 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_PARTIAL_SORT_HPP
+#define RANGES_V3_ALGORITHM_PARTIAL_SORT_HPP
+
+#include <functional>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/heap_algorithm.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(partial_sort)
+
+        /// \brief function template \c partial_sort
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(partial_sort)(
+            I first, I middle, S last, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                          //
+                requires sortable<I, C, P> && random_access_iterator<I> &&
+                sentinel_for<S, I>)
+        {
+            make_heap(first, middle, std::ref(pred), std::ref(proj));
+            auto const len = middle - first;
+            I i = middle;
+            for(; i != last; ++i)
+            {
+                if(invoke(pred, invoke(proj, *i), invoke(proj, *first)))
+                {
+                    iter_swap(i, first);
+                    detail::sift_down_n(
+                        first, len, first, std::ref(pred), std::ref(proj));
+                }
+            }
+            sort_heap(first, middle, std::ref(pred), std::ref(proj));
+            return i;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(partial_sort)(
+            Rng && rng, iterator_t<Rng> middle, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                //
+                requires sortable<iterator_t<Rng>, C, P> && random_access_range<Rng>)
+        {
+            return (*this)(begin(rng),
+                           std::move(middle),
+                           end(rng),
+                           std::move(pred),
+                           std::move(proj));
+        }
+
+    RANGES_FUNC_END(partial_sort)
+
+    namespace cpp20
+    {
+        using ranges::partial_sort;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/partial_sort_copy.hpp b/inst/include/range/v3/algorithm/partial_sort_copy.hpp
new file mode 100644
index 0000000..0d7220e
--- /dev/null
+++ b/inst/include/range/v3/algorithm/partial_sort_copy.hpp
@@ -0,0 +1,121 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_PARTIAL_SORT_COPY_HPP
+#define RANGES_V3_ALGORITHM_PARTIAL_SORT_COPY_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/heap_algorithm.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(partial_sort_copy)
+
+        /// \brief function template \c partial_sort_copy
+        template<typename I,
+                 typename SI,
+                 typename O,
+                 typename SO,
+                 typename C = less,
+                 typename PI = identity,
+                 typename PO = identity>
+        auto RANGES_FUNC(partial_sort_copy)(I first,
+                                            SI last,
+                                            O out_begin,
+                                            SO out_end,
+                                            C pred = C{},
+                                            PI in_proj = PI{},
+                                            PO out_proj = PO{}) //
+            ->CPP_ret(O)(                                       //
+                requires input_iterator<I> && sentinel_for<SI, I> &&
+                random_access_iterator<O> && sentinel_for<SO, O> &&
+                indirectly_copyable<I, O> && sortable<O, C, PO> &&
+                indirect_strict_weak_order<C, projected<I, PI>, projected<O, PO>>)
+        {
+            O r = out_begin;
+            if(r != out_end)
+            {
+                for(; first != last && r != out_end; ++first, ++r)
+                    *r = *first;
+                make_heap(out_begin, r, std::ref(pred), std::ref(out_proj));
+                auto len = r - out_begin;
+                for(; first != last; ++first)
+                {
+                    auto && x = *first;
+                    if(invoke(pred, invoke(in_proj, x), invoke(out_proj, *out_begin)))
+                    {
+                        *out_begin = (decltype(x) &&)x;
+                        detail::sift_down_n(out_begin,
+                                            len,
+                                            out_begin,
+                                            std::ref(pred),
+                                            std::ref(out_proj));
+                    }
+                }
+                sort_heap(out_begin, r, std::ref(pred), std::ref(out_proj));
+            }
+            return r;
+        }
+
+        /// \overload
+        template<typename InRng,
+                 typename OutRng,
+                 typename C = less,
+                 typename PI = identity,
+                 typename PO = identity>
+        auto RANGES_FUNC(partial_sort_copy)(InRng && in_rng,
+                                            OutRng && out_rng,
+                                            C pred = C{},
+                                            PI in_proj = PI{},
+                                            PO out_proj = PO{}) //
+            ->CPP_ret(safe_iterator_t<OutRng>)(                 //
+                requires input_range<InRng> && random_access_range<OutRng> &&
+                indirectly_copyable<iterator_t<InRng>, iterator_t<OutRng>> &&
+                sortable<iterator_t<OutRng>, C, PO> &&
+                indirect_strict_weak_order<C,
+                                           projected<iterator_t<InRng>, PI>,
+                                           projected<iterator_t<OutRng>, PO>>)
+        {
+            return (*this)(begin(in_rng),
+                           end(in_rng),
+                           begin(out_rng),
+                           end(out_rng),
+                           std::move(pred),
+                           std::move(in_proj),
+                           std::move(out_proj));
+        }
+
+    RANGES_FUNC_END(partial_sort_copy)
+
+    namespace cpp20
+    {
+        using ranges::partial_sort_copy;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/partition.hpp b/inst/include/range/v3/algorithm/partition.hpp
new file mode 100644
index 0000000..d93ce62
--- /dev/null
+++ b/inst/include/range/v3/algorithm/partition.hpp
@@ -0,0 +1,135 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===-------------------------- algorithm ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_PARTITION_HPP
+#define RANGES_V3_ALGORITHM_PARTITION_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S, typename C, typename P>
+        I partition_impl(I first, S last, C pred, P proj, std::forward_iterator_tag)
+        {
+            while(true)
+            {
+                if(first == last)
+                    return first;
+                if(!invoke(pred, invoke(proj, *first)))
+                    break;
+                ++first;
+            }
+            for(I p = first; ++p != last;)
+            {
+                if(invoke(pred, invoke(proj, *p)))
+                {
+                    ranges::iter_swap(first, p);
+                    ++first;
+                }
+            }
+            return first;
+        }
+
+        template<typename I, typename S, typename C, typename P>
+        I partition_impl(I first, S end_, C pred, P proj, std::bidirectional_iterator_tag)
+        {
+            I last = ranges::next(first, end_);
+            while(true)
+            {
+                while(true)
+                {
+                    if(first == last)
+                        return first;
+                    if(!invoke(pred, invoke(proj, *first)))
+                        break;
+                    ++first;
+                }
+                do
+                {
+                    if(first == --last)
+                        return first;
+                } while(!invoke(pred, invoke(proj, *last)));
+                ranges::iter_swap(first, last);
+                ++first;
+            }
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(partition)
+
+        /// \brief function template \c partition
+        template<typename I, typename S, typename C, typename P = identity>
+        auto RANGES_FUNC(partition)(I first, S last, C pred, P proj = P{}) //
+            ->CPP_ret(I)(                                                  //
+                requires permutable<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<C, projected<I, P>>)
+        {
+            return detail::partition_impl(std::move(first),
+                                          std::move(last),
+                                          std::move(pred),
+                                          std::move(proj),
+                                          iterator_tag_of<I>());
+        }
+
+        /// \overload
+        template<typename Rng, typename C, typename P = identity>
+        auto RANGES_FUNC(partition)(Rng && rng, C pred, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                          //
+                requires forward_range<Rng> && permutable<iterator_t<Rng>> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>)
+        {
+            return detail::partition_impl(begin(rng),
+                                          end(rng),
+                                          std::move(pred),
+                                          std::move(proj),
+                                          iterator_tag_of<iterator_t<Rng>>());
+        }
+
+    RANGES_FUNC_END(partition)
+
+    namespace cpp20
+    {
+        using ranges::partition;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/partition_copy.hpp b/inst/include/range/v3/algorithm/partition_copy.hpp
new file mode 100644
index 0000000..b4d30c2
--- /dev/null
+++ b/inst/include/range/v3/algorithm/partition_copy.hpp
@@ -0,0 +1,107 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_PARTITION_COPY_HPP
+#define RANGES_V3_ALGORITHM_PARTITION_COPY_HPP
+
+#include <tuple>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O0, typename O1>
+    using partition_copy_result = detail::in_out1_out2_result<I, O0, O1>;
+
+    RANGES_FUNC_BEGIN(partition_copy)
+
+        /// \brief function template \c partition_copy
+        template<typename I,
+                 typename S,
+                 typename O0,
+                 typename O1,
+                 typename C,
+                 typename P = identity>
+        auto RANGES_FUNC(partition_copy)(
+            I first, S last, O0 o0, O1 o1, C pred, P proj = P{})
+            ->CPP_ret(partition_copy_result<I, O0, O1>)( //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O0> && weakly_incrementable<O1> &&
+                indirectly_copyable<I, O0> && indirectly_copyable<I, O1> &&
+                indirect_unary_predicate<C, projected<I, P>>)
+        {
+            for(; first != last; ++first)
+            {
+                auto && x = *first;
+                if(invoke(pred, invoke(proj, x)))
+                {
+                    *o0 = (decltype(x) &&)x;
+                    ++o0;
+                }
+                else
+                {
+                    *o1 = (decltype(x) &&)x;
+                    ++o1;
+                }
+            }
+            return {first, o0, o1};
+        }
+
+        /// \overload
+        template<typename Rng,
+                 typename O0,
+                 typename O1,
+                 typename C,
+                 typename P = identity>
+        auto RANGES_FUNC(partition_copy)(
+            Rng && rng, O0 o0, O1 o1, C pred, P proj = P{})                 //
+            ->CPP_ret(partition_copy_result<safe_iterator_t<Rng>, O0, O1>)( //
+                requires input_range<Rng> && weakly_incrementable<O0> &&
+                weakly_incrementable<O1> && indirectly_copyable<iterator_t<Rng>, O0> &&
+                indirectly_copyable<iterator_t<Rng>, O1> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng),
+                           end(rng),
+                           std::move(o0),
+                           std::move(o1),
+                           std::move(pred),
+                           std::move(proj));
+        }
+
+    RANGES_FUNC_END(partition_copy)
+
+    namespace cpp20
+    {
+        using ranges::partition_copy;
+        using ranges::partition_copy_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/partition_point.hpp b/inst/include/range/v3/algorithm/partition_point.hpp
new file mode 100644
index 0000000..9c565f5
--- /dev/null
+++ b/inst/include/range/v3/algorithm/partition_point.hpp
@@ -0,0 +1,105 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===-------------------------- algorithm ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_PARTITION_POINT_HPP
+#define RANGES_V3_ALGORITHM_PARTITION_POINT_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/partition_point_n.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    RANGES_FUNC_BEGIN(partition_point)
+
+        /// \brief function template \c partition_point
+        template<typename I, typename S, typename C, typename P = identity>
+        auto RANGES_FUNC(partition_point)(I first, S last, C pred, P proj = P{}) //
+            ->CPP_ret(I)(                                                        //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<C, projected<I, P>>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_sentinel_for<S, I>))
+            {
+                auto len = distance(first, std::move(last));
+                return aux::partition_point_n(
+                    std::move(first), len, std::move(pred), std::move(proj));
+            }
+
+            // Probe exponentially for either last-of-range or an iterator
+            // that is past the partition point (i.e., does not satisfy pred).
+            auto len = iter_difference_t<I>{1};
+            while(true)
+            {
+                auto mid = first;
+                auto d = advance(mid, len, last);
+                if(mid == last || !invoke(pred, invoke(proj, *mid)))
+                {
+                    len -= d;
+                    return aux::partition_point_n(
+                        std::move(first), len, std::ref(pred), std::ref(proj));
+                }
+                first = std::move(mid);
+                len *= 2;
+            }
+        }
+
+        /// \overload
+        template<typename Rng, typename C, typename P = identity>
+        auto RANGES_FUNC(partition_point)(Rng && rng, C pred, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                //
+                requires forward_range<Rng> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_range<Rng>))
+            {
+                auto len = distance(rng);
+                return aux::partition_point_n(
+                    begin(rng), len, std::move(pred), std::move(proj));
+            }
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(partition_point)
+
+    namespace cpp20
+    {
+        using ranges::partition_point;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/permutation.hpp b/inst/include/range/v3/algorithm/permutation.hpp
new file mode 100644
index 0000000..962a776
--- /dev/null
+++ b/inst/include/range/v3/algorithm/permutation.hpp
@@ -0,0 +1,365 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===-------------------------- algorithm ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_PERMUTATION_HPP
+#define RANGES_V3_ALGORITHM_PERMUTATION_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/reverse.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I1, typename S1, typename I2, typename S2, typename C,
+                 typename P1, typename P2>
+        bool is_permutation_impl(I1 begin1, S1 end1, I2 begin2, S2 end2, C pred, P1 proj1,
+                                 P2 proj2)
+        {
+            // shorten sequences as much as possible by lopping off any equal parts
+            for(; begin1 != end1 && begin2 != end2; ++begin1, ++begin2)
+                if(!invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                    goto not_done;
+            return begin1 == end1 && begin2 == end2;
+        not_done:
+            // begin1 != end1 && begin2 != end2 && *begin1 != *begin2
+            auto l1 = distance(begin1, end1);
+            auto l2 = distance(begin2, end2);
+            if(l1 != l2)
+                return false;
+
+            // For each element in [f1, l1) see if there are the same number of
+            //    equal elements in [f2, l2)
+            for(I1 i = begin1; i != end1; ++i)
+            {
+                // Have we already counted the number of *i in [f1, l1)?
+                for(I1 j = begin1; j != i; ++j)
+                    if(invoke(pred, invoke(proj1, *j), invoke(proj1, *i)))
+                        goto next_iter;
+                {
+                    // Count number of *i in [f2, l2)
+                    iter_difference_t<I2> c2 = 0;
+                    for(I2 j = begin2; j != end2; ++j)
+                        if(invoke(pred, invoke(proj1, *i), invoke(proj2, *j)))
+                            ++c2;
+                    if(c2 == 0)
+                        return false;
+                    // Count number of *i in [i, l1) (we can start with 1)
+                    iter_difference_t<I1> c1 = 1;
+                    for(I1 j = next(i); j != end1; ++j)
+                        if(invoke(pred, invoke(proj1, *i), invoke(proj1, *j)))
+                            ++c1;
+                    if(c1 != c2)
+                        return false;
+                }
+            next_iter:;
+            }
+            return true;
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(is_permutation)
+
+        /// \brief function template \c is_permutation
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::is_permutation that takes an upper bound "
+            "for both sequences")
+        auto RANGES_FUNC(is_permutation)(I1 begin1,
+                                         S1 end1,
+                                         I2 begin2,
+                                         C pred = C{},
+                                         P1 proj1 = P1{},
+                                         P2 proj2 = P2{}) //
+            ->CPP_ret(bool)(                              //
+                requires forward_iterator<I1> && sentinel_for<S1, I1> &&
+                forward_iterator<I2> && indirectly_comparable<I1, I2, C, P1, P2>)
+        {
+            // shorten sequences as much as possible by lopping off any equal parts
+            for(; begin1 != end1; ++begin1, ++begin2)
+                if(!invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                    goto not_done;
+            return true;
+        not_done:
+            // begin1 != end1 && *begin1 != *begin2
+            auto l1 = distance(begin1, end1);
+            if(l1 == 1)
+                return false;
+            I2 end2 = next(begin2, l1);
+            // For each element in [f1, l1) see if there are the same number of
+            //    equal elements in [f2, l2)
+            for(I1 i = begin1; i != end1; ++i)
+            {
+                // Have we already counted the number of *i in [f1, l1)?
+                for(I1 j = begin1; j != i; ++j)
+                    if(invoke(pred, invoke(proj1, *j), invoke(proj1, *i)))
+                        goto next_iter;
+                {
+                    // Count number of *i in [f2, l2)
+                    iter_difference_t<I2> c2 = 0;
+                    for(I2 j = begin2; j != end2; ++j)
+                        if(invoke(pred, invoke(proj1, *i), invoke(proj2, *j)))
+                            ++c2;
+                    if(c2 == 0)
+                        return false;
+                    // Count number of *i in [i, l1) (we can start with 1)
+                    iter_difference_t<I1> c1 = 1;
+                    for(I1 j = next(i); j != end1; ++j)
+                        if(invoke(pred, invoke(proj1, *i), invoke(proj1, *j)))
+                            ++c1;
+                    if(c1 != c2)
+                        return false;
+                }
+            next_iter:;
+            }
+            return true;
+        }
+
+        /// \overload
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(is_permutation)(I1 begin1,
+                                         S1 end1,
+                                         I2 begin2,
+                                         S2 end2,
+                                         C pred = C{},
+                                         P1 proj1 = P1{},
+                                         P2 proj2 = P2{}) //
+            ->CPP_ret(bool)(                              //
+                requires forward_iterator<I1> && sentinel_for<S1, I1> &&
+                forward_iterator<I2> && sentinel_for<S2, I2> &&
+                indirectly_comparable<I1, I2, C, P1, P2>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_sentinel_for<S1, I1> &&
+                                   sized_sentinel_for<S2, I2>))
+            {
+                RANGES_DIAGNOSTIC_PUSH
+                RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+                return distance(begin1, end1) == distance(begin2, end2) &&
+                       (*this)(std::move(begin1),
+                               std::move(end1),
+                               std::move(begin2),
+                               std::move(pred),
+                               std::move(proj1),
+                               std::move(proj2));
+                RANGES_DIAGNOSTIC_POP
+            }
+            return detail::is_permutation_impl(std::move(begin1),
+                                               std::move(end1),
+                                               std::move(begin2),
+                                               std::move(end2),
+                                               std::move(pred),
+                                               std::move(proj1),
+                                               std::move(proj2));
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename I2Ref,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::is_permutation that takes an upper bound "
+            "for both sequences")
+        auto RANGES_FUNC(is_permutation)(Rng1 && rng1,
+                                         I2Ref && begin2,
+                                         C pred = C{},
+                                         P1 proj1 = P1{},
+                                         P2 proj2 = P2{}) //
+            ->CPP_ret(bool)(                              //
+                requires forward_range<Rng1> && forward_iterator<uncvref_t<I2Ref>> &&
+                indirectly_comparable<iterator_t<Rng1>, uncvref_t<I2Ref>, C, P1, P2>)
+        {
+            RANGES_DIAGNOSTIC_PUSH
+            RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           (I2Ref &&) begin2,
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+            RANGES_DIAGNOSTIC_POP
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(is_permutation)(
+            Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{}, P2 proj2 = P2{}) //
+            ->CPP_ret(bool)(                                                            //
+                requires forward_range<Rng1> && forward_range<Rng2> &&
+                indirectly_comparable<iterator_t<Rng1>, iterator_t<Rng2>, C, P1, P2>)
+        {
+            if(RANGES_CONSTEXPR_IF(sized_range<Rng1> && sized_range<Rng2>))
+            {
+                RANGES_DIAGNOSTIC_PUSH
+                RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+                return distance(rng1) == distance(rng2) && (*this)(begin(rng1),
+                                                                   end(rng1),
+                                                                   begin(rng2),
+                                                                   std::move(pred),
+                                                                   std::move(proj1),
+                                                                   std::move(proj2));
+                RANGES_DIAGNOSTIC_POP
+            }
+            return detail::is_permutation_impl(begin(rng1),
+                                               end(rng1),
+                                               begin(rng2),
+                                               end(rng2),
+                                               std::move(pred),
+                                               std::move(proj1),
+                                               std::move(proj2));
+        }
+
+    RANGES_FUNC_END(is_permutation)
+
+    RANGES_FUNC_BEGIN(next_permutation)
+
+        /// \brief function template \c next_permutation
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(next_permutation)(I first, S end_, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                                            //
+                requires bidirectional_iterator<I> && sentinel_for<S, I> &&
+                sortable<I, C, P>)
+        {
+            if(first == end_)
+                return false;
+            I last = ranges::next(first, end_), i = last;
+            if(first == --i)
+                return false;
+            while(true)
+            {
+                I ip1 = i;
+                if(invoke(pred, invoke(proj, *--i), invoke(proj, *ip1)))
+                {
+                    I j = last;
+                    while(!invoke(pred, invoke(proj, *i), invoke(proj, *--j)))
+                        ;
+                    ranges::iter_swap(i, j);
+                    ranges::reverse(ip1, last);
+                    return true;
+                }
+                if(i == first)
+                {
+                    ranges::reverse(first, last);
+                    return false;
+                }
+            }
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(next_permutation)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                                       //
+                requires bidirectional_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(next_permutation)
+
+    RANGES_FUNC_BEGIN(prev_permutation)
+
+        /// \brief function template \c prev_permutation
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(prev_permutation)(I first, S end_, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                                            //
+                requires bidirectional_iterator<I> && sentinel_for<S, I> &&
+                sortable<I, C, P>)
+        {
+            if(first == end_)
+                return false;
+            I last = ranges::next(first, end_), i = last;
+            if(first == --i)
+                return false;
+            while(true)
+            {
+                I ip1 = i;
+                if(invoke(pred, invoke(proj, *ip1), invoke(proj, *--i)))
+                {
+                    I j = last;
+                    while(!invoke(pred, invoke(proj, *--j), invoke(proj, *i)))
+                        ;
+                    ranges::iter_swap(i, j);
+                    ranges::reverse(ip1, last);
+                    return true;
+                }
+                if(i == first)
+                {
+                    ranges::reverse(first, last);
+                    return false;
+                }
+            }
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(prev_permutation)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(bool)(                                                       //
+                requires bidirectional_range<Rng> && sortable<iterator_t<Rng>, C, P>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(prev_permutation)
+
+    namespace cpp20
+    {
+        using ranges::is_permutation;
+        using ranges::next_permutation;
+        using ranges::prev_permutation;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/remove.hpp b/inst/include/range/v3/algorithm/remove.hpp
new file mode 100644
index 0000000..16fd521
--- /dev/null
+++ b/inst/include/range/v3/algorithm/remove.hpp
@@ -0,0 +1,79 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REMOVE_HPP
+#define RANGES_V3_ALGORITHM_REMOVE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/find.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(remove)
+
+        /// \brief function template \c remove
+        template<typename I, typename S, typename T, typename P = identity>
+        auto RANGES_FUNC(remove)(I first, S last, T const & val, P proj = P{}) //
+            ->CPP_ret(I)(                                                      //
+                requires permutable<I> && sentinel_for<S, I> &&
+                indirect_relation<equal_to, projected<I, P>, T const *>)
+        {
+            first = find(std::move(first), last, val, std::ref(proj));
+            if(first != last)
+            {
+                for(I i = next(first); i != last; ++i)
+                {
+                    if(!(invoke(proj, *i) == val))
+                    {
+                        *first = iter_move(i);
+                        ++first;
+                    }
+                }
+            }
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename T, typename P = identity>
+        auto RANGES_FUNC(remove)(Rng && rng, T const & val, P proj = P{})
+            ->CPP_ret(safe_iterator_t<Rng>)( //
+                requires forward_range<Rng> && permutable<iterator_t<Rng>> &&
+                indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T const *>)
+        {
+            return (*this)(begin(rng), end(rng), val, std::move(proj));
+        }
+
+    RANGES_FUNC_END(remove)
+
+    namespace cpp20
+    {
+        using ranges::remove;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/remove_copy.hpp b/inst/include/range/v3/algorithm/remove_copy.hpp
new file mode 100644
index 0000000..e6dc606
--- /dev/null
+++ b/inst/include/range/v3/algorithm/remove_copy.hpp
@@ -0,0 +1,83 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REMOVE_COPY_HPP
+#define RANGES_V3_ALGORITHM_REMOVE_COPY_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using remove_copy_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(remove_copy)
+
+        /// \brief function template \c remove_copy
+        template<typename I, typename S, typename O, typename T, typename P = identity>
+        auto RANGES_FUNC(remove_copy)(
+            I first, S last, O out, T const & val, P proj = P{}) //
+            ->CPP_ret(remove_copy_result<I, O>)(                 //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> &&
+                indirect_relation<equal_to, projected<I, P>, T const *> &&
+                indirectly_copyable<I, O>)
+        {
+            for(; first != last; ++first)
+            {
+                auto && x = *first;
+                if(!(invoke(proj, x) == val))
+                {
+                    *out = (decltype(x) &&)x;
+                    ++out;
+                }
+            }
+            return {first, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename T, typename P = identity>
+        auto RANGES_FUNC(remove_copy)(Rng && rng, O out, T const & val, P proj = P{}) //
+            ->CPP_ret(remove_copy_result<safe_iterator_t<Rng>, O>)(                   //
+                requires input_range<Rng> && weakly_incrementable<O> &&
+                indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T const *> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(out), val, std::move(proj));
+        }
+
+    RANGES_FUNC_END(remove_copy)
+
+    namespace cpp20
+    {
+        using ranges::remove_copy;
+        using ranges::remove_copy_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/remove_copy_if.hpp b/inst/include/range/v3/algorithm/remove_copy_if.hpp
new file mode 100644
index 0000000..58dbdb9
--- /dev/null
+++ b/inst/include/range/v3/algorithm/remove_copy_if.hpp
@@ -0,0 +1,82 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REMOVE_COPY_IF_HPP
+#define RANGES_V3_ALGORITHM_REMOVE_COPY_IF_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using remove_copy_if_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(remove_copy_if)
+
+        /// \brief function template \c remove_copy_if
+        template<typename I, typename S, typename O, typename C, typename P = identity>
+        auto RANGES_FUNC(remove_copy_if)(I first, S last, O out, C pred, P proj = P{}) //
+            ->CPP_ret(remove_copy_if_result<I, O>)(                                    //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && indirect_unary_predicate<C, projected<I, P>> &&
+                indirectly_copyable<I, O>)
+        {
+            for(; first != last; ++first)
+            {
+                auto && x = *first;
+                if(!(invoke(pred, invoke(proj, x))))
+                {
+                    *out = (decltype(x) &&)x;
+                    ++out;
+                }
+            }
+            return {first, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename C, typename P = identity>
+        auto RANGES_FUNC(remove_copy_if)(Rng && rng, O out, C pred, P proj = P{}) //
+            ->CPP_ret(remove_copy_if_result<safe_iterator_t<Rng>, O>)(            //
+                requires input_range<Rng> && weakly_incrementable<O> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(
+                begin(rng), end(rng), std::move(out), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(remove_copy_if)
+
+    namespace cpp20
+    {
+        using ranges::remove_copy_if;
+        using ranges::remove_copy_if_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/remove_if.hpp b/inst/include/range/v3/algorithm/remove_if.hpp
new file mode 100644
index 0000000..6ef0e4d
--- /dev/null
+++ b/inst/include/range/v3/algorithm/remove_if.hpp
@@ -0,0 +1,79 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REMOVE_IF_HPP
+#define RANGES_V3_ALGORITHM_REMOVE_IF_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/find_if.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(remove_if)
+
+        /// \brief function template \c remove_if
+        template<typename I, typename S, typename C, typename P = identity>
+        auto RANGES_FUNC(remove_if)(I first, S last, C pred, P proj = P{}) //
+            ->CPP_ret(I)(                                                  //
+                requires permutable<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<C, projected<I, P>>)
+        {
+            first = find_if(std::move(first), last, std::ref(pred), std::ref(proj));
+            if(first != last)
+            {
+                for(I i = next(first); i != last; ++i)
+                {
+                    if(!(invoke(pred, invoke(proj, *i))))
+                    {
+                        *first = iter_move(i);
+                        ++first;
+                    }
+                }
+            }
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename C, typename P = identity>
+        auto RANGES_FUNC(remove_if)(Rng && rng, C pred, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                          //
+                requires forward_range<Rng> && permutable<iterator_t<Rng>> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(remove_if)
+
+    namespace cpp20
+    {
+        using ranges::remove_if;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/replace.hpp b/inst/include/range/v3/algorithm/replace.hpp
new file mode 100644
index 0000000..012841e
--- /dev/null
+++ b/inst/include/range/v3/algorithm/replace.hpp
@@ -0,0 +1,71 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REPLACE_HPP
+#define RANGES_V3_ALGORITHM_REPLACE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(replace)
+
+        /// \brief function template \c replace
+        template<typename I, typename S, typename T1, typename T2, typename P = identity>
+        auto RANGES_FUNC(replace)(
+            I first, S last, T1 const & old_value, T2 const & new_value, P proj = {}) //
+            ->CPP_ret(I)(                                                             //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                writable<I, T2 const &> &&
+                indirect_relation<equal_to, projected<I, P>, T1 const *>)
+        {
+            for(; first != last; ++first)
+                if(invoke(proj, *first) == old_value)
+                    *first = new_value;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename T1, typename T2, typename P = identity>
+        auto RANGES_FUNC(replace)(
+            Rng && rng, T1 const & old_value, T2 const & new_value, P proj = {}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                     //
+                requires input_range<Rng> && writable<iterator_t<Rng>, T2 const &> &&
+                indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T1 const *>)
+        {
+            return (*this)(begin(rng), end(rng), old_value, new_value, std::move(proj));
+        }
+
+    RANGES_FUNC_END(replace)
+
+    namespace cpp20
+    {
+        using ranges::replace;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/replace_copy.hpp b/inst/include/range/v3/algorithm/replace_copy.hpp
new file mode 100644
index 0000000..d68797d
--- /dev/null
+++ b/inst/include/range/v3/algorithm/replace_copy.hpp
@@ -0,0 +1,100 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REPLACE_COPY_HPP
+#define RANGES_V3_ALGORITHM_REPLACE_COPY_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using replace_copy_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(replace_copy)
+
+        /// \brief function template \c replace_copy
+        template<typename I,
+                 typename S,
+                 typename O,
+                 typename T1,
+                 typename T2,
+                 typename P = identity>
+        auto RANGES_FUNC(replace_copy)(I first,
+                                       S last,
+                                       O out,
+                                       T1 const & old_value,
+                                       T2 const & new_value,
+                                       P proj = {}) //
+            ->CPP_ret(replace_copy_result<I, O>)(   //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                output_iterator<O, T2 const &> && indirectly_copyable<I, O> &&
+                indirect_relation<equal_to, projected<I, P>, T1 const *>)
+        {
+            for(; first != last; ++first, ++out)
+            {
+                auto && x = *first;
+                if(invoke(proj, x) == old_value)
+                    *out = new_value;
+                else
+                    *out = (decltype(x) &&)x;
+            }
+            return {first, out};
+        }
+
+        /// \overload
+        template<typename Rng,
+                 typename O,
+                 typename T1,
+                 typename T2,
+                 typename P = identity>
+        auto RANGES_FUNC(replace_copy)(
+            Rng && rng, O out, T1 const & old_value, T2 const & new_value, P proj = {}) //
+            ->CPP_ret(replace_copy_result<safe_iterator_t<Rng>, O>)(                    //
+                requires input_range<Rng> && output_iterator<O, T2 const &> &&
+                indirectly_copyable<iterator_t<Rng>, O> &&
+                indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T1 const *>)
+        {
+            return (*this)(begin(rng),
+                           end(rng),
+                           std::move(out),
+                           old_value,
+                           new_value,
+                           std::move(proj));
+        }
+
+    RANGES_FUNC_END(replace_copy)
+
+    namespace cpp20
+    {
+        using ranges::replace_copy;
+        using ranges::replace_copy_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/replace_copy_if.hpp b/inst/include/range/v3/algorithm/replace_copy_if.hpp
new file mode 100644
index 0000000..f6d9404
--- /dev/null
+++ b/inst/include/range/v3/algorithm/replace_copy_if.hpp
@@ -0,0 +1,92 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REPLACE_COPY_IF_HPP
+#define RANGES_V3_ALGORITHM_REPLACE_COPY_IF_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using replace_copy_if_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(replace_copy_if)
+
+        /// \brief function template \c replace_copy_if
+        template<typename I,
+                 typename S,
+                 typename O,
+                 typename C,
+                 typename T,
+                 typename P = identity>
+        auto RANGES_FUNC(replace_copy_if)(
+            I first, S last, O out, C pred, T const & new_value, P proj = {}) //
+            ->CPP_ret(replace_copy_if_result<I, O>)(                          //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                output_iterator<O, T const &> &&
+                indirect_unary_predicate<C, projected<I, P>> && indirectly_copyable<I, O>)
+        {
+            for(; first != last; ++first, ++out)
+            {
+                auto && x = *first;
+                if(invoke(pred, invoke(proj, x)))
+                    *out = new_value;
+                else
+                    *out = (decltype(x) &&)x;
+            }
+            return {first, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename C, typename T, typename P = identity>
+        auto RANGES_FUNC(replace_copy_if)(
+            Rng && rng, O out, C pred, T const & new_value, P proj = {}) //
+            ->CPP_ret(replace_copy_if_result<safe_iterator_t<Rng>, O>)(  //
+                requires input_range<Rng> && output_iterator<O, T const &> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng),
+                           end(rng),
+                           std::move(out),
+                           std::move(pred),
+                           new_value,
+                           std::move(proj));
+        }
+
+    RANGES_FUNC_END(replace_copy_if)
+
+    namespace cpp20
+    {
+        using ranges::replace_copy_if;
+        using ranges::replace_copy_if_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/replace_if.hpp b/inst/include/range/v3/algorithm/replace_if.hpp
new file mode 100644
index 0000000..48eb0a7
--- /dev/null
+++ b/inst/include/range/v3/algorithm/replace_if.hpp
@@ -0,0 +1,72 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REPLACE_IF_HPP
+#define RANGES_V3_ALGORITHM_REPLACE_IF_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(replace_if)
+
+        /// \brief function template \c replace_if
+        template<typename I, typename S, typename C, typename T, typename P = identity>
+        auto RANGES_FUNC(replace_if)(
+            I first, S last, C pred, T const & new_value, P proj = P{}) //
+            ->CPP_ret(I)(                                               //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<C, projected<I, P>> && writable<I, T const &>)
+        {
+            for(; first != last; ++first)
+                if(invoke(pred, invoke(proj, *first)))
+                    *first = new_value;
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename C, typename T, typename P = identity>
+        auto RANGES_FUNC(replace_if)(
+            Rng && rng, C pred, T const & new_value, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                       //
+                requires input_range<Rng> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> &&
+                writable<iterator_t<Rng>, T const &>)
+        {
+            return (*this)(
+                begin(rng), end(rng), std::move(pred), new_value, std::move(proj));
+        }
+
+    RANGES_FUNC_END(replace_if)
+
+    namespace cpp20
+    {
+        using ranges::replace_if;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/result_types.hpp b/inst/include/range/v3/algorithm/result_types.hpp
new file mode 100644
index 0000000..ca3d877
--- /dev/null
+++ b/inst/include/range/v3/algorithm/result_types.hpp
@@ -0,0 +1,165 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#ifndef RANGES_V3_ALGORITHM_RESULT_TYPES_HPP
+#define RANGES_V3_ALGORITHM_RESULT_TYPES_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // Extensions: the dangling story actually works, and result structs
+        // are conditionally equality_comparable
+#define RANGES_ALGO_RESULT_AUX_2(C, T1, M1, T2, M2)                                   \
+    CPP_template(typename X, typename Y)(requires convertible_to<T1 const &, X> &&    \
+                                         convertible_to<T2 const &, Y>)               \
+    operator C<X, Y>() const &                                                        \
+    {                                                                                 \
+        return {M1, M2};                                                              \
+    }                                                                                 \
+    CPP_template(typename X,                                                          \
+                 typename Y)(requires convertible_to<T1, X> && convertible_to<T2, Y>) \
+    operator C<X, Y>() &&                                                             \
+    {                                                                                 \
+        return {static_cast<T1 &&>(M1), static_cast<T2 &&>(M2)};                      \
+    }                                                                                 \
+    CPP_broken_friend_member                                                          \
+    friend constexpr auto operator==(C<T1, T2> const & x, C<T1, T2> const & y)        \
+        ->CPP_broken_friend_ret(bool)(requires equality_comparable<T1> &&             \
+                                      equality_comparable<T2>)                        \
+    {                                                                                 \
+        return x.M1 == y.M1 && x.M2 == y.M2;                                          \
+    }                                                                                 \
+    CPP_broken_friend_member                                                          \
+    friend constexpr auto operator!=(C<T1, T2> const & x, C<T1, T2> const & y)        \
+        ->CPP_broken_friend_ret(bool)(requires equality_comparable<T1> &&             \
+                                      equality_comparable<T2>)                        \
+    {                                                                                 \
+        return !(x == y);                                                             \
+    }                                                                                 \
+    /**/
+
+#define RANGES_ALGO_RESULT_AUX_3(C, T1, M1, T2, M2, T3, M3)                              \
+    CPP_template(typename X, typename Y, typename Z)(                                    \
+        requires convertible_to<T1 const &, X> && convertible_to<T2 const &, Y> &&       \
+        convertible_to<T3 const &, Z>)                                                   \
+    operator C<X, Y, Z>() const &                                                        \
+    {                                                                                    \
+        return {M1, M2, M3};                                                             \
+    }                                                                                    \
+    CPP_template(typename X, typename Y, typename Z)(requires convertible_to<T1, X> &&   \
+                                                     convertible_to<T2, Y> &&            \
+                                                     convertible_to<T3, Z>)              \
+    operator C<X, Y, Z>() &&                                                             \
+    {                                                                                    \
+        return {static_cast<T1 &&>(M1), static_cast<T2 &&>(M2), static_cast<T3 &&>(M3)}; \
+    }                                                                                    \
+    CPP_broken_friend_member                                                             \
+    friend constexpr auto operator==(C<T1, T2, T3> const & x, C<T1, T2, T3> const & y)   \
+        ->CPP_broken_friend_ret(bool)(requires equality_comparable<T1> &&                \
+                                      equality_comparable<T2> &&                         \
+                                      equality_comparable<T3>)                           \
+    {                                                                                    \
+        return x.M1 == y.M1 && x.M2 == y.M2 && x.M3 == y.M3;                             \
+    }                                                                                    \
+    CPP_broken_friend_member                                                             \
+    friend constexpr auto operator!=(C<T1, T2, T3> const & x, C<T1, T2, T3> const & y)   \
+        ->CPP_broken_friend_ret(bool)(requires equality_comparable<T1> &&                \
+                                      equality_comparable<T2> &&                         \
+                                      equality_comparable<T3>)                           \
+    {                                                                                    \
+        return !(x == y);                                                                \
+    }                                                                                    \
+    /**/
+
+        template<typename I, typename O>
+        struct in_out_result
+        {
+            I in;
+            O out;
+
+            RANGES_ALGO_RESULT_AUX_2(in_out_result, I, in, O, out)
+        };
+
+        template<typename I1, typename O>
+        struct in1_out_result
+        {
+            I1 in1;
+            O out;
+
+            RANGES_ALGO_RESULT_AUX_2(in1_out_result, I1, in1, O, out)
+        };
+
+        template<typename I1, typename I2>
+        struct in1_in2_result
+        {
+            I1 in1;
+            I2 in2;
+
+            RANGES_ALGO_RESULT_AUX_2(in1_in2_result, I1, in1, I2, in2)
+        };
+
+        template<typename I, typename Fun>
+        struct in_fun_result
+        {
+            I in;
+            Fun fun;
+
+            RANGES_ALGO_RESULT_AUX_2(in_fun_result, I, in, Fun, fun)
+        };
+
+        template<typename O, typename Fun>
+        struct out_fun_result
+        {
+            O out;
+            Fun fun;
+
+            RANGES_ALGO_RESULT_AUX_2(out_fun_result, O, out, Fun, fun)
+        };
+
+        template<typename T, typename U>
+        struct min_max_result
+        {
+            T min;
+            U max;
+
+            RANGES_ALGO_RESULT_AUX_2(min_max_result, T, min, U, max)
+        };
+
+        template<typename I1, typename I2, typename O>
+        struct in1_in2_out_result
+        {
+            I1 in1;
+            I2 in2;
+            O out;
+
+            RANGES_ALGO_RESULT_AUX_3(in1_in2_out_result, I1, in1, I2, in2, O, out)
+        };
+
+        template<typename I, typename O1, typename O2>
+        struct in_out1_out2_result
+        {
+            I in;
+            O1 out1;
+            O2 out2;
+
+            RANGES_ALGO_RESULT_AUX_3(in_out1_out2_result, I, in, O1, out1, O2, out2)
+        };
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/algorithm/reverse.hpp b/inst/include/range/v3/algorithm/reverse.hpp
new file mode 100644
index 0000000..d9803e3
--- /dev/null
+++ b/inst/include/range/v3/algorithm/reverse.hpp
@@ -0,0 +1,89 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REVERSE_HPP
+#define RANGES_V3_ALGORITHM_REVERSE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        void reverse_impl(I first, I last, std::bidirectional_iterator_tag)
+        {
+            while(first != last)
+            {
+                if(first == --last)
+                    break;
+                ranges::iter_swap(first, last);
+                ++first;
+            }
+        }
+
+        template<typename I>
+        void reverse_impl(I first, I last, std::random_access_iterator_tag)
+        {
+            if(first != last)
+                for(; first < --last; ++first)
+                    ranges::iter_swap(first, last);
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(reverse)
+
+        /// \brief function template \c reverse
+        template<typename I, typename S>
+        auto RANGES_FUNC(reverse)(I first, S end_) //
+            ->CPP_ret(I)(                          //
+                requires bidirectional_iterator<I> && sentinel_for<S, I> && permutable<I>)
+        {
+            I last = ranges::next(first, end_);
+            detail::reverse_impl(first, last, iterator_tag_of<I>{});
+            return last;
+        }
+
+        /// \overload
+        template<typename Rng, typename I = iterator_t<Rng>>
+        auto RANGES_FUNC(reverse)(Rng && rng) //
+            ->CPP_ret(safe_iterator_t<Rng>)(  //
+                requires bidirectional_range<Rng> && permutable<I>)
+        {
+            return (*this)(begin(rng), end(rng));
+        }
+
+    RANGES_FUNC_END(reverse)
+
+    namespace cpp20
+    {
+        using ranges::reverse;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/reverse_copy.hpp b/inst/include/range/v3/algorithm/reverse_copy.hpp
new file mode 100644
index 0000000..c9ec73c
--- /dev/null
+++ b/inst/include/range/v3/algorithm/reverse_copy.hpp
@@ -0,0 +1,72 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_REVERSE_COPY_HPP
+#define RANGES_V3_ALGORITHM_REVERSE_COPY_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using reverse_copy_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(reverse_copy)
+
+        /// \brief function template \c reverse_copy
+        template<typename I, typename S, typename O>
+        auto RANGES_FUNC(reverse_copy)(I first, S end_, O out) //
+            ->CPP_ret(reverse_copy_result<I, O>)(              //
+                requires bidirectional_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && indirectly_copyable<I, O>)
+        {
+            I last = ranges::next(first, end_), res = last;
+            for(; first != last; ++out)
+                *out = *--last;
+            return {res, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O>
+        auto RANGES_FUNC(reverse_copy)(Rng && rng, O out)            //
+            ->CPP_ret(reverse_copy_result<safe_iterator_t<Rng>, O>)( //
+                requires bidirectional_range<Rng> && weakly_incrementable<O> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(out));
+        }
+
+    RANGES_FUNC_END(reverse_copy)
+
+    namespace cpp20
+    {
+        using ranges::reverse_copy;
+        using ranges::reverse_copy_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/rotate.hpp b/inst/include/range/v3/algorithm/rotate.hpp
new file mode 100644
index 0000000..bb9de31
--- /dev/null
+++ b/inst/include/range/v3/algorithm/rotate.hpp
@@ -0,0 +1,232 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_ROTATE_HPP
+#define RANGES_V3_ALGORITHM_ROTATE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/move.hpp>
+#include <range/v3/algorithm/move_backward.hpp>
+#include <range/v3/algorithm/swap_ranges.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    /// \cond
+    namespace detail
+    {
+        template<typename I> // Forward
+        subrange<I> rotate_left(I first, I last)
+        {
+            iter_value_t<I> tmp = iter_move(first);
+            I lm1 = ranges::move(next(first), last, first).out;
+            *lm1 = std::move(tmp);
+            return {lm1, last};
+        }
+
+        template<typename I> // Bidirectional
+        subrange<I> rotate_right(I first, I last)
+        {
+            I lm1 = prev(last);
+            iter_value_t<I> tmp = iter_move(lm1);
+            I fp1 = move_backward(first, lm1, last).out;
+            *first = std::move(tmp);
+            return {fp1, last};
+        }
+
+        template<typename I, typename S> // Forward
+        subrange<I> rotate_forward(I first, I middle, S last)
+        {
+            I i = middle;
+            while(true)
+            {
+                ranges::iter_swap(first, i);
+                ++first;
+                if(++i == last)
+                    break;
+                if(first == middle)
+                    middle = i;
+            }
+            I r = first;
+            if(first != middle)
+            {
+                I j = middle;
+                while(true)
+                {
+                    ranges::iter_swap(first, j);
+                    ++first;
+                    if(++j == last)
+                    {
+                        if(first == middle)
+                            break;
+                        j = middle;
+                    }
+                    else if(first == middle)
+                        middle = j;
+                }
+            }
+            return {r, i};
+        }
+
+        template<typename D>
+        D gcd(D x, D y)
+        {
+            do
+            {
+                D t = x % y;
+                x = y;
+                y = t;
+            } while(y);
+            return x;
+        }
+
+        template<typename I> // Random
+        subrange<I> rotate_gcd(I first, I middle, I last)
+        {
+            auto const m1 = middle - first;
+            auto const m2 = last - middle;
+            if(m1 == m2)
+            {
+                swap_ranges(first, middle, middle);
+                return {middle, last};
+            }
+            auto const g = detail::gcd(m1, m2);
+            for(I p = first + g; p != first;)
+            {
+                iter_value_t<I> t = iter_move(--p);
+                I p1 = p;
+                I p2 = p1 + m1;
+                do
+                {
+                    *p1 = iter_move(p2);
+                    p1 = p2;
+                    auto const d = last - p2;
+                    if(m1 < d)
+                        p2 += m1;
+                    else
+                        p2 = first + (m1 - d);
+                } while(p2 != p);
+                *p1 = std::move(t);
+            }
+            return {first + m2, last};
+        }
+
+        template<typename I, typename S>
+        subrange<I> rotate_(I first, I middle, S last, std::forward_iterator_tag)
+        {
+            return detail::rotate_forward(first, middle, last);
+        }
+
+        template<typename I>
+        subrange<I> rotate_(I first, I middle, I last, std::forward_iterator_tag)
+        {
+            using value_type = iter_value_t<I>;
+            if(detail::is_trivially_move_assignable<value_type>::value)
+            {
+                if(next(first) == middle)
+                    return detail::rotate_left(first, last);
+            }
+            return detail::rotate_forward(first, middle, last);
+        }
+
+        template<typename I>
+        subrange<I> rotate_(I first, I middle, I last, std::bidirectional_iterator_tag)
+        {
+            using value_type = iter_value_t<I>;
+            if(detail::is_trivially_move_assignable<value_type>::value)
+            {
+                if(next(first) == middle)
+                    return detail::rotate_left(first, last);
+                if(next(middle) == last)
+                    return detail::rotate_right(first, last);
+            }
+            return detail::rotate_forward(first, middle, last);
+        }
+
+        template<typename I>
+        subrange<I> rotate_(I first, I middle, I last, std::random_access_iterator_tag)
+        {
+            using value_type = iter_value_t<I>;
+            if(detail::is_trivially_move_assignable<value_type>::value)
+            {
+                if(next(first) == middle)
+                    return detail::rotate_left(first, last);
+                if(next(middle) == last)
+                    return detail::rotate_right(first, last);
+                return detail::rotate_gcd(first, middle, last);
+            }
+            return detail::rotate_forward(first, middle, last);
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(rotate)
+
+        /// \brief function template \c rotate
+        template<typename I, typename S>
+        auto RANGES_FUNC(rotate)(I first, I middle, S last) //
+            ->CPP_ret(subrange<I>)(                         //
+                requires permutable<I> && sentinel_for<S, I>)
+        {
+            if(first == middle)
+            {
+                first = ranges::next(std::move(first), last);
+                return {first, first};
+            }
+            if(middle == last)
+            {
+                return {first, middle};
+            }
+            return detail::rotate_(first, middle, last, iterator_tag_of<I>{});
+        }
+
+        /// \overload
+        template<typename Rng, typename I = iterator_t<Rng>>
+        auto RANGES_FUNC(rotate)(Rng && rng, I middle) //
+            ->CPP_ret(safe_subrange_t<Rng>)(           //
+                requires range<Rng> && permutable<I>)
+        {
+            return (*this)(begin(rng), std::move(middle), end(rng));
+        }
+
+    RANGES_FUNC_END(rotate)
+
+    namespace cpp20
+    {
+        using ranges::rotate;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/rotate_copy.hpp b/inst/include/range/v3/algorithm/rotate_copy.hpp
new file mode 100644
index 0000000..6d5d1c1
--- /dev/null
+++ b/inst/include/range/v3/algorithm/rotate_copy.hpp
@@ -0,0 +1,72 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_ROTATE_COPY_HPP
+#define RANGES_V3_ALGORITHM_ROTATE_COPY_HPP
+
+#include <functional>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/copy.hpp>
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using rotate_copy_result = detail::in_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(rotate_copy)
+
+        /// \brief function template \c rotate_copy
+        template<typename I, typename S, typename O, typename P = identity>
+        auto RANGES_FUNC(rotate_copy)(I first, I middle, S last, O out) //
+            ->CPP_ret(rotate_copy_result<I, O>)(                        //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && indirectly_copyable<I, O>)
+        {
+            auto res = ranges::copy(middle, std::move(last), std::move(out));
+            return {std::move(res.in),
+                    ranges::copy(std::move(first), middle, std::move(res.out)).out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename P = identity>
+        auto RANGES_FUNC(rotate_copy)(Rng && rng, iterator_t<Rng> middle, O out) //
+            ->CPP_ret(rotate_copy_result<safe_iterator_t<Rng>, O>)(              //
+                requires range<Rng> && weakly_incrementable<O> &&
+                indirectly_copyable<iterator_t<Rng>, O>)
+        {
+            return (*this)(begin(rng), std::move(middle), end(rng), std::move(out));
+        }
+
+    RANGES_FUNC_END(rotate_copy)
+
+    namespace cpp20
+    {
+        using ranges::rotate_copy;
+        using ranges::rotate_copy_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/sample.hpp b/inst/include/range/v3/algorithm/sample.hpp
new file mode 100644
index 0000000..b1f9d6e
--- /dev/null
+++ b/inst/include/range/v3/algorithm/sample.hpp
@@ -0,0 +1,246 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_SAMPLE_HPP
+#define RANGES_V3_ALGORITHM_SAMPLE_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/copy_n.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/random.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+RANGES_DISABLE_WARNINGS
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using sample_result = detail::in_out_result<I, O>;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S, typename O, typename Gen>
+        auto sample_sized_impl(I first, S last, iter_difference_t<I> pop_size, O out,
+                               iter_difference_t<O> sample_size, Gen && gen)
+            -> sample_result<I, O>
+        {
+            if(pop_size > 0 && sample_size > 0)
+            {
+                std::uniform_int_distribution<iter_difference_t<I>> dist;
+                using param_t = typename decltype(dist)::param_type;
+                for(; first != last; ++first)
+                {
+                    if(sample_size >= pop_size)
+                        return copy_n(std::move(first), pop_size, std::move(out));
+
+                    if(dist(gen, param_t{0, --pop_size}) < sample_size)
+                    {
+                        *out = *first;
+                        ++out;
+                        if(--sample_size == 0)
+                            break;
+                    }
+                }
+            }
+
+            return {std::move(first), std::move(out)};
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(sample)
+
+        /// \brief function template \c sample
+        template<typename I,
+                 typename S,
+                 typename O,
+                 typename Gen = detail::default_random_engine &>
+        auto RANGES_FUNC(sample)(I first,
+                                 S last,
+                                 O out,
+                                 iter_difference_t<O> const n,
+                                 Gen && gen = detail::get_random_engine()) //
+            ->CPP_ret(sample_result<I, O>)(                                //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && indirectly_copyable<I, O> &&
+                uniform_random_bit_generator<std::remove_reference_t<Gen>> &&
+                (random_access_iterator<O> || forward_iterator<I> ||
+                 sized_sentinel_for<S, I>))
+        {
+            if(RANGES_CONSTEXPR_IF(forward_iterator<I> || sized_sentinel_for<S, I>))
+            {
+                auto const k = distance(first, last);
+                return detail::sample_sized_impl(std::move(first),
+                                                 std::move(last),
+                                                 k,
+                                                 std::move(out),
+                                                 n,
+                                                 static_cast<Gen &&>(gen));
+            }
+            else
+            {
+                // out is random-access here; calls to advance(out,n) and
+                // next(out,n) are O(1).
+                if(n > 0)
+                {
+                    for(iter_difference_t<O> i = 0; i < n; (void)++i, ++first)
+                    {
+                        if(first == last)
+                        {
+                            advance(out, i);
+                            goto done;
+                        }
+                        *next(out, i) = *first;
+                    }
+
+                    std::uniform_int_distribution<iter_difference_t<O>> dist;
+                    using param_t = typename decltype(dist)::param_type;
+                    for(auto pop_size = n; first != last; (void)++first, ++pop_size)
+                    {
+                        auto const i = dist(gen, param_t{0, pop_size});
+                        if(i < n)
+                            *next(out, i) = *first;
+                    }
+
+                    advance(out, n);
+                }
+            done:
+                return {std::move(first), std::move(out)};
+            }
+        }
+
+        /// \overload
+        template<typename I,
+                 typename S,
+                 typename ORng,
+                 typename Gen = detail::default_random_engine &>
+        auto RANGES_FUNC(sample)(I first,
+                                 S last,
+                                 ORng && out,
+                                 Gen && gen = detail::get_random_engine()) //
+            ->CPP_ret(sample_result<I, safe_iterator_t<ORng>>)(            //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<iterator_t<ORng>> &&
+                indirectly_copyable<I, iterator_t<ORng>> &&
+                uniform_random_bit_generator<std::remove_reference_t<Gen>> &&
+                (forward_range<ORng> ||
+                 sized_range<ORng>)&&(random_access_iterator<iterator_t<ORng>> ||
+                                      forward_iterator<I> || sized_sentinel_for<S, I>))
+        {
+            if(RANGES_CONSTEXPR_IF(forward_iterator<I> || sized_sentinel_for<S, I>))
+            {
+                auto k = distance(first, last);
+                return detail::sample_sized_impl(std::move(first),
+                                                 std::move(last),
+                                                 k,
+                                                 begin(out),
+                                                 distance(out),
+                                                 static_cast<Gen &&>(gen));
+            }
+            else
+            {
+                return (*this)(std::move(first),
+                               std::move(last),
+                               begin(out),
+                               distance(out),
+                               static_cast<Gen &&>(gen));
+            }
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename Gen = detail::default_random_engine &>
+        auto RANGES_FUNC(sample)(Rng && rng,
+                                 O out,
+                                 iter_difference_t<O> const n,
+                                 Gen && gen = detail::get_random_engine()) //
+            ->CPP_ret(sample_result<safe_iterator_t<Rng>, O>)(             //
+                requires input_range<Rng> && weakly_incrementable<O> &&
+                indirectly_copyable<iterator_t<Rng>, O> &&
+                uniform_random_bit_generator<std::remove_reference_t<Gen>> &&
+                (random_access_iterator<O> || forward_range<Rng> || sized_range<Rng>))
+        {
+            if(RANGES_CONSTEXPR_IF(forward_range<Rng> || sized_range<Rng>))
+            {
+                return detail::sample_sized_impl(begin(rng),
+                                                 end(rng),
+                                                 distance(rng),
+                                                 std::move(out),
+                                                 n,
+                                                 static_cast<Gen &&>(gen));
+            }
+            else
+            {
+                return (*this)(
+                    begin(rng), end(rng), std::move(out), n, static_cast<Gen &&>(gen));
+            }
+        }
+
+        /// \overload
+        template<typename IRng,
+                 typename ORng,
+                 typename Gen = detail::default_random_engine &>
+        auto RANGES_FUNC(sample)(IRng && rng,
+                                 ORng && out,
+                                 Gen && gen = detail::get_random_engine())          //
+            ->CPP_ret(sample_result<safe_iterator_t<IRng>, safe_iterator_t<ORng>>)( //
+                requires input_range<IRng> && range<ORng> &&
+                indirectly_copyable<iterator_t<IRng>, iterator_t<ORng>> &&
+                uniform_random_bit_generator<std::remove_reference_t<Gen>> &&
+                (random_access_iterator<iterator_t<ORng>> || forward_range<IRng> ||
+                 sized_range<IRng>)&&(forward_range<ORng> || sized_range<ORng>))
+        {
+            if(RANGES_CONSTEXPR_IF(forward_range<IRng> || sized_range<IRng>))
+            {
+                return detail::sample_sized_impl(begin(rng),
+                                                 end(rng),
+                                                 distance(rng),
+                                                 begin(out),
+                                                 distance(out),
+                                                 static_cast<Gen &&>(gen));
+            }
+            else
+            {
+                return (*this)(begin(rng),
+                               end(rng),
+                               begin(out),
+                               distance(out),
+                               static_cast<Gen &&>(gen));
+            }
+        }
+
+    RANGES_FUNC_END(sample)
+
+    // Not yet!
+    //  namespace cpp20
+    // {
+    //     using ranges::sample_result;
+    //     using ranges::sample;
+    // }
+    /// @}
+} // namespace ranges
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/algorithm/search.hpp b/inst/include/range/v3/algorithm/search.hpp
new file mode 100644
index 0000000..f13315b
--- /dev/null
+++ b/inst/include/range/v3/algorithm/search.hpp
@@ -0,0 +1,227 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_SEARCH_HPP
+#define RANGES_V3_ALGORITHM_SEARCH_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I1, typename S1, typename D1, typename I2, typename S2,
+                 typename D2, typename C, typename P1, typename P2>
+        subrange<I1> search_sized_impl(I1 const begin1_, S1 end1, D1 const d1_, I2 begin2,
+                                       S2 end2, D2 d2, C & pred, P1 & proj1, P2 & proj2)
+        {
+            D1 d1 = d1_;
+            auto begin1 = uncounted(begin1_);
+            while(true)
+            {
+                // Find first element in sequence 1 that matches *begin2, with a mininum
+                // of loop checks
+                while(true)
+                {
+                    if(d1 < d2) // return the last if we've run out of room
+                    {
+                        auto e =
+                            ranges::next(recounted(begin1_, std::move(begin1), d1_ - d1),
+                                         std::move(end1));
+                        return {e, e};
+                    }
+                    if(invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                        break;
+                    ++begin1;
+                    --d1;
+                }
+                // *begin1 matches *begin2, now match elements after here
+                auto m1 = begin1;
+                I2 m2 = begin2;
+                while(true)
+                {
+                    if(++m2 == end2) // If pattern exhausted, begin1 is the answer (works
+                                     // for 1 element pattern)
+                    {
+                        return {recounted(begin1_, std::move(begin1), d1_ - d1),
+                                recounted(begin1_, std::move(++m1), d1_ - d1)};
+                    }
+                    ++m1; // No need to check, we know we have room to match successfully
+                    if(!invoke(
+                           pred,
+                           invoke(proj1, *m1),
+                           invoke(
+                               proj2,
+                               *m2))) // if there is a mismatch, restart with a new begin1
+                    {
+                        ++begin1;
+                        --d1;
+                        break;
+                    } // else there is a match, check next elements
+                }
+            }
+        }
+
+        template<typename I1, typename S1, typename I2, typename S2, typename C,
+                 typename P1, typename P2>
+        subrange<I1> search_impl(I1 begin1, S1 end1, I2 begin2, S2 end2, C & pred,
+                                 P1 & proj1, P2 & proj2)
+        {
+            while(true)
+            {
+                // Find first element in sequence 1 that matches *begin2, with a mininum
+                // of loop checks
+                while(true)
+                {
+                    if(begin1 == end1) // return end1 if no element matches *begin2
+                        return {begin1, begin1};
+                    if(invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                        break;
+                    ++begin1;
+                }
+                // *begin1 matches *begin2, now match elements after here
+                I1 m1 = begin1;
+                I2 m2 = begin2;
+                while(true)
+                {
+                    if(++m2 == end2) // If pattern exhausted, begin1 is the answer (works
+                                     // for 1 element pattern)
+                        return {begin1, ++m1};
+                    if(++m1 == end1) // Otherwise if source exhausted, pattern not found
+                        return {m1, m1};
+                    if(!invoke(
+                           pred,
+                           invoke(proj1, *m1),
+                           invoke(
+                               proj2,
+                               *m2))) // if there is a mismatch, restart with a new begin1
+                    {
+                        ++begin1;
+                        break;
+                    } // else there is a match, check next elements
+                }
+            }
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(search)
+
+        /// \brief function template \c search
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(search)(I1 begin1,
+                                 S1 end1,
+                                 I2 begin2,
+                                 S2 end2,
+                                 C pred = C{},
+                                 P1 proj1 = P1{},
+                                 P2 proj2 = P2{}) //
+            ->CPP_ret(subrange<I1>)(              //
+                requires forward_iterator<I1> && sentinel_for<S1, I1> &&
+                forward_iterator<I2> && sentinel_for<S2, I2> &&
+                indirectly_comparable<I1, I2, C, P1, P2>)
+        {
+            if(begin2 == end2)
+                return {begin1, begin1};
+            if(RANGES_CONSTEXPR_IF(sized_sentinel_for<S1, I1> &&
+                                   sized_sentinel_for<S2, I2>))
+                return detail::search_sized_impl(std::move(begin1),
+                                                 std::move(end1),
+                                                 distance(begin1, end1),
+                                                 std::move(begin2),
+                                                 std::move(end2),
+                                                 distance(begin2, end2),
+                                                 pred,
+                                                 proj1,
+                                                 proj2);
+            else
+                return detail::search_impl(std::move(begin1),
+                                           std::move(end1),
+                                           std::move(begin2),
+                                           std::move(end2),
+                                           pred,
+                                           proj1,
+                                           proj2);
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename C = equal_to,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(search)(
+            Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{}, P2 proj2 = P2{}) //
+            ->CPP_ret(safe_subrange_t<Rng1>)(                                           //
+                requires forward_range<Rng1> && forward_range<Rng2> &&
+                indirectly_comparable<iterator_t<Rng1>, iterator_t<Rng2>, C, P1, P2>)
+        {
+            if(empty(rng2))
+                return subrange<iterator_t<Rng1>>{begin(rng1), begin(rng1)};
+            if(RANGES_CONSTEXPR_IF(sized_range<Rng1> && sized_range<Rng2>))
+                return detail::search_sized_impl(begin(rng1),
+                                                 end(rng1),
+                                                 distance(rng1),
+                                                 begin(rng2),
+                                                 end(rng2),
+                                                 distance(rng2),
+                                                 pred,
+                                                 proj1,
+                                                 proj2);
+            else
+                return detail::search_impl(
+                    begin(rng1), end(rng1), begin(rng2), end(rng2), pred, proj1, proj2);
+        }
+
+    RANGES_FUNC_END(search)
+
+    namespace cpp20
+    {
+        using ranges::search;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/search_n.hpp b/inst/include/range/v3/algorithm/search_n.hpp
new file mode 100644
index 0000000..c7ad306
--- /dev/null
+++ b/inst/include/range/v3/algorithm/search_n.hpp
@@ -0,0 +1,197 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_SEARCH_N_HPP
+#define RANGES_V3_ALGORITHM_SEARCH_N_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S, typename D, typename V, typename C, typename P>
+        subrange<I> search_n_sized_impl(I const begin_, S last, D const d_, D cnt,
+                                        V const & val, C & pred, P & proj)
+        {
+            D d = d_; // always the distance from first to end
+            auto first = uncounted(begin_);
+            while(true)
+            {
+                // Find first element in sequence 1 that matches val, with a mininum of
+                // loop checks
+                while(true)
+                {
+                    if(d < cnt) // return the last if we've run out of room
+                    {
+                        auto e = ranges::next(recounted(begin_, std::move(first), d_ - d),
+                                              std::move(last));
+                        return {e, e};
+                    }
+                    if(invoke(pred, invoke(proj, *first), val))
+                        break;
+                    ++first;
+                    --d;
+                }
+                // *first matches val, now match elements after here
+                auto m = first;
+                D c = 0;
+                while(true)
+                {
+                    if(++c == cnt) // If pattern exhausted, first is the answer (works
+                                   // for 1 element pattern)
+                        return {recounted(begin_, std::move(first), d_ - d),
+                                recounted(begin_, std::move(++m), d_ - d)};
+                    ++m; // No need to check, we know we have room to match successfully
+                    if(!invoke(pred,
+                               invoke(proj, *m),
+                               val)) // if there is a mismatch, restart with a new begin
+                    {
+                        first = next(std::move(m));
+                        d -= (c + 1);
+                        break;
+                    } // else there is a match, check next elements
+                }
+            }
+        }
+
+        template<typename I, typename S, typename D, typename V, typename C, typename P>
+        subrange<I> search_n_impl(I first, S last, D cnt, V const & val, C & pred,
+                                  P & proj)
+        {
+            while(true)
+            {
+                // Find first element in sequence 1 that matches val, with a mininum of
+                // loop checks
+                while(true)
+                {
+                    if(first == last) // return last if no element matches val
+                        return {first, first};
+                    if(invoke(pred, invoke(proj, *first), val))
+                        break;
+                    ++first;
+                }
+                // *first matches val, now match elements after here
+                I m = first;
+                D c = 0;
+                while(true)
+                {
+                    if(++c == cnt) // If pattern exhausted, first is the answer (works
+                                   // for 1 element pattern)
+                        return {first, ++m};
+                    if(++m == last) // Otherwise if source exhausted, pattern not found
+                        return {m, m};
+                    if(!invoke(pred,
+                               invoke(proj, *m),
+                               val)) // if there is a mismatch, restart with a new begin
+                    {
+                        first = next(std::move(m));
+                        break;
+                    } // else there is a match, check next elements
+                }
+            }
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(search_n)
+
+        /// \brief function template \c search_n
+        template<typename I,
+                 typename S,
+                 typename V,
+                 typename C = equal_to,
+                 typename P = identity>
+        auto RANGES_FUNC(search_n)(I first,
+                                   S last,
+                                   iter_difference_t<I>
+                                       cnt,
+                                   V const & val,
+                                   C pred = C{},
+                                   P proj = P{}) //
+            ->CPP_ret(subrange<I>)(              //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirectly_comparable<I, V const *, C, P>)
+        {
+            if(cnt <= 0)
+                return {first, first};
+            if(RANGES_CONSTEXPR_IF(sized_sentinel_for<S, I>))
+                return detail::search_n_sized_impl(std::move(first),
+                                                   std::move(last),
+                                                   distance(first, last),
+                                                   cnt,
+                                                   val,
+                                                   pred,
+                                                   proj);
+            else
+                return detail::search_n_impl(
+                    std::move(first), std::move(last), cnt, val, pred, proj);
+        }
+
+        /// \overload
+        template<typename Rng, typename V, typename C = equal_to, typename P = identity>
+        auto RANGES_FUNC(search_n)(Rng && rng,
+                                   iter_difference_t<iterator_t<Rng>>
+                                       cnt,
+                                   V const & val,
+                                   C pred = C{},
+                                   P proj = P{}) //
+            ->CPP_ret(safe_subrange_t<Rng>)(     //
+                requires forward_range<Rng> &&
+                indirectly_comparable<iterator_t<Rng>, V const *, C, P>)
+        {
+            if(cnt <= 0)
+                return subrange<iterator_t<Rng>>{begin(rng), begin(rng)};
+            if(RANGES_CONSTEXPR_IF(sized_range<Rng>))
+                return detail::search_n_sized_impl(
+                    begin(rng), end(rng), distance(rng), cnt, val, pred, proj);
+            else
+                return detail::search_n_impl(begin(rng), end(rng), cnt, val, pred, proj);
+        }
+
+    RANGES_FUNC_END(search_n)
+
+    namespace cpp20
+    {
+        using ranges::search_n;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/set_algorithm.hpp b/inst/include/range/v3/algorithm/set_algorithm.hpp
new file mode 100644
index 0000000..23b9ee1
--- /dev/null
+++ b/inst/include/range/v3/algorithm/set_algorithm.hpp
@@ -0,0 +1,447 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_SET_ALGORITHM_HPP
+#define RANGES_V3_ALGORITHM_SET_ALGORITHM_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/copy.hpp>
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(includes)
+
+        /// \brief function template \c includes
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(includes)(I1 begin1,
+                                   S1 end1,
+                                   I2 begin2,
+                                   S2 end2,
+                                   C pred = C{},
+                                   P1 proj1 = P1{},
+                                   P2 proj2 = P2{}) //
+            ->CPP_ret(bool)(                        //
+                requires input_iterator<I1> && sentinel_for<S1, I1> &&
+                input_iterator<I2> && sentinel_for<S2, I2> &&
+                indirect_strict_weak_order<C, projected<I1, P1>, projected<I2, P2>>)
+        {
+            for(; begin2 != end2; ++begin1)
+            {
+                if(begin1 == end1 ||
+                   invoke(pred, invoke(proj2, *begin2), invoke(proj1, *begin1)))
+                    return false;
+                if(!invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                    ++begin2;
+            }
+            return true;
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(includes)(
+            Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{}, P2 proj2 = P2{}) //
+            ->CPP_ret(bool)(                                                            //
+                requires input_range<Rng1> && input_range<Rng2> &&
+                indirect_strict_weak_order<C,
+                                           projected<iterator_t<Rng1>, P1>,
+                                           projected<iterator_t<Rng2>, P2>>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+    RANGES_FUNC_END(includes)
+
+    namespace cpp20
+    {
+        using ranges::includes;
+    }
+
+    template<typename I1, typename I2, typename O>
+    using set_union_result = detail::in1_in2_out_result<I1, I2, O>;
+
+    RANGES_FUNC_BEGIN(set_union)
+
+        /// \brief function template \c set_union
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_union)(I1 begin1,
+                                    S1 end1,
+                                    I2 begin2,
+                                    S2 end2,
+                                    O out,
+                                    C pred = C{},
+                                    P1 proj1 = P1{},
+                                    P2 proj2 = P2{}) //
+            ->CPP_ret(set_union_result<I1, I2, O>)(  //
+                requires sentinel_for<S1, I1> && sentinel_for<S2, I2> &&
+                mergeable<I1, I2, O, C, P1, P2>)
+        {
+            for(; begin1 != end1; ++out)
+            {
+                if(begin2 == end2)
+                {
+                    auto tmp = ranges::copy(begin1, end1, out);
+                    return {tmp.in, begin2, tmp.out};
+                }
+                if(invoke(pred, invoke(proj2, *begin2), invoke(proj1, *begin1)))
+                {
+                    *out = *begin2;
+                    ++begin2;
+                }
+                else
+                {
+                    *out = *begin1;
+                    if(!invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                        ++begin2;
+                    ++begin1;
+                }
+            }
+            auto tmp = ranges::copy(begin2, end2, out);
+            return {begin1, tmp.in, tmp.out};
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_union)(Rng1 && rng1,
+                                    Rng2 && rng2,
+                                    O out,
+                                    C pred = C{},
+                                    P1 proj1 = P1{},
+                                    P2 proj2 = P2{}) //
+            ->CPP_ret(
+                set_union_result<safe_iterator_t<Rng1>, safe_iterator_t<Rng2>, O>)( //
+                requires range<Rng1> && range<Rng2> &&
+                mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(out),
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+    RANGES_FUNC_END(set_union)
+
+    namespace cpp20
+    {
+        using ranges::set_union;
+        using ranges::set_union_result;
+    } // namespace cpp20
+
+    RANGES_FUNC_BEGIN(set_intersection)
+
+        /// \brief function template \c set_intersection
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_intersection)(I1 begin1,
+                                           S1 end1,
+                                           I2 begin2,
+                                           S2 end2,
+                                           O out,
+                                           C pred = C{},
+                                           P1 proj1 = P1{},
+                                           P2 proj2 = P2{}) //
+            ->CPP_ret(O)(                                   //
+                requires sentinel_for<S1, I1> && sentinel_for<S2, I2> &&
+                mergeable<I1, I2, O, C, P1, P2>)
+        {
+            while(begin1 != end1 && begin2 != end2)
+            {
+                if(invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                    ++begin1;
+                else
+                {
+                    if(!invoke(pred, invoke(proj2, *begin2), invoke(proj1, *begin1)))
+                    {
+                        *out = *begin1;
+                        ++out;
+                        ++begin1;
+                    }
+                    ++begin2;
+                }
+            }
+            return out;
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_intersection)(Rng1 && rng1,
+                                           Rng2 && rng2,
+                                           O out,
+                                           C pred = C{},
+                                           P1 proj1 = P1{},
+                                           P2 proj2 = P2{}) //
+            ->CPP_ret(O)(                                   //
+                requires range<Rng1> && range<Rng2> &&
+                mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(out),
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+    RANGES_FUNC_END(set_intersection)
+
+    namespace cpp20
+    {
+        using ranges::set_intersection;
+    }
+
+    template<typename I, typename O>
+    using set_difference_result = detail::in1_out_result<I, O>;
+
+    RANGES_FUNC_BEGIN(set_difference)
+
+        /// \brief function template \c set_difference
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_difference)(I1 begin1,
+                                         S1 end1,
+                                         I2 begin2,
+                                         S2 end2,
+                                         O out,
+                                         C pred = C{},
+                                         P1 proj1 = P1{},
+                                         P2 proj2 = P2{}) //
+            ->CPP_ret(set_difference_result<I1, O>)(      //
+                requires sentinel_for<S1, I1> && sentinel_for<S2, I2> &&
+                mergeable<I1, I2, O, C, P1, P2>)
+        {
+            while(begin1 != end1)
+            {
+                if(begin2 == end2)
+                {
+                    auto tmp = ranges::copy(begin1, end1, out);
+                    return {tmp.in, tmp.out};
+                }
+                if(invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                {
+                    *out = *begin1;
+                    ++out;
+                    ++begin1;
+                }
+                else
+                {
+                    if(!invoke(pred, invoke(proj2, *begin2), invoke(proj1, *begin1)))
+                        ++begin1;
+                    ++begin2;
+                }
+            }
+            return {begin1, out};
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_difference)(Rng1 && rng1,
+                                         Rng2 && rng2,
+                                         O out,
+                                         C pred = C{},
+                                         P1 proj1 = P1{},
+                                         P2 proj2 = P2{})               //
+            ->CPP_ret(set_difference_result<safe_iterator_t<Rng1>, O>)( //
+                requires range<Rng1> && range<Rng2> &&
+                mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(out),
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+    RANGES_FUNC_END(set_difference)
+
+    namespace cpp20
+    {
+        using ranges::set_difference;
+        using ranges::set_difference_result;
+    } // namespace cpp20
+
+    template<typename I1, typename I2, typename O>
+    using set_symmetric_difference_result = detail::in1_in2_out_result<I1, I2, O>;
+
+    RANGES_FUNC_BEGIN(set_symmetric_difference)
+
+        /// \brief function template \c set_symmetric_difference
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_symmetric_difference)(I1 begin1,
+                                                   S1 end1,
+                                                   I2 begin2,
+                                                   S2 end2,
+                                                   O out,
+                                                   C pred = C{},
+                                                   P1 proj1 = P1{},
+                                                   P2 proj2 = P2{}) //
+            ->CPP_ret(set_symmetric_difference_result<I1, I2, O>)(  //
+                requires sentinel_for<S1, I1> && sentinel_for<S2, I2> &&
+                mergeable<I1, I2, O, C, P1, P2>)
+        {
+            while(begin1 != end1)
+            {
+                if(begin2 == end2)
+                {
+                    auto tmp = ranges::copy(begin1, end1, out);
+                    return {tmp.in, begin2, tmp.out};
+                }
+                if(invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))
+                {
+                    *out = *begin1;
+                    ++out;
+                    ++begin1;
+                }
+                else
+                {
+                    if(invoke(pred, invoke(proj2, *begin2), invoke(proj1, *begin1)))
+                    {
+                        *out = *begin2;
+                        ++out;
+                    }
+                    else
+                        ++begin1;
+                    ++begin2;
+                }
+            }
+            auto tmp = ranges::copy(begin2, end2, out);
+            return {begin1, tmp.in, tmp.out};
+        }
+
+        /// \overload
+        template<typename Rng1,
+                 typename Rng2,
+                 typename O,
+                 typename C = less,
+                 typename P1 = identity,
+                 typename P2 = identity>
+        auto RANGES_FUNC(set_symmetric_difference)(Rng1 && rng1,
+                                                   Rng2 && rng2,
+                                                   O out,
+                                                   C pred = C{},
+                                                   P1 proj1 = P1{},
+                                                   P2 proj2 = P2{}) //
+            ->CPP_ret(set_symmetric_difference_result<safe_iterator_t<Rng1>,
+                                                      safe_iterator_t<Rng2>,
+                                                      O>)( //
+                requires range<Rng1> && range<Rng2> &&
+                mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(out),
+                           std::move(pred),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+    RANGES_FUNC_END(set_symmetric_difference)
+
+    namespace cpp20
+    {
+        using ranges::set_symmetric_difference;
+        using ranges::set_symmetric_difference_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/shuffle.hpp b/inst/include/range/v3/algorithm/shuffle.hpp
new file mode 100644
index 0000000..504eba3
--- /dev/null
+++ b/inst/include/range/v3/algorithm/shuffle.hpp
@@ -0,0 +1,87 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_SHUFFLE_HPP
+#define RANGES_V3_ALGORITHM_SHUFFLE_HPP
+
+#include <cstdint>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/random.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(shuffle)
+
+        /// \brief function template \c shuffle
+        template<typename I, typename S, typename Gen = detail::default_random_engine &>
+        auto RANGES_FUNC(shuffle)(I const first,
+                                  S const last,
+                                  Gen && gen = detail::get_random_engine()) //
+            ->CPP_ret(I)(                                                   //
+                requires random_access_iterator<I> && sentinel_for<S, I> &&
+                permutable<I> &&
+                uniform_random_bit_generator<std::remove_reference_t<Gen>> &&
+                convertible_to<invoke_result_t<Gen &>, iter_difference_t<I>>)
+        {
+            auto mid = first;
+            if(mid == last)
+                return mid;
+            using D1 = iter_difference_t<I>;
+            using D2 = detail::if_then_t<std::is_integral<D1>::value, D1, std::ptrdiff_t>;
+            std::uniform_int_distribution<D2> uid{};
+            using param_t = typename decltype(uid)::param_type;
+            while(++mid != last)
+            {
+                RANGES_ENSURE(mid - first <= PTRDIFF_MAX);
+                if(auto const i = uid(gen, param_t{0, D2(mid - first)}))
+                    ranges::iter_swap(mid - i, mid);
+            }
+            return mid;
+        }
+
+        /// \overload
+        template<typename Rng, typename Gen = detail::default_random_engine &>
+        auto RANGES_FUNC(shuffle)(Rng && rng,
+                                  Gen && rand = detail::get_random_engine()) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                 //
+                requires random_access_range<Rng> && permutable<iterator_t<Rng>> &&
+                uniform_random_bit_generator<std::remove_reference_t<Gen>> &&
+                convertible_to<invoke_result_t<Gen &>,
+                               iter_difference_t<iterator_t<Rng>>>)
+        {
+            return (*this)(begin(rng), end(rng), static_cast<Gen &&>(rand));
+        }
+
+    RANGES_FUNC_END(shuffle)
+
+    namespace cpp20
+    {
+        using ranges::shuffle;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/sort.hpp b/inst/include/range/v3/algorithm/sort.hpp
new file mode 100644
index 0000000..434e5fc
--- /dev/null
+++ b/inst/include/range/v3/algorithm/sort.hpp
@@ -0,0 +1,229 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//  Copyright (c) 1994
+//  Hewlett-Packard Company
+//
+//  Permission to use, copy, modify, distribute and sell this software
+//  and its documentation for any purpose is hereby granted without fee,
+//  provided that the above copyright notice appear in all copies and
+//  that both that copyright notice and this permission notice appear
+//  in supporting documentation.  Hewlett-Packard Company makes no
+//  representations about the suitability of this software for any
+//  purpose.  It is provided "as is" without express or implied warranty.
+//
+//  Copyright (c) 1996
+//  Silicon Graphics Computer Systems, Inc.
+//
+//  Permission to use, copy, modify, distribute and sell this software
+//  and its documentation for any purpose is hereby granted without fee,
+//  provided that the above copyright notice appear in all copies and
+//  that both that copyright notice and this permission notice appear
+//  in supporting documentation.  Silicon Graphics makes no
+//  representations about the suitability of this software for any
+//  purpose.  It is provided "as is" without express or implied warranty.
+//
+
+#ifndef RANGES_V3_ALGORITHM_SORT_HPP
+#define RANGES_V3_ALGORITHM_SORT_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/heap_algorithm.hpp>
+#include <range/v3/algorithm/move_backward.hpp>
+#include <range/v3/algorithm/partial_sort.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename C, typename P>
+        inline I unguarded_partition(I first, I last, C & pred, P & proj)
+        {
+            I mid = first + (last - first) / 2, penultimate = ranges::prev(last);
+            auto &&x = *first, &&y = *mid, &&z = *penultimate;
+            auto &&a = invoke(proj, (decltype(x) &&)x),
+                 &&b = invoke(proj, (decltype(y) &&)y),
+                 &&c = invoke(proj, (decltype(z) &&)z);
+
+            // Find the median:
+            I pivot_pnt =
+                invoke(pred, a, b)
+                    ? (invoke(pred, b, c) ? mid
+                                          : (invoke(pred, a, c) ? penultimate : first))
+                    : (invoke(pred, a, c) ? first
+                                          : (invoke(pred, b, c) ? penultimate : mid));
+
+            // Do the partition:
+            while(true)
+            {
+                auto && v = *pivot_pnt;
+                auto && pivot = invoke(proj, (decltype(v) &&)v);
+                while(invoke(pred, invoke(proj, *first), pivot))
+                    ++first;
+                --last;
+                while(invoke(pred, pivot, invoke(proj, *last)))
+                    --last;
+                if(!(first < last))
+                    return first;
+                ranges::iter_swap(first, last);
+                pivot_pnt =
+                    pivot_pnt == first ? last : (pivot_pnt == last ? first : pivot_pnt);
+                ++first;
+            }
+        }
+
+        template<typename I, typename C, typename P>
+        inline void unguarded_linear_insert(I last, iter_value_t<I> val, C & pred,
+                                            P & proj)
+        {
+            I next = prev(last);
+            while(invoke(pred, invoke(proj, val), invoke(proj, *next)))
+            {
+                *last = iter_move(next);
+                last = next;
+                --next;
+            }
+            *last = std::move(val);
+        }
+
+        template<typename I, typename C, typename P>
+        inline void linear_insert(I first, I last, C & pred, P & proj)
+        {
+            iter_value_t<I> val = iter_move(last);
+            if(invoke(pred, invoke(proj, val), invoke(proj, *first)))
+            {
+                move_backward(first, last, last + 1);
+                *first = std::move(val);
+            }
+            else
+                detail::unguarded_linear_insert(last, std::move(val), pred, proj);
+        }
+
+        template<typename I, typename C, typename P>
+        inline void insertion_sort(I first, I last, C & pred, P & proj)
+        {
+            if(first == last)
+                return;
+            for(I i = next(first); i != last; ++i)
+                detail::linear_insert(first, i, pred, proj);
+        }
+
+        template<typename I, typename C, typename P>
+        inline void unguarded_insertion_sort(I first, I last, C & pred, P & proj)
+        {
+            for(I i = first; i != last; ++i)
+                detail::unguarded_linear_insert(i, iter_move(i), pred, proj);
+        }
+
+        constexpr int introsort_threshold()
+        {
+            return 16;
+        }
+
+        template<typename I, typename C, typename P>
+        inline void final_insertion_sort(I first, I last, C & pred, P & proj)
+        {
+            if(last - first > detail::introsort_threshold())
+            {
+                detail::insertion_sort(
+                    first, first + detail::introsort_threshold(), pred, proj);
+                detail::unguarded_insertion_sort(
+                    first + detail::introsort_threshold(), last, pred, proj);
+            }
+            else
+                detail::insertion_sort(first, last, pred, proj);
+        }
+
+        template<typename Size>
+        inline Size log2(Size n)
+        {
+            Size k = 0;
+            for(; n != 1; n >>= 1)
+                ++k;
+            return k;
+        }
+
+        template<typename I, typename Size, typename C, typename P>
+        inline void introsort_loop(I first, I last, Size depth_limit, C & pred, P & proj)
+        {
+            while(last - first > detail::introsort_threshold())
+            {
+                if(depth_limit == 0)
+                    return partial_sort(
+                               first, last, last, std::ref(pred), std::ref(proj)),
+                           void();
+                I cut = detail::unguarded_partition(first, last, pred, proj);
+                detail::introsort_loop(cut, last, --depth_limit, pred, proj);
+                last = cut;
+            }
+        }
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-algorithms
+    /// @{
+
+    // Introsort: Quicksort to a certain depth, then Heapsort. Insertion
+    // sort below a certain threshold.
+    // TODO Forward iterators, like EoP?
+
+    RANGES_FUNC_BEGIN(sort)
+
+        /// \brief function template \c sort
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(sort)(I first, S end_, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                                   //
+                requires sortable<I, C, P> && random_access_iterator<I> &&
+                sentinel_for<S, I>)
+        {
+            I last = ranges::next(first, std::move(end_));
+            if(first != last)
+            {
+                detail::introsort_loop(
+                    first, last, detail::log2(last - first) * 2, pred, proj);
+                detail::final_insertion_sort(first, last, pred, proj);
+            }
+            return last;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(sort)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                           //
+                requires sortable<iterator_t<Rng>, C, P> && random_access_range<Rng>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(sort)
+
+    namespace cpp20
+    {
+        using ranges::sort;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/stable_partition.hpp b/inst/include/range/v3/algorithm/stable_partition.hpp
new file mode 100644
index 0000000..2d34052
--- /dev/null
+++ b/inst/include/range/v3/algorithm/stable_partition.hpp
@@ -0,0 +1,328 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===-------------------------- algorithm ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_ALGORITHM_STABLE_PARTITION_HPP
+#define RANGES_V3_ALGORITHM_STABLE_PARTITION_HPP
+
+#include <functional>
+#include <memory>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/move.hpp>
+#include <range/v3/algorithm/partition_copy.hpp>
+#include <range/v3/algorithm/rotate.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/move_iterators.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/memory.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename C, typename P, typename D, typename Pair>
+        I stable_partition_impl(I first, I last, C pred, P proj, D len, Pair const p,
+                                std::forward_iterator_tag fi)
+        {
+            // *first is known to be false
+            // len >= 1
+            if(len == 1)
+                return first;
+            if(len == 2)
+            {
+                I tmp = first;
+                if(invoke(pred, invoke(proj, *++tmp)))
+                {
+                    ranges::iter_swap(first, tmp);
+                    return tmp;
+                }
+                return first;
+            }
+            if(len <= p.second)
+            { // The buffer is big enough to use
+                // Move the falses into the temporary buffer, and the trues to the front
+                // of the line Update first to always point to the last of the trues
+                auto tmpbuf = make_raw_buffer(p.first);
+                auto buf = tmpbuf.begin();
+                *buf = iter_move(first);
+                ++buf;
+                auto res = partition_copy(make_move_iterator(next(first)),
+                                          make_move_sentinel(last),
+                                          first,
+                                          buf,
+                                          std::ref(pred),
+                                          std::ref(proj));
+                // All trues now at start of range, all falses in buffer
+                // Move falses back into range, but don't mess up first which points to
+                // first false
+                ranges::move(p.first, res.out2.base().base(), res.out1);
+                // h destructs moved-from values out of the temp buffer, but doesn't
+                // deallocate buffer
+                return res.out1;
+            }
+            // Else not enough buffer, do in place
+            // len >= 3
+            D half = len / 2; // half >= 2
+            I middle = next(first, half);
+            // recurse on [first, middle), *first know to be false
+            // F?????????????????
+            // f       m         l
+            I begin_false =
+                detail::stable_partition_impl(first, middle, pred, proj, half, p, fi);
+            // TTTFFFFF??????????
+            // f  ff   m         l
+            // recurse on [middle, last], except increase middle until *(middle) is false,
+            // *last know to be true
+            I m1 = middle;
+            D len_half = len - half;
+            while(invoke(pred, invoke(proj, *m1)))
+            {
+                if(++m1 == last)
+                    return ranges::rotate(begin_false, middle, last).begin();
+                --len_half;
+            }
+            // TTTFFFFFTTTF??????
+            // f  ff   m  m1     l
+            I end_false =
+                detail::stable_partition_impl(m1, last, pred, proj, len_half, p, fi);
+            // TTTFFFFFTTTTTFFFFF
+            // f  ff   m    sf   l
+            return ranges::rotate(begin_false, middle, end_false).begin();
+            // TTTTTTTTFFFFFFFFFF
+            //         |
+        }
+
+        template<typename I, typename S, typename C, typename P>
+        I stable_partition_impl(I first, S last, C pred, P proj,
+                                std::forward_iterator_tag fi)
+        {
+            using difference_type = iter_difference_t<I>;
+            difference_type const alloc_limit = 3; // might want to make this a function
+                                                   // of trivial assignment.
+            // Either prove all true and return first or point to first false
+            while(true)
+            {
+                if(first == last)
+                    return first;
+                if(!invoke(pred, invoke(proj, *first)))
+                    break;
+                ++first;
+            }
+            // We now have a reduced range [first, last)
+            // *first is known to be false
+            using value_type = iter_value_t<I>;
+            auto len_end = enumerate(first, last);
+            auto p = len_end.first >= alloc_limit
+                         ? detail::get_temporary_buffer<value_type>(len_end.first)
+                         : detail::value_init{};
+            std::unique_ptr<value_type, detail::return_temporary_buffer> const h{p.first};
+            return detail::stable_partition_impl(
+                first, len_end.second, pred, proj, len_end.first, p, fi);
+        }
+
+        template<typename I, typename C, typename P, typename D, typename Pair>
+        I stable_partition_impl(I first, I last, C pred, P proj, D len, Pair p,
+                                std::bidirectional_iterator_tag bi)
+        {
+            // *first is known to be false
+            // *last is known to be true
+            // len >= 2
+            if(len == 2)
+            {
+                ranges::iter_swap(first, last);
+                return last;
+            }
+            if(len == 3)
+            {
+                I tmp = first;
+                if(invoke(pred, invoke(proj, *++tmp)))
+                {
+                    ranges::iter_swap(first, tmp);
+                    ranges::iter_swap(tmp, last);
+                    return last;
+                }
+                ranges::iter_swap(tmp, last);
+                ranges::iter_swap(first, tmp);
+                return tmp;
+            }
+            if(len <= p.second)
+            { // The buffer is big enough to use
+                // Move the falses into the temporary buffer, and the trues to the front
+                // of the line Update first to always point to the last of the trues
+                auto tmpbuf = ranges::make_raw_buffer(p.first);
+                auto buf = tmpbuf.begin();
+                *buf = iter_move(first);
+                ++buf;
+                auto res = partition_copy(make_move_iterator(next(first)),
+                                          make_move_sentinel(last),
+                                          first,
+                                          buf,
+                                          std::ref(pred),
+                                          std::ref(proj));
+                first = res.out1;
+                // move *last, known to be true
+                *first = iter_move(res.in);
+                ++first;
+                // All trues now at start of range, all falses in buffer
+                // Move falses back into range, but don't mess up first which points to
+                // first false
+                ranges::move(p.first, res.out2.base().base(), first);
+                // h destructs moved-from values out of the temp buffer, but doesn't
+                // deallocate buffer
+                return first;
+            }
+            // Else not enough buffer, do in place
+            // len >= 4
+            I middle = first;
+            D half = len / 2; // half >= 2
+            advance(middle, half);
+            // recurse on [first, middle-1], except reduce middle-1 until *(middle-1) is
+            // true, *first know to be false F????????????????T f       m        l
+            I m1 = middle;
+            I begin_false = first;
+            D len_half = half;
+            while(!invoke(pred, invoke(proj, *--m1)))
+            {
+                if(m1 == first)
+                    goto first_half_done;
+                --len_half;
+            }
+            // F???TFFF?????????T
+            // f   m1  m        l
+            begin_false =
+                detail::stable_partition_impl(first, m1, pred, proj, len_half, p, bi);
+        first_half_done:
+            // TTTFFFFF?????????T
+            // f  ff   m        l
+            // recurse on [middle, last], except increase middle until *(middle) is false,
+            // *last know to be true
+            m1 = middle;
+            len_half = len - half;
+            while(invoke(pred, invoke(proj, *m1)))
+            {
+                if(++m1 == last)
+                    return ranges::rotate(begin_false, middle, ++last).begin();
+                --len_half;
+            }
+            // TTTFFFFFTTTF?????T
+            // f  ff   m  m1    l
+            I end_false =
+                detail::stable_partition_impl(m1, last, pred, proj, len_half, p, bi);
+            // TTTFFFFFTTTTTFFFFF
+            // f  ff   m    sf  l
+            return ranges::rotate(begin_false, middle, end_false).begin();
+            // TTTTTTTTFFFFFFFFFF
+            //         |
+        }
+
+        template<typename I, typename S, typename C, typename P>
+        I stable_partition_impl(I first, S end_, C pred, P proj,
+                                std::bidirectional_iterator_tag bi)
+        {
+            using difference_type = iter_difference_t<I>;
+            using value_type = iter_value_t<I>;
+            difference_type const alloc_limit =
+                4; // might want to make this a function of trivial assignment
+            // Either prove all true and return first or point to first false
+            while(true)
+            {
+                if(first == end_)
+                    return first;
+                if(!invoke(pred, invoke(proj, *first)))
+                    break;
+                ++first;
+            }
+            // first points to first false, everything prior to first is already set.
+            // Either prove [first, last) is all false and return first, or point last to
+            // last true
+            I last = ranges::next(first, end_);
+            do
+            {
+                if(first == --last)
+                    return first;
+            } while(!invoke(pred, invoke(proj, *last)));
+            // We now have a reduced range [first, last]
+            // *first is known to be false
+            // *last is known to be true
+            // len >= 2
+            auto len = distance(first, last) + 1;
+            auto p = len >= alloc_limit ? detail::get_temporary_buffer<value_type>(len)
+                                        : detail::value_init{};
+            std::unique_ptr<value_type, detail::return_temporary_buffer> const h{p.first};
+            return detail::stable_partition_impl(first, last, pred, proj, len, p, bi);
+        }
+    } // namespace detail
+    /// endcond
+
+    RANGES_FUNC_BEGIN(stable_partition)
+
+        /// \brief function template \c stable_partition
+        template<typename I, typename S, typename C, typename P = identity>
+        auto RANGES_FUNC(stable_partition)(I first, S last, C pred, P proj = P{}) //
+            ->CPP_ret(I)(                                                         //
+                requires bidirectional_iterator<I> && sentinel_for<S, I> &&
+                indirect_unary_predicate<C, projected<I, P>> && permutable<I>)
+        {
+            return detail::stable_partition_impl(std::move(first),
+                                                 std::move(last),
+                                                 std::ref(pred),
+                                                 std::ref(proj),
+                                                 iterator_tag_of<I>());
+        }
+
+        // BUGBUG Can this be optimized if Rng has O1 size?
+        /// \overload
+        template<typename Rng, typename C, typename P = identity>
+        auto RANGES_FUNC(stable_partition)(Rng && rng, C pred, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                 //
+                requires bidirectional_range<Rng> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> &&
+                permutable<iterator_t<Rng>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(stable_partition)
+
+    namespace cpp20
+    {
+        using ranges::stable_partition;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/stable_sort.hpp b/inst/include/range/v3/algorithm/stable_sort.hpp
new file mode 100644
index 0000000..421e6c4
--- /dev/null
+++ b/inst/include/range/v3/algorithm/stable_sort.hpp
@@ -0,0 +1,233 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//  Copyright (c) 1994
+//  Hewlett-Packard Company
+//
+//  Permission to use, copy, modify, distribute and sell this software
+//  and its documentation for any purpose is hereby granted without fee,
+//  provided that the above copyright notice appear in all copies and
+//  that both that copyright notice and this permission notice appear
+//  in supporting documentation.  Hewlett-Packard Company makes no
+//  representations about the suitability of this software for any
+//  purpose.  It is provided "as is" without express or implied warranty.
+//
+//  Copyright (c) 1996
+//  Silicon Graphics Computer Systems, Inc.
+//
+//  Permission to use, copy, modify, distribute and sell this software
+//  and its documentation for any purpose is hereby granted without fee,
+//  provided that the above copyright notice appear in all copies and
+//  that both that copyright notice and this permission notice appear
+//  in supporting documentation.  Silicon Graphics makes no
+//  representations about the suitability of this software for any
+//  purpose.  It is provided "as is" without express or implied warranty.
+//
+
+#ifndef RANGES_V3_ALGORITHM_STABLE_SORT_HPP
+#define RANGES_V3_ALGORITHM_STABLE_SORT_HPP
+
+#include <functional>
+#include <iterator>
+#include <memory>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/inplace_merge.hpp>
+#include <range/v3/algorithm/merge.hpp>
+#include <range/v3/algorithm/min.hpp>
+#include <range/v3/algorithm/sort.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/move_iterators.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/memory.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename C, typename P>
+        void inplace_stable_sort(I first, I last, C & pred, P & proj)
+        {
+            if(last - first < 15)
+                return detail::insertion_sort(first, last, pred, proj), void();
+            I middle = first + (last - first) / 2;
+            detail::inplace_stable_sort(first, middle, pred, proj);
+            detail::inplace_stable_sort(middle, last, pred, proj);
+            detail::inplace_merge_no_buffer(first,
+                                            middle,
+                                            last,
+                                            middle - first,
+                                            last - middle,
+                                            std::ref(pred),
+                                            std::ref(proj));
+        }
+
+        template<typename I1, typename I2, typename D, typename C, typename P>
+        void merge_sort_loop(I1 first, I1 last, I2 result, D step_size, C & pred,
+                             P & proj)
+        {
+            D two_step = 2 * step_size;
+            while(last - first >= two_step)
+            {
+                result = merge(make_move_iterator(first),
+                               make_move_iterator(first + step_size),
+                               make_move_iterator(first + step_size),
+                               make_move_iterator(first + two_step),
+                               result,
+                               std::ref(pred),
+                               std::ref(proj),
+                               std::ref(proj))
+                             .out;
+                first += two_step;
+            }
+            step_size = ranges::min(D(last - first), step_size);
+            merge(make_move_iterator(first),
+                  make_move_iterator(first + step_size),
+                  make_move_iterator(first + step_size),
+                  make_move_iterator(last),
+                  result,
+                  std::ref(pred),
+                  std::ref(proj),
+                  std::ref(proj));
+        }
+
+        constexpr int merge_sort_chunk_size()
+        {
+            return 7;
+        }
+
+        template<typename I, typename D, typename C, typename P>
+        void chunk_insertion_sort(I first, I last, D chunk_size, C & pred, P & proj)
+        {
+            while(last - first >= chunk_size)
+            {
+                detail::insertion_sort(first, first + chunk_size, pred, proj);
+                first += chunk_size;
+            }
+            detail::insertion_sort(first, last, pred, proj);
+        }
+
+        // buffer points to raw memory, we create objects, and then restore the buffer to
+        // raw memory by destroying the objects on return.
+        template<typename I, typename V, typename C, typename P>
+        void merge_sort_with_buffer(I first, I last, V * buffer, C & pred, P & proj)
+        {
+            iter_difference_t<I> len = last - first,
+                                 step_size = detail::merge_sort_chunk_size();
+            detail::chunk_insertion_sort(first, last, step_size, pred, proj);
+            if(step_size >= len)
+                return;
+            // The first call to merge_sort_loop moves into raw storage. Construct
+            // on-demand and keep track of how many objects we need to destroy.
+            V * buffer_end = buffer + static_cast<std::ptrdiff_t>(len);
+            auto tmpbuf = make_raw_buffer(buffer);
+            detail::merge_sort_loop(first, last, tmpbuf.begin(), step_size, pred, proj);
+            step_size *= 2;
+        loop:
+            detail::merge_sort_loop(
+                buffer, buffer_end, first, (std::ptrdiff_t)step_size, pred, proj);
+            step_size *= 2;
+            if(step_size >= len)
+                return;
+            detail::merge_sort_loop(first, last, buffer, step_size, pred, proj);
+            step_size *= 2;
+            goto loop;
+        }
+
+        // buffer points to raw memory
+        template<typename I, typename V, typename C, typename P>
+        void stable_sort_adaptive(I first, I last, V * buffer, std::ptrdiff_t buffer_size,
+                                  C & pred, P & proj)
+        {
+            iter_difference_t<I> len = (last - first + 1) / 2;
+            I middle = first + len;
+            if(len > buffer_size)
+            {
+                detail::stable_sort_adaptive(
+                    first, middle, buffer, buffer_size, pred, proj);
+                detail::stable_sort_adaptive(
+                    middle, last, buffer, buffer_size, pred, proj);
+            }
+            else
+            {
+                detail::merge_sort_with_buffer(first, middle, buffer, pred, proj);
+                detail::merge_sort_with_buffer(middle, last, buffer, pred, proj);
+            }
+            detail::merge_adaptive(first,
+                                   middle,
+                                   last,
+                                   middle - first,
+                                   last - middle,
+                                   buffer,
+                                   buffer_size,
+                                   std::ref(pred),
+                                   std::ref(proj));
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(stable_sort)
+
+        /// \brief function template \c stable_sort
+        template<typename I, typename S, typename C = less, typename P = identity>
+        auto RANGES_FUNC(stable_sort)(I first, S end_, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                                          //
+                requires sortable<I, C, P> && random_access_iterator<I> &&
+                sentinel_for<S, I>)
+        {
+            I last = ranges::next(first, end_);
+            using D = iter_difference_t<I>;
+            using V = iter_value_t<I>;
+            D len = last - first;
+            auto buf =
+                len > 256 ? detail::get_temporary_buffer<V>(len) : detail::value_init{};
+            std::unique_ptr<V, detail::return_temporary_buffer> h{buf.first};
+            if(buf.first == nullptr)
+                detail::inplace_stable_sort(first, last, pred, proj);
+            else
+                detail::stable_sort_adaptive(
+                    first, last, buf.first, buf.second, pred, proj);
+            return last;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = less, typename P = identity>
+        auto RANGES_FUNC(stable_sort)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                  //
+                requires sortable<iterator_t<Rng>, C, P> && random_access_range<Rng>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(stable_sort)
+
+    namespace cpp20
+    {
+        using ranges::stable_sort;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/starts_with.hpp b/inst/include/range/v3/algorithm/starts_with.hpp
new file mode 100644
index 0000000..50286b8
--- /dev/null
+++ b/inst/include/range/v3/algorithm/starts_with.hpp
@@ -0,0 +1,98 @@
+// Range v3 library
+//
+//  Copyright 2019 Christopher Di Bella
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+#ifndef RANGES_V3_ALGORITHM_STARTS_WITH_HPP
+#define RANGES_V3_ALGORITHM_STARTS_WITH_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/equal.hpp>
+#include <range/v3/algorithm/mismatch.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    // template<typename I1, typename I2>
+    // struct starts_with_result : detail::in1_in2_result<I1, I2>
+    // {
+    //     bool result;
+    // };
+
+    RANGES_FUNC_BEGIN(starts_with)
+
+        /// \brief function template \c starts_with
+        template<typename I1,
+                 typename S1,
+                 typename I2,
+                 typename S2,
+                 typename Comp = equal_to,
+                 typename Proj1 = identity,
+                 typename Proj2 = identity>
+        constexpr auto RANGES_FUNC(starts_with)(I1 first1,
+                                                S1 last1,
+                                                I2 first2,
+                                                S2 last2,
+                                                Comp comp = {},
+                                                Proj1 proj1 = {},
+                                                Proj2 proj2 = {}) //
+            ->CPP_ret(bool)(                                      //
+                requires input_iterator<I1> && sentinel_for<S1, I1> &&
+                input_iterator<I2> && sentinel_for<S2, I2> &&
+                indirectly_comparable<I1, I2, Comp, Proj1, Proj2>)
+        {
+            return mismatch(std::move(first1),
+                            std::move(last1),
+                            std::move(first2),
+                            last2,
+                            std::move(comp),
+                            std::move(proj1),
+                            std::move(proj2))
+                       .in2 == last2;
+        }
+
+        /// \overload
+        template<typename R1,
+                 typename R2,
+                 typename Comp = equal_to,
+                 typename Proj1 = identity,
+                 typename Proj2 = identity>
+        constexpr auto RANGES_FUNC(starts_with)(
+            R1 && r1, R2 && r2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) //
+            ->CPP_ret(bool)(                                                        //
+                requires input_range<R1> && input_range<R2> &&
+                indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Comp, Proj1, Proj2>)
+        {
+            return (*this)( //
+                begin(r1),
+                end(r1),
+                begin(r2),
+                end(r2),
+                std::move(comp),
+                std::move(proj1),
+                std::move(proj2));
+        }
+
+    RANGES_FUNC_END(starts_with)
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ALGORITHM_STARTS_WITH_HPP
diff --git a/inst/include/range/v3/algorithm/swap_ranges.hpp b/inst/include/range/v3/algorithm/swap_ranges.hpp
new file mode 100644
index 0000000..494013f
--- /dev/null
+++ b/inst/include/range/v3/algorithm/swap_ranges.hpp
@@ -0,0 +1,93 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_SWAP_RANGES_HPP
+#define RANGES_V3_ALGORITHM_SWAP_RANGES_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I1, typename I2>
+    using swap_ranges_result = detail::in1_in2_result<I1, I2>;
+
+    RANGES_FUNC_BEGIN(swap_ranges)
+
+        /// \brief function template \c swap_ranges
+        template<typename I1, typename S1, typename I2>
+        auto RANGES_FUNC(swap_ranges)(I1 begin1, S1 end1, I2 begin2) //
+            ->CPP_ret(swap_ranges_result<I1, I2>)(                   //
+                requires input_iterator<I1> && sentinel_for<S1, I1> &&
+                input_iterator<I2> && indirectly_swappable<I1, I2>)
+        {
+            for(; begin1 != end1; ++begin1, ++begin2)
+                ranges::iter_swap(begin1, begin2);
+            return {begin1, begin2};
+        }
+
+        /// \overload
+        template<typename I1, typename S1, typename I2, typename S2>
+        auto RANGES_FUNC(swap_ranges)(I1 begin1,
+                                      S1 end1,
+                                      I2 begin2,
+                                      S2 end2)     //
+            ->CPP_ret(swap_ranges_result<I1, I2>)( //
+                requires input_iterator<I1> && sentinel_for<S1, I1> &&
+                input_iterator<I2> && sentinel_for<S2, I2> &&
+                indirectly_swappable<I1, I2>)
+        {
+            for(; begin1 != end1 && begin2 != end2; ++begin1, ++begin2)
+                ranges::iter_swap(begin1, begin2);
+            return {begin1, begin2};
+        }
+
+        template<typename Rng1, typename I2_>
+        auto RANGES_FUNC(swap_ranges)(Rng1 && rng1, I2_ && begin2)           //
+            ->CPP_ret(swap_ranges_result<iterator_t<Rng1>, uncvref_t<I2_>>)( //
+                requires input_range<Rng1> && input_iterator<uncvref_t<I2_>> &&
+                indirectly_swappable<iterator_t<Rng1>, uncvref_t<I2_>>)
+        {
+            return (*this)(begin(rng1), end(rng1), (I2_ &&) begin2);
+        }
+
+        template<typename Rng1, typename Rng2>
+        auto RANGES_FUNC(swap_ranges)(Rng1 && rng1, Rng2 && rng2) //
+            ->CPP_ret(
+                swap_ranges_result<safe_iterator_t<Rng1>, safe_iterator_t<Rng2>>)( //
+                requires input_range<Rng1> && input_range<Rng2> &&
+                indirectly_swappable<iterator_t<Rng1>, iterator_t<Rng2>>)
+        {
+            return (*this)(begin(rng1), end(rng1), begin(rng2), end(rng2));
+        }
+
+    RANGES_FUNC_END(swap_ranges)
+
+    namespace cpp20
+    {
+        using ranges::swap_ranges;
+        using ranges::swap_ranges_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/tagspec.hpp b/inst/include/range/v3/algorithm/tagspec.hpp
new file mode 100644
index 0000000..c4c726b
--- /dev/null
+++ b/inst/include/range/v3/algorithm/tagspec.hpp
@@ -0,0 +1,48 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#ifndef RANGES_V3_ALGORITHM_TAGSPEC_HPP
+#define RANGES_V3_ALGORITHM_TAGSPEC_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/tagged_pair.hpp>
+
+RANGES_DEPRECATED_HEADER(
+    "This file is deprecated. Please discontinue using the tag types defined here and "
+    "define your own.")
+
+namespace ranges
+{
+    /// \cond
+    RANGES_DEFINE_TAG_SPECIFIER(in)
+    RANGES_DEFINE_TAG_SPECIFIER(in1)
+    RANGES_DEFINE_TAG_SPECIFIER(in2)
+    RANGES_DEFINE_TAG_SPECIFIER(out)
+    RANGES_DEFINE_TAG_SPECIFIER(out1)
+    RANGES_DEFINE_TAG_SPECIFIER(out2)
+    RANGES_DEFINE_TAG_SPECIFIER(fun)
+    RANGES_DEFINE_TAG_SPECIFIER(min)
+    RANGES_DEFINE_TAG_SPECIFIER(max)
+    RANGES_DEFINE_TAG_SPECIFIER(begin)
+    RANGES_DEFINE_TAG_SPECIFIER(end)
+
+    RANGES_DEFINE_TAG_SPECIFIER(current)
+    RANGES_DEFINE_TAG_SPECIFIER(engine)
+    RANGES_DEFINE_TAG_SPECIFIER(range)
+    RANGES_DEFINE_TAG_SPECIFIER(size)
+
+    RANGES_DEFINE_TAG_SPECIFIER(first)
+    RANGES_DEFINE_TAG_SPECIFIER(second)
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/algorithm/transform.hpp b/inst/include/range/v3/algorithm/transform.hpp
new file mode 100644
index 0000000..22c8bfd
--- /dev/null
+++ b/inst/include/range/v3/algorithm/transform.hpp
@@ -0,0 +1,210 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_TRANSFORM_HPP
+#define RANGES_V3_ALGORITHM_TRANSFORM_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    template<typename I, typename O>
+    using unary_transform_result = detail::in_out_result<I, O>;
+
+    template<typename I1, typename I2, typename O>
+    using binary_transform_result = detail::in1_in2_out_result<I1, I2, O>;
+
+    RANGES_FUNC_BEGIN(transform)
+
+        // Single-range variant
+        /// \brief function template \c transform
+        template<typename I, typename S, typename O, typename F, typename P = identity>
+        auto RANGES_FUNC(transform)(I first, S last, O out, F fun, P proj = P{}) //
+            ->CPP_ret(unary_transform_result<I, O>)(                             //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                weakly_incrementable<O> && copy_constructible<F> &&
+                writable<O, indirect_result_t<F &, projected<I, P>>>)
+        {
+            for(; first != last; ++first, ++out)
+                *out = invoke(fun, invoke(proj, *first));
+            return {first, out};
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename F, typename P = identity>
+        auto RANGES_FUNC(transform)(Rng && rng, O out, F fun, P proj = P{}) //
+            ->CPP_ret(unary_transform_result<safe_iterator_t<Rng>, O>)(     //
+                requires input_range<Rng> && weakly_incrementable<O> &&
+                copy_constructible<F> &&
+                writable<O, indirect_result_t<F &, projected<iterator_t<Rng>, P>>>)
+        {
+            return (*this)(
+                begin(rng), end(rng), std::move(out), std::move(fun), std::move(proj));
+        }
+
+        // Double-range variant, 4-iterator version
+        /// \overload
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename S1,
+                 typename O,
+                 typename F,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        auto RANGES_FUNC(transform)(I0 begin0,
+                                    S0 end0,
+                                    I1 begin1,
+                                    S1 end1,
+                                    O out,
+                                    F fun,
+                                    P0 proj0 = P0{},
+                                    P1 proj1 = P1{})       //
+            ->CPP_ret(binary_transform_result<I0, I1, O>)( //
+                requires input_iterator<I0> && sentinel_for<S0, I0> &&
+                input_iterator<I1> && sentinel_for<S1, I1> && weakly_incrementable<O> &&
+                copy_constructible<F> &&
+                writable<O, indirect_result_t<F &, projected<I0, P0>, projected<I1, P1>>>)
+        {
+            for(; begin0 != end0 && begin1 != end1; ++begin0, ++begin1, ++out)
+                *out = invoke(fun, invoke(proj0, *begin0), invoke(proj1, *begin1));
+            return {begin0, begin1, out};
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename Rng1,
+                 typename O,
+                 typename F,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        auto RANGES_FUNC(transform)(
+            Rng0 && rng0, Rng1 && rng1, O out, F fun, P0 proj0 = P0{}, P1 proj1 = P1{}) //
+            ->CPP_ret(binary_transform_result<safe_iterator_t<Rng0>,
+                                              safe_iterator_t<Rng1>,
+                                              O>)( //
+                requires input_range<Rng0> && input_range<Rng1> &&
+                weakly_incrementable<O> && copy_constructible<F> &&
+                writable<O,
+                         indirect_result_t<F &,
+                                           projected<iterator_t<Rng0>, P0>,
+                                           projected<iterator_t<Rng1>, P1>>>)
+        {
+            return (*this)(begin(rng0),
+                           end(rng0),
+                           begin(rng1),
+                           end(rng1),
+                           std::move(out),
+                           std::move(fun),
+                           std::move(proj0),
+                           std::move(proj1));
+        }
+
+        // Double-range variant, 3-iterator version
+        /// \overload
+        template<typename I0,
+                 typename S0,
+                 typename I1,
+                 typename O,
+                 typename F,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::transform that takes an upper bound "
+            "for both input ranges")
+        auto RANGES_FUNC(transform)(I0 begin0,
+                                    S0 end0,
+                                    I1 begin1,
+                                    O out,
+                                    F fun,
+                                    P0 proj0 = P0{},
+                                    P1 proj1 = P1{})       //
+            ->CPP_ret(binary_transform_result<I0, I1, O>)( //
+                requires input_iterator<I0> && sentinel_for<S0, I0> &&
+                input_iterator<I1> && weakly_incrementable<O> && copy_constructible<F> &&
+                writable<O, indirect_result_t<F &, projected<I0, P0>, projected<I1, P1>>>)
+        {
+            return (*this)(std::move(begin0),
+                           std::move(end0),
+                           std::move(begin1),
+                           unreachable,
+                           std::move(out),
+                           std::move(fun),
+                           std::move(proj0),
+                           std::move(proj1));
+        }
+
+        /// \overload
+        template<typename Rng0,
+                 typename I1Ref,
+                 typename O,
+                 typename F,
+                 typename P0 = identity,
+                 typename P1 = identity>
+        RANGES_DEPRECATED(
+            "Use the variant of ranges::transform that takes an upper bound "
+            "for both input ranges")
+        auto RANGES_FUNC(transform)(Rng0 && rng0,
+                                    I1Ref && begin1,
+                                    O out,
+                                    F fun,
+                                    P0 proj0 = P0{},
+                                    P1 proj1 = P1{}) //
+            ->CPP_ret(
+                binary_transform_result<safe_iterator_t<Rng0>, uncvref_t<I1Ref>, O>)( //
+                requires input_range<Rng0> && input_iterator<uncvref_t<I1Ref>> &&
+                weakly_incrementable<O> && copy_constructible<F> &&
+                writable<O,
+                         indirect_result_t<F &,
+                                           projected<iterator_t<Rng0>, P0>,
+                                           projected<uncvref_t<I1Ref>, P1>>>)
+        {
+            return (*this)(begin(rng0),
+                           end(rng0),
+                           static_cast<I1Ref &&>(begin1),
+                           unreachable,
+                           std::move(out),
+                           std::move(fun),
+                           std::move(proj0),
+                           std::move(proj1));
+        }
+
+    RANGES_FUNC_END(transform)
+
+    namespace cpp20
+    {
+        using ranges::binary_transform_result;
+        using ranges::transform;
+        using ranges::unary_transform_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/unique.hpp b/inst/include/range/v3/algorithm/unique.hpp
new file mode 100644
index 0000000..c3abb25
--- /dev/null
+++ b/inst/include/range/v3/algorithm/unique.hpp
@@ -0,0 +1,83 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Implementation based on the code in libc++
+//   http://http://libcxx.llvm.org/
+
+#ifndef RANGES_V3_ALGORITHM_UNIQUE_HPP
+#define RANGES_V3_ALGORITHM_UNIQUE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/adjacent_find.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(unique)
+
+        /// \brief template function \c unique
+        ///
+        /// range-based version of the \c unique std algorithm
+        ///
+        /// \pre `Rng` is a model of the `forward_range` concept
+        /// \pre `I` is a model of the `forward_iterator` concept
+        /// \pre `S` is a model of the `sentinel_for` concept
+        /// \pre `C` is a model of the `relation` concept
+        ///
+        template<typename I, typename S, typename C = equal_to, typename P = identity>
+        auto RANGES_FUNC(unique)(I first, S last, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                                     //
+                requires sortable<I, C, P> && sentinel_for<S, I>)
+        {
+            first = adjacent_find(std::move(first), last, std::ref(pred), std::ref(proj));
+
+            if(first != last)
+            {
+                for(I i = next(first); ++i != last;)
+                    if(!invoke(pred, invoke(proj, *first), invoke(proj, *i)))
+                        *++first = iter_move(i);
+                ++first;
+            }
+            return first;
+        }
+
+        /// \overload
+        template<typename Rng, typename C = equal_to, typename P = identity>
+        auto RANGES_FUNC(unique)(Rng && rng, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                             //
+                requires sortable<iterator_t<Rng>, C, P> && range<Rng>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(unique)
+
+    namespace cpp20
+    {
+        using ranges::unique;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/unique_copy.hpp b/inst/include/range/v3/algorithm/unique_copy.hpp
new file mode 100644
index 0000000..fa58f6b
--- /dev/null
+++ b/inst/include/range/v3/algorithm/unique_copy.hpp
@@ -0,0 +1,175 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_UNIQUE_COPY_HPP
+#define RANGES_V3_ALGORITHM_UNIQUE_COPY_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    template<typename I, typename O>
+    using unique_copy_result = detail::in_out_result<I, O>;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S, typename O, typename C, typename P>
+        unique_copy_result<I, O> unique_copy_impl(I first, S last, O out, C pred, P proj,
+                                                  std::input_iterator_tag,
+                                                  std::false_type)
+        {
+            if(first != last)
+            {
+                // Must save a copy into a local because we will need this value
+                // even after we advance the input iterator.
+                iter_value_t<I> value =
+                    *first; // This is guaranteed by indirectly_copyable
+                *out = value;
+                ++out;
+                while(++first != last)
+                {
+                    auto && x = *first;
+                    if(!invoke(pred, invoke(proj, value), invoke(proj, x)))
+                    {
+                        value = (decltype(x) &&)x;
+                        *out = value;
+                        ++out;
+                    }
+                }
+            }
+            return {first, out};
+        }
+
+        template<typename I, typename S, typename O, typename C, typename P>
+        unique_copy_result<I, O> unique_copy_impl(I first, S last, O out, C pred, P proj,
+                                                  std::forward_iterator_tag,
+                                                  std::false_type)
+        {
+            if(first != last)
+            {
+                I tmp = first;
+                *out = *tmp;
+                ++out;
+                while(++first != last)
+                {
+                    auto && x = *first;
+                    if(!invoke(pred, invoke(proj, *tmp), invoke(proj, x)))
+                    {
+                        *out = (decltype(x) &&)x;
+                        ++out;
+                        tmp = first;
+                    }
+                }
+            }
+            return {first, out};
+        }
+
+        template<typename I, typename S, typename O, typename C, typename P>
+        unique_copy_result<I, O> unique_copy_impl(I first, S last, O out, C pred, P proj,
+                                                  std::input_iterator_tag, std::true_type)
+        {
+            if(first != last)
+            {
+                *out = *first;
+                while(++first != last)
+                {
+                    auto && x = *first;
+                    if(!invoke(pred, invoke(proj, *out), invoke(proj, x)))
+                        *++out = (decltype(x) &&)x;
+                }
+                ++out;
+            }
+            return {first, out};
+        }
+    } // namespace detail
+    /// \endcond
+
+    RANGES_FUNC_BEGIN(unique_copy)
+
+        /// \brief template function unique_copy
+        ///
+        /// range-based version of the `unique_copy` std algorithm
+        ///
+        /// \pre `Rng` is a model of the `input_range` concept
+        /// \pre `O` is a model of the `weakly_incrementable` concept
+        /// \pre `C` is a model of the `relation` concept
+        template<typename I,
+                 typename S,
+                 typename O,
+                 typename C = equal_to,
+                 typename P = identity>
+        auto RANGES_FUNC(unique_copy)(
+            I first, S last, O out, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(unique_copy_result<I, O>)(                //
+                requires input_iterator<I> && sentinel_for<S, I> &&
+                indirect_relation<C, projected<I, P>> && weakly_incrementable<O> &&
+                indirectly_copyable<I, O> &&
+                (forward_iterator<I> || forward_iterator<O> ||
+                 indirectly_copyable_storable<I, O>))
+        {
+            return detail::unique_copy_impl(std::move(first),
+                                            std::move(last),
+                                            std::move(out),
+                                            std::move(pred),
+                                            std::move(proj),
+                                            iterator_tag_of<I>(),
+                                            meta::bool_<forward_iterator<O>>{});
+        }
+
+        /// \overload
+        template<typename Rng, typename O, typename C = equal_to, typename P = identity>
+        auto RANGES_FUNC(unique_copy)(Rng && rng, O out, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(unique_copy_result<safe_iterator_t<Rng>, O>)(                  //
+                requires input_range<Rng> &&
+                indirect_relation<C, projected<iterator_t<Rng>, P>> &&
+                weakly_incrementable<O> && indirectly_copyable<iterator_t<Rng>, O> &&
+                (forward_iterator<iterator_t<Rng>> || forward_iterator<O> ||
+                 indirectly_copyable_storable<iterator_t<Rng>, O>))
+        {
+            return detail::unique_copy_impl(begin(rng),
+                                            end(rng),
+                                            std::move(out),
+                                            std::move(pred),
+                                            std::move(proj),
+                                            iterator_tag_of<iterator_t<Rng>>(),
+                                            meta::bool_<forward_iterator<O>>{});
+        }
+
+    RANGES_FUNC_END(unique_copy)
+
+    namespace cpp20
+    {
+        using ranges::unique_copy;
+        using ranges::unique_copy_result;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/algorithm/unstable_remove_if.hpp b/inst/include/range/v3/algorithm/unstable_remove_if.hpp
new file mode 100644
index 0000000..e038d94
--- /dev/null
+++ b/inst/include/range/v3/algorithm/unstable_remove_if.hpp
@@ -0,0 +1,83 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrey Diduh 2019
+//  Copyright Casey Carter 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_UNSTABLE_REMOVE_IF_HPP
+#define RANGES_V3_ALGORITHM_UNSTABLE_REMOVE_IF_HPP
+
+#include <functional>
+#include <utility>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/find_if.hpp>
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/reverse_iterator.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+
+    /// unstable_remove have O(1) complexity for each element remove, unlike remove O(n)
+    /// [for worst case]. Each erased element overwritten (moved in) with last one.
+    /// unstable_remove_if does not preserve relative element order.
+    RANGES_FUNC_BEGIN(unstable_remove_if)
+
+        /// \brief function template \c unstable_remove_if
+        template<typename I, typename C, typename P = identity>
+        auto RANGES_FUNC(unstable_remove_if)(I first, I last, C pred, P proj = {}) //
+            ->CPP_ret(I)(                                                          //
+                requires bidirectional_iterator<I> && permutable<I> &&
+                indirect_unary_predicate<C, projected<I, P>>)
+        {
+            while(true)
+            {
+                first = find_if(std::move(first), last, std::ref(pred), std::ref(proj));
+                last = find_if_not(make_reverse_iterator(std::move(last)),
+                                   make_reverse_iterator(first),
+                                   std::ref(pred),
+                                   std::ref(proj))
+                           .base();
+                if(first == last)
+                    return first;
+                *first = iter_move(--last);
+
+                // discussion here: https://github.com/ericniebler/range-v3/issues/988
+                ++first;
+            }
+        }
+
+        /// \overload
+        template<typename Rng, typename C, typename P = identity>
+        auto RANGES_FUNC(unstable_remove_if)(Rng && rng, C pred, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                                   //
+                requires bidirectional_range<Rng> && common_range<Rng> &&
+                permutable<iterator_t<Rng>> &&
+                indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>)
+        {
+            return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
+        }
+
+    RANGES_FUNC_END(unstable_remove_if)
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ALGORITHM_UNSTABLE_REMOVE_IF_HPP
diff --git a/inst/include/range/v3/algorithm/upper_bound.hpp b/inst/include/range/v3/algorithm/upper_bound.hpp
new file mode 100644
index 0000000..b6a780f
--- /dev/null
+++ b/inst/include/range/v3/algorithm/upper_bound.hpp
@@ -0,0 +1,74 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ALGORITHM_UPPER_BOUND_HPP
+#define RANGES_V3_ALGORITHM_UPPER_BOUND_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/aux_/upper_bound_n.hpp>
+#include <range/v3/algorithm/partition_point.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-algorithms
+    /// @{
+    RANGES_FUNC_BEGIN(upper_bound)
+
+        /// \brief function template \c upper_bound
+        template<typename I,
+                 typename S,
+                 typename V,
+                 typename C = less,
+                 typename P = identity>
+        auto RANGES_FUNC(upper_bound)(
+            I first, S last, V const & val, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(I)(                                               //
+                requires forward_iterator<I> && sentinel_for<S, I> &&
+                indirect_strict_weak_order<C, V const *, projected<I, P>>)
+        {
+            return partition_point(std::move(first),
+                                   std::move(last),
+                                   detail::make_upper_bound_predicate(pred, val),
+                                   std::move(proj));
+        }
+
+        /// \overload
+        template<typename Rng, typename V, typename C = less, typename P = identity>
+        auto RANGES_FUNC(upper_bound)(
+            Rng && rng, V const & val, C pred = C{}, P proj = P{}) //
+            ->CPP_ret(safe_iterator_t<Rng>)(                       //
+                requires forward_range<Rng> &&
+                indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>)
+        {
+            return partition_point(
+                rng, detail::make_upper_bound_predicate(pred, val), std::move(proj));
+        }
+
+    RANGES_FUNC_END(upper_bound)
+
+    namespace cpp20
+    {
+        using ranges::upper_bound;
+    }
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/all.hpp b/inst/include/range/v3/all.hpp
new file mode 100644
index 0000000..71ed69b
--- /dev/null
+++ b/inst/include/range/v3/all.hpp
@@ -0,0 +1,27 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013,2014.
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ALL_HPP
+#define RANGES_V3_ALL_HPP
+
+#include <range/v3/action.hpp>
+#include <range/v3/algorithm.hpp>
+#include <range/v3/core.hpp>
+#include <range/v3/functional.hpp>
+#include <range/v3/iterator.hpp>
+#include <range/v3/numeric.hpp>
+#include <range/v3/range.hpp>
+#include <range/v3/utility.hpp>
+#include <range/v3/view.hpp>
+
+#endif
diff --git a/inst/include/range/v3/at.hpp b/inst/include/range/v3/at.hpp
new file mode 100644
index 0000000..8979ce0
--- /dev/null
+++ b/inst/include/range/v3/at.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Gonzalo Brito Gadeschi 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_AT_HPP
+#define RANGES_V3_AT_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/operations.hpp> instead.")
+
+#include <range/v3/range/operations.hpp>
+
+#endif
diff --git a/inst/include/range/v3/back.hpp b/inst/include/range/v3/back.hpp
new file mode 100644
index 0000000..74300e0
--- /dev/null
+++ b/inst/include/range/v3/back.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_BACK_HPP
+#define RANGES_V3_BACK_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/operations.hpp> instead.")
+
+#include <range/v3/range/operations.hpp>
+
+#endif
diff --git a/inst/include/range/v3/begin_end.hpp b/inst/include/range/v3/begin_end.hpp
new file mode 100644
index 0000000..f872a8f
--- /dev/null
+++ b/inst/include/range/v3/begin_end.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_BEGIN_END_HPP
+#define RANGES_V3_BEGIN_END_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/access.hpp> instead.")
+
+#include <range/v3/range/access.hpp>
+
+#endif
diff --git a/inst/include/range/v3/core.hpp b/inst/include/range/v3/core.hpp
new file mode 100644
index 0000000..0485bbb
--- /dev/null
+++ b/inst/include/range/v3/core.hpp
@@ -0,0 +1,33 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_CORE_HPP
+#define RANGES_V3_CORE_HPP
+
+#include <range/v3/iterator/common_iterator.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/range/operations.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/range_for.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/getlines.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/istream.hpp>
+#include <range/v3/view/subrange.hpp>
+
+#endif
diff --git a/inst/include/range/v3/data.hpp b/inst/include/range/v3/data.hpp
new file mode 100644
index 0000000..b62a29a
--- /dev/null
+++ b/inst/include/range/v3/data.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_DATA_HPP
+#define RANGES_V3_DATA_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/primitives.hpp> instead.")
+
+#include <range/v3/range/primitives.hpp>
+
+#endif // RANGES_V3_DATA_HPP
diff --git a/inst/include/range/v3/detail/adl_get.hpp b/inst/include/range/v3/detail/adl_get.hpp
new file mode 100644
index 0000000..a8801f4
--- /dev/null
+++ b/inst/include/range/v3/detail/adl_get.hpp
@@ -0,0 +1,140 @@
+// Range v3 library
+//
+//  Copyright Casey Carter 2018
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#ifndef RANGES_V3_DETAIL_ADL_GET_HPP
+#define RANGES_V3_DETAIL_ADL_GET_HPP
+
+#include <cstddef>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        namespace _adl_get_
+        {
+            template<typename>
+            void get();
+
+            template<std::size_t I, typename TupleLike>
+            constexpr auto adl_get(TupleLike && t) noexcept
+                -> decltype(get<I>(static_cast<TupleLike &&>(t)))
+            {
+                return get<I>(static_cast<TupleLike &&>(t));
+            }
+            template<typename T, typename TupleLike>
+            constexpr auto adl_get(TupleLike && t) noexcept
+                -> decltype(get<T>(static_cast<TupleLike &&>(t)))
+            {
+                return get<T>(static_cast<TupleLike &&>(t));
+            }
+        } // namespace _adl_get_
+        using _adl_get_::adl_get;
+    } // namespace detail
+
+    namespace _tuple_wrapper_
+    {
+        template<typename TupleLike>
+        struct forward_tuple_interface : TupleLike
+        {
+            forward_tuple_interface() = default;
+            using TupleLike::TupleLike;
+#if !defined(__clang__) || __clang_major__ > 3
+            CPP_member
+            constexpr CPP_ctor(forward_tuple_interface)(TupleLike && base)(    //
+                noexcept(std::is_nothrow_move_constructible<TupleLike>::value) //
+                requires move_constructible<TupleLike>)
+              : TupleLike(static_cast<TupleLike &&>(base))
+            {}
+            CPP_member
+            constexpr CPP_ctor(forward_tuple_interface)(TupleLike const & base)( //
+                noexcept(std::is_nothrow_copy_constructible<TupleLike>::value)   //
+                requires copy_constructible<TupleLike>)
+              : TupleLike(base)
+            {}
+#else
+            // Clang 3.x have a problem with inheriting constructors
+            // that causes the declarations in the preceeding PP block to get
+            // instantiated too early.
+            CPP_template(typename B = TupleLike)( //
+                requires move_constructible<B>)   //
+                constexpr forward_tuple_interface(TupleLike && base) noexcept(
+                    std::is_nothrow_move_constructible<TupleLike>::value)
+              : TupleLike(static_cast<TupleLike &&>(base))
+            {}
+            CPP_template(typename B = TupleLike)( //
+                requires copy_constructible<B>)   //
+                constexpr forward_tuple_interface(TupleLike const & base) noexcept(
+                    std::is_nothrow_copy_constructible<TupleLike>::value)
+              : TupleLike(base)
+            {}
+#endif
+
+            // clang-format off
+            template<std::size_t I, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> &wb)
+            (
+                return detail::adl_get<I>(static_cast<U &>(wb))
+            )
+            template<std::size_t I, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> const &wb)
+            (
+                return detail::adl_get<I>(static_cast<U const &>(wb))
+            )
+            template<std::size_t I, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> &&wb)
+            (
+                return detail::adl_get<I>(static_cast<U &&>(wb))
+            )
+            template<std::size_t I, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> const &&wb)
+            (
+                return detail::adl_get<I>(static_cast<U const &&>(wb))
+            )
+            template<typename T, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> &wb)
+            (
+                return detail::adl_get<T>(static_cast<U &>(wb))
+            )
+            template<typename T, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> const &wb)
+            (
+                return detail::adl_get<T>(static_cast<U const &>(wb))
+            )
+            template<typename T, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> &&wb)
+            (
+                return detail::adl_get<T>(static_cast<U &&>(wb))
+            )
+            template<typename T, typename U = TupleLike>
+            friend constexpr auto CPP_auto_fun(get)(
+                forward_tuple_interface<TupleLike> const &&wb)
+            (
+                return detail::adl_get<T>(static_cast<U const &&>(wb))
+            )
+            // clang-format on
+        };
+    } // namespace _tuple_wrapper_
+    /// \endcond
+} // namespace ranges
+
+#endif // RANGES_V3_DETAIL_ADL_GET_HPP
diff --git a/inst/include/range/v3/detail/config.hpp b/inst/include/range/v3/detail/config.hpp
new file mode 100644
index 0000000..a970006
--- /dev/null
+++ b/inst/include/range/v3/detail/config.hpp
@@ -0,0 +1,744 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_DETAIL_CONFIG_HPP
+#define RANGES_V3_DETAIL_CONFIG_HPP
+
+// Grab some version information.
+#ifndef __has_include
+#include <iosfwd>
+#elif __has_include(<version>)
+#include <version>
+#else
+#include <iosfwd>
+#endif
+
+#if(defined(NDEBUG) && !defined(RANGES_ENSURE_MSG)) || \
+    (!defined(NDEBUG) && !defined(RANGES_ASSERT) &&    \
+     ((defined(__GNUC__) && !defined(__clang__) &&     \
+       (__GNUC__ < 5 || defined(__MINGW32__))) ||      \
+      defined(_MSVC_STL_VERSION)))
+#include <cstdio>
+#include <cstdlib>
+
+namespace ranges
+{
+    namespace detail
+    {
+        template<typename = void>
+        [[noreturn]] void assert_failure(char const * file, int line, char const * msg)
+        {
+            std::fprintf(stderr, "%s(%d): %s\n", file, line, msg);
+            std::abort();
+        }
+    } // namespace detail
+} // namespace ranges
+#endif
+
+#ifndef RANGES_ASSERT
+// Always use our hand-rolled assert implementation on older GCCs, which do
+// not allow assert to be used in a constant expression, and on MSVC whose
+// assert is not marked [[noreturn]].
+#if !defined(NDEBUG) && ((defined(__GNUC__) && !defined(__clang__) && \
+                          (__GNUC__ < 5 || defined(__MINGW32__))) ||  \
+                         defined(_MSVC_STL_VERSION))
+#define RANGES_ASSERT(...)                                    \
+    static_cast<void>((__VA_ARGS__)                           \
+                          ? void(0)                           \
+                          : ::ranges::detail::assert_failure( \
+                                __FILE__, __LINE__, "assertion failed: " #__VA_ARGS__))
+#else
+#include <cassert>
+#define RANGES_ASSERT assert
+#endif
+#endif
+
+#include <meta/meta_fwd.hpp>
+
+#ifndef RANGES_ASSUME
+#if defined(__clang__) || defined(__GNUC__)
+#define RANGES_ASSUME(COND) static_cast<void>((COND) ? void(0) : __builtin_unreachable())
+#elif defined(_MSC_VER)
+#define RANGES_ASSUME(COND) static_cast<void>(__assume(COND))
+#else
+#define RANGES_ASSUME(COND) static_cast<void>(COND)
+#endif
+#endif // RANGES_ASSUME
+
+#ifndef RANGES_EXPECT
+#ifdef NDEBUG
+#define RANGES_EXPECT(COND) RANGES_ASSUME(COND)
+#else // NDEBUG
+#define RANGES_EXPECT(COND) RANGES_ASSERT(COND)
+#endif // NDEBUG
+#endif // RANGES_EXPECT
+
+#ifndef RANGES_ENSURE_MSG
+#if defined(NDEBUG)
+#define RANGES_ENSURE_MSG(COND, MSG)                             \
+    static_cast<void>((COND) ? void(0)                           \
+                             : ::ranges::detail::assert_failure( \
+                                   __FILE__, __LINE__, "ensure failed: " MSG))
+#else
+#define RANGES_ENSURE_MSG(COND, MSG) RANGES_ASSERT((COND) && MSG)
+#endif
+#endif
+
+#ifndef RANGES_ENSURE
+#define RANGES_ENSURE(...) RANGES_ENSURE_MSG((__VA_ARGS__), #__VA_ARGS__)
+#endif
+
+#define RANGES_DECLTYPE_AUTO_RETURN(...) \
+    ->decltype(__VA_ARGS__)              \
+    {                                    \
+        return (__VA_ARGS__);            \
+    }                                    \
+    /**/
+
+#define RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT(...)                                 \
+    noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__)))->decltype(__VA_ARGS__) \
+    {                                                                             \
+        return (__VA_ARGS__);                                                     \
+    }                                                                             \
+    /**/
+
+#define RANGES_AUTO_RETURN_NOEXCEPT(...)                   \
+    noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__))) \
+    {                                                      \
+        return (__VA_ARGS__);                              \
+    }                                                      \
+    /**/
+
+#define RANGES_DECLTYPE_NOEXCEPT(...) \
+    noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__)))->decltype(__VA_ARGS__) /**/
+
+// Non-portable forward declarations of standard containers
+#define RANGES_BEGIN_NAMESPACE_STD META_BEGIN_NAMESPACE_STD
+#define RANGES_END_NAMESPACE_STD META_END_NAMESPACE_STD
+#define RANGES_BEGIN_NAMESPACE_VERSION META_BEGIN_NAMESPACE_VERSION
+#define RANGES_END_NAMESPACE_VERSION META_END_NAMESPACE_VERSION
+#define RANGES_BEGIN_NAMESPACE_CONTAINER META_BEGIN_NAMESPACE_CONTAINER
+#define RANGES_END_NAMESPACE_CONTAINER META_END_NAMESPACE_CONTAINER
+
+// Database of feature versions
+#define RANGES_CXX_STATIC_ASSERT_11 200410L
+#define RANGES_CXX_STATIC_ASSERT_14 RANGES_CXX_STATIC_ASSERT_11
+#define RANGES_CXX_STATIC_ASSERT_17 201411L
+#define RANGES_CXX_VARIABLE_TEMPLATES_11 0L
+#define RANGES_CXX_VARIABLE_TEMPLATES_14 201304L
+#define RANGES_CXX_VARIABLE_TEMPLATES_17 RANGES_CXX_VARIABLE_TEMPLATES_14
+#define RANGES_CXX_ATTRIBUTE_DEPRECATED_11 0L
+#define RANGES_CXX_ATTRIBUTE_DEPRECATED_14 201309L
+#define RANGES_CXX_ATTRIBUTE_DEPRECATED_17 RANGES_CXX_ATTRIBUTE_DEPRECATED_14
+#define RANGES_CXX_CONSTEXPR_11 200704L
+#define RANGES_CXX_CONSTEXPR_14 201304L
+#define RANGES_CXX_CONSTEXPR_17 201603L
+#define RANGES_CXX_CONSTEXPR_LAMBDAS 201603L
+#define RANGES_CXX_RANGE_BASED_FOR_11 200907L
+#define RANGES_CXX_RANGE_BASED_FOR_14 RANGES_CXX_RANGE_BASED_FOR_11
+#define RANGES_CXX_RANGE_BASED_FOR_17 201603L
+#define RANGES_CXX_LIB_IS_FINAL_11 0L
+#define RANGES_CXX_LIB_IS_FINAL_14 201402L
+#define RANGES_CXX_LIB_IS_FINAL_17 RANGES_CXX_LIB_IS_FINAL_14
+#define RANGES_CXX_RETURN_TYPE_DEDUCTION_11 0L
+#define RANGES_CXX_RETURN_TYPE_DEDUCTION_14 201304L
+#define RANGES_CXX_RETURN_TYPE_DEDUCTION_17 RANGES_CXX_RETURN_TYPE_DEDUCTION_14
+#define RANGES_CXX_GENERIC_LAMBDAS_11 0L
+#define RANGES_CXX_GENERIC_LAMBDAS_14 201304L
+#define RANGES_CXX_GENERIC_LAMBDAS_17 RANGES_CXX_GENERIC_LAMBDAS_14
+#define RANGES_CXX_STD_11 201103L
+#define RANGES_CXX_STD_14 201402L
+#define RANGES_CXX_STD_17 201703L
+#define RANGES_CXX_THREAD_LOCAL_PRE_STANDARD \
+    200000L // Arbitrary number between 0 and C++11
+#define RANGES_CXX_THREAD_LOCAL_11 RANGES_CXX_STD_11
+#define RANGES_CXX_THREAD_LOCAL_14 RANGES_CXX_THREAD_LOCAL_11
+#define RANGES_CXX_THREAD_LOCAL_17 RANGES_CXX_THREAD_LOCAL_14
+#define RANGES_CXX_INLINE_VARIABLES_11 0L
+#define RANGES_CXX_INLINE_VARIABLES_14 0L
+#define RANGES_CXX_INLINE_VARIABLES_17 201606L
+#define RANGES_CXX_COROUTINES_11 0L
+#define RANGES_CXX_COROUTINES_14 0L
+#define RANGES_CXX_COROUTINES_17 0L
+#define RANGES_CXX_COROUTINES_TS1 201703L
+#define RANGES_CXX_DEDUCTION_GUIDES_11 0L
+#define RANGES_CXX_DEDUCTION_GUIDES_14 0L
+#define RANGES_CXX_DEDUCTION_GUIDES_17 201606L
+#define RANGES_CXX_IF_CONSTEXPR_11 0L
+#define RANGES_CXX_IF_CONSTEXPR_14 0L
+#define RANGES_CXX_IF_CONSTEXPR_17 201606L
+#define RANGES_CXX_ALIGNED_NEW_11 0L
+#define RANGES_CXX_ALIGNED_NEW_14 0L
+#define RANGES_CXX_ALIGNED_NEW_17 201606L
+
+// Implementation-specific diagnostic control
+#if defined(_MSC_VER) && !defined(__clang__)
+#define RANGES_DIAGNOSTIC_PUSH __pragma(warning(push))
+#define RANGES_DIAGNOSTIC_POP __pragma(warning(pop))
+#define RANGES_DIAGNOSTIC_IGNORE_PRAGMAS __pragma(warning(disable : 4068))
+#define RANGES_DIAGNOSTIC_IGNORE(X) \
+    RANGES_DIAGNOSTIC_IGNORE_PRAGMAS __pragma(warning(disable : X))
+#define RANGES_DIAGNOSTIC_IGNORE_SHADOWING RANGES_DIAGNOSTIC_IGNORE(4456)
+#define RANGES_DIAGNOSTIC_IGNORE_INDENTATION
+#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL
+#define RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS RANGES_DIAGNOSTIC_IGNORE(4099)
+#define RANGES_DIAGNOSTIC_IGNORE_GLOBAL_CONSTRUCTORS
+#define RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION
+#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_INTERNAL
+#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER
+#define RANGES_DIAGNOSTIC_IGNORE_ZERO_LENGTH_ARRAY
+#define RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
+#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL
+#define RANGES_DIAGNOSTIC_IGNORE_MISSING_BRACES
+#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
+#define RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE
+#define RANGES_DIAGNOSTIC_IGNORE_RANGE_LOOP_ANALYSIS
+#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS RANGES_DIAGNOSTIC_IGNORE(4996)
+#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_THIS_CAPTURE
+#define RANGES_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME
+// Ignores both "divide by zero" and "mod by zero":
+#define RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO RANGES_DIAGNOSTIC_IGNORE(4723 4724)
+#define RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH RANGES_DIAGNOSTIC_IGNORE(4146)
+#define RANGES_DIAGNOSTIC_IGNORE_TRUNCATION RANGES_DIAGNOSTIC_IGNORE(4244)
+#define RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS \
+    RANGES_DIAGNOSTIC_IGNORE(4522)
+
+#define RANGES_CXX_VER _MSVC_LANG
+
+#if _MSC_VER < 1920 || _MSVC_LANG < 201703L || !defined(_MSVC_TRADITIONAL) || \
+    _MSVC_TRADITIONAL != 0
+#error range-v3 requires Visual Studio 2019 with the /std:c++17 (or /std:c++latest) /permissive- and /experimental:preprocessor options.
+#endif
+
+#if _MSC_VER < 1923
+#define RANGES_WORKAROUND_MSVC_934330 // Deduction guide not correctly preferred to copy
+                                      // deduction candidate [No workaround]
+
+#if _MSC_VER < 1922
+#define RANGES_WORKAROUND_MSVC_756601 // constexpr friend non-template erroneously
+                                      // rejected with C3615
+#define RANGES_WORKAROUND_MSVC_793042 // T[0] sometimes accepted as a valid type in SFINAE
+                                      // context
+
+#if _MSC_VER < 1921
+#define RANGES_WORKAROUND_MSVC_785522 // SFINAE failure for error in immediate context
+#define RANGES_WORKAROUND_MSVC_786376 // Assertion casting anonymous union member in
+                                      // trailing-return-type
+#define RANGES_WORKAROUND_MSVC_787074 // Over-eager substitution of dependent type in
+                                      // non-instantiated nested class template
+#define RANGES_WORKAROUND_MSVC_790554 // Assert for return type that uses dependent
+                                      // default non-type template argument
+#endif                                // _MSC_VER < 1921
+#endif                                // _MSC_VER < 1922
+#endif                                // _MSC_VER < 1923
+
+#if 1 // Fixed in 1920, but more bugs hiding behind workaround
+#define RANGES_WORKAROUND_MSVC_701385 // Yet another alias expansion error
+#endif
+
+#define RANGES_WORKAROUND_MSVC_249830 // constexpr and arguments that aren't subject to
+                                      // lvalue-to-rvalue conversion
+#define RANGES_WORKAROUND_MSVC_573728 // rvalues of array types bind to lvalue references
+                                      // [no workaround]
+#define RANGES_WORKAROUND_MSVC_677925 // Bogus C2676 "binary '++': '_Ty' does not define
+                                      // this operator"
+#define RANGES_WORKAROUND_MSVC_683388 // decltype(*i) is incorrectly an rvalue reference
+                                      // for pointer-to-array i
+#define RANGES_WORKAROUND_MSVC_688606 // SFINAE failing to account for access control
+                                      // during specialization matching
+#define RANGES_WORKAROUND_MSVC_779708 // ADL for operands of function type [No workaround]
+#define RANGES_WORKAROUND_MSVC_786312 // Yet another mixed-pack-expansion failure
+#define RANGES_WORKAROUND_MSVC_792338 // Failure to match specialization enabled via call
+                                      // to constexpr function
+#define RANGES_WORKAROUND_MSVC_835948 // Silent bad codegen destroying sized_generator [No
+                                      // workaround]
+#define RANGES_WORKAROUND_MSVC_895622 // Error when phase 1 name binding finds only
+                                      // deleted function
+#define RANGES_WORKAROUND_MSVC_934264 // Explicitly-defaulted inherited default
+                                      // constructor is not correctly implicitly constexpr
+#if _MSVC_LANG <= 201703L
+#define RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+#endif
+
+#elif defined(__GNUC__) || defined(__clang__)
+#define RANGES_PRAGMA(X) _Pragma(#X)
+#define RANGES_DIAGNOSTIC_PUSH RANGES_PRAGMA(GCC diagnostic push)
+#define RANGES_DIAGNOSTIC_POP RANGES_PRAGMA(GCC diagnostic pop)
+#define RANGES_DIAGNOSTIC_IGNORE_PRAGMAS RANGES_PRAGMA(GCC diagnostic ignored "-Wpragmas")
+#define RANGES_DIAGNOSTIC_IGNORE(X)                                  \
+    RANGES_DIAGNOSTIC_IGNORE_PRAGMAS                                 \
+    RANGES_PRAGMA(GCC diagnostic ignored "-Wunknown-pragmas")        \
+    RANGES_PRAGMA(GCC diagnostic ignored "-Wunknown-warning-option") \
+    RANGES_PRAGMA(GCC diagnostic ignored X)
+#define RANGES_DIAGNOSTIC_IGNORE_SHADOWING RANGES_DIAGNOSTIC_IGNORE("-Wshadow")
+#define RANGES_DIAGNOSTIC_IGNORE_INDENTATION \
+    RANGES_DIAGNOSTIC_IGNORE("-Wmisleading-indentation")
+#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL \
+    RANGES_DIAGNOSTIC_IGNORE("-Wundefined-internal")
+#define RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS \
+    RANGES_DIAGNOSTIC_IGNORE("-Wmismatched-tags")
+#define RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION \
+    RANGES_DIAGNOSTIC_IGNORE("-Wsign-conversion")
+#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL RANGES_DIAGNOSTIC_IGNORE("-Wfloat-equal")
+#define RANGES_DIAGNOSTIC_IGNORE_MISSING_BRACES \
+    RANGES_DIAGNOSTIC_IGNORE("-Wmissing-braces")
+#define RANGES_DIAGNOSTIC_IGNORE_GLOBAL_CONSTRUCTORS \
+    RANGES_DIAGNOSTIC_IGNORE("-Wglobal-constructors")
+#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_INTERNAL \
+    RANGES_DIAGNOSTIC_IGNORE("-Wunneeded-internal-declaration")
+#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER \
+    RANGES_DIAGNOSTIC_IGNORE("-Wunneeded-member-function")
+#define RANGES_DIAGNOSTIC_IGNORE_ZERO_LENGTH_ARRAY \
+    RANGES_DIAGNOSTIC_IGNORE("-Wzero-length-array")
+#define RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT RANGES_DIAGNOSTIC_IGNORE("-Wc++1z-compat")
+#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE \
+    RANGES_DIAGNOSTIC_IGNORE("-Wundefined-func-template")
+#define RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE \
+    RANGES_DIAGNOSTIC_IGNORE("-Winconsistent-missing-override")
+#define RANGES_DIAGNOSTIC_IGNORE_RANGE_LOOP_ANALYSIS \
+    RANGES_DIAGNOSTIC_IGNORE("-Wrange-loop-analysis")
+#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS \
+    RANGES_DIAGNOSTIC_IGNORE("-Wdeprecated-declarations")
+#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_THIS_CAPTURE \
+    RANGES_DIAGNOSTIC_IGNORE("-Wdeprecated-this-capture")
+#define RANGES_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME \
+    RANGES_DIAGNOSTIC_IGNORE("-Winit-list-lifetime")
+#define RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO
+#define RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
+#define RANGES_DIAGNOSTIC_IGNORE_TRUNCATION
+#define RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS
+
+#define RANGES_WORKAROUND_CWG_1554
+#ifdef __clang__
+#if __clang_major__ < 4
+#define RANGES_WORKAROUND_CLANG_23135 // constexpr leads to premature instantiation on
+                                      // clang-3.x
+#endif
+#define RANGES_WORKAROUND_CLANG_43400 // template friend is redefinition of itself
+#else                                 // __GNUC__
+#if __GNUC__ < 6
+#define RANGES_WORKAROUND_GCC_UNFILED0 /* Workaround old GCC name lookup bug */
+#endif
+#if __GNUC__ == 7 || __GNUC__ == 8
+#define RANGES_WORKAROUND_GCC_91525 /* Workaround strange GCC ICE */
+#endif
+#if __GNUC__ >= 9
+#ifdef __cpp_concepts
+#define RANGES_WORKAROUND_GCC_89953 // ICE in nothrow_spec_p, at cp/except.c:1244
+#endif
+#if __GNUC__ == 9 && __GNUC_MINOR__ < 3 && __cplusplus <= RANGES_CXX_STD_17
+#define RANGES_WORKAROUND_GCC_91923 // Failure-to-SFINAE with class type NTTP in C++17
+#endif
+#endif
+#endif
+
+#else
+#define RANGES_DIAGNOSTIC_PUSH
+#define RANGES_DIAGNOSTIC_POP
+#define RANGES_DIAGNOSTIC_IGNORE_PRAGMAS
+#define RANGES_DIAGNOSTIC_IGNORE_SHADOWING
+#define RANGES_DIAGNOSTIC_IGNORE_INDENTATION
+#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL
+#define RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+#define RANGES_DIAGNOSTIC_IGNORE_GLOBAL_CONSTRUCTORS
+#define RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION
+#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_INTERNAL
+#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER
+#define RANGES_DIAGNOSTIC_IGNORE_ZERO_LENGTH_ARRAY
+#define RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
+#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL
+#define RANGES_DIAGNOSTIC_IGNORE_MISSING_BRACES
+#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
+#define RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE
+#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_THIS_CAPTURE
+#define RANGES_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME
+#define RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO
+#define RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
+#define RANGES_DIAGNOSTIC_IGNORE_TRUNCATION
+#define RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS
+#endif
+
+// Configuration via feature-test macros, with fallback to __cplusplus
+#ifndef RANGES_CXX_VER
+#define RANGES_CXX_VER __cplusplus
+#endif
+
+#define RANGES_CXX_FEATURE_CONCAT2(y, z) RANGES_CXX_##y##_##z
+#define RANGES_CXX_FEATURE_CONCAT(y, z) RANGES_CXX_FEATURE_CONCAT2(y, z)
+
+#if RANGES_CXX_VER >= RANGES_CXX_STD_17
+#define RANGES_CXX_STD RANGES_CXX_STD_17
+#define RANGES_CXX_FEATURE(x) RANGES_CXX_FEATURE_CONCAT(x, 17)
+#elif RANGES_CXX_VER >= RANGES_CXX_STD_14
+#define RANGES_CXX_STD RANGES_CXX_STD_14
+#define RANGES_CXX_FEATURE(x) RANGES_CXX_FEATURE_CONCAT(x, 14)
+#else
+#define RANGES_CXX_STD RANGES_CXX_STD_11
+#define RANGES_CXX_FEATURE(x) RANGES_CXX_FEATURE_CONCAT(x, 11)
+#endif
+
+#ifndef RANGES_CXX_STATIC_ASSERT
+#ifdef __cpp_static_assert
+#define RANGES_CXX_STATIC_ASSERT __cpp_static_assert
+#else
+#define RANGES_CXX_STATIC_ASSERT RANGES_CXX_FEATURE(STATIC_ASSERT)
+#endif
+#endif
+
+#ifndef RANGES_CXX_VARIABLE_TEMPLATES
+#ifdef __cpp_variable_templates
+#define RANGES_CXX_VARIABLE_TEMPLATES __cpp_variable_templates
+#else
+#define RANGES_CXX_VARIABLE_TEMPLATES RANGES_CXX_FEATURE(VARIABLE_TEMPLATES)
+#endif
+#endif
+
+#if(defined(__cpp_lib_type_trait_variable_templates) && \
+    __cpp_lib_type_trait_variable_templates > 0) ||     \
+    RANGES_CXX_VER >= RANGES_CXX_STD_17
+#define RANGES_CXX_TRAIT_VARIABLE_TEMPLATES 1
+#else
+#define RANGES_CXX_TRAIT_VARIABLE_TEMPLATES 0
+#endif
+
+#ifndef RANGES_CXX_ATTRIBUTE_DEPRECATED
+#ifdef __has_cpp_attribute
+#define RANGES_CXX_ATTRIBUTE_DEPRECATED __has_cpp_attribute(deprecated)
+#elif defined(__cpp_attribute_deprecated)
+#define RANGES_CXX_ATTRIBUTE_DEPRECATED __cpp_attribute_deprecated
+#else
+#define RANGES_CXX_ATTRIBUTE_DEPRECATED RANGES_CXX_FEATURE(ATTRIBUTE_DEPRECATED)
+#endif
+#endif
+
+#ifndef RANGES_CXX_CONSTEXPR
+#ifdef __cpp_constexpr
+#define RANGES_CXX_CONSTEXPR __cpp_constexpr
+#else
+#define RANGES_CXX_CONSTEXPR RANGES_CXX_FEATURE(CONSTEXPR)
+#endif
+#endif
+
+#ifndef RANGES_CXX_RANGE_BASED_FOR
+#ifdef __cpp_range_based_for
+#define RANGES_CXX_RANGE_BASED_FOR __cpp_range_based_for
+#else
+#define RANGES_CXX_RANGE_BASED_FOR RANGES_CXX_FEATURE(RANGE_BASED_FOR)
+#endif
+#endif
+
+#ifndef RANGES_CXX_LIB_IS_FINAL
+#include <type_traits>
+#ifdef __cpp_lib_is_final
+#define RANGES_CXX_LIB_IS_FINAL __cpp_lib_is_final
+#else
+#define RANGES_CXX_LIB_IS_FINAL RANGES_CXX_FEATURE(LIB_IS_FINAL)
+#endif
+#endif
+
+#ifndef RANGES_CXX_RETURN_TYPE_DEDUCTION
+#ifdef __cpp_return_type_deduction
+#define RANGES_CXX_RETURN_TYPE_DEDUCTION __cpp_return_type_deduction
+#else
+#define RANGES_CXX_RETURN_TYPE_DEDUCTION RANGES_CXX_FEATURE(RETURN_TYPE_DEDUCTION)
+#endif
+#endif
+
+#ifndef RANGES_CXX_GENERIC_LAMBDAS
+#ifdef __cpp_generic_lambdas
+#define RANGES_CXX_GENERIC_LAMBDAS __cpp_generic_lambdas
+#else
+#define RANGES_CXX_GENERIC_LAMBDAS RANGES_CXX_FEATURE(GENERIC_LAMBDAS)
+#endif
+#endif
+
+#ifndef RANGES_CXX_THREAD_LOCAL
+#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED <= 70100
+#define RANGES_CXX_THREAD_LOCAL 0
+#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) || \
+    (defined(__clang__) && (defined(__CYGWIN__) || defined(__apple_build_version__)))
+// BUGBUG avoid unresolved __cxa_thread_atexit
+#define RANGES_CXX_THREAD_LOCAL RANGES_CXX_THREAD_LOCAL_PRE_STANDARD
+#else
+#define RANGES_CXX_THREAD_LOCAL RANGES_CXX_FEATURE(THREAD_LOCAL)
+#endif
+#endif
+
+#if !defined(RANGES_DEPRECATED) && !defined(RANGES_DISABLE_DEPRECATED_WARNINGS)
+#if defined(__GNUC__) && !defined(__clang__)
+// GCC's support for [[deprecated("message")]] is unusably buggy.
+#define RANGES_DEPRECATED(MSG) __attribute__((deprecated(MSG)))
+#elif RANGES_CXX_ATTRIBUTE_DEPRECATED && \
+    !((defined(__clang__) || defined(__GNUC__)) && RANGES_CXX_STD < RANGES_CXX_STD_14)
+#define RANGES_DEPRECATED(MSG) [[deprecated(MSG)]]
+#elif defined(__clang__) || defined(__GNUC__)
+#define RANGES_DEPRECATED(MSG) __attribute__((deprecated(MSG)))
+#endif
+#endif
+#ifndef RANGES_DEPRECATED
+#define RANGES_DEPRECATED(MSG)
+#endif
+
+#if !defined(RANGES_DEPRECATED_HEADER) && !defined(RANGES_DISABLE_DEPRECATED_WARNINGS)
+#ifdef __GNUC__
+#define RANGES_DEPRECATED_HEADER(MSG) RANGES_PRAGMA(GCC warning MSG)
+#elif defined(_MSC_VER)
+#define RANGES_STRINGIZE_(MSG) #MSG
+#define RANGES_STRINGIZE(MSG) RANGES_STRINGIZE_(MSG)
+#define RANGES_DEPRECATED_HEADER(MSG) \
+    __pragma(message(__FILE__ "(" RANGES_STRINGIZE(__LINE__) ") : Warning: " MSG))
+#endif
+#else
+#define RANGES_DEPRECATED_HEADER(MSG) /**/
+#endif
+// #ifndef RANGES_DEPRECATED_HEADER
+// #define RANGES_DEPRECATED_HEADER(MSG)
+// #endif
+
+#ifndef RANGES_CXX_COROUTINES
+#ifdef __cpp_coroutines
+#define RANGES_CXX_COROUTINES __cpp_coroutines
+#else
+#define RANGES_CXX_COROUTINES RANGES_CXX_FEATURE(COROUTINES)
+#endif
+#endif
+
+// RANGES_CXX14_CONSTEXPR macro (see also BOOST_CXX14_CONSTEXPR)
+// Note: constexpr implies inline, to retain the same visibility
+// C++14 constexpr functions are inline in C++11
+#if RANGES_CXX_CONSTEXPR >= RANGES_CXX_CONSTEXPR_14
+#define RANGES_CXX14_CONSTEXPR constexpr
+#else
+#define RANGES_CXX14_CONSTEXPR inline
+#endif
+
+#ifdef NDEBUG
+#define RANGES_NDEBUG_CONSTEXPR constexpr
+#else
+#define RANGES_NDEBUG_CONSTEXPR inline
+#endif
+
+#ifndef RANGES_CXX_INLINE_VARIABLES
+#ifdef __cpp_inline_variables
+#define RANGES_CXX_INLINE_VARIABLES __cpp_inline_variables
+#elif defined(__clang__) && (__clang_major__ == 3 && __clang_minor__ == 9) && \
+    RANGES_CXX_VER > RANGES_CXX_STD_14
+// Clang 3.9 supports inline variables in C++17 mode, but doesn't define
+// __cpp_inline_variables
+#define RANGES_CXX_INLINE_VARIABLES RANGES_CXX_INLINE_VARIABLES_17
+#else
+#define RANGES_CXX_INLINE_VARIABLES RANGES_CXX_FEATURE(INLINE_VARIABLES)
+#endif // __cpp_inline_variables
+#endif // RANGES_CXX_INLINE_VARIABLES
+
+#if RANGES_CXX_INLINE_VARIABLES < RANGES_CXX_INLINE_VARIABLES_17 && \
+    !defined(RANGES_DOXYGEN_INVOKED)
+#define RANGES_INLINE_VAR
+#define RANGES_INLINE_VARIABLE(type, name)                           \
+    namespace                                                        \
+    {                                                                \
+        constexpr auto & name = ::ranges::static_const<type>::value; \
+    }
+#else // RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
+#define RANGES_INLINE_VAR inline
+#define RANGES_INLINE_VARIABLE(type, name) \
+    inline constexpr type name{};          \
+    /**/
+#endif // RANGES_CXX_INLINE_VARIABLES
+
+#if defined(RANGES_DOXYGEN_INVOKED)
+#define RANGES_DEFINE_CPO(type, name) \
+    inline constexpr type name{};     \
+    /**/
+#elif RANGES_CXX_INLINE_VARIABLES < RANGES_CXX_INLINE_VARIABLES_17
+#define RANGES_DEFINE_CPO(type, name)                                \
+    namespace                                                        \
+    {                                                                \
+        constexpr auto & name = ::ranges::static_const<type>::value; \
+    }                                                                \
+    /**/
+#else // RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
+#define RANGES_DEFINE_CPO(type, name) \
+    namespace _                       \
+    {                                 \
+        inline constexpr type name{}; \
+    }                                 \
+    using namespace _;                \
+    /**/
+#endif // RANGES_CXX_INLINE_VARIABLES
+
+#ifndef RANGES_DOXYGEN_INVOKED
+#define RANGES_HIDDEN_DETAIL(...) __VA_ARGS__
+#else
+#define RANGES_HIDDEN_DETAIL(...)
+#endif
+
+#ifndef RANGES_DOXYGEN_INVOKED
+#define RANGES_ADL_BARRIER_FOR(S) S##_ns
+#define RANGES_STRUCT_WITH_ADL_BARRIER(S) \
+    _ranges_adl_barrier_noop_;            \
+    namespace RANGES_ADL_BARRIER_FOR(S)   \
+    {                                     \
+        struct S;                         \
+    }                                     \
+    using RANGES_ADL_BARRIER_FOR(S)::S;   \
+    struct RANGES_ADL_BARRIER_FOR(S)::S /**/
+#else
+#define RANGES_ADL_BARRIER_FOR(S)
+#define RANGES_STRUCT_WITH_ADL_BARRIER(S) S
+#endif
+
+#ifndef RANGES_DOXYGEN_INVOKED
+#define RANGES_FUNC_BEGIN(NAME) \
+    struct NAME##_fn            \
+    {
+#define RANGES_FUNC_END(NAME) \
+    }                         \
+    ;                         \
+    RANGES_INLINE_VARIABLE(NAME##_fn, NAME)
+#define RANGES_FUNC(NAME) operator() RANGES_FUNC_CONST_ /**/
+#define RANGES_FUNC_CONST_(...) (__VA_ARGS__) const
+#else
+#define RANGES_FUNC_BEGIN(NAME)
+#define RANGES_FUNC_END(NAME)
+#define RANGES_FUNC(NAME) NAME
+#endif
+
+#ifndef RANGES_CXX_DEDUCTION_GUIDES
+#if defined(__clang__) && defined(__apple_build_version__)
+// Apple's clang version doesn't do deduction guides very well.
+#define RANGES_CXX_DEDUCTION_GUIDES 0
+#elif defined(__cpp_deduction_guides)
+#define RANGES_CXX_DEDUCTION_GUIDES __cpp_deduction_guides
+#else
+#define RANGES_CXX_DEDUCTION_GUIDES RANGES_CXX_FEATURE(DEDUCTION_GUIDES)
+#endif // __cpp_deduction_guides
+#endif // RANGES_CXX_DEDUCTION_GUIDES
+
+// __VA_OPT__
+#ifndef RANGES_CXX_VA_OPT
+#if __cplusplus > 201703L
+#define RANGES_CXX_THIRD_ARG_(A, B, C, ...) C
+#define RANGES_CXX_VA_OPT_I_(...) RANGES_CXX_THIRD_ARG_(__VA_OPT__(, ), 1, 0, ?)
+#define RANGES_CXX_VA_OPT RANGES_CXX_VA_OPT_I_(?)
+#else
+#define RANGES_CXX_VA_OPT 0
+#endif
+#endif // RANGES_CXX_VA_OPT
+
+#ifndef RANGES_CXX_IF_CONSTEXPR
+#ifdef __cpp_if_constexpr
+#define RANGES_CXX_IF_CONSTEXPR __cpp_if_constexpr
+#else
+#define RANGES_CXX_IF_CONSTEXPR RANGES_CXX_FEATURE(IF_CONSTEXPR)
+#endif
+#endif // RANGES_CXX_IF_CONSTEXPR
+
+// Its not enough for the compiler to support this; the stdlib must support it too.
+#ifndef RANGES_CXX_ALIGNED_NEW
+#if(!defined(_LIBCPP_VERSION) ||                                                 \
+    (_LIBCPP_VERSION >= 4000 && !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION))) && \
+    (!defined(__GLIBCXX__) || (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 7))
+#if defined(__cpp_aligned_new)
+#define RANGES_CXX_ALIGNED_NEW __cpp_aligned_new
+#else
+#define RANGES_CXX_ALIGNED_NEW RANGES_CXX_FEATURE(ALIGNED_NEW)
+#endif
+#else // _LIBCPP_VERSION < 4000 || __GLIBCXX__ < 20170502
+#define RANGES_CXX_ALIGNED_NEW 0L
+#endif
+#endif // RANGES_CXX_ALIGNED_NEW
+
+#if defined(__clang__)
+#define RANGES_IS_SAME(...) __is_same(__VA_ARGS__)
+#elif defined(__GNUC__) && __GNUC__ >= 6
+#define RANGES_IS_SAME(...) __is_same_as(__VA_ARGS__)
+#elif RANGES_CXX_TRAIT_VARIABLE_TEMPLATES
+#define RANGES_IS_SAME(...) std::is_same_v<__VA_ARGS__>
+#else
+#define RANGES_IS_SAME(...) std::is_same<__VA_ARGS__>::value
+#endif
+
+#ifdef RANGES_FEWER_WARNINGS
+#define RANGES_DISABLE_WARNINGS                 \
+    RANGES_DIAGNOSTIC_PUSH                      \
+    RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL \
+    RANGES_DIAGNOSTIC_IGNORE_INDENTATION        \
+    RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
+
+#define RANGES_RE_ENABLE_WARNINGS RANGES_DIAGNOSTIC_POP
+#else
+#define RANGES_DISABLE_WARNINGS
+#define RANGES_RE_ENABLE_WARNINGS
+#endif
+
+#if defined(__has_cpp_attribute) && __has_cpp_attribute(no_unique_address)
+#define RANGES_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+#define RANGES_NO_UNIQUE_ADDRESS
+#endif
+
+#if defined(__clang__)
+#if __has_attribute(no_sanitize)
+#define RANGES_INTENDED_MODULAR_ARITHMETIC \
+    __attribute__((__no_sanitize__("unsigned-integer-overflow")))
+#else
+#define RANGES_INTENDED_MODULAR_ARITHMETIC
+#endif
+#else
+#define RANGES_INTENDED_MODULAR_ARITHMETIC
+#endif
+
+#ifndef RANGES_CONSTEXPR_IF
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+#define RANGES_CONSTEXPR_IF(...) false) \
+    {} else if constexpr(__VA_ARGS__
+#else
+#define RANGES_CONSTEXPR_IF(...) __VA_ARGS__
+#endif
+#endif // RANGES_CONSTEXPR_IF
+
+#if !defined(RANGES_BROKEN_CPO_LOOKUP) && !defined(RANGES_DOXYGEN_INVOKED) && \
+    (defined(RANGES_WORKAROUND_GCC_UNFILED0) || defined(RANGES_WORKAROUND_MSVC_895622))
+#define RANGES_BROKEN_CPO_LOOKUP 1
+#endif
+#ifndef RANGES_BROKEN_CPO_LOOKUP
+#define RANGES_BROKEN_CPO_LOOKUP 0
+#endif
+
+#ifndef RANGES_NODISCARD
+#if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard)
+#if defined(__clang__) && __cplusplus < 201703L
+// clang complains about using nodiscard in C++14 mode.
+#define RANGES_NODISCARD                           \
+    RANGES_DIAGNOSTIC_PUSH                         \
+    RANGES_DIAGNOSTIC_IGNORE("-Wc++1z-extensions") \
+    [[nodiscard]] RANGES_DIAGNOSTIC_POP /**/
+#else
+#define RANGES_NODISCARD [[nodiscard]]
+#endif
+#else
+#define RANGES_NODISCARD
+#endif
+#endif
+
+#ifndef RANGES_EMPTY_BASES
+#ifdef _MSC_VER
+#define RANGES_EMPTY_BASES __declspec(empty_bases)
+#else
+#define RANGES_EMPTY_BASES
+#endif
+#endif
+
+#endif
diff --git a/inst/include/range/v3/detail/range_access.hpp b/inst/include/range/v3/detail/range_access.hpp
new file mode 100644
index 0000000..19eacbb
--- /dev/null
+++ b/inst/include/range/v3/detail/range_access.hpp
@@ -0,0 +1,368 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_DETAIL_RANGE_ACCESS_HPP
+#define RANGES_V3_DETAIL_RANGE_ACCESS_HPP
+
+#include <cstddef>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    struct range_access
+    {
+        /// \cond
+    private:
+        template<typename T>
+        static std::false_type single_pass_2_(long);
+        template<typename T>
+        static typename T::single_pass single_pass_2_(int);
+
+        template<typename T>
+        struct single_pass_
+        {
+            using type = decltype(range_access::single_pass_2_<T>(42));
+        };
+
+        template<typename T>
+        static std::false_type contiguous_2_(long);
+        template<typename T>
+        static typename T::contiguous contiguous_2_(int);
+
+        template<typename T>
+        struct contiguous_
+        {
+            using type = decltype(range_access::contiguous_2_<T>(42));
+        };
+
+        template<typename T>
+        static basic_mixin<T> mixin_base_2_(long);
+        template<typename T>
+        static typename T::mixin mixin_base_2_(int);
+
+        template<typename Cur>
+        struct mixin_base_
+        {
+            using type = decltype(range_access::mixin_base_2_<Cur>(42));
+        };
+
+    public:
+        template<typename Cur>
+        using single_pass_t = meta::_t<single_pass_<Cur>>;
+
+        template<typename Cur>
+        using contiguous_t = meta::_t<contiguous_<Cur>>;
+
+        template<typename Cur>
+        using mixin_base_t = meta::_t<mixin_base_<Cur>>;
+
+        // clang-format off
+        template<typename Rng>
+        static constexpr auto CPP_auto_fun(begin_cursor)(Rng &rng)
+        (
+            return rng.begin_cursor()
+        )
+        template<typename Rng>
+        static constexpr auto CPP_auto_fun(end_cursor)(Rng &rng)
+        (
+            return rng.end_cursor()
+        )
+
+        template<typename Rng>
+        static constexpr auto CPP_auto_fun(begin_adaptor)(Rng &rng)
+        (
+            return rng.begin_adaptor()
+        )
+        template<typename Rng>
+        static constexpr auto CPP_auto_fun(end_adaptor)(Rng &rng)
+        (
+            return rng.end_adaptor()
+        )
+
+        template<typename Cur>
+        static constexpr auto CPP_auto_fun(read)(Cur const &pos)
+        (
+            return pos.read()
+        )
+        template<typename Cur>
+        static constexpr auto CPP_auto_fun(arrow)(Cur const &pos)
+        (
+            return pos.arrow()
+        )
+        template<typename Cur>
+        static constexpr auto CPP_auto_fun(move)(Cur const &pos)
+        (
+            return pos.move()
+        )
+        template<typename Cur, typename T>
+        static constexpr auto CPP_auto_fun(write)(Cur &pos, T &&t)
+        (
+            return pos.write((T &&) t)
+        )
+        template<typename Cur>
+        static constexpr auto CPP_auto_fun(next)(Cur & pos)
+        (
+            return pos.next()
+        )
+        template<typename Cur, typename O>
+        static constexpr auto CPP_auto_fun(equal)(Cur const &pos, O const &other)
+        (
+            return pos.equal(other)
+        )
+        template<typename Cur>
+        static constexpr auto CPP_auto_fun(prev)(Cur & pos)
+        (
+            return pos.prev()
+        )
+        template<typename Cur, typename D>
+        static constexpr auto CPP_auto_fun(advance)(Cur & pos, D n)
+        (
+            return pos.advance(n)
+        )
+        template<typename Cur, typename O>
+        static constexpr auto CPP_auto_fun(distance_to)(Cur const &pos, O const &other)
+        (
+            return pos.distance_to(other)
+        )
+
+    private:
+        template<typename Cur>
+        using sized_cursor_difference_t = decltype(
+            range_access::distance_to(std::declval<Cur>(), std::declval<Cur>()));
+        // clang-format on
+
+        template<typename T>
+        static std::ptrdiff_t cursor_difference_2_(detail::ignore_t);
+        template<typename T>
+        static sized_cursor_difference_t<T> cursor_difference_2_(long);
+        template<typename T>
+        static typename T::difference_type cursor_difference_2_(int);
+
+        template<typename T>
+        using cursor_reference_t = decltype(std::declval<T const &>().read());
+
+        template<typename T>
+        static meta::id<uncvref_t<cursor_reference_t<T>>> cursor_value_2_(long);
+        template<typename T>
+        static meta::id<typename T::value_type> cursor_value_2_(int);
+
+#ifdef RANGES_WORKAROUND_CWG_1554
+        template<typename Cur>
+        struct cursor_difference
+        {
+            using type = decltype(range_access::cursor_difference_2_<Cur>(42));
+        };
+
+        template<typename Cur>
+        struct cursor_value : decltype(range_access::cursor_value_2_<Cur>(42))
+        {};
+#endif // RANGES_WORKAROUND_CWG_1554
+    public:
+#ifdef RANGES_WORKAROUND_CWG_1554
+        template<typename Cur>
+        using cursor_difference_t = meta::_t<cursor_difference<Cur>>;
+
+        template<typename Cur>
+        using cursor_value_t = meta::_t<cursor_value<Cur>>;
+#else  // ^^^ workaround ^^^ / vvv no workaround vvv
+        template<typename Cur>
+        using cursor_difference_t = decltype(range_access::cursor_difference_2_<Cur>(42));
+
+        template<typename Cur>
+        using cursor_value_t = meta::_t<decltype(range_access::cursor_value_2_<Cur>(42))>;
+#endif // RANGES_WORKAROUND_CWG_1554
+
+        template<typename Cur>
+        static constexpr Cur & pos(basic_iterator<Cur> & it) noexcept
+        {
+            return it.pos();
+        }
+        template<typename Cur>
+        static constexpr Cur const & pos(basic_iterator<Cur> const & it) noexcept
+        {
+            return it.pos();
+        }
+        template<typename Cur>
+        static constexpr Cur && pos(basic_iterator<Cur> && it) noexcept
+        {
+            return detail::move(it.pos());
+        }
+
+        template<typename Cur>
+        static constexpr Cur cursor(basic_iterator<Cur> it)
+        {
+            return std::move(it.pos());
+        }
+        /// endcond
+    };
+    /// @}
+
+    /// \cond
+    namespace detail
+    {
+        //
+        // Concepts that the range cursor must model
+        // clang-format off
+        //
+        CPP_def
+        (
+            template(typename T)
+            concept cursor,
+                semiregular<T> && semiregular<range_access::mixin_base_t<T>> &&
+                constructible_from<range_access::mixin_base_t<T>, T> &&
+                constructible_from<range_access::mixin_base_t<T>, T const &>
+                // Axiom: mixin_base_t<T> has a member get(), accessible to derived classes,
+                //   which perfectly-returns the contained cursor object and does not throw
+                //   exceptions.
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept has_cursor_next,
+                requires (T &t)
+                (
+                    range_access::next(t)
+                )
+        );
+        CPP_def
+        (
+            template(typename S, typename C)
+            concept sentinel_for_cursor,
+                requires (S &s, C &c)
+                (
+                    range_access::equal(c, s),
+                    concepts::requires_<convertible_to<decltype(
+                        range_access::equal(c, s)), bool>>
+                ) &&
+                semiregular<S> && cursor<C>
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept readable_cursor,
+                requires (T &t)
+                (
+                    range_access::read(t)
+                )
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept has_cursor_arrow,
+                requires (T const &t)
+                (
+                    range_access::arrow(t)
+                )
+        );
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept writable_cursor,
+                requires (T &t, U &&u)
+                (
+                    range_access::write(t, (U &&) u)
+                )
+        );
+        CPP_def
+        (
+            template(typename S, typename C)
+            concept sized_sentinel_for_cursor,
+                requires (S &s, C &c)
+                (
+                    range_access::distance_to(c, s),
+                    concepts::requires_<signed_integer_like_<decltype(
+                        range_access::distance_to(c, s))>>
+                ) &&
+                sentinel_for_cursor<S, C>
+        );
+        CPP_def
+        (
+            template(typename T, typename U)
+            concept output_cursor,
+                writable_cursor<T, U> && cursor<T>
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept input_cursor,
+                readable_cursor<T> && cursor<T> && has_cursor_next<T>
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept forward_cursor,
+                input_cursor<T> && sentinel_for_cursor<T, T> &&
+                !range_access::single_pass_t<uncvref_t<T>>::value
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept bidirectional_cursor,
+                requires (T &t)
+                (
+                    range_access::prev(t)
+                ) &&
+                forward_cursor<T>
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept random_access_cursor,
+                requires (T &t)
+                (
+                    range_access::advance(t, range_access::distance_to(t, t))
+                ) &&
+                bidirectional_cursor<T> && sized_sentinel_for_cursor<T, T>
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept contiguous_cursor,
+                requires (T &t)
+                (
+                    concepts::requires_<std::is_lvalue_reference<decltype(range_access::read(t))>::value>
+                ) &&
+                random_access_cursor<T> &&
+                range_access::contiguous_t<uncvref_t<T>>::value
+        );
+        // clang-format on
+
+        template<typename Cur, bool IsReadable>
+        struct is_writable_cursor_ : std::true_type
+        {};
+
+        template<typename Cur>
+        struct is_writable_cursor_<Cur, true>
+          : meta::bool_<(bool)writable_cursor<Cur, range_access::cursor_value_t<Cur>>>
+        {};
+
+        template<typename Cur>
+        struct is_writable_cursor
+          : detail::is_writable_cursor_<Cur, (bool)readable_cursor<Cur>>
+        {};
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/detail/satisfy_boost_range.hpp b/inst/include/range/v3/detail/satisfy_boost_range.hpp
new file mode 100644
index 0000000..ef566a8
--- /dev/null
+++ b/inst/include/range/v3/detail/satisfy_boost_range.hpp
@@ -0,0 +1,87 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_DETAIL_SATISFY_BOOST_RANGE_HPP
+#define RANGES_V3_DETAIL_SATISFY_BOOST_RANGE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+
+#ifndef RANGES_DOXYGEN_INVOKED
+namespace boost
+{
+    /// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
+    /// views
+    template<typename T, typename U>
+    struct range_mutable_iterator;
+
+    /// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
+    /// views
+    template<typename T, typename U>
+    struct range_const_iterator;
+
+    /// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
+    /// views
+    template<typename T>
+    struct range_value;
+
+    /// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
+    /// views
+    template<typename T>
+    struct range_size;
+} // namespace boost
+
+/// \brief Macro specialising Boost Range metafunctions for the specified view
+#define RANGES_SATISFY_BOOST_RANGE(view_name)                                           \
+    namespace boost                                                                     \
+    {                                                                                   \
+        template<typename... Ts>                                                        \
+        struct range_mutable_iterator<                                                  \
+            view_name<Ts...>,                                                           \
+            ::meta::if_c<(bool)::ranges::common_range<view_name<Ts...>>>>               \
+        {                                                                               \
+            using type = ::ranges::iterator_t<view_name<Ts...>>;                        \
+        };                                                                              \
+        template<typename... Ts>                                                        \
+        struct range_const_iterator<                                                    \
+            view_name<Ts...>,                                                           \
+            ::meta::if_c<(bool)::ranges::common_range<view_name<Ts...> const>>>         \
+        {                                                                               \
+            using type = ::ranges::iterator_t<view_name<Ts...> const>;                  \
+        };                                                                              \
+        template<typename... Ts>                                                        \
+        struct range_value<view_name<Ts...>>                                            \
+        {                                                                               \
+            using type = ::ranges::range_value_t<view_name<Ts...>>;                     \
+        };                                                                              \
+        template<typename... Ts>                                                        \
+        struct range_size<view_name<Ts...>>                                             \
+          : ::meta::if_c<(bool)::ranges::common_range<view_name<Ts...>>,                \
+                         ::meta::defer<::ranges::range_size_t, view_name<Ts...>>,       \
+                         ::meta::nil_>                                                  \
+        {};                                                                             \
+        template<typename... Ts>                                                        \
+        struct range_size<view_name<Ts...> const>                                       \
+          : ::meta::if_c<(bool)::ranges::common_range<view_name<Ts...> const>,          \
+                         ::meta::defer<::ranges::range_size_t, view_name<Ts...> const>, \
+                         ::meta::nil_>                                                  \
+        {};                                                                             \
+    }
+#else
+#define RANGES_SATISFY_BOOST_RANGE(view_name)
+#endif
+
+#endif
diff --git a/inst/include/range/v3/detail/variant.hpp b/inst/include/range/v3/detail/variant.hpp
new file mode 100644
index 0000000..0756add
--- /dev/null
+++ b/inst/include/range/v3/detail/variant.hpp
@@ -0,0 +1,895 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_DETAIL_VARIANT_HPP
+#define RANGES_V3_DETAIL_VARIANT_HPP
+
+#include <iterator>
+#include <memory>
+#include <new>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/reference_wrapper.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/get.hpp>
+
+namespace ranges
+{
+    template<std::size_t I>
+    struct emplaced_index_t;
+
+    template<std::size_t I>
+    struct emplaced_index_t : meta::size_t<I>
+    {};
+
+/// \cond
+#if !RANGES_CXX_VARIABLE_TEMPLATES
+    template<std::size_t I>
+    inline emplaced_index_t<I> emplaced_index()
+    {
+        return {};
+    }
+    template<std::size_t I>
+    using _emplaced_index_t_ = emplaced_index_t<I> (&)();
+#define RANGES_EMPLACED_INDEX_T(I) _emplaced_index_t_<I>
+#else
+    /// \endcond
+
+#if RANGES_CXX_INLINE_VARIABLES < RANGES_CXX_INLINE_VARIABLES_17
+    namespace
+    {
+        template<std::size_t I>
+        constexpr auto & emplaced_index = static_const<emplaced_index_t<I>>::value;
+    }
+#else  // RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
+    template<std::size_t I>
+    inline constexpr emplaced_index_t<I> emplaced_index{};
+#endif // RANGES_CXX_INLINE_VARIABLES
+
+/// \cond
+#define RANGES_EMPLACED_INDEX_T(I) emplaced_index_t<I>
+#endif
+    /// \endcond
+
+    struct bad_variant_access : std::logic_error
+    {
+        explicit bad_variant_access(std::string const & what_arg)
+          : std::logic_error(what_arg)
+        {}
+        explicit bad_variant_access(char const * what_arg)
+          : std::logic_error(what_arg)
+        {}
+    };
+
+    template<typename T, std::size_t Index>
+    struct indexed_element
+    {
+    private:
+        reference_wrapper<T> ref_;
+
+    public:
+        constexpr indexed_element(reference_wrapper<T> r) noexcept
+          : ref_(r)
+        {}
+        constexpr decltype(auto) get() const noexcept
+        {
+            return ref_.get();
+        }
+    };
+    template<std::size_t Index>
+    struct indexed_element<void, Index>
+    {
+        void get() const noexcept
+        {}
+    };
+
+    /// \cond
+    namespace detail
+    {
+        struct indexed_element_fn;
+
+        template<typename I, typename S, typename O>
+        auto uninitialized_copy(I first, S last, O out) -> CPP_ret(O)( //
+            requires(!sized_sentinel_for<S, I>))
+        {
+            for(; first != last; ++first, ++out)
+                ::new((void *)std::addressof(*out)) iter_value_t<O>(*first);
+            return out;
+        }
+
+        template<typename I, typename S, typename O>
+        auto uninitialized_copy(I first, S last, O out) -> CPP_ret(O)( //
+            requires sized_sentinel_for<S, I>)
+        {
+            return std::uninitialized_copy_n(first, (last - first), out);
+        }
+
+        template<typename I, typename O>
+        O uninitialized_copy(I first, I last, O out)
+        {
+            return std::uninitialized_copy(first, last, out);
+        }
+
+        template<typename T, typename Index>
+        struct indexed_datum
+        {
+        private:
+            template<typename, typename>
+            friend struct indexed_datum;
+            T datum_;
+
+        public:
+            CPP_member
+            constexpr CPP_ctor(indexed_datum)()(                          //
+                noexcept(std::is_nothrow_default_constructible<T>::value) //
+                requires default_constructible<T>)
+              : datum_{}
+            {}
+            CPP_template(typename... Ts)(                                      //
+                requires constructible_from<T, Ts...> && (sizeof...(Ts) != 0)) //
+                constexpr indexed_datum(Ts &&... ts) noexcept(
+                    std::is_nothrow_constructible<T, Ts...>::value)
+              : datum_(static_cast<Ts &&>(ts)...)
+            {}
+            template<typename U>
+            constexpr CPP_ctor(indexed_datum)(indexed_datum<U, Index> that)( //
+                noexcept(std::is_nothrow_constructible<T, U>::value)         //
+                requires(!same_as<T, U>) &&
+                convertible_to<U, T>)
+              : datum_(std::move(that.datum_))
+            {}
+            constexpr indexed_element<T, Index::value> ref() noexcept
+            {
+                return {datum_};
+            }
+            constexpr indexed_element<T const, Index::value> ref() const noexcept
+            {
+                return {datum_};
+            }
+            constexpr T & get() noexcept
+            {
+                return datum_;
+            }
+            constexpr T const & get() const noexcept
+            {
+                return datum_;
+            }
+        };
+
+        template<typename T, std::size_t N, typename Index>
+        struct indexed_datum<T[N], Index>;
+
+        template<typename T, typename Index>
+        struct indexed_datum<T &, Index>
+        {
+        private:
+            template<typename, typename>
+            friend struct indexed_datum;
+            reference_wrapper<T &> ref_;
+
+        public:
+            constexpr indexed_datum(reference_wrapper<T &> ref) noexcept
+              : ref_(ref)
+            {}
+            constexpr indexed_element<T &, Index::value> ref() const noexcept
+            {
+                return {ref_.get()};
+            }
+        };
+        template<typename T, typename Index>
+        struct indexed_datum<T &&, Index>
+        {
+        private:
+            template<typename, typename>
+            friend struct indexed_datum;
+            reference_wrapper<T &&> ref_;
+
+        public:
+            constexpr indexed_datum(reference_wrapper<T &&> ref) noexcept
+              : ref_(ref)
+            {}
+            constexpr indexed_element<T &&, Index::value> ref() const noexcept
+            {
+                return {ref_.get()};
+            }
+        };
+        template<typename Index>
+        struct indexed_datum<void, Index>
+        {
+            void get() const noexcept
+            {}
+            constexpr indexed_element<void, Index::value> ref() const noexcept
+            {
+                return {};
+            }
+        };
+
+        template<std::size_t Index, typename... Ts>
+        using variant_datum_t =
+            detail::indexed_datum<meta::at_c<meta::list<Ts...>, Index>,
+                                  meta::size_t<Index>>;
+    } // namespace detail
+
+    template<std::size_t N, typename... Ts, typename... Args>
+    meta::if_c<(bool)constructible_from<detail::variant_datum_t<N, Ts...>, Args...>>
+    emplace(variant<Ts...> &, Args &&...);
+
+    namespace detail
+    {
+        using variant_nil = indexed_datum<void, meta::npos>;
+
+        template<typename Ts,
+                 bool Trivial = meta::apply<
+                     meta::quote<meta::and_>,
+                     meta::transform<Ts, meta::quote<std::is_trivially_destructible>>>::
+                     type::value>
+        struct variant_data_
+        {
+            using type = indexed_datum<void, meta::npos>;
+        };
+
+        template<typename T, typename... Ts>
+        struct variant_data_<meta::list<T, Ts...>, true>
+        {
+            struct type
+            {
+                using head_t = T;
+                using tail_t = meta::_t<variant_data_<meta::list<Ts...>>>;
+                union
+                {
+                    head_t head;
+                    tail_t tail;
+                };
+
+                type() noexcept
+                {}
+                template<typename... Args>
+                constexpr type(meta::size_t<0>, Args &&... args) noexcept(
+                    std::is_nothrow_constructible<head_t, Args...>::value)
+                  : head{((Args &&) args)...}
+                {}
+                template<std::size_t N, typename... Args>
+                constexpr type(meta::size_t<N>, Args &&... args) noexcept(
+                    std::is_nothrow_constructible<tail_t, meta::size_t<N - 1>,
+                                                  Args...>::value)
+                  : tail{meta::size_t<N - 1>{}, ((Args &&) args)...}
+                {}
+            };
+        };
+
+        template<typename T, typename... Ts>
+        struct variant_data_<meta::list<T, Ts...>, false>
+        {
+            struct type
+            {
+                using head_t = T;
+                using tail_t = meta::_t<variant_data_<meta::list<Ts...>>>;
+                union
+                {
+                    head_t head;
+                    tail_t tail;
+                };
+
+                type() noexcept
+                {}
+                ~type()
+                {}
+                template<typename... Args>
+                constexpr type(meta::size_t<0>, Args &&... args) noexcept(
+                    std::is_nothrow_constructible<head_t, Args...>::value)
+                  : head{((Args &&) args)...}
+                {}
+                template<std::size_t N, typename... Args>
+                constexpr type(meta::size_t<N>, Args &&... args) noexcept(
+                    std::is_nothrow_constructible<tail_t, meta::size_t<N - 1>,
+                                                  Args...>::value)
+                  : tail{meta::size_t<N - 1>{}, ((Args &&) args)...}
+                {}
+            };
+        };
+
+        template<typename... Ts>
+        using variant_data = meta::_t<variant_data_<meta::transform<
+            meta::list<Ts...>, meta::as_list<meta::make_index_sequence<sizeof...(Ts)>>,
+            meta::quote<indexed_datum>>>>;
+
+        inline std::size_t variant_move_copy_(std::size_t, variant_nil, variant_nil)
+        {
+            return 0;
+        }
+        template<typename Data0, typename Data1>
+        std::size_t variant_move_copy_(std::size_t n, Data0 & self, Data1 && that)
+        {
+            using Head = typename Data0::head_t;
+            return 0 == n
+                       ? ((void)::new((void *)&self.head) Head(((Data1 &&) that).head), 0)
+                       : variant_move_copy_(n - 1, self.tail, ((Data1 &&) that).tail) + 1;
+        }
+        constexpr bool variant_equal_(std::size_t, variant_nil, variant_nil)
+        {
+            return true;
+        }
+        template<typename Data0, typename Data1>
+        constexpr bool variant_equal_(std::size_t n, Data0 const & self,
+                                      Data1 const & that)
+        {
+            return n == 0 ? self.head.get() == that.head.get()
+                          : variant_equal_(n - 1, self.tail, that.tail);
+        }
+        template<typename Fun, typename Proj = indexed_element_fn>
+        constexpr int variant_visit_(std::size_t, variant_nil, Fun, Proj = {})
+        {
+            return (RANGES_EXPECT(false), 0);
+        }
+        template<typename Data, typename Fun, typename Proj = indexed_element_fn>
+        constexpr int variant_visit_(std::size_t n, Data & self, Fun fun, Proj proj = {})
+        {
+            return 0 == n ? ((void)invoke(fun, invoke(proj, self.head)), 0)
+                          : detail::variant_visit_(
+                                n - 1, self.tail, detail::move(fun), detail::move(proj));
+        }
+
+        struct get_datum_fn
+        {
+            template<typename T>
+            decltype(auto) operator()(T && t) const noexcept
+            {
+                return t.get();
+            }
+        };
+
+        struct indexed_element_fn
+        {
+            template<typename T>
+            decltype(auto) operator()(T && t) const noexcept
+            {
+                return t.ref();
+            }
+        };
+
+        struct empty_variant_tag
+        {};
+
+        struct variant_core_access
+        {
+            template<typename... Ts>
+            static constexpr variant_data<Ts...> & data(variant<Ts...> & var) noexcept
+            {
+                return var.data_();
+            }
+            template<typename... Ts>
+            static constexpr variant_data<Ts...> const & data(
+                variant<Ts...> const & var) noexcept
+            {
+                return var.data_();
+            }
+            template<typename... Ts>
+            static constexpr variant_data<Ts...> && data(variant<Ts...> && var) noexcept
+            {
+                return detail::move(var.data_());
+            }
+            template<typename... Ts>
+            static variant<Ts...> make_empty(meta::id<variant<Ts...>> = {}) noexcept
+            {
+                return variant<Ts...>{empty_variant_tag{}};
+            }
+        };
+
+        struct delete_fn
+        {
+            template<typename T>
+            void operator()(T const & t) const noexcept
+            {
+                t.~T();
+            }
+        };
+
+        template<std::size_t N, typename... Ts>
+        struct construct_fn
+        {
+            std::tuple<Ts...> args_;
+
+            template<typename U, std::size_t... Is>
+            void construct_(U & u, meta::index_sequence<Is...>) noexcept(
+                std::is_nothrow_constructible<U, Ts...>::value)
+            {
+                ::new((void *)std::addressof(u))
+                    U(static_cast<Ts &&>(std::get<Is>(args_))...);
+            }
+
+            construct_fn(Ts &&... ts) noexcept(
+                std::is_nothrow_constructible<std::tuple<Ts...>, Ts...>::value)
+              : args_{static_cast<Ts &&>(ts)...}
+            {}
+            template<typename U, std::size_t M>
+            [[noreturn]] meta::if_c<N != M> operator()(
+                indexed_datum<U, meta::size_t<M>> &) noexcept
+            {
+                RANGES_EXPECT(false);
+            }
+            template<typename U>
+            meta::if_<std::is_object<U>> operator()(
+                indexed_datum<U, meta::size_t<N>> &
+                    u) noexcept(std::is_nothrow_constructible<U, Ts...>::value)
+            {
+                this->construct_(u.get(), meta::make_index_sequence<sizeof...(Ts)>{});
+            }
+            template<typename U>
+            meta::if_<meta::not_<std::is_object<U>>> operator()(
+                indexed_datum<U, meta::size_t<N>> &
+                    u) noexcept(std::is_nothrow_constructible<detail::decay_t<U>,
+                                                              Ts...>::value)
+            {
+                this->construct_(u, meta::make_index_sequence<sizeof...(Ts)>{});
+            }
+        };
+
+        template<typename T, std::size_t N>
+        struct get_fn
+        {
+            T ** t_;
+
+            template<typename U, std::size_t M>
+            [[noreturn]] meta::if_c<M != N> operator()(indexed_element<U, M>) const
+            {
+                throw bad_variant_access("bad variant access");
+            }
+            template<typename U>
+            void operator()(indexed_element<U, N> t) const noexcept
+            {
+                *t_ = std::addressof(t.get());
+            }
+            template<typename U>
+            void operator()(indexed_element<U &&, N> t) const noexcept
+            {
+                U && u = t.get();
+                *t_ = std::addressof(u);
+            }
+            void operator()(indexed_element<void, N>) const noexcept
+            {}
+        };
+
+        template<typename Variant, std::size_t N>
+        struct emplace_fn
+        {
+            Variant * var_;
+            // clang-format off
+            template<typename...Ts>
+            auto CPP_auto_fun(operator())(Ts &&...ts) (const)
+            (
+                return ranges::emplace<N>(*var_, static_cast<Ts &&>(ts)...)
+            )
+            // clang-format on
+        };
+
+        template<typename Fun, typename Variant>
+        struct variant_visitor
+        {
+            Fun fun_;
+            Variant * var_;
+
+            // clang-format off
+            template<typename U, std::size_t N>
+            auto CPP_auto_fun(operator())(indexed_element<U, N> u)
+            (
+                return compose(emplace_fn<Variant, N>{var_}, fun_)(u)
+            )
+            // clang-format on
+        };
+
+        template<typename Variant, typename Fun>
+        variant_visitor<Fun, Variant> make_variant_visitor(
+            Variant & var,
+            Fun fun) noexcept(std::is_nothrow_move_constructible<Fun>::value)
+        {
+            return {detail::move(fun), &var};
+        }
+
+        template<typename To, typename From>
+        struct unique_visitor;
+
+        template<typename... To, typename... From>
+        struct unique_visitor<variant<To...>, variant<From...>>
+        {
+            variant<To...> * var_;
+
+            template<typename T, std::size_t N>
+            void operator()(indexed_element<T, N> t) const
+            {
+                using E = meta::at_c<meta::list<From...>, N>;
+                static_assert(RANGES_IS_SAME(T const, E const),
+                              "Is indexed_element broken?");
+                using F = meta::find<meta::list<To...>, E>;
+                static constexpr std::size_t M = sizeof...(To) - F::size();
+                compose(emplace_fn<variant<To...>, M>{var_}, get_datum_fn{})(t);
+            }
+        };
+
+        template<typename T>
+        constexpr T & variant_deref_(T * t) noexcept
+        {
+            return *t;
+        }
+        inline void variant_deref_(void const volatile *) noexcept
+        {}
+
+        template<typename Variant>
+        struct variant_get
+        {
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            // get
+            template<std::size_t N>
+            friend meta::_t<
+                std::add_lvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>
+            get(Variant & var)
+            {
+                using elem_t = meta::_t<
+                    std::remove_reference<meta::at_c<meta::as_list<Variant>, N>>>;
+                elem_t * elem = nullptr;
+                auto & data_var = detail::variant_core_access::data(var);
+                detail::variant_visit_(
+                    var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
+                return detail::variant_deref_(elem);
+            }
+            template<std::size_t N>
+            friend meta::_t<
+                std::add_lvalue_reference<meta::at_c<meta::as_list<Variant>, N> const>>
+            get(Variant const & var)
+            {
+                using elem_t = meta::_t<
+                    std::remove_reference<meta::at_c<meta::as_list<Variant>, N> const>>;
+                elem_t * elem = nullptr;
+                auto & data_var = detail::variant_core_access::data(var);
+                detail::variant_visit_(
+                    var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
+                return detail::variant_deref_(elem);
+            }
+            template<std::size_t N>
+            friend meta::_t<
+                std::add_rvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>
+            get(Variant && var)
+            {
+                using elem_t = meta::_t<
+                    std::remove_reference<meta::at_c<meta::as_list<Variant>, N>>>;
+                elem_t * elem = nullptr;
+                auto & data_var = detail::variant_core_access::data(var);
+                detail::variant_visit_(
+                    var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
+                using res_t = meta::_t<
+                    std::add_rvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>;
+                return static_cast<res_t>(detail::variant_deref_(elem));
+            }
+        };
+
+        template<typename Variant,
+                 bool Trivial = std::is_trivially_destructible<meta::apply<
+                     meta::quote<variant_data>, meta::as_list<Variant>>>::value>
+        struct variant_base : variant_get<Variant>
+        {
+            ~variant_base()
+            {
+                static_cast<Variant *>(this)->clear_();
+            }
+        };
+        template<typename... Ts>
+        struct variant_base<variant<Ts...>, true> : variant_get<variant<Ts...>>
+        {};
+
+        template<typename Fun, typename Types, typename Indices, typename = void>
+        struct variant_visit_results
+        {};
+        template<typename Fun, typename... Ts, std::size_t... Is>
+        struct variant_visit_results<
+            Fun, meta::list<Ts...>, meta::index_sequence<Is...>,
+            meta::void_<invoke_result_t<Fun &, indexed_element<Ts, Is>>...>>
+        {
+            using type = variant<invoke_result_t<Fun &, indexed_element<Ts, Is>>...>;
+        };
+        template<typename Fun, typename... Ts>
+        using variant_visit_results_t =
+            meta::_t<variant_visit_results<Fun, meta::list<Ts...>,
+                                           meta::make_index_sequence<sizeof...(Ts)>>>;
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-utility
+    /// @{
+    template<typename... Ts>
+    struct variant
+      : private detail::variant_data<Ts...>
+      , private detail::variant_base<variant<Ts...>>
+    {
+    private:
+        friend detail::variant_core_access;
+        template<typename...>
+        friend struct variant;
+        friend detail::variant_base<variant, false>;
+        template<std::size_t Index>
+        using datum_t = detail::variant_datum_t<Index, Ts...>;
+        template<typename T>
+        using add_const_t = meta::if_<std::is_void<T>, void, T const>;
+        using unbox_fn = detail::get_datum_fn;
+
+        detail::variant_data<Ts...> & data_() & noexcept
+        {
+            return *this;
+        }
+        detail::variant_data<Ts...> const & data_() const & noexcept
+        {
+            return *this;
+        }
+        detail::variant_data<Ts...> && data_() && noexcept
+        {
+            return static_cast<detail::variant_data<Ts...> &&>(*this);
+        }
+
+        std::size_t index_;
+
+        void clear_() noexcept
+        {
+            if(valid())
+            {
+                detail::variant_visit_(index_, data_(), detail::delete_fn{}, identity{});
+                index_ = (std::size_t)-1;
+            }
+        }
+        template<typename That>
+        void assign_(That && that)
+        {
+            if(that.valid())
+                index_ = detail::variant_move_copy_(
+                    that.index_, data_(), ((That &&) that).data_());
+        }
+        constexpr variant(detail::empty_variant_tag) noexcept
+          : detail::variant_data<Ts...>{}
+          , index_((std::size_t)-1)
+        {}
+        template<typename... Args>
+        static constexpr auto all_convertible_to(int) noexcept -> CPP_ret(bool)( //
+            requires(sizeof...(Args) == sizeof...(Ts)))
+        {
+            return and_v<convertible_to<Args, Ts>...>;
+        }
+        template<typename... Args>
+        static constexpr bool all_convertible_to(long) noexcept
+        {
+            return false;
+        }
+
+    public:
+        CPP_member
+        constexpr CPP_ctor(variant)()(                                         //
+            noexcept(std::is_nothrow_default_constructible<datum_t<0>>::value) //
+            requires default_constructible<datum_t<0>>)
+          : variant{emplaced_index<0>}
+        {}
+        CPP_template(std::size_t N, typename... Args)(        //
+            requires constructible_from<datum_t<N>, Args...>) //
+            constexpr variant(RANGES_EMPLACED_INDEX_T(N), Args &&... args) noexcept(
+                std::is_nothrow_constructible<datum_t<N>, Args...>::value)
+          : detail::variant_data<Ts...>{meta::size_t<N>{}, static_cast<Args &&>(args)...}
+          , index_(N)
+        {}
+        CPP_template(std::size_t N, typename T, typename... Args)( //
+            requires constructible_from<datum_t<N>, std::initializer_list<T> &,
+                                        Args...>) //
+            constexpr variant(
+                RANGES_EMPLACED_INDEX_T(N), std::initializer_list<T> il,
+                Args &&... args) noexcept(std::
+                                              is_nothrow_constructible<
+                                                  datum_t<N>, std::initializer_list<T> &,
+                                                  Args...>::value)
+          : detail::variant_data<Ts...>{meta::size_t<N>{},
+                                        il,
+                                        static_cast<Args &&>(args)...}
+          , index_(N)
+        {}
+        template<std::size_t N>
+        constexpr CPP_ctor(variant)(RANGES_EMPLACED_INDEX_T(N), meta::nil_)(       //
+            noexcept(std::is_nothrow_constructible<datum_t<N>, meta::nil_>::value) //
+            requires constructible_from<datum_t<N>, meta::nil_>)
+          : detail::variant_data<Ts...>{meta::size_t<N>{}, meta::nil_{}}
+          , index_(N)
+        {}
+        variant(variant && that)
+          : detail::variant_data<Ts...>{}
+          , index_(detail::variant_move_copy_(that.index(), data_(),
+                                              std::move(that.data_())))
+        {}
+        variant(variant const & that)
+          : detail::variant_data<Ts...>{}
+          , index_(detail::variant_move_copy_(that.index(), data_(), that.data_()))
+        {}
+        template<typename... Args>
+        CPP_ctor(variant)(variant<Args...> that)( //
+            requires(!same_as<variant<Args...>, variant>) &&
+            (all_convertible_to<Args...>(0)))
+          : detail::variant_data<Ts...>{}
+          , index_(detail::variant_move_copy_(that.index(), data_(),
+                                              std::move(that.data_())))
+        {}
+        variant & operator=(variant && that)
+        {
+            // TODO do a simple move assign when index()==that.index()
+            this->clear_();
+            this->assign_(detail::move(that));
+            return *this;
+        }
+        variant & operator=(variant const & that)
+        {
+            // TODO do a simple copy assign when index()==that.index()
+            this->clear_();
+            this->assign_(that);
+            return *this;
+        }
+        template<typename... Args>
+        auto operator=(variant<Args...> that) -> CPP_ret(variant &)( //
+            requires(!same_as<variant<Args...>, variant>) &&
+            (all_convertible_to<Args...>(0)))
+        {
+            // TODO do a simple copy assign when index()==that.index()
+            this->clear_();
+            this->assign_(that);
+            return *this;
+        }
+        static constexpr std::size_t size() noexcept
+        {
+            return sizeof...(Ts);
+        }
+        template<std::size_t N, typename... Args>
+        auto emplace(Args &&... args) -> CPP_ret(void)( //
+            requires constructible_from<datum_t<N>, Args...>)
+        {
+            this->clear_();
+            detail::construct_fn<N, Args &&...> fn{static_cast<Args &&>(args)...};
+            detail::variant_visit_(N, data_(), std::ref(fn), identity{});
+            index_ = N;
+        }
+        constexpr bool valid() const noexcept
+        {
+            return index() != (std::size_t)-1;
+        }
+        constexpr std::size_t index() const noexcept
+        {
+            return index_;
+        }
+        template<typename Fun>
+        detail::variant_visit_results_t<composed<Fun, unbox_fn>, Ts...> visit(Fun fun)
+        {
+            detail::variant_visit_results_t<composed<Fun, unbox_fn>, Ts...> res{
+                detail::empty_variant_tag{}};
+            detail::variant_visit_(index_,
+                                   data_(),
+                                   detail::make_variant_visitor(
+                                       res, compose(detail::move(fun), unbox_fn{})));
+            return res;
+        }
+        template<typename Fun>
+        detail::variant_visit_results_t<composed<Fun, unbox_fn>, add_const_t<Ts>...>
+        visit(Fun fun) const
+        {
+            detail::variant_visit_results_t<composed<Fun, unbox_fn>, add_const_t<Ts>...>
+                res{detail::empty_variant_tag{}};
+            detail::variant_visit_(index_,
+                                   data_(),
+                                   detail::make_variant_visitor(
+                                       res, compose(detail::move(fun), unbox_fn{})));
+            return res;
+        }
+        template<typename Fun>
+        detail::variant_visit_results_t<Fun, Ts...> visit_i(Fun fun)
+        {
+            detail::variant_visit_results_t<Fun, Ts...> res{detail::empty_variant_tag{}};
+            detail::variant_visit_(
+                index_, data_(), detail::make_variant_visitor(res, detail::move(fun)));
+            return res;
+        }
+        template<typename Fun>
+        detail::variant_visit_results_t<Fun, add_const_t<Ts>...> visit_i(Fun fun) const
+        {
+            detail::variant_visit_results_t<Fun, add_const_t<Ts>...> res{
+                detail::empty_variant_tag{}};
+            detail::variant_visit_(
+                index_, data_(), detail::make_variant_visitor(res, detail::move(fun)));
+            return res;
+        }
+    };
+
+    template<typename... Ts, typename... Us>
+    auto operator==(variant<Ts...> const & lhs, variant<Us...> const & rhs)
+        -> CPP_ret(bool)( //
+            requires and_v<equality_comparable_with<Ts, Us>...>)
+    {
+        return (!lhs.valid() && !rhs.valid()) ||
+               (lhs.index() == rhs.index() &&
+                detail::variant_equal_(lhs.index(),
+                                       detail::variant_core_access::data(lhs),
+                                       detail::variant_core_access::data(rhs)));
+    }
+
+    template<typename... Ts, typename... Us>
+    auto operator!=(variant<Ts...> const & lhs, variant<Us...> const & rhs)
+        -> CPP_ret(bool)( //
+            requires and_v<equality_comparable_with<Ts, Us>...>)
+    {
+        return !(lhs == rhs);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // emplace
+    template<std::size_t N, typename... Ts, typename... Args>
+    meta::if_c<(bool)constructible_from<detail::variant_datum_t<N, Ts...>, Args...>>
+    emplace(variant<Ts...> & var, Args &&... args)
+    {
+        var.template emplace<N>(static_cast<Args &&>(args)...);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // variant_unique
+    template<typename Var>
+    struct variant_unique
+    {};
+
+    template<typename... Ts>
+    struct variant_unique<variant<Ts...>>
+    {
+        using type = meta::apply<meta::quote<variant>, meta::unique<meta::list<Ts...>>>;
+    };
+
+    template<typename Var>
+    using variant_unique_t = meta::_t<variant_unique<Var>>;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // unique_variant
+    template<typename... Ts>
+    variant_unique_t<variant<Ts...>> unique_variant(variant<Ts...> const & var)
+    {
+        using From = variant<Ts...>;
+        using To = variant_unique_t<From>;
+        auto res = detail::variant_core_access::make_empty(meta::id<To>{});
+        var.visit_i(detail::unique_visitor<To, From>{&res});
+        RANGES_EXPECT(res.valid());
+        return res;
+    }
+    /// @}
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+
+namespace std
+{
+    template<typename... Ts>
+    struct tuple_size<::ranges::variant<Ts...>> : tuple_size<tuple<Ts...>>
+    {};
+
+    template<size_t I, typename... Ts>
+    struct tuple_element<I, ::ranges::variant<Ts...>> : tuple_element<I, tuple<Ts...>>
+    {};
+} // namespace std
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/detail/with_braced_init_args.hpp b/inst/include/range/v3/detail/with_braced_init_args.hpp
new file mode 100644
index 0000000..69a165f
--- /dev/null
+++ b/inst/include/range/v3/detail/with_braced_init_args.hpp
@@ -0,0 +1,76 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_DETAIL_WITH_BRACED_INIT_ARGS_HPP
+#define RANGES_V3_DETAIL_WITH_BRACED_INIT_ARGS_HPP
+
+#include <initializer_list>
+
+#include <range/v3/functional/invoke.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // Accepts initializer_lists as either the first or second parameter, or both,
+        // and forwards on to an implementation.
+        template<typename ImplFn>
+        struct with_braced_init_args : ImplFn
+        {
+        private:
+            constexpr ImplFn const & base() const
+            {
+                return *this;
+            }
+
+        public:
+            using ImplFn::operator();
+
+            template<typename V0, typename... Args>
+            constexpr auto operator()(std::initializer_list<V0> && rng0,
+                                      Args &&... args) const
+                -> invoke_result_t<ImplFn const &, std::initializer_list<V0>, Args...>
+            {
+                return base()(static_cast<std::initializer_list<V0> &&>(rng0),
+                              static_cast<Args &&>(args)...);
+            }
+            /// \overload
+            template<typename Rng0, typename V1, typename... Args>
+            constexpr auto operator()(Rng0 && rng0, std::initializer_list<V1> && rng1,
+                                      Args &&... args) const
+                -> invoke_result_t<ImplFn const &, Rng0, std::initializer_list<V1>,
+                                   Args...>
+            {
+                return base()( //
+                    static_cast<Rng0 &&>(rng0),
+                    static_cast<std::initializer_list<V1> &&>(rng1),
+                    static_cast<Args &&>(args)...);
+            }
+            /// \overload
+            template<typename V0, typename V1, typename... Args>
+            constexpr auto operator()(std::initializer_list<V0> && rng0,
+                                      std::initializer_list<V1> && rng1,
+                                      Args &&... args) const
+                -> invoke_result_t<ImplFn const &, std::initializer_list<V0>,
+                                   std::initializer_list<V1>, Args...>
+            {
+                return base()( //
+                    static_cast<std::initializer_list<V0> &&>(rng0),
+                    static_cast<std::initializer_list<V1> &&>(rng1),
+                    static_cast<Args &&>(args)...);
+            }
+        };
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/distance.hpp b/inst/include/range/v3/distance.hpp
new file mode 100644
index 0000000..6ea8e73
--- /dev/null
+++ b/inst/include/range/v3/distance.hpp
@@ -0,0 +1,24 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Michel Morin 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_DISTANCE_HPP
+#define RANGES_V3_DISTANCE_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/iterator/operations.hpp> "
+    "instead.")
+
+#include <range/v3/iterator/operations.hpp>
+
+#endif
diff --git a/inst/include/range/v3/empty.hpp b/inst/include/range/v3/empty.hpp
new file mode 100644
index 0000000..c23c1a8
--- /dev/null
+++ b/inst/include/range/v3/empty.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_EMPTY_HPP
+#define RANGES_V3_EMPTY_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/primitives.hpp> instead.")
+
+#include <range/v3/range/primitives.hpp>
+
+#endif
diff --git a/inst/include/range/v3/experimental/utility/generator.hpp b/inst/include/range/v3/experimental/utility/generator.hpp
new file mode 100644
index 0000000..8c81767
--- /dev/null
+++ b/inst/include/range/v3/experimental/utility/generator.hpp
@@ -0,0 +1,364 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Casey Carter 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_EXPERIMENTAL_UTILITY_GENERATOR_HPP
+#define RANGES_V3_EXPERIMENTAL_UTILITY_GENERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+#if RANGES_CXX_COROUTINES >= RANGES_CXX_COROUTINES_TS1
+#include <atomic>
+#include <cstddef>
+#include <exception>
+#include <experimental/coroutine>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/swap.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+
+#if defined(_MSC_VER) && !defined(RANGES_SILENCE_COROUTINE_WARNING)
+#ifdef __clang__
+#pragma message(                                                 \
+    "DANGER: clang doesn't (yet?) grok the MSVC coroutine ABI. " \
+    "Use at your own risk. "                                     \
+    "(RANGES_SILENCE_COROUTINE_WARNING will silence this message.)")
+#elif defined RANGES_WORKAROUND_MSVC_835948
+#pragma message(                                                                 \
+    "DANGER: ranges::experimental::generator is fine, but this "                 \
+    "version of MSVC likely miscompiles ranges::experimental::sized_generator. " \
+    "Use the latter at your own risk. "                                          \
+    "(RANGES_SILENCE_COROUTINE_WARNING will silence this message.)")
+#endif
+#endif // RANGES_SILENCE_COROUTINE_WARNINGS
+
+namespace ranges
+{
+    /// \addtogroup group-view
+    /// @{
+    namespace experimental
+    {
+        // The type of size() for a sized_generator
+        using generator_size_t = std::size_t;
+
+        // Type upon which to co_await to set the size of a sized_generator
+        enum struct generator_size : generator_size_t
+        {
+            invalid = ~generator_size_t(0)
+        };
+
+        template<typename Promise = void>
+        struct RANGES_EMPTY_BASES coroutine_owner;
+
+        class enable_coroutine_owner
+        {
+            template<class>
+            friend struct coroutine_owner;
+            std::atomic<unsigned int> refcount_{1};
+        };
+    } // namespace experimental
+
+    /// \cond
+    namespace detail
+    {
+        inline void resume(std::experimental::coroutine_handle<> coro)
+        {
+            // Pre: coro refers to a suspended coroutine.
+            RANGES_EXPECT(coro);
+            RANGES_EXPECT(!coro.done());
+            coro.resume();
+        }
+
+        namespace coroutine_owner_
+        {
+            struct adl_hook
+            {};
+
+            template<typename Promise>
+            void swap(experimental::coroutine_owner<Promise> & x,
+                      experimental::coroutine_owner<Promise> & y) noexcept
+            {
+                x.swap(y);
+            }
+        } // namespace coroutine_owner_
+    }     // namespace detail
+    /// \endcond
+
+    namespace experimental
+    {
+        // An owning coroutine_handle
+        template<typename Promise>
+        struct RANGES_EMPTY_BASES coroutine_owner
+          : private std::experimental::coroutine_handle<Promise>
+          , private detail::coroutine_owner_::adl_hook
+        {
+            CPP_assert(derived_from<Promise, enable_coroutine_owner>);
+            using base_t = std::experimental::coroutine_handle<Promise>;
+
+            using base_t::operator bool;
+            using base_t::done;
+            using base_t::promise;
+
+            coroutine_owner() = default;
+            explicit constexpr coroutine_owner(base_t coro) noexcept
+              : base_t(coro)
+            {}
+            coroutine_owner(coroutine_owner && that) noexcept
+              : base_t(ranges::exchange(that.base(), {}))
+              , copied_(that.copied_.load(std::memory_order_relaxed))
+            {}
+            coroutine_owner(coroutine_owner const & that) noexcept
+              : base_t(that.handle())
+              , copied_(that.handle() != nullptr)
+            {
+                if(*this)
+                {
+                    that.copied_.store(true, std::memory_order_relaxed);
+                    base().promise().refcount_.fetch_add(1, std::memory_order_relaxed);
+                }
+            }
+            ~coroutine_owner()
+            {
+                if(base() && (!copied_.load(std::memory_order_relaxed) ||
+                              1 == base().promise().refcount_.fetch_sub(
+                                       1, std::memory_order_acq_rel)))
+                    base().destroy();
+            }
+            coroutine_owner & operator=(coroutine_owner that) noexcept
+            {
+                swap(that);
+                return *this;
+            }
+            void resume()
+            {
+                detail::resume(handle());
+            }
+            void operator()()
+            {
+                detail::resume(handle());
+            }
+            void swap(coroutine_owner & that) noexcept
+            {
+                bool tmp = copied_.load(std::memory_order_relaxed);
+                copied_.store(that.copied_.load(std::memory_order_relaxed),
+                              std::memory_order_relaxed);
+                that.copied_.store(tmp, std::memory_order_relaxed);
+                std::swap(base(), that.base());
+            }
+            base_t handle() const noexcept
+            {
+                return *this;
+            }
+
+        private:
+            std::atomic<bool> copied_{false};
+
+            base_t & base() noexcept
+            {
+                return *this;
+            }
+        };
+    } // namespace experimental
+
+    /// \cond
+    namespace detail
+    {
+        template<typename Reference>
+        struct generator_promise : experimental::enable_coroutine_owner
+        {
+            std::exception_ptr except_ = nullptr;
+
+            CPP_assert(std::is_reference<Reference>::value ||
+                       copy_constructible<Reference>);
+
+            generator_promise * get_return_object() noexcept
+            {
+                return this;
+            }
+            std::experimental::suspend_always initial_suspend() const noexcept
+            {
+                return {};
+            }
+            std::experimental::suspend_always final_suspend() const noexcept
+            {
+                return {};
+            }
+            void return_void() const noexcept
+            {}
+            void unhandled_exception() noexcept
+            {
+                except_ = std::current_exception();
+                RANGES_EXPECT(except_);
+            }
+            template<typename Arg>
+            auto yield_value(Arg && arg) noexcept(
+                std::is_nothrow_assignable<semiregular_box_t<Reference> &, Arg>::value)
+                -> CPP_ret(std::experimental::suspend_always)( //
+                    requires convertible_to<Arg, Reference> &&
+                        std::is_assignable<semiregular_box_t<Reference> &, Arg>::value)
+            {
+                ref_ = std::forward<Arg>(arg);
+                return {};
+            }
+            std::experimental::suspend_never await_transform(
+                experimental::generator_size) const noexcept
+            {
+                RANGES_ENSURE_MSG(false,
+                                  "Invalid size request for a non-sized generator");
+                return {};
+            }
+            meta::if_<std::is_reference<Reference>, Reference, Reference const &> read()
+                const noexcept
+            {
+                return ref_;
+            }
+
+        private:
+            semiregular_box_t<Reference> ref_;
+        };
+
+        template<typename Reference>
+        struct sized_generator_promise : generator_promise<Reference>
+        {
+            sized_generator_promise * get_return_object() noexcept
+            {
+                return this;
+            }
+            std::experimental::suspend_never initial_suspend() const noexcept
+            {
+                // sized_generator doesn't suspend at its initial suspend point because...
+                return {};
+            }
+            std::experimental::suspend_always await_transform(
+                experimental::generator_size size) noexcept
+            {
+                // ...we need the coroutine set the size of the range first by
+                // co_awaiting on a generator_size.
+                size_ = size;
+                return {};
+            }
+            experimental::generator_size_t size() const noexcept
+            {
+                RANGES_EXPECT(size_ != experimental::generator_size::invalid);
+                return static_cast<experimental::generator_size_t>(size_);
+            }
+
+        private:
+            experimental::generator_size size_ = experimental::generator_size::invalid;
+        };
+    } // namespace detail
+    /// \endcond
+
+    namespace experimental
+    {
+        template<typename Reference, typename Value = uncvref_t<Reference>>
+        struct sized_generator;
+
+        template<typename Reference, typename Value = uncvref_t<Reference>>
+        struct generator : view_facade<generator<Reference, Value>>
+        {
+            using promise_type = detail::generator_promise<Reference>;
+
+            constexpr generator() noexcept = default;
+            generator(promise_type * p)
+              : coro_{handle::from_promise(*p)}
+            {
+                RANGES_EXPECT(coro_);
+            }
+
+        private:
+            friend range_access;
+            friend struct sized_generator<Reference, Value>;
+            using handle = std::experimental::coroutine_handle<promise_type>;
+            coroutine_owner<promise_type> coro_;
+
+            struct cursor
+            {
+                using value_type = Value;
+
+                cursor() = default;
+                constexpr explicit cursor(handle coro) noexcept
+                  : coro_{coro}
+                {}
+                bool equal(default_sentinel_t) const
+                {
+                    RANGES_EXPECT(coro_);
+                    if(coro_.done())
+                    {
+                        auto & e = coro_.promise().except_;
+                        if(e)
+                            std::rethrow_exception(std::move(e));
+                        return true;
+                    }
+                    return false;
+                }
+                void next()
+                {
+                    detail::resume(coro_);
+                }
+                Reference read() const
+                {
+                    RANGES_EXPECT(coro_);
+                    return coro_.promise().read();
+                }
+
+            private:
+                handle coro_ = nullptr;
+            };
+
+            cursor begin_cursor()
+            {
+                detail::resume(coro_.handle());
+                return cursor{coro_.handle()};
+            }
+        };
+
+        template<typename Reference, typename Value /* = uncvref_t<Reference>*/>
+        struct sized_generator : generator<Reference, Value>
+        {
+            using promise_type = detail::sized_generator_promise<Reference>;
+            using handle = std::experimental::coroutine_handle<promise_type>;
+
+            constexpr sized_generator() noexcept = default;
+            sized_generator(promise_type * p)
+              : generator<Reference, Value>{p}
+            {}
+            generator_size_t size() const noexcept
+            {
+                return promise().size();
+            }
+
+        private:
+            using generator<Reference, Value>::coro_;
+
+            promise_type const & promise() const noexcept
+            {
+                RANGES_EXPECT(coro_);
+                return static_cast<promise_type const &>(coro_.promise());
+            }
+        };
+    } // namespace experimental
+
+    /// @}
+} // namespace ranges
+#endif // RANGES_CXX_COROUTINES >= RANGES_CXX_COROUTINES_TS1
+
+#endif // RANGES_V3_EXPERIMENTAL_UTILITY_GENERATOR_HPP
diff --git a/inst/include/range/v3/experimental/view/shared.hpp b/inst/include/range/v3/experimental/view/shared.hpp
new file mode 100644
index 0000000..f4f9c7c
--- /dev/null
+++ b/inst/include/range/v3/experimental/view/shared.hpp
@@ -0,0 +1,128 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Filip Matzner 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_EXPERIMENTAL_VIEW_SHARED_HPP
+#define RANGES_V3_EXPERIMENTAL_VIEW_SHARED_HPP
+
+#include <memory>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/view/all.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    namespace experimental
+    {
+        template<typename Rng>
+        struct shared_view
+          : view_interface<shared_view<Rng>, range_cardinality<Rng>::value>
+        {
+        private:
+            // shared storage
+            std::shared_ptr<Rng> rng_ptr_;
+
+        public:
+            shared_view() = default;
+
+            // construct from a range rvalue
+            explicit shared_view(Rng rng)
+              : rng_ptr_{std::make_shared<Rng>(std::move(rng))}
+            {}
+
+            // use the stored range's begin and end
+            iterator_t<Rng> begin() const
+            {
+                return ranges::begin(*rng_ptr_);
+            }
+            sentinel_t<Rng> end() const
+            {
+                return ranges::end(*rng_ptr_);
+            }
+
+            CPP_member
+            auto CPP_fun(size)()(const requires sized_range<Rng>)
+            {
+                return ranges::size(*rng_ptr_);
+            }
+        };
+
+        template<typename SharedFn>
+        struct shared_closure;
+
+        struct RANGES_STRUCT_WITH_ADL_BARRIER(shared_closure_base)
+        {
+            // Piping requires viewable_ranges.
+            CPP_template(typename Rng, typename SharedFn)(      //
+                requires range<Rng> && (!viewable_range<Rng>)&& //
+                constructible_from<detail::decay_t<Rng>, Rng>)  //
+                friend constexpr auto
+                operator|(Rng && rng, shared_closure<SharedFn> vw)
+            {
+                return static_cast<SharedFn &&>(vw)(static_cast<Rng &&>(rng));
+            }
+
+            template<typename SharedFn, typename Pipeable>
+            friend constexpr auto operator|(shared_closure<SharedFn> sh, Pipeable pipe)
+                -> CPP_broken_friend_ret(shared_closure<composed<Pipeable, SharedFn>>)(
+                    requires(is_pipeable_v<Pipeable>))
+            {
+                return shared_closure<composed<Pipeable, SharedFn>>{compose(
+                    static_cast<Pipeable &&>(pipe), static_cast<SharedFn &&>(sh))};
+            }
+        };
+
+        template<typename SharedFn>
+        struct shared_closure
+          : shared_closure_base
+          , SharedFn
+        {
+            shared_closure() = default;
+            constexpr explicit shared_closure(SharedFn fn)
+              : SharedFn(static_cast<SharedFn &&>(fn))
+            {}
+        };
+
+        namespace views
+        {
+            struct shared_fn
+            {
+                template<typename Rng>
+                auto operator()(Rng && rng) const                       //
+                    -> CPP_ret(shared_view<detail::decay_t<Rng>>)(      //
+                        requires range<Rng> && (!viewable_range<Rng>)&& //
+                        constructible_from<detail::decay_t<Rng>, Rng>)
+                {
+                    return shared_view<detail::decay_t<Rng>>{static_cast<Rng &&>(rng)};
+                }
+            };
+
+            /// \relates shared_fn
+            /// \ingroup group-views
+            RANGES_INLINE_VARIABLE(shared_closure<shared_fn>, shared)
+        } // namespace views
+    }     // namespace experimental
+
+    template<typename SharedFn>
+    RANGES_INLINE_VAR constexpr bool
+        is_pipeable_v<experimental::shared_closure<SharedFn>> = true;
+    /// @}
+} // namespace ranges
+
+#endif // include guard
diff --git a/inst/include/range/v3/front.hpp b/inst/include/range/v3/front.hpp
new file mode 100644
index 0000000..60ed3e3
--- /dev/null
+++ b/inst/include/range/v3/front.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_FRONT_HPP
+#define RANGES_V3_FRONT_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/operations.hpp> instead.")
+
+#include <range/v3/range/operations.hpp>
+
+#endif
diff --git a/inst/include/range/v3/functional.hpp b/inst/include/range/v3/functional.hpp
new file mode 100644
index 0000000..5ef2485
--- /dev/null
+++ b/inst/include/range/v3/functional.hpp
@@ -0,0 +1,37 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2019-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_FUNCTIONAL_HPP
+#define RANGES_V3_FUNCTIONAL_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DISABLE_WARNINGS
+
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/bind.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/indirect.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/not_fn.hpp>
+#include <range/v3/functional/on.hpp>
+#include <range/v3/functional/overload.hpp>
+#include <range/v3/functional/pipeable.hpp>
+#include <range/v3/functional/reference_wrapper.hpp>
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/functional/arithmetic.hpp b/inst/include/range/v3/functional/arithmetic.hpp
new file mode 100644
index 0000000..dfbbb09
--- /dev/null
+++ b/inst/include/range/v3/functional/arithmetic.hpp
@@ -0,0 +1,108 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_ARITHMETIC_HPP
+#define RANGES_V3_FUNCTIONAL_ARITHMETIC_HPP
+
+#include <concepts/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    struct plus
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> decltype((T &&) t + (U &&) u)
+        {
+            return (T &&) t + (U &&) u;
+        }
+        using is_transparent = void;
+    };
+
+    struct minus
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> decltype((T &&) t - (U &&) u)
+        {
+            return (T &&) t - (U &&) u;
+        }
+        using is_transparent = void;
+    };
+
+    struct multiplies
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> decltype((T &&) t * (U &&) u)
+        {
+            return (T &&) t * (U &&) u;
+        }
+        using is_transparent = void;
+    };
+
+    struct bitwise_or
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> decltype((T &&) t | (U &&) u)
+        {
+            return (T &&) t | (U &&) u;
+        }
+        using is_transparent = void;
+    };
+
+    template<typename T>
+    struct convert_to
+    {
+        // clang-format off
+        template<typename U>
+        constexpr auto CPP_auto_fun(operator())(U &&u)(const)
+        (
+            return static_cast<T>((U &&) u)
+        )
+        // clang-format on
+    };
+
+    template<typename T>
+    struct coerce
+    {
+        constexpr T & operator()(T & t) const
+        {
+            return t;
+        }
+        /// \overload
+        constexpr T const & operator()(T const & t) const
+        {
+            return t;
+        }
+        /// \overload
+        constexpr T operator()(T && t) const
+        {
+            return (T &&) t;
+        }
+        T operator()(T const &&) const = delete;
+    };
+
+    template<typename T>
+    struct coerce<T const> : coerce<T>
+    {};
+
+    template<typename T>
+    struct coerce<T &> : coerce<T>
+    {};
+
+    template<typename T>
+    struct coerce<T &&> : coerce<T>
+    {};
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/bind.hpp b/inst/include/range/v3/functional/bind.hpp
new file mode 100644
index 0000000..409a264
--- /dev/null
+++ b/inst/include/range/v3/functional/bind.hpp
@@ -0,0 +1,121 @@
+
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_BIND_HPP
+#define RANGES_V3_FUNCTIONAL_BIND_HPP
+
+#include <functional>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    template<typename T,
+             typename U = meta::if_<
+                 std::is_lvalue_reference<T>,
+                 std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
+    U bind_forward(meta::_t<std::remove_reference<T>> & t) noexcept
+    {
+        return static_cast<U>(t);
+    }
+
+    template<typename T>
+    T && bind_forward(meta::_t<std::remove_reference<T>> && t) noexcept
+    {
+        // This is to catch way sketchy stuff like: forward<int const &>(42)
+        static_assert(!std::is_lvalue_reference<T>::value, "You didn't just do that!");
+        return static_cast<T &&>(t);
+    }
+
+    template<typename T>
+    struct bind_element
+      : meta::if_c<RANGES_IS_SAME(detail::decay_t<T>, T), meta::id<T>,
+                   bind_element<detail::decay_t<T>>>
+    {};
+
+    template<typename T>
+    struct bind_element<std::reference_wrapper<T>>
+    {
+        using type = T &;
+    };
+
+    template<typename T>
+    struct bind_element<reference_wrapper<T>>
+    {
+        using type = typename reference_wrapper<T>::reference;
+    };
+
+    template<typename T>
+    using bind_element_t = meta::_t<bind_element<T>>;
+
+    template<typename Bind>
+    struct protector
+    {
+    private:
+        Bind bind_;
+
+    public:
+        protector() = default;
+        protector(Bind b)
+          : bind_(std::move(b))
+        {}
+        // clang-format off
+        template<typename...Ts>
+        auto CPP_auto_fun(operator())(Ts &&...ts)
+        (
+            return bind_(static_cast<Ts &&>(ts)...)
+        )
+        /// \overload
+        template<typename...Ts>
+        auto CPP_auto_fun(operator())(Ts &&...ts) (const)
+        (
+            return bind_(static_cast<Ts &&>(ts)...)
+        )
+        // clang-format on
+    };
+
+    struct protect_fn
+    {
+        template<typename F>
+        auto operator()(F && f) const -> CPP_ret(protector<uncvref_t<F>>)( //
+            requires std::is_bind_expression<uncvref_t<F>>::value)
+        {
+            return {static_cast<F &&>(f)};
+        }
+        /// \overload
+        template<typename F>
+        auto operator()(F && f) const -> CPP_ret(F)( //
+            requires(!std::is_bind_expression<uncvref_t<F>>::value))
+        {
+            return static_cast<F &&>(f);
+        }
+    };
+
+    /// Protect a callable so that it can be safely used in a bind expression without
+    /// accidentally becoming a "nested" bind.
+    /// \ingroup group-functional
+    /// \sa `protect_fn`
+    RANGES_INLINE_VARIABLE(protect_fn, protect)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/bind_back.hpp b/inst/include/range/v3/functional/bind_back.hpp
new file mode 100644
index 0000000..f061726
--- /dev/null
+++ b/inst/include/range/v3/functional/bind_back.hpp
@@ -0,0 +1,186 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrey Diduh 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGE_V3_DETAIL_BIND_BACK_HPP
+#define RANGE_V3_DETAIL_BIND_BACK_HPP
+
+#include <tuple>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/tuple_algorithm.hpp>
+
+namespace ranges
+{
+    // bind_back like std::bind_front has no special treatment for nested
+    // bind-expressions or reference_wrappers; there is no need to wrap
+    // Callables with ranges::protect.
+    namespace detail
+    {
+        template<typename Fn, typename... Args>
+        struct bind_back_fn_
+        {
+            using tuple_t = std::tuple<Fn, Args...>;
+            tuple_t fn_args_;
+
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) &&
+                noexcept(is_nothrow_invocable_v<Fn, CallArgs..., Args...>)
+                    -> invoke_result_t<Fn, CallArgs..., Args...>
+            {
+                return tuple_apply(
+                    [&](auto && fn, auto &&... args) -> decltype(auto) {
+                        return invoke((decltype(fn))fn,
+                                      (CallArgs &&) cargs...,
+                                      (decltype(args))args...);
+                    },
+                    (std::tuple<Fn, Args...> &&) fn_args_);
+            }
+
+            /// \overload
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) &
+                noexcept(is_nothrow_invocable_v<Fn &, CallArgs..., Args &...>)
+                    -> invoke_result_t<Fn &, CallArgs..., Args &...>
+            {
+                return tuple_apply(
+                    [&](auto & fn, auto &... args) -> decltype(auto) {
+                        return invoke(fn, (CallArgs &&) cargs..., args...);
+                    },
+                    fn_args_);
+            }
+
+            /// \overload
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) const &
+                noexcept(is_nothrow_invocable_v<Fn const &, CallArgs..., Args const &...>)
+                    -> invoke_result_t<Fn const &, CallArgs..., Args const &...>
+            {
+                return tuple_apply(
+                    [&](auto & fn, auto &... args) -> decltype(auto) {
+                        return invoke(fn, (CallArgs &&) cargs..., args...);
+                    },
+                    fn_args_);
+            }
+        };
+
+        /// \cond
+        // Unroll a few instantiations to avoid a heavy-weight tuple instantiation
+        template<typename Fn, typename Arg>
+        struct bind_back_fn_<Fn, Arg>
+        {
+            struct tuple_t
+            {
+                Fn fn_;
+                Arg arg_;
+            };
+            tuple_t fn_args_;
+
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) &&
+                noexcept(is_nothrow_invocable_v<Fn, CallArgs..., Arg>)
+                    -> invoke_result_t<Fn, CallArgs..., Arg>
+            {
+                return invoke(
+                    (Fn &&) fn_args_.fn_, (CallArgs &&) cargs..., (Arg &&) fn_args_.arg_);
+            }
+
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) &
+                noexcept(is_nothrow_invocable_v<Fn &, CallArgs..., Arg &>)
+                    -> invoke_result_t<Fn &, CallArgs..., Arg &>
+            {
+                return invoke(fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg_);
+            }
+
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) const &
+                noexcept(is_nothrow_invocable_v<Fn const &, CallArgs..., Arg const &>)
+                    -> invoke_result_t<Fn const &, CallArgs..., Arg const &>
+            {
+                return invoke(fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg_);
+            }
+        };
+
+        template<typename Fn, typename Arg0, typename Arg1>
+        struct bind_back_fn_<Fn, Arg0, Arg1>
+        {
+            struct tuple_t
+            {
+                Fn fn_;
+                Arg0 arg0_;
+                Arg1 arg1_;
+            };
+            tuple_t fn_args_;
+
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) &&
+                noexcept(is_nothrow_invocable_v<Fn, CallArgs..., Arg0, Arg1>)
+                    -> invoke_result_t<Fn, CallArgs..., Arg0, Arg1>
+            {
+                return invoke((Fn &&) fn_args_.fn_,
+                              (CallArgs &&) cargs...,
+                              (Arg0 &&) fn_args_.arg0_,
+                              (Arg1 &&) fn_args_.arg1_);
+            }
+
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) &
+                noexcept(is_nothrow_invocable_v<Fn &, CallArgs..., Arg0 &, Arg1 &>)
+                    -> invoke_result_t<Fn &, CallArgs..., Arg0 &, Arg1 &>
+            {
+                return invoke(
+                    fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg0_, fn_args_.arg1_);
+            }
+
+            template<typename... CallArgs>
+            constexpr auto operator()(CallArgs &&... cargs) const & noexcept(
+                is_nothrow_invocable_v<Fn const &, CallArgs..., Arg0 const &,
+                                       Arg1 const &>)
+                -> invoke_result_t<Fn const &, CallArgs..., Arg0 const &, Arg1 const &>
+            {
+                return invoke(
+                    fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg0_, fn_args_.arg1_);
+            }
+        };
+        /// \endcond
+
+        template<typename Fn, typename... Args>
+        using bind_back_fn = bind_back_fn_<decay_t<Fn>, decay_t<Args>...>;
+    } // namespace detail
+
+    struct bind_back_fn
+    {
+        template<typename Fn, typename Arg1, typename... Args>
+        constexpr auto operator()(Fn && fn, Arg1 && arg1, Args &&... args) const
+            -> detail::bind_back_fn<Fn, Arg1, Args...>
+        {
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+            using T = typename detail::bind_back_fn<Fn, Arg1, Args...>::tuple_t;
+            return {T{(Fn &&) fn, (Arg1 &&) arg1, (Args &&) args...}};
+#else
+            return {{(Fn &&) fn, (Arg1 &&) arg1, (Args &&) args...}};
+#endif
+        }
+    };
+
+    /// \ingroup group-utility
+    /// \sa `bind_back_fn`
+    RANGES_INLINE_VARIABLE(bind_back_fn, bind_back)
+
+} // namespace ranges
+
+#endif // RANGE_V3_DETAIL_BIND_BACK_HPP
diff --git a/inst/include/range/v3/functional/comparisons.hpp b/inst/include/range/v3/functional/comparisons.hpp
new file mode 100644
index 0000000..0bdf60d
--- /dev/null
+++ b/inst/include/range/v3/functional/comparisons.hpp
@@ -0,0 +1,106 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_COMPARISONS_HPP
+#define RANGES_V3_FUNCTIONAL_COMPARISONS_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    struct equal_to
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> CPP_ret(bool)( //
+            requires equality_comparable_with<T, U>)
+        {
+            return (T &&) t == (U &&) u;
+        }
+        using is_transparent = void;
+    };
+
+    struct not_equal_to
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> CPP_ret(bool)( //
+            requires equality_comparable_with<T, U>)
+        {
+            return !equal_to{}((T &&) t, (U &&) u);
+        }
+        using is_transparent = void;
+    };
+
+    struct less
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            return (T &&) t < (U &&) u;
+        }
+        using is_transparent = void;
+    };
+
+    struct less_equal
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            return !less{}((U &&) u, (T &&) t);
+        }
+        using is_transparent = void;
+    };
+
+    struct greater_equal
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            return !less{}((T &&) t, (U &&) u);
+        }
+        using is_transparent = void;
+    };
+
+    struct greater
+    {
+        template<typename T, typename U>
+        constexpr auto operator()(T && t, U && u) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            return less{}((U &&) u, (T &&) t);
+        }
+        using is_transparent = void;
+    };
+
+    using ordered_less RANGES_DEPRECATED(
+        "Repace uses of ranges::ordered_less with ranges::less") = less;
+
+    namespace cpp20
+    {
+        using ranges::equal_to;
+        using ranges::greater;
+        using ranges::greater_equal;
+        using ranges::less;
+        using ranges::less_equal;
+        using ranges::not_equal_to;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/compose.hpp b/inst/include/range/v3/functional/compose.hpp
new file mode 100644
index 0000000..97cd301
--- /dev/null
+++ b/inst/include/range/v3/functional/compose.hpp
@@ -0,0 +1,99 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_COMPOSE_HPP
+#define RANGES_V3_FUNCTIONAL_COMPOSE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/detail/config.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    template<typename Second, typename First>
+    struct composed
+    {
+    private:
+        RANGES_NO_UNIQUE_ADDRESS
+        First first_;
+        RANGES_NO_UNIQUE_ADDRESS
+        Second second_;
+
+        // clang-format off
+        template<typename A, typename B, typename... Ts>
+        static constexpr auto CPP_auto_fun(do_)(A &&a, B &&b, std::false_type, Ts &&... ts)
+        (
+            return invoke((B &&) b, invoke((A &&) a, (Ts &&) ts...))
+        )
+        template<typename A, typename B, typename... Ts>
+        static constexpr auto CPP_auto_fun(do_)(A &&a, B &&b, std::true_type, Ts &&... ts)
+        (
+            return (invoke((A &&) a, (Ts &&) ts...), invoke((B &&) b))
+        )
+    public:
+        composed() = default;
+        // clang-format on
+        constexpr composed(Second second, First first)
+          : first_(std::move(first))
+          , second_(std::move(second))
+        {}
+        // clang-format off
+        template<typename... Ts>
+        constexpr auto CPP_auto_fun(operator())(Ts &&... ts)(mutable &)
+        (
+            return composed::do_(first_,
+                                 second_,
+                                 std::is_void<invoke_result_t<First &, Ts...>>{},
+                                 (Ts &&) ts...)
+        )
+        template<typename... Ts>
+        constexpr auto CPP_auto_fun(operator())(Ts &&... ts)(const &)
+        (
+            return composed::do_((First const &)first_,
+                                 (Second const &)second_,
+                                 std::is_void<invoke_result_t<First const &, Ts...>>{},
+                                 (Ts &&) ts...)
+        )
+        template<typename... Ts>
+        constexpr auto CPP_auto_fun(operator())(Ts &&... ts)(mutable &&)
+        (
+            return composed::do_((First &&)first_,
+                                 (Second &&)second_,
+                                 std::is_void<invoke_result_t<First &&, Ts...>>{},
+                                 (Ts &&) ts...)
+        )
+        // clang-format on
+    };
+
+    struct compose_fn
+    {
+        template<typename Second, typename First>
+        constexpr composed<Second, First> operator()(Second second, First first) const
+        {
+            return {std::move(second), std::move(first)};
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `compose_fn`
+    RANGES_INLINE_VARIABLE(compose_fn, compose)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/concepts.hpp b/inst/include/range/v3/functional/concepts.hpp
new file mode 100644
index 0000000..4b2a258
--- /dev/null
+++ b/inst/include/range/v3/functional/concepts.hpp
@@ -0,0 +1,82 @@
+
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_CONCEPTS_HPP
+#define RANGES_V3_FUNCTIONAL_CONCEPTS_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/functional/invoke.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename Fun, typename... Args)
+        (concept invocable)(Fun, Args...),
+            requires (Fun&& fn)
+            (
+                invoke(static_cast<Fun &&>(fn), std::declval<Args>()...)
+            )
+    );
+
+    CPP_def
+    (
+        template(typename Fun, typename... Args)
+        (concept regular_invocable)(Fun, Args...),
+            invocable<Fun, Args...>
+            // Axiom: equality_preserving(invoke(f, args...))
+    );
+
+    CPP_def
+    (
+        template(typename Fun, typename... Args)
+        (concept predicate)(Fun, Args...),
+            regular_invocable<Fun, Args...> &&
+            convertible_to<invoke_result_t<Fun, Args...>, bool>
+    );
+
+    CPP_def
+    (
+        template(typename R, typename T, typename U)
+        concept relation,
+            predicate<R, T, T> &&
+            predicate<R, U, U> &&
+            predicate<R, T, U> &&
+            predicate<R, U, T>
+    );
+
+    CPP_def
+    (
+        template(typename R, typename T, typename U)
+        concept strict_weak_order,
+            relation<R, T, U>
+    );
+    // clang-format on
+
+    namespace cpp20
+    {
+        using ranges::invocable;
+        using ranges::predicate;
+        using ranges::regular_invocable;
+        using ranges::relation;
+        using ranges::strict_weak_order;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/identity.hpp b/inst/include/range/v3/functional/identity.hpp
new file mode 100644
index 0000000..47cec1a
--- /dev/null
+++ b/inst/include/range/v3/functional/identity.hpp
@@ -0,0 +1,44 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_IDENTITY_HPP
+#define RANGES_V3_FUNCTIONAL_IDENTITY_HPP
+
+#include <range/v3/detail/config.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    struct identity
+    {
+        template<typename T>
+        constexpr T && operator()(T && t) const noexcept
+        {
+            return (T &&) t;
+        }
+        using is_transparent = void;
+    };
+
+    /// \cond
+    using ident RANGES_DEPRECATED("Replace uses of ranges::ident with ranges::identity") =
+        identity;
+    /// \endcond
+
+    namespace cpp20
+    {
+        using ranges::identity;
+    }
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/indirect.hpp b/inst/include/range/v3/functional/indirect.hpp
new file mode 100644
index 0000000..8183d40
--- /dev/null
+++ b/inst/include/range/v3/functional/indirect.hpp
@@ -0,0 +1,96 @@
+
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_INDIRECT_HPP
+#define RANGES_V3_FUNCTIONAL_INDIRECT_HPP
+
+#include <utility>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    template<typename Fn>
+    struct indirected
+    {
+    private:
+        RANGES_NO_UNIQUE_ADDRESS
+        Fn fn_;
+
+    public:
+        indirected() = default;
+        indirected(Fn fn)
+          : fn_(std::move(fn))
+        {}
+        // value_type (needs no impl)
+        template<typename... Its>
+        [[noreturn]] auto operator()(copy_tag, Its...) const
+            -> invoke_result_t<Fn &, iter_reference_t<Its>...>
+        {
+            RANGES_EXPECT(false);
+        }
+
+        // Reference
+        // clang-format off
+        template<typename... Its>
+        auto CPP_auto_fun(operator())(Its... its)
+        (
+            return invoke(fn_, *its...)
+        )
+        template<typename... Its>
+        auto CPP_auto_fun(operator())(Its... its)(const)
+        (
+            return invoke((Fn const &)fn_, *its...)
+        )
+
+        // Rvalue reference
+        template<typename... Its>
+        auto CPP_auto_fun(operator())(move_tag, Its... its)
+        (
+            return static_cast<
+                aux::move_t<invoke_result_t<Fn &, iter_reference_t<Its>...>>>(
+                aux::move(invoke(fn_, *its...)))
+        )
+        template<typename... Its>
+        auto CPP_auto_fun(operator())(move_tag, Its... its)(const)
+        (
+            return static_cast<
+                aux::move_t<invoke_result_t<Fn const &, iter_reference_t<Its>...>>>(
+                aux::move(invoke((Fn const &)fn_, *its...)))
+        )
+        // clang-format on
+    };
+
+    struct indirect_fn
+    {
+        template<typename Fn>
+        constexpr indirected<Fn> operator()(Fn fn) const
+        {
+            return indirected<Fn>{detail::move(fn)};
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `indirect_fn`
+    RANGES_INLINE_VARIABLE(indirect_fn, indirect)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/invoke.hpp b/inst/include/range/v3/functional/invoke.hpp
new file mode 100644
index 0000000..1fc1fe9
--- /dev/null
+++ b/inst/include/range/v3/functional/invoke.hpp
@@ -0,0 +1,229 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_INVOKE_HPP
+#define RANGES_V3_FUNCTIONAL_INVOKE_HPP
+
+#include <functional>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/static_const.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
+RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+
+#ifndef RANGES_CONSTEXPR_INVOKE
+#ifdef RANGES_WORKAROUND_CLANG_23135
+#define RANGES_CONSTEXPR_INVOKE 0
+#else
+#define RANGES_CONSTEXPR_INVOKE 1
+#endif
+#endif
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename U>
+        U & can_reference_(U &&);
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename T)
+            concept dereferenceable_,
+                requires (T &&t)
+                (
+                    detail::can_reference_(*static_cast<T &&>(t))
+                )
+        );
+        // clang-format on
+
+        template<class T>
+        RANGES_INLINE_VAR constexpr bool is_reference_wrapper_v =
+            meta::is<T, reference_wrapper>::value ||
+            meta::is<T, std::reference_wrapper>::value;
+    } // namespace detail
+    /// \endcond
+
+    template<class T>
+    RANGES_INLINE_VAR constexpr bool is_reference_wrapper_v =
+        detail::is_reference_wrapper_v<detail::decay_t<T>>;
+
+    template<typename T>
+    using is_reference_wrapper = meta::bool_<is_reference_wrapper_v<T>>;
+
+    template<typename T>
+    using is_reference_wrapper_t RANGES_DEPRECATED(
+        "is_reference_wrapper_t is deprecated.") = meta::_t<is_reference_wrapper<T>>;
+
+    struct invoke_fn
+    {
+    private:
+        template<class, class T1>
+        static constexpr decltype(auto) CPP_fun(coerce)(T1 && t1, long)( //
+            noexcept(noexcept(*static_cast<T1 &&>(t1)))                  //
+            requires detail::dereferenceable_<T1>)
+        {
+            return *static_cast<T1 &&>(t1);
+        }
+
+        template<class T, class T1>
+        static constexpr auto coerce(T1 && t1, int) noexcept -> CPP_ret(T1 &&)( //
+            requires derived_from<detail::decay_t<T1>, T>)
+        {
+            return static_cast<T1 &&>(t1);
+        }
+
+        template<class, class T1>
+        static constexpr decltype(auto) CPP_fun(coerce)(T1 && t1, int)(
+            noexcept(true) //
+            requires detail::is_reference_wrapper_v<detail::decay_t<T1>>)
+        {
+            return static_cast<T1 &&>(t1).get();
+        }
+
+    public:
+        // clang-format off
+        template<class F, class T, class T1, class... Args>
+        constexpr auto CPP_auto_fun(operator())(F T::*f, T1&& t1, Args&&... args)(const)
+        (
+            return (invoke_fn::coerce<T>(static_cast<T1&&>(t1), 0).*f)
+                (static_cast<Args&&>(args)...)
+        )
+
+        template<class D, class T, class T1>
+        constexpr auto CPP_auto_fun(operator())(D T::*f, T1&& t1)(const)
+        (
+            return invoke_fn::coerce<T>(static_cast<T1&&>(t1), 0).*f
+        )
+
+        template<class F, class... Args>
+        CPP_PP_IIF(RANGES_CONSTEXPR_INVOKE)(CPP_PP_EXPAND, CPP_PP_EAT)(constexpr)
+        auto CPP_auto_fun(operator())(F&& f, Args&&... args)(const)
+        (
+            return static_cast<F&&>(f)(static_cast<Args&&>(args)...)
+        )
+        // clang-format on
+    };
+
+    RANGES_INLINE_VARIABLE(invoke_fn, invoke)
+
+#ifdef RANGES_WORKAROUND_MSVC_701385
+    /// \cond
+    namespace detail
+    {
+        template<typename Void, typename Fun, typename... Args>
+        struct _invoke_result_
+        {};
+
+        template<typename Fun, typename... Args>
+        struct _invoke_result_<
+            meta::void_<decltype(invoke(std::declval<Fun>(), std::declval<Args>()...))>,
+            Fun, Args...>
+        {
+            using type = decltype(invoke(std::declval<Fun>(), std::declval<Args>()...));
+        };
+    } // namespace detail
+    /// \endcond
+
+    template<typename Fun, typename... Args>
+    using invoke_result = detail::_invoke_result_<void, Fun, Args...>;
+
+    template<typename Fun, typename... Args>
+    using invoke_result_t = meta::_t<invoke_result<Fun, Args...>>;
+
+#else  // RANGES_WORKAROUND_MSVC_701385
+    template<typename Fun, typename... Args>
+    using invoke_result_t =
+        decltype(invoke(std::declval<Fun>(), std::declval<Args>()...));
+
+    template<typename Fun, typename... Args>
+    struct invoke_result : meta::defer<invoke_result_t, Fun, Args...>
+    {};
+#endif // RANGES_WORKAROUND_MSVC_701385
+
+    /// \cond
+    namespace detail
+    {
+        template<bool IsInvocable>
+        struct is_nothrow_invocable_impl_
+        {
+            template<typename Fn, typename... Args>
+            static constexpr bool apply() noexcept
+            {
+                return false;
+            }
+        };
+        template<>
+        struct is_nothrow_invocable_impl_<true>
+        {
+            template<typename Fn, typename... Args>
+            static constexpr bool apply() noexcept
+            {
+                return noexcept(invoke(std::declval<Fn>(), std::declval<Args>()...));
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    template<typename Fn, typename... Args>
+    RANGES_INLINE_VAR constexpr bool is_invocable_v =
+        meta::is_trait<invoke_result<Fn, Args...>>::value;
+
+    template<typename Fn, typename... Args>
+    RANGES_INLINE_VAR constexpr bool is_nothrow_invocable_v =
+        detail::is_nothrow_invocable_impl_<is_invocable_v<Fn, Args...>>::template apply<
+            Fn, Args...>();
+
+    /// \cond
+    template<typename Sig>
+    struct RANGES_DEPRECATED(
+        "ranges::result_of is deprecated. "
+        "Please use ranges::invoke_result") result_of
+    {};
+
+    template<typename Fun, typename... Args>
+    struct RANGES_DEPRECATED(
+        "ranges::result_of is deprecated. "
+        "Please use ranges::invoke_result") result_of<Fun(Args...)>
+      : meta::defer<invoke_result_t, Fun, Args...>
+    {};
+    /// \endcond
+
+    namespace cpp20
+    {
+        using ranges::invoke;
+        using ranges::invoke_result;
+        using ranges::invoke_result_t;
+        using ranges::is_invocable_v;
+        using ranges::is_nothrow_invocable_v;
+    } // namespace cpp20
+
+    /// @}
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_POP
+
+#endif // RANGES_V3_FUNCTIONAL_INVOKE_HPP
diff --git a/inst/include/range/v3/functional/not_fn.hpp b/inst/include/range/v3/functional/not_fn.hpp
new file mode 100644
index 0000000..df7163e
--- /dev/null
+++ b/inst/include/range/v3/functional/not_fn.hpp
@@ -0,0 +1,95 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_NOT_FN_HPP
+#define RANGES_V3_FUNCTIONAL_NOT_FN_HPP
+
+#include <type_traits>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    template<typename FD>
+    struct logical_negate
+    {
+    private:
+        CPP_assert(same_as<FD, detail::decay_t<FD>> && move_constructible<FD>);
+        RANGES_NO_UNIQUE_ADDRESS FD pred_;
+
+    public:
+        CPP_member
+        constexpr CPP_ctor(logical_negate)()(                          //
+            noexcept(std::is_nothrow_default_constructible<FD>::value) //
+            requires default_constructible<FD>)
+        {}
+        template<typename T>
+        explicit constexpr CPP_ctor(logical_negate)(T && pred)( //
+            requires(!defer::same_as<detail::decay_t<T>, logical_negate>) &&
+            defer::constructible_from<FD, T>)
+          : pred_(static_cast<T &&>(pred))
+        {}
+
+        template<typename... Args>
+        constexpr auto operator()(Args &&... args) & -> CPP_ret(bool)( //
+            requires predicate<FD &, Args...>)
+        {
+            return !invoke(pred_, static_cast<Args &&>(args)...);
+        }
+        /// \overload
+        template<typename... Args>
+        constexpr auto operator()(Args &&... args) const & -> CPP_ret(bool)( //
+            requires predicate<FD const &, Args...>)
+        {
+            return !invoke(pred_, static_cast<Args &&>(args)...);
+        }
+        /// \overload
+        template<typename... Args>
+        constexpr auto operator()(Args &&... args) && -> CPP_ret(bool)( //
+            requires predicate<FD, Args...>)
+        {
+            return !invoke(static_cast<FD &&>(pred_), static_cast<Args &&>(args)...);
+        }
+    };
+
+    struct not_fn_fn
+    {
+        template<typename Pred>
+        constexpr auto operator()(Pred && pred) const
+            -> CPP_ret(logical_negate<detail::decay_t<Pred>>)( //
+                requires move_constructible<detail::decay_t<Pred>> &&
+                    constructible_from<detail::decay_t<Pred>, Pred>)
+        {
+            return logical_negate<detail::decay_t<Pred>>{(Pred &&) pred};
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `not_fn_fn`
+    RANGES_INLINE_VARIABLE(not_fn_fn, not_fn)
+
+    namespace cpp20
+    {
+        using ranges::not_fn;
+    }
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/on.hpp b/inst/include/range/v3/functional/on.hpp
new file mode 100644
index 0000000..ab86308
--- /dev/null
+++ b/inst/include/range/v3/functional/on.hpp
@@ -0,0 +1,70 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_ON_HPP
+#define RANGES_V3_FUNCTIONAL_ON_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/detail/config.hpp>
+#include <range/v3/functional/invoke.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    template<typename Fn1, typename Fn2>
+    struct transformed
+    {
+    private:
+        RANGES_NO_UNIQUE_ADDRESS
+        Fn1 first_;
+        RANGES_NO_UNIQUE_ADDRESS
+        Fn2 second_;
+
+    public:
+        transformed() = default;
+        constexpr transformed(Fn1 fn1, Fn2 fn2)
+          : first_(static_cast<Fn1 &&>(fn1))
+          , second_(static_cast<Fn2 &&>(fn2))
+        {}
+        // clang-format off
+        template<typename... Args>
+        auto CPP_auto_fun(operator())(Args &&... args)
+        (
+            return invoke(first_, invoke(second_, static_cast<Args &&>(args)...))
+        )
+        template<typename... Args>
+        auto CPP_auto_fun(operator())(Args &&... args)(const)
+        (
+            return invoke((Fn1 const &)first_,
+                          invoke((Fn2 const &)second_, static_cast<Args &&>(args)...))
+        )
+        // clang-format on
+    };
+
+    struct on_fn
+    {
+        template<typename Fn1, typename Fn2>
+        constexpr transformed<Fn1, Fn2> operator()(Fn1 fn1, Fn2 fn2) const
+        {
+            return transformed<Fn1, Fn2>{detail::move(fn1), detail::move(fn2)};
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `on_fn`
+    RANGES_INLINE_VARIABLE(on_fn, on)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/overload.hpp b/inst/include/range/v3/functional/overload.hpp
new file mode 100644
index 0000000..941b026
--- /dev/null
+++ b/inst/include/range/v3/functional/overload.hpp
@@ -0,0 +1,137 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_OVERLOAD_HPP
+#define RANGES_V3_FUNCTIONAL_OVERLOAD_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+    template<typename... Ts>
+    struct overloaded;
+
+    template<>
+    struct overloaded<>
+    {};
+
+    template<typename First, typename... Rest>
+    struct overloaded<First, Rest...>
+    {
+    private:
+        RANGES_NO_UNIQUE_ADDRESS
+        First first_;
+        RANGES_NO_UNIQUE_ADDRESS
+        overloaded<Rest...> second_;
+
+#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
+        template<typename This, typename... Args>
+        static constexpr decltype(auto) select(std::true_type, This && ovr,
+                                               Args &&... args)
+        {
+            return invoke(((This &&) ovr).first_, (Args &&) args...);
+        }
+        template<typename This, typename... Args>
+        static constexpr decltype(auto) select(std::false_type, This && ovr,
+                                               Args &&... args)
+        {
+            return invoke(((This &&) ovr).second_, (Args &&) args...);
+        }
+#endif
+
+    public:
+        overloaded() = default;
+        constexpr overloaded(First first, Rest... rest)
+          : first_(static_cast<First &&>(first))
+          , second_{static_cast<Rest &&>(rest)...}
+        {}
+        CPP_template(typename... Args)( //
+            requires(defer::invocable<First &, Args...> ||
+                     defer::invocable<overloaded<Rest...> &, Args...>)) //
+            constexpr decltype(auto)
+            operator()(Args &&... args) &
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(invocable<First &, Args...>)
+                return invoke(first_, (Args &&) args...);
+            else
+                return invoke(second_, (Args &&) args...);
+#else
+            return overloaded::select(
+                meta::bool_<invocable<First &, Args...>>{}, *this, (Args &&) args...);
+#endif
+        }
+        CPP_template(typename... Args)( //
+            requires(defer::invocable<First const &, Args...> ||
+                     defer::invocable<overloaded<Rest...> const &, Args...>)) //
+            constexpr decltype(auto)
+            operator()(Args &&... args) const &
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(invocable<First const &, Args...>)
+                return invoke(first_, (Args &&) args...);
+            else
+                return invoke(second_, (Args &&) args...);
+#else
+            return overloaded::select(meta::bool_<invocable<First const &, Args...>>{},
+                                      *this,
+                                      (Args &&) args...);
+#endif
+        }
+        CPP_template(typename... Args)( //
+            requires(defer::invocable<First, Args...> ||
+                     defer::invocable<overloaded<Rest...>, Args...>)) //
+            constexpr decltype(auto)
+            operator()(Args &&... args) &&
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(invocable<First const &, Args...>)
+                return invoke((First &&) first_, (Args &&) args...);
+            else
+                return invoke((overloaded<Rest...> &&) second_, (Args &&) args...);
+#else
+            return overloaded::select(meta::bool_<invocable<First, Args...>>{},
+                                      (overloaded &&) * this,
+                                      (Args &&) args...);
+#endif
+        }
+    };
+
+    struct overload_fn
+    {
+        template<typename Fn>
+        constexpr Fn operator()(Fn fn) const
+        {
+            return fn;
+        }
+        template<typename... Fns>
+        constexpr overloaded<Fns...> operator()(Fns... fns) const
+        {
+            return overloaded<Fns...>{static_cast<Fns &&>(fns)...};
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `overload_fn`
+    RANGES_INLINE_VARIABLE(overload_fn, overload)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/pipeable.hpp b/inst/include/range/v3/functional/pipeable.hpp
new file mode 100644
index 0000000..5bf0062
--- /dev/null
+++ b/inst/include/range/v3/functional/pipeable.hpp
@@ -0,0 +1,126 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_PIPEABLE_HPP
+#define RANGES_V3_FUNCTIONAL_PIPEABLE_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+
+    struct pipeable_base;
+
+    template<typename T>
+    RANGES_INLINE_VAR constexpr bool is_pipeable_v = META_IS_BASE_OF(pipeable_base, T);
+
+    template<typename T>
+    RANGES_INLINE_VAR constexpr bool is_pipeable_v<T &> = META_IS_BASE_OF(pipeable_base,
+                                                                          T);
+    template<typename T>
+    RANGES_INLINE_VAR constexpr bool is_pipeable_v<T &&> = META_IS_BASE_OF(pipeable_base,
+                                                                           T);
+    template<typename T>
+    using is_pipeable = meta::bool_<is_pipeable_v<T>>;
+
+    struct pipeable_base;
+
+    struct make_pipeable_fn
+    {
+        template<typename Fun, typename PipeableBase = pipeable_base>
+        constexpr auto operator()(Fun fun) const
+        {
+            struct local
+              : Fun
+              , PipeableBase
+            {
+                constexpr explicit local(Fun && f)
+                  : Fun(static_cast<Fun &&>(f))
+                {}
+            };
+            return local{static_cast<Fun &&>(fun)};
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `make_pipeable_fn`
+    RANGES_INLINE_VARIABLE(make_pipeable_fn, make_pipeable)
+
+    struct pipeable_access
+    {
+        template<typename Pipeable>
+        struct impl : Pipeable
+        {
+            using Pipeable::pipe;
+        };
+    };
+
+    struct pipeable_base
+    {
+    private:
+        friend pipeable_access;
+
+        // Evaluate the pipe with an argument
+        CPP_template(typename Arg, typename Pipe)( //
+            requires(!is_pipeable_v<Arg>) && is_pipeable_v<Pipe> &&
+            invocable<Pipe, Arg>) // clang-format off
+        friend constexpr auto operator|(Arg &&arg, Pipe pipe) // clang-format off
+        {
+            return static_cast<Pipe &&>(pipe)(static_cast<Arg &&>(arg));
+        }
+
+        // Compose two pipes
+        CPP_template(typename Pipe0, typename Pipe1)( //
+            requires is_pipeable_v<Pipe0> && is_pipeable_v<Pipe1>) // clang-format off
+        friend constexpr auto operator|(Pipe0 pipe0, Pipe1 pipe1) // clang-format on
+        {
+            return make_pipeable(compose(detail::move(pipe1), detail::move(pipe0)));
+        }
+
+        template<typename Arg, typename Pipe>
+        friend auto operator|=(Arg & arg, Pipe pipe) //
+            -> CPP_broken_friend_ret(Arg &)(         //
+                requires(is_pipeable_v<Pipe>) &&
+                (!is_pipeable_v<Arg>)&&invocable<Pipe, Arg &>)
+        {
+            static_cast<Pipe &&>(pipe)(arg);
+            return arg;
+        }
+
+        // Default Pipe behavior just passes the argument to the pipe's function call
+        // operator
+        // clang-format off
+        template<typename Arg, typename Pipe>
+        static constexpr auto CPP_auto_fun(pipe)(Arg && arg, Pipe p)
+        (
+            return static_cast<Pipe &&>(p)(static_cast<Arg &&>(arg))
+        )
+        // clang-format on
+    };
+
+    template<typename>
+    using pipeable RANGES_DEPRECATED("Please use pipeable_base instead") = pipeable_base;
+
+    /// \endcond
+
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/functional/reference_wrapper.hpp b/inst/include/range/v3/functional/reference_wrapper.hpp
new file mode 100644
index 0000000..216fa7b
--- /dev/null
+++ b/inst/include/range/v3/functional/reference_wrapper.hpp
@@ -0,0 +1,191 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_FUNCTIONAL_REFERENCE_WRAPPER_HPP
+#define RANGES_V3_FUNCTIONAL_REFERENCE_WRAPPER_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-functional
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        struct reference_wrapper_
+        {
+            T * t_ = nullptr;
+            constexpr reference_wrapper_() = default;
+            constexpr reference_wrapper_(T & t) noexcept
+              : t_(detail::addressof(t))
+            {}
+            constexpr reference_wrapper_(T &&) = delete;
+            constexpr T & get() const noexcept
+            {
+                return *t_;
+            }
+        };
+        template<typename T>
+        struct reference_wrapper_<T &> : reference_wrapper_<T>
+        {
+            using reference_wrapper_<T>::reference_wrapper_;
+        };
+        template<typename T>
+        struct reference_wrapper_<T &&>
+        {
+            T * t_ = nullptr;
+            constexpr reference_wrapper_() = default;
+            constexpr reference_wrapper_(T && t) noexcept
+              : t_(detail::addressof(t))
+            {}
+            constexpr T && get() const noexcept
+            {
+                return static_cast<T &&>(*t_);
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    // Can be used to store rvalue references in addition to lvalue references.
+    // Also, see: https://wg21.link/lwg2993
+    template<typename T>
+    struct reference_wrapper : private detail::reference_wrapper_<T>
+    {
+    private:
+        using base_ = detail::reference_wrapper_<T>;
+        using base_::t_;
+
+    public:
+        using type = meta::_t<std::remove_reference<T>>;
+        using reference = meta::if_<std::is_reference<T>, T, T &>;
+
+        constexpr reference_wrapper() = default;
+#if !defined(__clang__) || __clang_major__ > 3
+        template<typename U>
+        constexpr CPP_ctor(reference_wrapper)(U && u)(               //
+            noexcept(std::is_nothrow_constructible<base_, U>::value) //
+            requires(!defer::same_as<uncvref_t<U>, reference_wrapper>) &&
+            defer::constructible_from<base_, U>)
+          : detail::reference_wrapper_<T>{static_cast<U &&>(u)}
+        {}
+#else
+        // BUGBUG clang-3.7 prefers a CPP_template here instead of a CPP_ctor
+        CPP_template(typename U)( //
+            requires(!defer::same_as<uncvref_t<U>, reference_wrapper>) &&
+            defer::constructible_from<base_, U>) //
+            constexpr reference_wrapper(U && u) noexcept(
+                std::is_nothrow_constructible<base_, U>::value)
+          : detail::reference_wrapper_<T>{static_cast<U &&>(u)}
+        {}
+#endif
+        constexpr reference get() const noexcept
+        {
+            return this->base_::get();
+        }
+        constexpr operator reference() const noexcept
+        {
+            return get();
+        }
+        CPP_template(typename...)(                         //
+            requires(!std::is_rvalue_reference<T>::value)) //
+        operator std::reference_wrapper<type>() const noexcept
+        {
+            return {get()};
+        }
+        // clang-format off
+        template<typename ...Args>
+        constexpr auto CPP_auto_fun(operator())(Args &&...args) (const)
+        (
+            return invoke(static_cast<reference>(*t_), static_cast<Args &&>(args)...)
+        )
+        // clang-format on
+    };
+
+    struct ref_fn
+    {
+        template<typename T>
+        auto operator()(T & t) const -> CPP_ret(reference_wrapper<T>)( //
+            requires(!is_reference_wrapper_v<T>))
+        {
+            return {t};
+        }
+        /// \overload
+        template<typename T>
+        reference_wrapper<T> operator()(reference_wrapper<T> t) const
+        {
+            return t;
+        }
+        /// \overload
+        template<typename T>
+        reference_wrapper<T> operator()(std::reference_wrapper<T> t) const
+        {
+            return {t.get()};
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `ref_fn`
+    RANGES_INLINE_VARIABLE(ref_fn, ref)
+
+    template<typename T>
+    using ref_t = decltype(ref(std::declval<T>()));
+
+    struct unwrap_reference_fn
+    {
+        template<typename T>
+        T && operator()(T && t) const noexcept
+        {
+            return static_cast<T &&>(t);
+        }
+        /// \overload
+        template<typename T>
+        typename reference_wrapper<T>::reference operator()(reference_wrapper<T> t) const
+            noexcept
+        {
+            return t.get();
+        }
+        /// \overload
+        template<typename T>
+        T & operator()(std::reference_wrapper<T> t) const noexcept
+        {
+            return t.get();
+        }
+        /// \overload
+        template<typename T>
+        T & operator()(ref_view<T> t) const noexcept
+        {
+            return t.base();
+        }
+    };
+
+    /// \ingroup group-functional
+    /// \sa `unwrap_reference_fn`
+    RANGES_INLINE_VARIABLE(unwrap_reference_fn, unwrap_reference)
+
+    template<typename T>
+    using unwrap_reference_t = decltype(unwrap_reference(std::declval<T>()));
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/getlines.hpp b/inst/include/range/v3/getlines.hpp
new file mode 100644
index 0000000..a3599b3
--- /dev/null
+++ b/inst/include/range/v3/getlines.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_GETLINES_HPP
+#define RANGES_V3_GETLINES_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/view/getlines.hpp> instead.")
+
+#include <range/v3/view/getlines.hpp>
+
+#endif
diff --git a/inst/include/range/v3/index.hpp b/inst/include/range/v3/index.hpp
new file mode 100644
index 0000000..4bcd4cb
--- /dev/null
+++ b/inst/include/range/v3/index.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Gonzalo Brito Gadeschi 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_INDEX_HPP
+#define RANGES_V3_INDEX_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/operations.hpp> instead.")
+
+#include <range/v3/range/operations.hpp>
+
+#endif // RANGES_V3_INDEX_HPP
diff --git a/inst/include/range/v3/istream_range.hpp b/inst/include/range/v3/istream_range.hpp
new file mode 100644
index 0000000..150ef94
--- /dev/null
+++ b/inst/include/range/v3/istream_range.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ISTREAM_RANGE_HPP
+#define RANGES_V3_ISTREAM_RANGE_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/view/istream.hpp> instead.")
+
+#include <range/v3/view/istream.hpp>
+
+#endif
diff --git a/inst/include/range/v3/iterator.hpp b/inst/include/range/v3/iterator.hpp
new file mode 100644
index 0000000..e229e65
--- /dev/null
+++ b/inst/include/range/v3/iterator.hpp
@@ -0,0 +1,37 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2019-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_HPP
+#define RANGES_V3_ITERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DISABLE_WARNINGS
+
+#include <range/v3/iterator/access.hpp>
+#include <range/v3/iterator/basic_iterator.hpp>
+#include <range/v3/iterator/common_iterator.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/counted_iterator.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/diffmax_t.hpp>
+#include <range/v3/iterator/insert_iterators.hpp>
+#include <range/v3/iterator/move_iterators.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/reverse_iterator.hpp>
+#include <range/v3/iterator/stream_iterators.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/iterator/access.hpp b/inst/include/range/v3/iterator/access.hpp
new file mode 100644
index 0000000..2e54ae2
--- /dev/null
+++ b/inst/include/range/v3/iterator/access.hpp
@@ -0,0 +1,297 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_ACCESS_HPP
+#define RANGES_V3_ITERATOR_ACCESS_HPP
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include <std/detail/associated_types.hpp>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I,
+#ifdef RANGES_WORKAROUND_MSVC_683388
+                 typename R = detail::if_then_t<
+                     std::is_pointer<uncvref_t<I>>::value &&
+                         std::is_array<std::remove_pointer_t<uncvref_t<I>>>::value,
+                     std::add_lvalue_reference_t<std::remove_pointer_t<uncvref_t<I>>>,
+                     decltype(*std::declval<I &>())>,
+#else
+                 typename R = decltype(*std::declval<I &>()),
+#endif
+                 typename = R &>
+        using iter_reference_t_ = R;
+
+#if defined(RANGES_DEEP_STL_INTEGRATION) && RANGES_DEEP_STL_INTEGRATION && \
+    !defined(RANGES_DOXYGEN_INVOKED)
+        template<typename T>
+        using iter_value_t_ =
+            typename if_then_t<is_std_iterator_traits_specialized_v<T>,
+                               std::iterator_traits<T>, readable_traits<T>>::value_type;
+#else
+        template<typename T>
+        using iter_value_t_ = typename readable_traits<T>::value_type;
+#endif
+    } // namespace detail
+    /// \endcond
+
+    template<typename R>
+    using iter_reference_t = detail::iter_reference_t_<R>;
+
+    template<typename R>
+    using iter_value_t = detail::iter_value_t_<uncvref_t<R>>;
+
+    /// \cond
+    namespace _iter_move_
+    {
+#if RANGES_BROKEN_CPO_LOOKUP
+        void iter_move(); // unqualified name lookup block
+#endif
+
+        template<typename T>
+        decltype(iter_move(std::declval<T>())) try_adl_iter_move_(int);
+
+        template<typename T>
+        void try_adl_iter_move_(long);
+
+        template<typename T>
+        RANGES_INLINE_VAR constexpr bool is_adl_indirectly_movable_v =
+            !RANGES_IS_SAME(void, decltype(_iter_move_::try_adl_iter_move_<T>(42)));
+
+        struct fn
+        {
+            // clang-format off
+            template<typename I,
+                     typename = detail::enable_if_t<is_adl_indirectly_movable_v<I &>>>
+#ifndef RANGES_WORKAROUND_CLANG_23135
+            constexpr
+#endif // RANGES_WORKAROUND_CLANG_23135
+            auto CPP_auto_fun(operator())(I &&i)(const)
+            (
+                return iter_move(i)
+            )
+
+            template<
+                typename I,
+                typename = detail::enable_if_t<!is_adl_indirectly_movable_v<I &>>,
+                typename R = iter_reference_t<I>>
+#ifndef RANGES_WORKAROUND_CLANG_23135
+            constexpr
+#endif // RANGES_WORKAROUND_CLANG_23135
+            auto CPP_auto_fun(operator())(I &&i)(const)
+            (
+                return static_cast<aux::move_t<R>>(aux::move(*i))
+            )
+            // clang-format on
+        };
+    } // namespace _iter_move_
+    /// \endcond
+
+    RANGES_DEFINE_CPO(_iter_move_::fn, iter_move)
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename O>
+        auto is_indirectly_movable_(I & (*i)(), O & (*o)(), iter_value_t<I> * v = nullptr)
+            -> always_<std::true_type, decltype(iter_value_t<I>(iter_move(i()))),
+                       decltype(*v = iter_move(i())),
+                       decltype(*o() = (iter_value_t<I> &&) * v),
+                       decltype(*o() = iter_move(i()))>;
+        template<typename I, typename O>
+        auto is_indirectly_movable_(...) -> std::false_type;
+
+        template<typename I, typename O>
+        auto is_nothrow_indirectly_movable_(iter_value_t<I> * v) -> meta::bool_<
+            noexcept(iter_value_t<I>(iter_move(std::declval<I &>()))) &&
+            noexcept(*v = iter_move(std::declval<I &>())) &&
+            noexcept(*std::declval<O &>() = (iter_value_t<I> &&) * v) &&
+            noexcept(*std::declval<O &>() = iter_move(std::declval<I &>()))>;
+        template<typename I, typename O>
+        auto is_nothrow_indirectly_movable_(...) -> std::false_type;
+    } // namespace detail
+    /// \endcond
+
+    template<typename I, typename O>
+    RANGES_INLINE_VAR constexpr bool is_indirectly_movable_v =
+        decltype(detail::is_indirectly_movable_<I, O>(nullptr, nullptr))::value;
+
+    template<typename I, typename O>
+    RANGES_INLINE_VAR constexpr bool is_nothrow_indirectly_movable_v =
+        decltype(detail::is_nothrow_indirectly_movable_<I, O>(nullptr))::value;
+
+    template<typename I, typename O>
+    struct is_indirectly_movable : meta::bool_<is_indirectly_movable_v<I, O>>
+    {};
+
+    template<typename I, typename O>
+    struct is_nothrow_indirectly_movable
+      : meta::bool_<is_nothrow_indirectly_movable_v<I, O>>
+    {};
+
+    /// \cond
+    namespace _iter_swap_
+    {
+        struct nope
+        {};
+
+        // Q: Should std::reference_wrapper be considered a proxy wrt swapping rvalues?
+        // A: No. Its operator= is currently defined to reseat the references, so
+        //    std::swap(ra, rb) already means something when ra and rb are (lvalue)
+        //    reference_wrappers. That reseats the reference wrappers but leaves the
+        //    referents unmodified. Treating rvalue reference_wrappers differently would
+        //    be confusing.
+
+        // Q: Then why is it OK to "re"-define swap for pairs and tuples of references?
+        // A: Because as defined above, swapping an rvalue tuple of references has the
+        //    same semantics as swapping an lvalue tuple of references. Rather than
+        //    reseat the references, assignment happens *through* the references.
+
+        // Q: But I have an iterator whose operator* returns an rvalue
+        //    std::reference_wrapper<T>. How do I make it model indirectly_swappable?
+        // A: With an overload of iter_swap.
+
+        // Intentionally create an ambiguity with std::iter_swap, which is
+        // unconstrained.
+        template<typename T, typename U>
+        nope iter_swap(T, U) = delete;
+
+#ifdef RANGES_WORKAROUND_MSVC_895622
+        nope iter_swap();
+#endif
+
+        template<typename T, typename U>
+        decltype(iter_swap(std::declval<T>(), std::declval<U>())) try_adl_iter_swap_(int);
+
+        template<typename T, typename U>
+        nope try_adl_iter_swap_(long);
+
+        // Test whether an overload of iter_swap for a T and a U can be found
+        // via ADL with the iter_swap overload above participating in the
+        // overload set. This depends on user-defined iter_swap overloads
+        // being a better match than the overload in namespace std.
+        template<typename T, typename U>
+        RANGES_INLINE_VAR constexpr bool is_adl_indirectly_swappable_v =
+            !RANGES_IS_SAME(nope, decltype(_iter_swap_::try_adl_iter_swap_<T, U>(42)));
+
+        struct fn
+        {
+            // *If* a user-defined iter_swap is found via ADL, call that:
+            template<typename T, typename U>
+            constexpr detail::enable_if_t<is_adl_indirectly_swappable_v<T, U>> operator()(
+                T && t, U && u) const noexcept(noexcept(iter_swap((T &&) t, (U &&) u)))
+            {
+                (void)iter_swap((T &&) t, (U &&) u);
+            }
+
+            // *Otherwise*, for readable types with swappable reference
+            // types, call ranges::swap(*a, *b)
+            template<typename I0, typename I1>
+            constexpr detail::enable_if_t<
+                !is_adl_indirectly_swappable_v<I0, I1> &&
+                is_swappable_with<iter_reference_t<I0>, iter_reference_t<I1>>::value>
+            operator()(I0 && a, I1 && b) const noexcept(noexcept(ranges::swap(*a, *b)))
+            {
+                ranges::swap(*a, *b);
+            }
+
+            // *Otherwise*, for readable types that are mutually
+            // indirectly_movable_storable, implement as:
+            //      iter_value_t<T0> tmp = iter_move(a);
+            //      *a = iter_move(b);
+            //      *b = std::move(tmp);
+            template<typename I0, typename I1>
+            constexpr detail::enable_if_t<
+                !is_adl_indirectly_swappable_v<I0, I1> &&
+                !is_swappable_with<iter_reference_t<I0>, iter_reference_t<I1>>::value &&
+                is_indirectly_movable_v<I0, I1> && is_indirectly_movable_v<I1, I0>>
+            operator()(I0 && a, I1 && b) const
+                noexcept(is_nothrow_indirectly_movable_v<I0, I1> &&
+                             is_nothrow_indirectly_movable_v<I1, I0>)
+            {
+                iter_value_t<I0> v0 = iter_move(a);
+                *a = iter_move(b);
+                *b = detail::move(v0);
+            }
+        };
+    } // namespace _iter_swap_
+    /// \endcond
+
+    /// \relates _iter_swap_::fn
+    RANGES_DEFINE_CPO(_iter_swap_::fn, iter_swap)
+
+    /// \cond
+    namespace detail
+    {
+        template<typename T, typename U>
+        auto is_indirectly_swappable_(T & (*t)(), U & (*u)())
+            -> detail::always_<std::true_type, decltype(iter_swap(t(), u()))>;
+        template<typename T, typename U>
+        auto is_indirectly_swappable_(...) -> std::false_type;
+
+        template<typename T, typename U>
+        auto is_nothrow_indirectly_swappable_(int)
+            -> meta::bool_<noexcept(iter_swap(std::declval<T &>(), std::declval<U &>()))>;
+        template<typename T, typename U>
+        auto is_nothrow_indirectly_swappable_(long) -> std::false_type;
+    } // namespace detail
+    /// \endcond
+
+    template<typename T, typename U>
+    RANGES_INLINE_VAR constexpr bool is_indirectly_swappable_v =
+        decltype(detail::is_indirectly_swappable_<T, U>(nullptr, nullptr))::value;
+
+    template<typename T, typename U>
+    RANGES_INLINE_VAR constexpr bool is_nothrow_indirectly_swappable_v =
+        decltype(detail::is_nothrow_indirectly_swappable_<T, U>(0))::value;
+
+    template<typename T, typename U>
+    struct is_indirectly_swappable : meta::bool_<is_indirectly_swappable_v<T, U>>
+    {};
+
+    template<typename T, typename U>
+    struct is_nothrow_indirectly_swappable
+      : meta::bool_<is_nothrow_indirectly_swappable_v<T, U>>
+    {};
+
+    namespace cpp20
+    {
+        using ranges::iter_move;
+        using ranges::iter_reference_t;
+        using ranges::iter_swap;
+        using ranges::iter_value_t;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ITERATOR_ACCESS_HPP
diff --git a/inst/include/range/v3/iterator/basic_iterator.hpp b/inst/include/range/v3/iterator/basic_iterator.hpp
new file mode 100644
index 0000000..877bbc4
--- /dev/null
+++ b/inst/include/range/v3/iterator/basic_iterator.hpp
@@ -0,0 +1,939 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_BASIC_ITERATOR_HPP
+#define RANGES_V3_ITERATOR_BASIC_ITERATOR_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/detail/range_access.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS
+
+namespace ranges
+{
+    /// \addtogroup group-iterator Iterator
+    /// @{
+    ///
+    template<typename T>
+    struct basic_mixin : private box<T>
+    {
+        CPP_member
+        constexpr CPP_ctor(basic_mixin)()(                            //
+            noexcept(std::is_nothrow_default_constructible<T>::value) //
+            requires default_constructible<T>)
+          : box<T>{}
+        {}
+        CPP_member
+        explicit constexpr CPP_ctor(basic_mixin)(T && t)(          //
+            noexcept(std::is_nothrow_move_constructible<T>::value) //
+            requires move_constructible<T>)
+          : box<T>(detail::move(t))
+        {}
+        CPP_member
+        explicit constexpr CPP_ctor(basic_mixin)(T const & t)(     //
+            noexcept(std::is_nothrow_copy_constructible<T>::value) //
+            requires copy_constructible<T>)
+          : box<T>(t)
+        {}
+
+    protected:
+        using box<T>::get;
+    };
+
+    /// \cond
+    namespace detail
+    {
+        template<typename Cur>
+        using cursor_reference_t =
+            decltype(range_access::read(std::declval<Cur const &>()));
+
+        // Compute the rvalue reference type of a cursor
+        template<typename Cur>
+        auto cursor_move(Cur const & cur, int) -> decltype(range_access::move(cur));
+        template<typename Cur>
+        auto cursor_move(Cur const & cur, long) -> aux::move_t<cursor_reference_t<Cur>>;
+
+        template<typename Cur>
+        using cursor_rvalue_reference_t =
+            decltype(detail::cursor_move(std::declval<Cur const &>(), 42));
+
+        // Define conversion operators from the proxy reference type
+        // to the common reference types, so that basic_iterator can model readable
+        // even with getters/setters.
+        template<typename Derived, typename Head>
+        struct proxy_reference_conversion
+        {
+            operator Head() const
+                noexcept(noexcept(Head(Head(std::declval<Derived const &>().read_()))))
+            {
+                return Head(static_cast<Derived const *>(this)->read_());
+            }
+        };
+
+        // Collect the reference types associated with cursors
+        template<typename Cur, bool IsReadable>
+        struct cursor_traits_
+        {
+        private:
+            struct private_
+            {};
+
+        public:
+            using value_t_ = private_;
+            using reference_t_ = private_;
+            using rvalue_reference_t_ = private_;
+            using common_refs = meta::list<>;
+        };
+
+        template<typename Cur>
+        struct cursor_traits_<Cur, true>
+        {
+            using value_t_ = range_access::cursor_value_t<Cur>;
+            using reference_t_ = cursor_reference_t<Cur>;
+            using rvalue_reference_t_ = cursor_rvalue_reference_t<Cur>;
+
+        private:
+            using R1 = reference_t_;
+            using R2 = common_reference_t<reference_t_, value_t_ &>;
+            using R3 = common_reference_t<reference_t_, rvalue_reference_t_>;
+            using tmp1 = meta::list<value_t_, R1>;
+            using tmp2 =
+                meta::if_<meta::in<tmp1, uncvref_t<R2>>, tmp1, meta::push_back<tmp1, R2>>;
+            using tmp3 =
+                meta::if_<meta::in<tmp2, uncvref_t<R3>>, tmp2, meta::push_back<tmp2, R3>>;
+
+        public:
+            using common_refs = meta::unique<meta::pop_front<tmp3>>;
+        };
+
+        template<typename Cur>
+        using cursor_traits = cursor_traits_<Cur, (bool)readable_cursor<Cur>>;
+
+        template<typename Cur>
+        using cursor_value_t = typename cursor_traits<Cur>::value_t_;
+
+        template<typename Cur, bool IsReadable>
+        struct basic_proxy_reference_;
+        template<typename Cur>
+        using basic_proxy_reference =
+            basic_proxy_reference_<Cur, (bool)readable_cursor<Cur>>;
+
+        // The One Proxy Reference type to rule them all. basic_iterator uses this
+        // as the return type of operator* when the cursor type has a set() member
+        // function of the correct signature (i.e., if it can accept a value_type &&).
+        template<typename Cur, bool IsReadable /*= (bool) readable_cursor<Cur>*/>
+        struct RANGES_EMPTY_BASES basic_proxy_reference_
+          : cursor_traits<Cur>
+          // The following adds conversion operators to the common reference
+          // types, so that basic_proxy_reference can model readable
+          , meta::inherit<meta::transform<
+                typename cursor_traits<Cur>::common_refs,
+                meta::bind_front<meta::quote<proxy_reference_conversion>,
+                                 basic_proxy_reference_<Cur, IsReadable>>>>
+        {
+        private:
+            Cur * cur_;
+            template<typename, bool>
+            friend struct basic_proxy_reference_;
+            template<typename, typename>
+            friend struct proxy_reference_conversion;
+            using typename cursor_traits<Cur>::value_t_;
+            using typename cursor_traits<Cur>::reference_t_;
+            using typename cursor_traits<Cur>::rvalue_reference_t_;
+            static_assert((bool)common_reference_with<value_t_ &, reference_t_>,
+                          "Your readable and writable cursor must have a value type and "
+                          "a reference type that share a common reference type. See the "
+                          "ranges::common_reference type trait.");
+            // BUGBUG make these private:
+        public:
+            constexpr reference_t_ read_() const noexcept(
+                noexcept(reference_t_(range_access::read(std::declval<Cur const &>()))))
+            {
+                return range_access::read(*cur_);
+            }
+            template<typename T>
+            constexpr void write_(T && t) const
+            {
+                range_access::write(*cur_, (T &&) t);
+            }
+            // public:
+            basic_proxy_reference_() = default;
+            basic_proxy_reference_(basic_proxy_reference_ const &) = default;
+            template<typename OtherCur>
+            constexpr CPP_ctor(basic_proxy_reference_)(
+                basic_proxy_reference<OtherCur> const & that)( //
+                noexcept(true)                                 //
+                requires convertible_to<OtherCur *, Cur *>)
+              : cur_(that.cur_)
+            {}
+            constexpr explicit basic_proxy_reference_(Cur & cur) noexcept
+              : cur_(&cur)
+            {}
+            CPP_member
+            constexpr auto operator=(basic_proxy_reference_ && that)
+                -> CPP_ret(basic_proxy_reference_ &)( //
+                    requires readable_cursor<Cur>)
+            {
+                return *this = that;
+            }
+            CPP_member
+            constexpr auto operator=(basic_proxy_reference_ const & that)
+                -> CPP_ret(basic_proxy_reference_ &)( //
+                    requires readable_cursor<Cur>)
+            {
+                this->write_(that.read_());
+                return *this;
+            }
+            CPP_member
+            constexpr auto operator=(basic_proxy_reference_ && that) const
+                -> CPP_ret(basic_proxy_reference_ const &)( //
+                    requires readable_cursor<Cur>)
+            {
+                return *this = that;
+            }
+            CPP_member
+            constexpr auto operator=(basic_proxy_reference_ const & that) const
+                -> CPP_ret(basic_proxy_reference_ const &)( //
+                    requires readable_cursor<Cur>)
+            {
+                this->write_(that.read_());
+                return *this;
+            }
+            template<typename OtherCur>
+            constexpr auto operator=(basic_proxy_reference<OtherCur> && that)
+                -> CPP_ret(basic_proxy_reference_ &)( //
+                    requires readable_cursor<OtherCur> &&
+                        writable_cursor<Cur, cursor_reference_t<OtherCur>>)
+            {
+                return *this = that;
+            }
+            template<typename OtherCur>
+            constexpr auto operator=(basic_proxy_reference<OtherCur> const & that)
+                -> CPP_ret(basic_proxy_reference_ &)( //
+                    requires readable_cursor<OtherCur> &&
+                        writable_cursor<Cur, cursor_reference_t<OtherCur>>)
+            {
+                this->write_(that.read_());
+                return *this;
+            }
+            template<typename OtherCur>
+            constexpr auto operator=(basic_proxy_reference<OtherCur> && that) const
+                -> CPP_ret(basic_proxy_reference_ const &)( //
+                    requires readable_cursor<OtherCur> &&
+                        writable_cursor<Cur, cursor_reference_t<OtherCur>>)
+            {
+                return *this = that;
+            }
+            template<typename OtherCur>
+            constexpr auto operator=(basic_proxy_reference<OtherCur> const & that) const
+                -> CPP_ret(basic_proxy_reference_ const &)( //
+                    requires readable_cursor<OtherCur> &&
+                        writable_cursor<Cur, cursor_reference_t<OtherCur>>)
+            {
+                this->write_(that.read_());
+                return *this;
+            }
+            template<typename T>
+            constexpr auto operator=(T && t) -> CPP_ret(basic_proxy_reference_ &)( //
+                requires writable_cursor<Cur, T>)
+            {
+                this->write_((T &&) t);
+                return *this;
+            }
+            template<typename T>
+            constexpr auto operator=(T && t) const
+                -> CPP_ret(basic_proxy_reference_ const &)( //
+                    requires writable_cursor<Cur, T>)
+            {
+                this->write_((T &&) t);
+                return *this;
+            }
+        };
+
+        template<typename Cur, bool IsReadable>
+        constexpr auto operator==(basic_proxy_reference_<Cur, IsReadable> const & x,
+                                  cursor_value_t<Cur> const & y) -> CPP_ret(bool)( //
+            requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>)
+        {
+            return x.read_() == y;
+        }
+        template<typename Cur, bool IsReadable>
+        constexpr auto operator!=(basic_proxy_reference_<Cur, IsReadable> const & x,
+                                  cursor_value_t<Cur> const & y) -> CPP_ret(bool)( //
+            requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>)
+        {
+            return !(x == y);
+        }
+        template<typename Cur, bool IsReadable>
+        constexpr auto operator==(cursor_value_t<Cur> const & x,
+                                  basic_proxy_reference_<Cur, IsReadable> const & y)
+            -> CPP_ret(bool)( //
+                requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>)
+        {
+            return x == y.read_();
+        }
+        template<typename Cur, bool IsReadable>
+        constexpr auto operator!=(cursor_value_t<Cur> const & x,
+                                  basic_proxy_reference_<Cur, IsReadable> const & y)
+            -> CPP_ret(bool)( //
+                requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>)
+        {
+            return !(x == y);
+        }
+        template<typename Cur, bool IsReadable>
+        constexpr auto operator==(basic_proxy_reference_<Cur, IsReadable> const & x,
+                                  basic_proxy_reference_<Cur, IsReadable> const & y)
+            -> CPP_ret(bool)( //
+                requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>)
+        {
+            return x.read_() == y.read_();
+        }
+        template<typename Cur, bool IsReadable>
+        constexpr auto operator!=(basic_proxy_reference_<Cur, IsReadable> const & x,
+                                  basic_proxy_reference_<Cur, IsReadable> const & y)
+            -> CPP_ret(bool)( //
+                requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>)
+        {
+            return !(x == y);
+        }
+
+        template<typename Cur>
+        using cpp20_iter_cat_of_t =                      //
+            std::enable_if_t<                            //
+                input_cursor<Cur>,                       //
+                detail::if_then_t<                       //
+                    random_access_cursor<Cur>,           //
+                    std::random_access_iterator_tag,     //
+                    detail::if_then_t<                   //
+                        bidirectional_cursor<Cur>,       //
+                        std::bidirectional_iterator_tag, //
+                        detail::if_then_t<               //
+                            forward_cursor<Cur>,         //
+                            std::forward_iterator_tag,   //
+                            std::input_iterator_tag>>>>;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename C)
+            concept cpp17_input_cursor,
+                input_cursor<C> &&
+                sentinel_for_cursor<C, C> &&
+                // Either it is not single-pass, or else we can create a
+                // proxy for postfix increment.
+                (
+                    !range_access::single_pass_t<uncvref_t<C>>::value ||
+                    (
+                        constructible_from<
+                            range_access::cursor_value_t<C>,
+                            cursor_reference_t<C>> &&
+                        move_constructible<range_access::cursor_value_t<C>>
+                    )
+                )
+        );
+
+        CPP_def
+        (
+            template(typename C)
+            concept cpp17_forward_cursor,
+                forward_cursor<C> &&
+                std::is_reference<cursor_reference_t<C>>::value
+        );
+        // clang-format on
+
+        template<typename Category, typename Base = void>
+        struct with_iterator_category : Base
+        {
+            using iterator_category = Category;
+        };
+
+        template<typename Category>
+        struct with_iterator_category<Category>
+        {
+            using iterator_category = Category;
+        };
+
+        template<typename Cur>
+        using cpp17_iter_cat_of_t =                      //
+            std::enable_if_t<                            //
+                cpp17_input_cursor<Cur>,                 //
+                detail::if_then_t<                       //
+                    random_access_cursor<Cur>,           //
+                    std::random_access_iterator_tag,     //
+                    detail::if_then_t<                   //
+                        bidirectional_cursor<Cur>,       //
+                        std::bidirectional_iterator_tag, //
+                        detail::if_then_t<               //
+                            cpp17_forward_cursor<Cur>,   //
+                            std::forward_iterator_tag,   //
+                            std::input_iterator_tag>>>>;
+
+        template<typename Cur, typename = void>
+        struct readable_iterator_associated_types_base : range_access::mixin_base_t<Cur>
+        {
+            using range_access::mixin_base_t<Cur>::mixin_base_t;
+        };
+
+        template<typename Cur>
+        struct readable_iterator_associated_types_base<
+            Cur, always_<void, cpp17_iter_cat_of_t<Cur>>>
+          : range_access::mixin_base_t<Cur>
+        {
+            using range_access::mixin_base_t<Cur>::mixin_base_t;
+            using iterator_category = cpp17_iter_cat_of_t<Cur>;
+        };
+
+        template<typename Cur, bool IsReadable /*= (bool) readable_cursor<Cur>*/>
+        struct iterator_associated_types_base_ : range_access::mixin_base_t<Cur>
+        {
+            // BUGBUG
+            // protected:
+            using iter_reference_t = basic_proxy_reference<Cur>;
+            using const_reference_t = basic_proxy_reference<Cur const>;
+
+        public:
+            using reference = void;
+            using difference_type = range_access::cursor_difference_t<Cur>;
+
+            using range_access::mixin_base_t<Cur>::mixin_base_t;
+        };
+
+        template<typename Cur>
+        using cursor_arrow_t = decltype(range_access::arrow(std::declval<Cur const &>()));
+
+        template<typename Cur>
+        struct iterator_associated_types_base_<Cur, true>
+          : readable_iterator_associated_types_base<Cur>
+        {
+            // BUGBUG
+            // protected:
+            using iter_reference_t =
+                if_then_t<is_writable_cursor<Cur const>::value,
+                          basic_proxy_reference<Cur const>,
+                          if_then_t<is_writable_cursor<Cur>::value,
+                                    basic_proxy_reference<Cur>, cursor_reference_t<Cur>>>;
+            using const_reference_t =
+                if_then_t<is_writable_cursor<Cur const>::value,
+                          basic_proxy_reference<Cur const>, cursor_reference_t<Cur>>;
+
+        public:
+            using difference_type = range_access::cursor_difference_t<Cur>;
+            using value_type = range_access::cursor_value_t<Cur>;
+            using reference = iter_reference_t;
+            using iterator_concept = cpp20_iter_cat_of_t<Cur>;
+            using pointer = meta::_t<
+                if_then_t<(bool)has_cursor_arrow<Cur>, meta::defer<cursor_arrow_t, Cur>,
+                          std::add_pointer<reference>>>;
+            using common_reference = common_reference_t<reference, value_type &>;
+
+            using readable_iterator_associated_types_base<
+                Cur>::readable_iterator_associated_types_base;
+        };
+
+        template<typename Cur>
+        using iterator_associated_types_base =
+            iterator_associated_types_base_<Cur, (bool)readable_cursor<Cur>>;
+
+        template<typename Value>
+        struct postfix_increment_proxy
+        {
+        private:
+            Value cache_;
+
+        public:
+            template<typename T>
+            constexpr postfix_increment_proxy(T && t)
+              : cache_(static_cast<T &&>(t))
+            {}
+            constexpr Value const & operator*() const noexcept
+            {
+                return cache_;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _basic_iterator_
+    {
+        template<typename>
+        struct adl_hook
+        {};
+    } // namespace _basic_iterator_
+#endif
+
+    template<typename Cur>
+    struct RANGES_EMPTY_BASES basic_iterator
+      : detail::iterator_associated_types_base<Cur>
+#if RANGES_BROKEN_CPO_LOOKUP
+      , private _basic_iterator_::adl_hook<basic_iterator<Cur>>
+#endif
+    {
+    private:
+        template<typename>
+        friend struct basic_iterator;
+        friend range_access;
+        using base_t = detail::iterator_associated_types_base<Cur>;
+        using mixin_t = range_access::mixin_base_t<Cur>;
+        static_assert((bool)detail::cursor<Cur>, "");
+        using assoc_types_ = detail::iterator_associated_types_base<Cur>;
+        using typename assoc_types_::const_reference_t;
+        using typename assoc_types_::iter_reference_t;
+        constexpr Cur & pos() noexcept
+        {
+            return this->mixin_t::basic_mixin::get();
+        }
+        constexpr Cur const & pos() const noexcept
+        {
+            return this->mixin_t::basic_mixin::get();
+        }
+
+    public:
+        using typename assoc_types_::difference_type;
+        constexpr basic_iterator() = default;
+        template<typename OtherCur>
+        constexpr CPP_ctor(basic_iterator)(basic_iterator<OtherCur> that)( //
+            requires(!same_as<OtherCur, Cur>) && convertible_to<OtherCur, Cur> &&
+            constructible_from<mixin_t, OtherCur>)
+          : base_t{std::move(that.pos())}
+        {}
+        // Mix in any additional constructors provided by the mixin
+        using base_t::base_t;
+
+        template<typename OtherCur>
+        constexpr auto operator=(basic_iterator<OtherCur> that)
+            -> CPP_ret(basic_iterator &)( //
+                requires(!same_as<OtherCur, Cur>) && convertible_to<OtherCur, Cur>)
+        {
+            pos() = std::move(that.pos());
+            return *this;
+        }
+
+        CPP_member
+        constexpr auto operator*() const
+            noexcept(noexcept(range_access::read(std::declval<Cur const &>())))
+                -> CPP_ret(const_reference_t)( //
+                    requires detail::readable_cursor<Cur> &&
+                    (!detail::is_writable_cursor<Cur>::value))
+        {
+            return range_access::read(pos());
+        }
+        CPP_member
+        constexpr auto operator*() noexcept(noexcept(iter_reference_t{
+            std::declval<Cur &>()})) -> CPP_ret(iter_reference_t)( //
+            requires detail::has_cursor_next<Cur> &&
+                detail::is_writable_cursor<Cur>::value)
+        {
+            return iter_reference_t{pos()};
+        }
+        CPP_member
+        constexpr auto operator*() const
+            noexcept(noexcept(const_reference_t{std::declval<Cur const &>()}))
+                -> CPP_ret(const_reference_t)( //
+                    requires detail::has_cursor_next<Cur> &&
+                        detail::is_writable_cursor<Cur const>::value)
+        {
+            return const_reference_t{pos()};
+        }
+        CPP_member
+        constexpr auto operator*() noexcept -> CPP_ret(basic_iterator &)( //
+            requires(!detail::has_cursor_next<Cur>))
+        {
+            return *this;
+        }
+
+        // Use cursor's arrow() member, if any.
+        template<typename C = Cur>
+        constexpr auto operator-> ()
+            const noexcept(noexcept(range_access::arrow(std::declval<C const &>())))
+                -> CPP_ret(detail::cursor_arrow_t<C>)( //
+                    requires detail::has_cursor_arrow<C>)
+        {
+            return range_access::arrow(pos());
+        }
+        // Otherwise, if iter_reference_t is an lvalue reference to cv-qualified
+        // iter_value_t, return the address of **this.
+        template<typename C = Cur>
+        constexpr auto operator-> ()
+            const noexcept(noexcept(*std::declval<basic_iterator const &>())) -> CPP_ret(
+                meta::_t<std::add_pointer<const_reference_t>>)( //
+                requires(!detail::has_cursor_arrow<C>) && detail::readable_cursor<C> &&
+                std::is_lvalue_reference<const_reference_t>::value &&
+                same_as<typename detail::iterator_associated_types_base<C>::value_type,
+                        uncvref_t<const_reference_t>>)
+        {
+            return detail::addressof(**this);
+        }
+
+        CPP_member
+        constexpr auto operator++() -> CPP_ret(basic_iterator &)( //
+            requires detail::has_cursor_next<Cur>)
+        {
+            range_access::next(pos());
+            return *this;
+        }
+        CPP_member
+        constexpr auto operator++() noexcept -> CPP_ret(basic_iterator &)( //
+            requires(!detail::has_cursor_next<Cur>))
+        {
+            return *this;
+        }
+
+    private:
+        constexpr basic_iterator post_increment_(std::false_type, int)
+        {
+            basic_iterator tmp{*this};
+            ++*this;
+            return tmp;
+        }
+        // Attempt to satisfy the C++17 iterator requirements by returning a
+        // proxy from postfix increment:
+        template<typename A = assoc_types_, typename V = typename A::value_type>
+        constexpr auto post_increment_(std::true_type, int) //
+            -> CPP_ret(detail::postfix_increment_proxy<V>)( //
+                requires constructible_from<V, typename A::reference> &&
+                    move_constructible<V>)
+        {
+            detail::postfix_increment_proxy<V> p{**this};
+            ++*this;
+            return p;
+        }
+        constexpr void post_increment_(std::true_type, long)
+        {
+            ++*this;
+        }
+
+    public:
+        CPP_member
+        constexpr auto operator++(int)
+        {
+            return this->post_increment_(meta::bool_ < detail::input_cursor<Cur> &&
+                                             !detail::forward_cursor<Cur> > {},
+                                         0);
+        }
+
+        CPP_member
+        constexpr auto operator--() -> CPP_ret(basic_iterator &)( //
+            requires detail::bidirectional_cursor<Cur>)
+        {
+            range_access::prev(pos());
+            return *this;
+        }
+        CPP_member
+        constexpr auto operator--(int) -> CPP_ret(basic_iterator)( //
+            requires detail::bidirectional_cursor<Cur>)
+        {
+            basic_iterator tmp(*this);
+            --*this;
+            return tmp;
+        }
+        CPP_member
+        constexpr auto operator+=(difference_type n) -> CPP_ret(basic_iterator &)( //
+            requires detail::random_access_cursor<Cur>)
+        {
+            range_access::advance(pos(), n);
+            return *this;
+        }
+        CPP_member
+        constexpr auto operator-=(difference_type n) -> CPP_ret(basic_iterator &)( //
+            requires detail::random_access_cursor<Cur>)
+        {
+            range_access::advance(pos(), (difference_type)-n);
+            return *this;
+        }
+        CPP_member
+        constexpr auto operator[](difference_type n) const
+            -> CPP_ret(const_reference_t)( //
+                requires detail::random_access_cursor<Cur>)
+        {
+            return *(*this + n);
+        }
+
+#if !RANGES_BROKEN_CPO_LOOKUP
+        // Optionally support hooking iter_move when the cursor sports a
+        // move() member function.
+        template<typename C = Cur>
+        friend constexpr auto iter_move(basic_iterator const & it) noexcept(
+            noexcept(range_access::move(std::declval<C const &>())))
+            -> CPP_broken_friend_ret(
+                decltype(range_access::move(std::declval<C const &>())))( //
+                requires same_as<C, Cur> && detail::input_cursor<Cur>)
+        {
+            return range_access::move(it.pos());
+        }
+#endif
+    };
+
+    template<typename Cur, typename Cur2>
+    constexpr auto operator==(basic_iterator<Cur> const & left,
+                              basic_iterator<Cur2> const & right) -> CPP_ret(bool)( //
+        requires detail::sentinel_for_cursor<Cur2, Cur>)
+    {
+        return range_access::equal(range_access::pos(left), range_access::pos(right));
+    }
+    template<typename Cur, typename Cur2>
+    constexpr auto operator!=(basic_iterator<Cur> const & left,
+                              basic_iterator<Cur2> const & right) -> CPP_ret(bool)( //
+        requires detail::sentinel_for_cursor<Cur2, Cur>)
+    {
+        return !(left == right);
+    }
+    template<typename Cur, typename S>
+    constexpr auto operator==(basic_iterator<Cur> const & left,
+                              S const & right) -> CPP_ret(bool)( //
+        requires detail::sentinel_for_cursor<S, Cur>)
+    {
+        return range_access::equal(range_access::pos(left), right);
+    }
+    template<typename Cur, typename S>
+    constexpr auto operator!=(basic_iterator<Cur> const & left,
+                              S const & right) -> CPP_ret(bool)( //
+        requires detail::sentinel_for_cursor<S, Cur>)
+    {
+        return !(left == right);
+    }
+    template<typename S, typename Cur>
+    constexpr auto operator==(S const & left,
+                              basic_iterator<Cur> const & right) -> CPP_ret(bool)( //
+        requires detail::sentinel_for_cursor<S, Cur>)
+    {
+        return right == left;
+    }
+    template<typename S, typename Cur>
+    constexpr auto operator!=(S const & left,
+                              basic_iterator<Cur> const & right) -> CPP_ret(bool)( //
+        requires detail::sentinel_for_cursor<S, Cur>)
+    {
+        return right != left;
+    }
+
+    template<typename Cur>
+    constexpr auto operator+(basic_iterator<Cur> left,
+                             typename basic_iterator<Cur>::difference_type n)
+        -> CPP_ret(basic_iterator<Cur>)( //
+            requires detail::random_access_cursor<Cur>)
+    {
+        left += n;
+        return left;
+    }
+    template<typename Cur>
+    constexpr auto operator+(typename basic_iterator<Cur>::difference_type n,
+                             basic_iterator<Cur> right)
+        -> CPP_ret(basic_iterator<Cur>)( //
+            requires detail::random_access_cursor<Cur>)
+    {
+        right += n;
+        return right;
+    }
+    template<typename Cur>
+    constexpr auto operator-(basic_iterator<Cur> left,
+                             typename basic_iterator<Cur>::difference_type n)
+        -> CPP_ret(basic_iterator<Cur>)( //
+            requires detail::random_access_cursor<Cur>)
+    {
+        left -= n;
+        return left;
+    }
+    template<typename Cur2, typename Cur>
+    constexpr auto operator-(basic_iterator<Cur2> const & left,
+                             basic_iterator<Cur> const & right)
+        -> CPP_ret(typename basic_iterator<Cur>::difference_type)( //
+            requires detail::sized_sentinel_for_cursor<Cur2, Cur>)
+    {
+        return range_access::distance_to(range_access::pos(right),
+                                         range_access::pos(left));
+    }
+    template<typename S, typename Cur>
+    constexpr auto operator-(S const & left, basic_iterator<Cur> const & right)
+        -> CPP_ret(typename basic_iterator<Cur>::difference_type)( //
+            requires detail::sized_sentinel_for_cursor<S, Cur>)
+    {
+        return range_access::distance_to(range_access::pos(right), left);
+    }
+    template<typename Cur, typename S>
+    constexpr auto operator-(basic_iterator<Cur> const & left, S const & right)
+        -> CPP_ret(typename basic_iterator<Cur>::difference_type)( //
+            requires detail::sized_sentinel_for_cursor<S, Cur>)
+    {
+        return -(right - left);
+    }
+    // Asymmetric comparisons
+    template<typename Left, typename Right>
+    constexpr auto operator<(basic_iterator<Left> const & left,
+                             basic_iterator<Right> const & right) -> CPP_ret(bool)( //
+        requires detail::sized_sentinel_for_cursor<Right, Left>)
+    {
+        return 0 < (right - left);
+    }
+    template<typename Left, typename Right>
+    constexpr auto operator<=(basic_iterator<Left> const & left,
+                              basic_iterator<Right> const & right) -> CPP_ret(bool)( //
+        requires detail::sized_sentinel_for_cursor<Right, Left>)
+    {
+        return 0 <= (right - left);
+    }
+    template<typename Left, typename Right>
+    constexpr auto operator>(basic_iterator<Left> const & left,
+                             basic_iterator<Right> const & right) -> CPP_ret(bool)( //
+        requires detail::sized_sentinel_for_cursor<Right, Left>)
+    {
+        return (right - left) < 0;
+    }
+    template<typename Left, typename Right>
+    constexpr auto operator>=(basic_iterator<Left> const & left,
+                              basic_iterator<Right> const & right) -> CPP_ret(bool)( //
+        requires detail::sized_sentinel_for_cursor<Right, Left>)
+    {
+        return (right - left) <= 0;
+    }
+
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _basic_iterator_
+    {
+        // Optionally support hooking iter_move when the cursor sports a
+        // move() member function.
+        template<typename Cur>
+        constexpr auto iter_move(basic_iterator<Cur> const & it) noexcept(
+            noexcept(range_access::move(std::declval<Cur const &>())))
+            -> CPP_broken_friend_ret(
+                decltype(range_access::move(std::declval<Cur const &>())))( //
+                requires detail::input_cursor<Cur>)
+        {
+            return range_access::move(range_access::pos(it));
+        }
+    } // namespace _basic_iterator_
+#endif
+
+    /// Get a cursor from a basic_iterator
+    struct get_cursor_fn
+    {
+        template<typename Cur>
+        constexpr Cur & operator()(basic_iterator<Cur> & it) const noexcept
+        {
+            return range_access::pos(it);
+        }
+        template<typename Cur>
+        constexpr Cur const & operator()(basic_iterator<Cur> const & it) const noexcept
+        {
+            return range_access::pos(it);
+        }
+        template<typename Cur>
+        constexpr Cur operator()(basic_iterator<Cur> && it) const
+            noexcept(std::is_nothrow_move_constructible<Cur>::value)
+        {
+            return range_access::pos(std::move(it));
+        }
+    };
+
+    /// \sa `get_cursor_fn`
+    RANGES_INLINE_VARIABLE(get_cursor_fn, get_cursor)
+    /// @}
+} // namespace ranges
+
+/// \cond
+namespace concepts
+{
+    // common_reference specializations for basic_proxy_reference
+    template<typename Cur, typename U, template<typename> class TQual,
+             template<typename> class UQual>
+    struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur, true>, U,
+                                  TQual, UQual>
+      : basic_common_reference<::ranges::detail::cursor_reference_t<Cur>, U, TQual, UQual>
+    {};
+    template<typename T, typename Cur, template<typename> class TQual,
+             template<typename> class UQual>
+    struct basic_common_reference<T, ::ranges::detail::basic_proxy_reference_<Cur, true>,
+                                  TQual, UQual>
+      : basic_common_reference<T, ::ranges::detail::cursor_reference_t<Cur>, TQual, UQual>
+    {};
+    template<typename Cur1, typename Cur2, template<typename> class TQual,
+             template<typename> class UQual>
+    struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur1, true>,
+                                  ::ranges::detail::basic_proxy_reference_<Cur2, true>,
+                                  TQual, UQual>
+      : basic_common_reference<::ranges::detail::cursor_reference_t<Cur1>,
+                               ::ranges::detail::cursor_reference_t<Cur2>, TQual, UQual>
+    {};
+
+    // common_type specializations for basic_proxy_reference
+    template<typename Cur, typename U>
+    struct common_type<::ranges::detail::basic_proxy_reference_<Cur, true>, U>
+      : common_type<::ranges::range_access::cursor_value_t<Cur>, U>
+    {};
+    template<typename T, typename Cur>
+    struct common_type<T, ::ranges::detail::basic_proxy_reference_<Cur, true>>
+      : common_type<T, ::ranges::range_access::cursor_value_t<Cur>>
+    {};
+    template<typename Cur1, typename Cur2>
+    struct common_type<::ranges::detail::basic_proxy_reference_<Cur1, true>,
+                       ::ranges::detail::basic_proxy_reference_<Cur2, true>>
+      : common_type<::ranges::range_access::cursor_value_t<Cur1>,
+                    ::ranges::range_access::cursor_value_t<Cur2>>
+    {};
+} // namespace concepts
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Cur, bool IsReadable>
+        struct std_iterator_traits_
+        {
+            using difference_type =
+                typename iterator_associated_types_base<Cur>::difference_type;
+            using value_type = void;
+            using reference = void;
+            using pointer = void;
+            using iterator_category = std::output_iterator_tag;
+            using iterator_concept = std::output_iterator_tag;
+        };
+
+        template<typename Cur>
+        struct std_iterator_traits_<Cur, true> : iterator_associated_types_base<Cur>
+        {};
+
+        template<typename Cur>
+        using std_iterator_traits = std_iterator_traits_<Cur, (bool)readable_cursor<Cur>>;
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+namespace std
+{
+    template<typename Cur>
+    struct iterator_traits<::ranges::basic_iterator<Cur>>
+      : ::ranges::detail::std_iterator_traits<Cur>
+    {};
+} // namespace std
+/// \endcond
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/iterator/common_iterator.hpp b/inst/include/range/v3/iterator/common_iterator.hpp
new file mode 100644
index 0000000..695a485
--- /dev/null
+++ b/inst/include/range/v3/iterator/common_iterator.hpp
@@ -0,0 +1,446 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_COMMON_ITERATOR_HPP
+#define RANGES_V3_ITERATOR_COMMON_ITERATOR_HPP
+
+#include <cstdint>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/detail/variant.hpp>
+#include <range/v3/iterator/basic_iterator.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/utility/common_tuple.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S>
+        variant<I, S> & cidata(common_iterator<I, S> & that)
+        {
+            return that.data_;
+        }
+
+        template<typename I, typename S>
+        variant<I, S> const & cidata(common_iterator<I, S> const & that)
+        {
+            return that.data_;
+        }
+    } // namespace detail
+
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _common_iterator_
+    {
+        struct adl_hook
+        {};
+    } // namespace _common_iterator_
+#endif
+    /// \endcond
+
+    template<typename I, typename S>
+    struct common_iterator
+#if RANGES_BROKEN_CPO_LOOKUP
+      : private _common_iterator_::adl_hook
+#endif
+    {
+    private:
+        CPP_assert(input_or_output_iterator<I>);
+        CPP_assert(sentinel_for<S, I>);
+        CPP_assert(!same_as<I, S>);
+        variant<I, S> data_;
+
+        friend variant<I, S> & detail::cidata<>(common_iterator<I, S> &);
+        friend variant<I, S> const & detail::cidata<>(common_iterator<I, S> const &);
+        struct emplace_fn
+        {
+            variant<I, S> * data_;
+            template<typename T, std::size_t N>
+            void operator()(indexed_element<T, N> t) const
+            {
+                ranges::emplace<N>(*data_, t.get());
+            }
+        };
+        struct arrow_proxy_
+        {
+        private:
+            friend common_iterator;
+            iter_value_t<I> keep_;
+            arrow_proxy_(iter_reference_t<I> && x)
+              : keep_(std::move(x))
+            {}
+
+        public:
+            const iter_value_t<I> * operator->() const noexcept
+            {
+                return std::addressof(keep_);
+            }
+        };
+        template<typename T>
+        static T * operator_arrow_(T * p, int) noexcept
+        {
+            return p;
+        }
+        template<typename J, typename = detail::iter_arrow_t<J const>>
+        static J operator_arrow_(J const & j, int) noexcept(noexcept(J(j)))
+        {
+            return j;
+        }
+        template<typename J, typename R = iter_reference_t<J>>
+        static auto operator_arrow_(J const & j, long) noexcept
+            -> CPP_ret(meta::_t<std::add_pointer<R>>)( //
+                requires std::is_reference<R>::value)
+        {
+            auto && r = *j;
+            return std::addressof(r);
+        }
+        template<typename J, typename V = iter_value_t<J>>
+        static auto operator_arrow_(J const & j, ...) noexcept(noexcept(V(V(*j))))
+            -> CPP_ret(arrow_proxy_)( //
+                requires constructible_from<V, iter_reference_t<J>>)
+        {
+            return arrow_proxy_(*j);
+        }
+
+    public:
+        using difference_type = iter_difference_t<I>;
+
+        common_iterator() = default;
+        common_iterator(I i)
+          : data_(emplaced_index<0>, std::move(i))
+        {}
+        common_iterator(S s)
+          : data_(emplaced_index<1>, std::move(s))
+        {}
+        template<typename I2, typename S2>
+        CPP_ctor(common_iterator)(common_iterator<I2, S2> const & that)( //
+            requires convertible_to<I2, I> && convertible_to<S2, S>)
+          : data_(detail::variant_core_access::make_empty<I, S>())
+        {
+            detail::cidata(that).visit_i(emplace_fn{&data_});
+        }
+        template<typename I2, typename S2>
+        auto operator=(common_iterator<I2, S2> const & that)
+            -> CPP_ret(common_iterator &)( //
+                requires convertible_to<I2, I> && convertible_to<S2, S>)
+        {
+            detail::cidata(that).visit_i(emplace_fn{&data_});
+            return *this;
+        }
+        iter_reference_t<I> operator*() noexcept(
+            noexcept(iter_reference_t<I>(*std::declval<I &>())))
+        {
+            return *ranges::get<0>(data_);
+        }
+        CPP_member
+        auto operator*() const
+            noexcept(noexcept(iter_reference_t<I>(*std::declval<I const &>())))
+                -> CPP_ret(iter_reference_t<I>)( //
+                    requires readable<I const>)
+        {
+            return *ranges::get<0>(data_);
+        }
+        template<typename J = I>
+        auto operator-> () const noexcept(
+            noexcept(common_iterator::operator_arrow_(std::declval<I const &>(), 42)))
+            -> CPP_ret(decltype(
+                common_iterator::operator_arrow_(std::declval<J const &>(), 42)))( //
+                requires readable<J>)
+        {
+            return common_iterator::operator_arrow_(ranges::get<0>(data_), 42);
+        }
+        common_iterator & operator++()
+        {
+            ++ranges::get<0>(data_);
+            return *this;
+        }
+#ifdef RANGES_WORKAROUND_MSVC_677925
+        template<typename I2 = I>
+        auto operator++(int) -> CPP_ret(decltype(std::declval<I2 &>()++))( //
+            requires(!forward_iterator<I2>))
+        {
+            return ranges::get<0>(data_)++;
+        }
+#else  // ^^^ workaround ^^^ / vvv no workaround vvv
+        CPP_member
+        auto operator++(int) -> CPP_ret(decltype(std::declval<I &>()++))( //
+            requires(!forward_iterator<I>))
+        {
+            return ranges::get<0>(data_)++;
+        }
+#endif // RANGES_WORKAROUND_MSVC_677925
+        CPP_member
+        auto operator++(int) -> CPP_ret(common_iterator)( //
+            requires forward_iterator<I>)
+        {
+            return common_iterator(ranges::get<0>(data_)++);
+        }
+
+#if !RANGES_BROKEN_CPO_LOOKUP
+        template<typename I_ = I>
+        friend constexpr auto iter_move(common_iterator const & i) noexcept(
+            detail::has_nothrow_iter_move_v<I>)
+            -> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)( //
+                requires input_iterator<I_>)
+        {
+            return ranges::iter_move(ranges::get<0>(detail::cidata(i)));
+        }
+        template<typename I2, typename S2>
+        friend auto iter_swap(
+            common_iterator const & x,
+            common_iterator<I2, S2> const &
+                y) noexcept(is_nothrow_indirectly_swappable<I, I2>::value)
+            -> CPP_broken_friend_ret(void)( //
+                requires indirectly_swappable<I2, I>)
+        {
+            return ranges::iter_swap(ranges::get<0>(detail::cidata(x)),
+                                     ranges::get<0>(detail::cidata(y)));
+        }
+#endif
+    };
+
+    /// \cond
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _common_iterator_
+    {
+        template<typename I, typename S>
+        constexpr auto iter_move(common_iterator<I, S> const & i) noexcept(
+            detail::has_nothrow_iter_move_v<I>)
+            -> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)( //
+                requires input_iterator<I>)
+        {
+            return ranges::iter_move(ranges::get<0>(detail::cidata(i)));
+        }
+        template<typename I1, typename S1, typename I2, typename S2>
+        auto iter_swap(common_iterator<I1, S1> const & x,
+                       common_iterator<I2, S2> const & y) //
+            noexcept(is_nothrow_indirectly_swappable<I1, I2>::value)
+                -> CPP_broken_friend_ret(void)( //
+                    requires indirectly_swappable<I1, I2>)
+        {
+            return ranges::iter_swap(ranges::get<0>(detail::cidata(x)),
+                                     ranges::get<0>(detail::cidata(y)));
+        }
+    } // namespace _common_iterator_
+#endif
+    /// \endcond
+
+    template<typename I1, typename I2, typename S1, typename S2>
+    auto operator==(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
+        -> CPP_ret(bool)( //
+            requires sentinel_for<S1, I2> && sentinel_for<S2, I1> &&
+            (!equality_comparable_with<I1, I2>))
+    {
+        return detail::cidata(x).index() == 1u ? (detail::cidata(y).index() == 1u ||
+                                                  ranges::get<0>(detail::cidata(y)) ==
+                                                      ranges::get<1>(detail::cidata(x)))
+                                               : (detail::cidata(y).index() != 1u ||
+                                                  ranges::get<0>(detail::cidata(x)) ==
+                                                      ranges::get<1>(detail::cidata(y)));
+    }
+
+    template<typename I1, typename I2, typename S1, typename S2>
+    auto operator==(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
+        -> CPP_ret(bool)( //
+            requires sentinel_for<S1, I2> && sentinel_for<S2, I1> &&
+                equality_comparable_with<I1, I2>)
+    {
+        return detail::cidata(x).index() == 1u
+                   ? (detail::cidata(y).index() == 1u ||
+                      ranges::get<0>(detail::cidata(y)) ==
+                          ranges::get<1>(detail::cidata(x)))
+                   : (detail::cidata(y).index() == 1u
+                          ? ranges::get<0>(detail::cidata(x)) ==
+                                ranges::get<1>(detail::cidata(y))
+                          : ranges::get<0>(detail::cidata(x)) ==
+                                ranges::get<0>(detail::cidata(y)));
+    }
+
+    template<typename I1, typename I2, typename S1, typename S2>
+    auto operator!=(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
+        -> CPP_ret(bool)( //
+            requires sentinel_for<S1, I2> && sentinel_for<S2, I1>)
+    {
+        return !(x == y);
+    }
+
+    template<typename I1, typename I2, typename S1, typename S2>
+    auto operator-(common_iterator<I1, S1> const & x,
+                   common_iterator<I2, S2> const & y) //
+        -> CPP_ret(iter_difference_t<I2>)(            //
+            requires sized_sentinel_for<I1, I2> && sized_sentinel_for<S1, I2> &&
+                sized_sentinel_for<S2, I1>)
+    {
+        return detail::cidata(x).index() == 1u
+                   ? (detail::cidata(y).index() == 1u
+                          ? 0
+                          : ranges::get<1>(detail::cidata(x)) -
+                                ranges::get<0>(detail::cidata(y)))
+                   : (detail::cidata(y).index() == 1u
+                          ? ranges::get<0>(detail::cidata(x)) -
+                                ranges::get<1>(detail::cidata(y))
+                          : ranges::get<0>(detail::cidata(x)) -
+                                ranges::get<0>(detail::cidata(y)));
+    }
+
+    template<typename I, typename S>
+    struct readable_traits<common_iterator<I, S>>
+      : meta::if_c<(bool)readable<I>, readable_traits<I>, meta::nil_>
+    {};
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        auto demote_common_iter_cat(...) -> nil_;
+        template<typename I>
+        auto demote_common_iter_cat(long)
+            -> with_iterator_category<std::input_iterator_tag>;
+        template<typename I>
+        auto demote_common_iter_cat(int)
+            -> CPP_ret(with_iterator_category<std::forward_iterator_tag>)( //
+                requires derived_from<typename std::iterator_traits<I>::iterator_category,
+                                      std::forward_iterator_tag>);
+
+        template<typename I, bool = (bool)input_iterator<I>>
+        struct common_iterator_std_traits : decltype(detail::demote_common_iter_cat<I>(0))
+        {
+            using difference_type = iter_difference_t<I>;
+            using value_type = iter_value_t<I>;
+            using reference = iter_reference_t<I>;
+            using pointer = detail::iter_pointer_t<I>;
+            using iterator_concept =
+                if_then_t<(bool)forward_iterator<I>, std::forward_iterator_tag,
+                          std::input_iterator_tag>;
+        };
+
+        template<typename I>
+        struct common_iterator_std_traits<I, false>
+        {
+            using difference_type = iter_difference_t<I>;
+            using value_type = void;
+            using reference = void;
+            using pointer = void;
+            using iterator_category = std::output_iterator_tag;
+        };
+
+        // An iterator adaptor that demotes a user-defined difference_type to
+        // std::intmax_t, for use when constructing containers from such
+        // iterators.
+        template<typename I>
+        struct cpp17_iterator_cursor
+        {
+        private:
+            friend range_access;
+            I it_;
+            struct mixin : basic_mixin<cpp17_iterator_cursor>
+            {
+                mixin() = default;
+                using basic_mixin<cpp17_iterator_cursor>::basic_mixin;
+                explicit mixin(I it)
+                  : mixin{cpp17_iterator_cursor{std::move(it)}}
+                {}
+                I base() const
+                {
+                    return this->get().it_;
+                }
+            };
+
+        public:
+            using single_pass = meta::bool_<!forward_iterator<I>>;
+            using difference_type = std::ptrdiff_t;
+            using value_type = iter_value_t<I>;
+
+            cpp17_iterator_cursor() = default;
+            constexpr explicit cpp17_iterator_cursor(I i)
+              : it_(static_cast<I &&>(i))
+            {}
+
+            I arrow() const
+            {
+                return it_;
+            }
+            decltype(auto) read()
+            {
+                return *it_;
+            }
+            decltype(auto) read() const
+            {
+                return *it_;
+            }
+            void next()
+            {
+                ++it_;
+            }
+            bool equal(cpp17_iterator_cursor const & that) const
+            {
+                return it_ == that.it_;
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires bidirectional_iterator<I>)
+            {
+                --it_;
+            }
+            CPP_member
+            auto advance(std::ptrdiff_t n) -> CPP_ret(void)( //
+                requires random_access_iterator<I>)
+            {
+                it_ += static_cast<iter_difference_t<I>>(n);
+            }
+            CPP_member
+            auto distance_to(cpp17_iterator_cursor const & that)
+                -> CPP_ret(std::ptrdiff_t)( //
+                    requires random_access_iterator<I>)
+            {
+                auto d = that.it_ - it_;
+                RANGES_EXPECT(d <= PTRDIFF_MAX);
+                return static_cast<std::ptrdiff_t>(d);
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    namespace cpp20
+    {
+        using ranges::common_iterator;
+    }
+    /// @}
+} // namespace ranges
+
+/// \cond
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+
+namespace std
+{
+    template<typename I, typename S>
+    struct iterator_traits<::ranges::common_iterator<I, S>>
+      : ::ranges::detail::common_iterator_std_traits<I>
+    {};
+} // namespace std
+
+RANGES_DIAGNOSTIC_POP
+/// \endcond
+
+#endif
diff --git a/inst/include/range/v3/iterator/concepts.hpp b/inst/include/range/v3/iterator/concepts.hpp
new file mode 100644
index 0000000..37d70dc
--- /dev/null
+++ b/inst/include/range/v3/iterator/concepts.hpp
@@ -0,0 +1,782 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_CONCEPTS_HPP
+#define RANGES_V3_ITERATOR_CONCEPTS_HPP
+
+#include <iterator>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/access.hpp>
+#include <range/v3/iterator/traits.hpp>
+
+#ifdef _GLIBCXX_DEBUG
+#include <debug/safe_iterator.h>
+#endif
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        using iter_traits_t = if_then_t<is_std_iterator_traits_specialized_v<I>,
+                                        std::iterator_traits<I>, I>;
+
+#if defined(_GLIBCXX_DEBUG)
+        template<typename I, typename T, typename Seq>
+        auto iter_concept_(__gnu_debug::_Safe_iterator<T *, Seq>, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, __gnu_debug::_Safe_iterator<T *, Seq>>);
+#endif
+#if defined(__GLIBCXX__)
+        template<typename I, typename T, typename Seq>
+        auto iter_concept_(__gnu_cxx::__normal_iterator<T *, Seq>, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, __gnu_cxx::__normal_iterator<T *, Seq>>);
+#endif
+#if defined(_LIBCPP_VERSION)
+        template<typename I, typename T>
+        auto iter_concept_(std::__wrap_iter<T *>, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, std::__wrap_iter<T *>>);
+#endif
+#if defined(_MSVC_STL_VERSION)
+        template<typename I>
+        auto iter_concept_(I, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, class I::_Array_iterator>);
+        template<typename I>
+        auto iter_concept_(I, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, class I::_Array_const_iterator>);
+        template<typename I>
+        auto iter_concept_(I, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, class I::_Vector_iterator>);
+        template<typename I>
+        auto iter_concept_(I, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, class I::_Vector_const_iterator>);
+        template<typename I>
+        auto iter_concept_(I, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, class I::_String_iterator>);
+        template<typename I>
+        auto iter_concept_(I, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, class I::_String_const_iterator>);
+        template<typename I>
+        auto iter_concept_(I, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, class I::_String_view_iterator>);
+#endif
+        template<typename I, typename T>
+        auto iter_concept_(T *, priority_tag<3>)
+            -> CPP_ret(ranges::contiguous_iterator_tag)( //
+                requires same_as<I, T *>);
+        template<typename I>
+        auto iter_concept_(I, priority_tag<2>) ->
+            typename iter_traits_t<I>::iterator_concept;
+        template<typename I>
+        auto iter_concept_(I, priority_tag<1>) ->
+            typename iter_traits_t<I>::iterator_category;
+        template<typename I>
+        auto iter_concept_(I, priority_tag<0>)
+            -> enable_if_t<!is_std_iterator_traits_specialized_v<I>,
+                           std::random_access_iterator_tag>;
+
+        template<typename I>
+        using iter_concept_t =
+            decltype(iter_concept_<I>(std::declval<I>(), priority_tag<3>{}));
+
+        using ::concepts::detail::weakly_equality_comparable_with_;
+    } // namespace detail
+      /// \endcond
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename I)
+        concept readable,
+            requires (uncvref_t<I> const &i) (
+                // { *i } -> same_as<iter_reference_t<I>>;
+                // { iter_move(i) } -> same_as<iter_rvalue_reference_t<I>>;
+                concepts::requires_<same_as<decltype(*i), iter_reference_t<I>>>,
+                concepts::requires_<same_as<decltype(iter_move(i)), iter_rvalue_reference_t<I>>>
+            ) &&
+            common_reference_with<iter_reference_t<I> &&, iter_value_t<I> &> &&
+            common_reference_with<iter_reference_t<I> &&,
+                                  iter_rvalue_reference_t<I> &&> &&
+            common_reference_with<iter_rvalue_reference_t<I> &&, iter_value_t<I> const &>
+    );
+
+    CPP_def
+    (
+        template(typename Out, typename T)
+        concept writable,
+            requires (Out &&o, T &&t)
+            (
+                *o = static_cast<T &&>(t),
+                *((Out &&) o) = static_cast<T &&>(t),
+                const_cast<iter_reference_t<Out> const &&>(*o) = static_cast<T &&>(t),
+                const_cast<iter_reference_t<Out> const &&>(*((Out &&) o)) =
+                    static_cast<T &&>(t)
+            )
+    );
+    // clang-format on
+
+    /// \cond
+    namespace detail
+    {
+        template<typename D>
+        RANGES_INLINE_VAR constexpr bool _is_integer_like_ = std::is_integral<D>::value;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename D)
+            concept integer_like_,
+                _is_integer_like_<D>
+                // TODO additional syntactic and semantic requirements
+        );
+
+#ifdef RANGES_WORKAROUND_MSVC_792338
+        CPP_def
+        (
+            template(typename D)
+            concept signed_integer_like_,
+                concepts::type<decltype(std::integral_constant<bool, (D(-1) < D(0))>{})> &&
+                std::integral_constant<bool, (D(-1) < D(0))>::value
+        );
+#else // ^^^ workaround / no workaround vvv
+        CPP_def
+        (
+            template(typename D)
+            concept signed_integer_like_,
+                integer_like_<D> &&
+                concepts::type<std::integral_constant<bool, (D(-1) < D(0))>> &&
+                std::integral_constant<bool, (D(-1) < D(0))>::value
+        );
+#endif // RANGES_WORKAROUND_MSVC_792338
+       // clang-format on
+    } // namespace detail
+      /// \endcond
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename I)
+        concept weakly_incrementable,
+            requires (I i)
+            (
+                ++i,
+                i++,
+                concepts::requires_<same_as<I&, decltype(++i)>>
+            ) &&
+            concepts::type<iter_difference_t<I>> &&
+            detail::signed_integer_like_<iter_difference_t<I>> &&
+            semiregular<I>
+    );
+
+    CPP_def
+    (
+        template(typename I)
+        concept incrementable,
+            requires (I i)
+            (
+                concepts::requires_<same_as<I, decltype(i++)>>
+            ) &&
+            regular<I> && weakly_incrementable<I>
+    );
+
+    CPP_def
+    (
+        template(typename I)
+        concept input_or_output_iterator,
+            requires (I i)
+            (
+                *i
+            ) &&
+            weakly_incrementable<I>
+    );
+
+    CPP_def
+    (
+        template(typename S, typename I)
+        concept sentinel_for,
+            semiregular<S> && input_or_output_iterator<I> &&
+            detail::weakly_equality_comparable_with_<S, I>
+    );
+
+    CPP_def
+    (
+        template(typename S, typename I)
+        concept sized_sentinel_for,
+            requires (S const &s, I const &i)
+            (
+                s - i,
+                i - s,
+                concepts::requires_<same_as<iter_difference_t<I>, decltype(s - i)>>,
+                concepts::requires_<same_as<iter_difference_t<I>, decltype(i - s)>>
+            ) &&
+            // Short-circuit the test for sentinel_for if we're emulating concepts:
+            bool(!defer::is_true<disable_sized_sentinel<meta::_t<std::remove_cv<S>>, meta::_t<std::remove_cv<I>>>> &&
+            defer::sentinel_for<S, I>)
+    );
+
+    CPP_def
+    (
+        template(typename Out, typename T)
+        concept output_iterator,
+            requires (Out o, T &&t)
+            (
+                *o++ = static_cast<T &&>(t)
+            ) &&
+            input_or_output_iterator<Out> && writable<Out, T>
+    );
+
+    CPP_def
+    (
+        template(typename I)
+        concept input_iterator,
+            input_or_output_iterator<I> && readable<I> &&
+            derived_from<detail::iter_concept_t<I>, std::input_iterator_tag>
+    );
+
+    CPP_def
+    (
+        template(typename I)
+        concept forward_iterator,
+            input_iterator<I> && incrementable<I> &&
+            sentinel_for<I, I> &&
+            derived_from<detail::iter_concept_t<I>, std::forward_iterator_tag>
+    );
+
+    CPP_def
+    (
+        template(typename I)
+        concept bidirectional_iterator,
+            requires (I i)
+            (
+                --i,
+                i--,
+                concepts::requires_<same_as<I&, decltype(--i)>>,
+                concepts::requires_<same_as<I, decltype(i--)>>
+            ) &&
+            forward_iterator<I> &&
+            derived_from<detail::iter_concept_t<I>, std::bidirectional_iterator_tag>
+    );
+
+    CPP_def
+    (
+        template(typename I)
+        concept random_access_iterator,
+            requires (I i, iter_difference_t<I> n)
+            (
+                i + n,
+                n + i,
+                i - n,
+                i += n,
+                i -= n,
+                concepts::requires_<same_as<decltype(i + n), I>>,
+                concepts::requires_<same_as<decltype(n + i), I>>,
+                concepts::requires_<same_as<decltype(i - n), I>>,
+                concepts::requires_<same_as<decltype(i += n), I&>>,
+                concepts::requires_<same_as<decltype(i -= n), I&>>,
+                concepts::requires_<same_as<decltype(i[n]), iter_reference_t<I>>>
+            ) &&
+            bidirectional_iterator<I> &&
+            totally_ordered<I> &&
+            sized_sentinel_for<I, I> &&
+            derived_from<detail::iter_concept_t<I>, std::random_access_iterator_tag>
+    );
+
+    CPP_def
+    (
+        template(typename I)
+        concept contiguous_iterator,
+            random_access_iterator<I> &&
+            derived_from<detail::iter_concept_t<I>, ranges::contiguous_iterator_tag> &&
+            std::is_lvalue_reference<iter_reference_t<I>>::value &&
+            same_as<iter_value_t<I>, uncvref_t<iter_reference_t<I>>>
+    );
+    // clang-format on
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // iterator_tag_of
+    template<typename Rng>
+    using iterator_tag_of =                              //
+        std::enable_if_t<                                //
+            input_iterator<Rng>,                         //
+            detail::if_then_t<                           //
+                contiguous_iterator<Rng>,                //
+                ranges::contiguous_iterator_tag,         //
+                detail::if_then_t<                       //
+                    random_access_iterator<Rng>,         //
+                    std::random_access_iterator_tag,     //
+                    detail::if_then_t<                   //
+                        bidirectional_iterator<Rng>,     //
+                        std::bidirectional_iterator_tag, //
+                        detail::if_then_t<               //
+                            forward_iterator<Rng>,       //
+                            std::forward_iterator_tag,   //
+                            std::input_iterator_tag>>>>>;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename, bool>
+        struct iterator_category_
+        {};
+
+        template<typename I>
+        struct iterator_category_<I, true>
+        {
+            using type = iterator_tag_of<I>;
+        };
+
+        template<typename T, typename U = meta::_t<std::remove_const<T>>>
+        using iterator_category = iterator_category_<U, (bool)input_iterator<U>>;
+    } // namespace detail
+    /// \endcond
+
+    /// \cond
+    // Generally useful to know if an iterator is single-pass or not:
+    // clang-format off
+    CPP_def
+    (
+        template(typename I)
+        concept single_pass_iterator_,
+            input_or_output_iterator<I> && !forward_iterator<I>
+    );
+    // clang-format on
+    /// \endcond
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // indirect_result_t
+    template<typename Fun, typename... Is>
+    using indirect_result_t =
+        detail::enable_if_t<(bool)and_v<(bool)readable<Is>...>,
+                            invoke_result_t<Fun, iter_reference_t<Is>...>>;
+
+    /// \cond
+    namespace detail
+    {
+        // clang-format off
+        CPP_def
+        (
+            template(typename T1, typename T2, typename T3, typename T4)
+            concept common_reference_with_4_,
+                concepts::type<common_reference_t<T1, T2, T3, T4>> &&
+                convertible_to<T1, common_reference_t<T1, T2, T3, T4>> &&
+                convertible_to<T2, common_reference_t<T1, T2, T3, T4>> &&
+                convertible_to<T3, common_reference_t<T1, T2, T3, T4>> &&
+                convertible_to<T4, common_reference_t<T1, T2, T3, T4>>
+            // axiom: all permutations of T1,T2,T3,T4 have the same
+            // common reference type.
+        );
+
+        CPP_def
+        (
+            template(typename F, typename I)
+            concept indirectly_unary_invocable_,
+                readable<I> &&
+                invocable<F &, iter_value_t<I> &> &&
+                invocable<F &, iter_reference_t<I>> &&
+                invocable<F &, iter_common_reference_t<I>> &&
+                common_reference_with<
+                    invoke_result_t<F &, iter_value_t<I> &>,
+                    invoke_result_t<F &, iter_reference_t<I>>>
+        );
+        // clang-format on
+    } // namespace detail
+      /// \endcond
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename F, typename I)
+        concept indirectly_unary_invocable,
+            detail::indirectly_unary_invocable_<F, I> &&
+            copy_constructible<F>
+    );
+
+    CPP_def
+    (
+        template(typename F, typename I)
+        concept indirectly_regular_unary_invocable,
+            readable<I> &&
+            copy_constructible<F> &&
+            regular_invocable<F &, iter_value_t<I> &> &&
+            regular_invocable<F &, iter_reference_t<I>> &&
+            regular_invocable<F &, iter_common_reference_t<I>> &&
+            common_reference_with<
+                invoke_result_t<F &, iter_value_t<I> &>,
+                invoke_result_t<F &, iter_reference_t<I>>>
+    );
+
+    /// \cond
+    // Non-standard indirect invocable concepts
+    CPP_def
+    (
+        template(typename F, typename I1, typename I2)
+        concept indirectly_binary_invocable_,
+            readable<I1> && readable<I2> &&
+            copy_constructible<F> &&
+            invocable<F &, iter_value_t<I1> &, iter_value_t<I2> &> &&
+            invocable<F &, iter_value_t<I1> &, iter_reference_t<I2>> &&
+            invocable<F &, iter_reference_t<I1>, iter_value_t<I2> &> &&
+            invocable<F &, iter_reference_t<I1>, iter_reference_t<I2>> &&
+            invocable<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>> &&
+            detail::common_reference_with_4_<
+                invoke_result_t<F &, iter_value_t<I1> &, iter_value_t<I2> &>,
+                invoke_result_t<F &, iter_value_t<I1> &, iter_reference_t<I2>>,
+                invoke_result_t<F &, iter_reference_t<I1>, iter_value_t<I2> &>,
+                invoke_result_t<F &, iter_reference_t<I1>, iter_reference_t<I2>>>
+    );
+
+    CPP_def
+    (
+        template(typename F, typename I1, typename I2)
+        concept indirectly_regular_binary_invocable_,
+            readable<I1> && readable<I2> &&
+            copy_constructible<F> &&
+            regular_invocable<F &, iter_value_t<I1> &, iter_value_t<I2> &> &&
+            regular_invocable<F &, iter_value_t<I1> &, iter_reference_t<I2>> &&
+            regular_invocable<F &, iter_reference_t<I1>, iter_value_t<I2> &> &&
+            regular_invocable<F &, iter_reference_t<I1>, iter_reference_t<I2>> &&
+            regular_invocable<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>> &&
+            detail::common_reference_with_4_<
+                invoke_result_t<F &, iter_value_t<I1> &, iter_value_t<I2> &>,
+                invoke_result_t<F &, iter_value_t<I1> &, iter_reference_t<I2>>,
+                invoke_result_t<F &, iter_reference_t<I1>, iter_value_t<I2> &>,
+                invoke_result_t<F &, iter_reference_t<I1>, iter_reference_t<I2>>>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename F, typename I)
+        concept indirect_unary_predicate,
+            readable<I> &&
+            copy_constructible<F> &&
+            predicate<F &, iter_value_t<I> &> &&
+            predicate<F &, iter_reference_t<I>> &&
+            predicate<F &, iter_common_reference_t<I>>
+    );
+
+    CPP_def
+    (
+        template(typename F, typename I1, typename I2)
+        concept indirect_binary_predicate_,
+            readable<I1> && readable<I2> &&
+            copy_constructible<F> &&
+            predicate<F &, iter_value_t<I1> &, iter_value_t<I2> &> &&
+            predicate<F &, iter_value_t<I1> &, iter_reference_t<I2>> &&
+            predicate<F &, iter_reference_t<I1>, iter_value_t<I2> &> &&
+            predicate<F &, iter_reference_t<I1>, iter_reference_t<I2>> &&
+            predicate<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
+    );
+
+    CPP_def
+    (
+        template(typename F, typename I1, typename I2 = I1)
+        (concept indirect_relation)(F, I1, I2),
+            readable<I1> && readable<I2> &&
+            copy_constructible<F> &&
+            relation<F &, iter_value_t<I1> &, iter_value_t<I2> &> &&
+            relation<F &, iter_value_t<I1> &, iter_reference_t<I2>> &&
+            relation<F &, iter_reference_t<I1>, iter_value_t<I2> &> &&
+            relation<F &, iter_reference_t<I1>, iter_reference_t<I2>> &&
+            relation<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
+    );
+
+    CPP_def
+    (
+        template(class F, class I1, class I2 = I1)
+        (concept indirect_strict_weak_order)(F, I1, I2),
+            readable<I1> && readable<I2> &&
+            copy_constructible<F> &&
+            strict_weak_order<F &, iter_value_t<I1> &, iter_value_t<I2> &> &&
+            strict_weak_order<F &, iter_value_t<I1> &, iter_reference_t<I2>> &&
+            strict_weak_order<F &, iter_reference_t<I1>, iter_value_t<I2> &> &&
+            strict_weak_order<F &, iter_reference_t<I1>, iter_reference_t<I2>> &&
+            strict_weak_order<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
+    );
+    // clang-format on
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // projected struct, for "projecting" a readable with a unary callable
+    /// \cond
+    namespace detail
+    {
+        RANGES_DIAGNOSTIC_PUSH
+        RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL
+        template<typename I, typename Proj>
+        struct projected_
+        {
+            using reference = indirect_result_t<Proj &, I>;
+            using value_type = uncvref_t<reference>;
+            reference operator*() const;
+        };
+        RANGES_DIAGNOSTIC_POP
+
+        template<typename Proj>
+        struct select_projected_
+        {
+            template<typename I>
+            using apply =
+                detail::enable_if_t<(bool)indirectly_regular_unary_invocable<Proj, I>,
+                                    detail::projected_<I, Proj>>;
+        };
+
+        template<>
+        struct select_projected_<identity>
+        {
+            template<typename I>
+            using apply = detail::enable_if_t<(bool)readable<I>, I>;
+        };
+    } // namespace detail
+    /// \endcond
+
+    template<typename I, typename Proj>
+    using projected = typename detail::select_projected_<Proj>::template apply<I>;
+
+    template<typename I, typename Proj>
+    struct incrementable_traits<detail::projected_<I, Proj>> : incrementable_traits<I>
+    {};
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename I, typename O)
+        concept indirectly_movable,
+            readable<I> && writable<O, iter_rvalue_reference_t<I>>
+    );
+
+    CPP_def
+    (
+        template(typename I, typename O)
+        concept indirectly_movable_storable,
+            indirectly_movable<I, O> &&
+            writable<O, iter_value_t<I>> &&
+            movable<iter_value_t<I>> &&
+            constructible_from<iter_value_t<I>, iter_rvalue_reference_t<I>> &&
+            assignable_from<iter_value_t<I> &, iter_rvalue_reference_t<I>>
+    );
+
+    CPP_def
+    (
+        template(typename I, typename O)
+        concept indirectly_copyable,
+            readable<I> &&
+            writable<O, iter_reference_t<I>>
+    );
+
+    CPP_def
+    (
+        template(typename I, typename O)
+        concept indirectly_copyable_storable,
+            indirectly_copyable<I, O> &&
+            writable<O, iter_value_t<I> const &> &&
+            copyable<iter_value_t<I>> &&
+            constructible_from<iter_value_t<I>, iter_reference_t<I>> &&
+            assignable_from<iter_value_t<I> &, iter_reference_t<I>>
+    );
+
+    CPP_def
+    (
+        template(typename I1, typename I2 = I1)
+        (concept indirectly_swappable)(I1, I2),
+            requires (I1 const i1, I2 const i2)
+            (
+                ranges::iter_swap(i1, i2),
+                ranges::iter_swap(i1, i1),
+                ranges::iter_swap(i2, i2),
+                ranges::iter_swap(i2, i1)
+            ) &&
+            readable<I1> && readable<I2>
+    );
+
+    CPP_def
+    (
+        template(typename I1, typename I2, typename C,
+            typename P1 = identity, typename P2 = identity)
+        (concept indirectly_comparable)(I1, I2, C, P1, P2),
+            indirect_relation<C, projected<I1, P1>, projected<I2, P2>>
+    );
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // Composite concepts for use defining algorithms:
+    CPP_def
+    (
+        template(typename I)
+        concept permutable,
+            forward_iterator<I> &&
+            indirectly_swappable<I, I> &&
+            indirectly_movable_storable<I, I>
+    );
+
+    CPP_def
+    (
+        template(typename I0, typename I1, typename Out, typename C = less,
+            typename P0 = identity, typename P1 = identity)
+        (concept mergeable)(I0, I1, Out, C, P0, P1),
+            input_iterator<I0> &&
+            input_iterator<I1> &&
+            weakly_incrementable<Out> &&
+            indirectly_copyable<I0, Out> &&
+            indirectly_copyable<I1, Out> &&
+            indirect_strict_weak_order<C, projected<I0, P0>, projected<I1, P1>>
+    );
+
+    CPP_def
+    (
+        template(typename I, typename C = less, typename P = identity)
+        (concept sortable)(I, C, P),
+            permutable<I> &&
+            indirect_strict_weak_order<C, projected<I, P>>
+    );
+    // clang-format on
+
+    struct sentinel_tag
+    {};
+    struct sized_sentinel_tag : sentinel_tag
+    {};
+
+    template<typename S, typename I>
+    using sentinel_tag_of =               //
+        std::enable_if_t<                 //
+            sentinel_for<S, I>,           //
+            detail::if_then_t<            //
+                sized_sentinel_for<S, I>, //
+                sized_sentinel_tag,       //
+                sentinel_tag>>;
+
+    // Deprecated things:
+    /// \cond
+    template<typename I>
+    using iterator_category RANGES_DEPRECATED(
+        "iterator_category is deprecated. Use the iterator concepts instead") =
+        detail::iterator_category<I>;
+
+    template<typename I>
+    using iterator_category_t RANGES_DEPRECATED(
+        "iterator_category_t is deprecated. Use the iterator concepts instead") =
+        meta::_t<detail::iterator_category<I>>;
+
+    template<typename Fun, typename... Is>
+    using indirect_invoke_result_t RANGES_DEPRECATED(
+        "Please switch to indirect_result_t") = indirect_result_t<Fun, Is...>;
+
+    template<typename Fun, typename... Is>
+    struct RANGES_DEPRECATED("Please switch to indirect_result_t") indirect_invoke_result
+      : meta::defer<indirect_result_t, Fun, Is...>
+    {};
+
+    template<typename Sig>
+    struct indirect_result_of
+    {};
+
+    template<typename Fun, typename... Is>
+    struct RANGES_DEPRECATED("Please switch to indirect_result_t")
+        indirect_result_of<Fun(Is...)> : meta::defer<indirect_result_t, Fun, Is...>
+    {};
+
+    template<typename Sig>
+    using indirect_result_of_t RANGES_DEPRECATED("Please switch to indirect_result_t") =
+        meta::_t<indirect_result_of<Sig>>;
+    /// \endcond
+
+    namespace cpp20
+    {
+        using ranges::bidirectional_iterator;
+        using ranges::contiguous_iterator;
+        using ranges::forward_iterator;
+        using ranges::incrementable;
+        using ranges::indirect_relation;
+        using ranges::indirect_result_t;
+        using ranges::indirect_strict_weak_order;
+        using ranges::indirect_unary_predicate;
+        using ranges::indirectly_comparable;
+        using ranges::indirectly_copyable;
+        using ranges::indirectly_copyable_storable;
+        using ranges::indirectly_movable;
+        using ranges::indirectly_movable_storable;
+        using ranges::indirectly_regular_unary_invocable;
+        using ranges::indirectly_swappable;
+        using ranges::indirectly_unary_invocable;
+        using ranges::input_iterator;
+        using ranges::input_or_output_iterator;
+        using ranges::mergeable;
+        using ranges::output_iterator;
+        using ranges::permutable;
+        using ranges::projected;
+        using ranges::random_access_iterator;
+        using ranges::readable;
+        using ranges::sentinel_for;
+        using ranges::sized_sentinel_for;
+        using ranges::sortable;
+        using ranges::weakly_incrementable;
+        using ranges::writable;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#ifdef _GLIBCXX_DEBUG
+// HACKHACK: workaround underconstrained operator- for libstdc++ debug iterator wrapper
+// by intentionally creating an ambiguity when the wrapped types don't support the
+// necessary operation.
+namespace __gnu_debug
+{
+    template<typename I1, typename I2, typename Seq>
+    auto operator-(_Safe_iterator<I1, Seq> const &, _Safe_iterator<I2, Seq> const &)
+        -> CPP_ret(void)( //
+            requires(!::ranges::sized_sentinel_for<I1, I2>)) = delete;
+
+    template<typename I1, typename Seq>
+    auto operator-(_Safe_iterator<I1, Seq> const &, _Safe_iterator<I1, Seq> const &)
+        -> CPP_ret(void)( //
+            requires(!::ranges::sized_sentinel_for<I1, I1>)) = delete;
+} // namespace __gnu_debug
+#endif
+
+#if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 3900)
+// HACKHACK: workaround libc++ (https://llvm.org/bugs/show_bug.cgi?id=28421)
+// and libstdc++ (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71771)
+// underconstrained operator- for reverse_iterator by disabling sized_sentinel_for
+// when the base iterators do not model sized_sentinel_for.
+namespace ranges
+{
+    template<typename S, typename I>
+    /*inline*/ constexpr bool
+        disable_sized_sentinel<std::reverse_iterator<S>, std::reverse_iterator<I>> =
+            !static_cast<bool>(sized_sentinel_for<I, S>);
+}
+#endif // defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 3900)
+
+#endif // RANGES_V3_ITERATOR_CONCEPTS_HPP
diff --git a/inst/include/range/v3/iterator/counted_iterator.hpp b/inst/include/range/v3/iterator/counted_iterator.hpp
new file mode 100644
index 0000000..0b4b49a
--- /dev/null
+++ b/inst/include/range/v3/iterator/counted_iterator.hpp
@@ -0,0 +1,461 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_COUNTED_ITERATOR_HPP
+#define RANGES_V3_ITERATOR_COUNTED_ITERATOR_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    /// \cond
+    namespace _counted_iterator_
+    {
+        struct access
+        {
+            template<typename I>
+            static constexpr iter_difference_t<counted_iterator<I>> & count(
+                counted_iterator<I> & ci) noexcept
+            {
+                return ci.cnt_;
+            }
+
+            template<typename I>
+            static constexpr I & current(counted_iterator<I> & ci) noexcept
+            {
+                return ci.current_;
+            }
+
+            template<typename I>
+            static constexpr I const & current(counted_iterator<I> const & ci) noexcept
+            {
+                return ci.current_;
+            }
+        };
+
+        template<bool>
+        struct contiguous_iterator_concept_base
+        {};
+
+        template<>
+        struct contiguous_iterator_concept_base<true>
+        {
+            using iterator_concept = ranges::contiguous_iterator_tag;
+        };
+    } // namespace _counted_iterator_
+    /// \endcond
+
+    CPP_template_def(typename I)(             //
+        requires input_or_output_iterator<I>) //
+        struct counted_iterator
+      : _counted_iterator_::contiguous_iterator_concept_base<(bool)contiguous_iterator<I>>
+    {
+    private:
+        friend advance_fn;
+        CPP_assert(input_or_output_iterator<I>);
+        friend _counted_iterator_::access;
+
+        I current_{};
+        iter_difference_t<I> cnt_{0};
+
+        constexpr void post_increment_(std::true_type)
+        {
+            CPP_assert(std::is_void<decltype(current_++)>());
+            ++current_;
+        }
+        constexpr auto post_increment_(std::false_type) -> decltype(current_++)
+        {
+            CPP_assert(!std::is_void<decltype(current_++)>());
+            auto && tmp = current_++;
+            --cnt_;
+            return static_cast<decltype(tmp) &&>(tmp);
+        }
+
+    public:
+        using iterator_type = I;
+        using difference_type = iter_difference_t<I>;
+
+        counted_iterator() = default;
+
+        constexpr counted_iterator(I x, iter_difference_t<I> n)
+          : current_(std::move(x))
+          , cnt_(n)
+        {
+            RANGES_EXPECT(n >= 0);
+        }
+
+        template<typename I2>
+        constexpr CPP_ctor(counted_iterator)(counted_iterator<I2> const & i)( //
+            requires convertible_to<I2, I>)
+          : current_(_counted_iterator_::access::current(i))
+          , cnt_(i.count())
+        {}
+
+        template<typename I2>
+        constexpr auto operator=(counted_iterator<I2> const & i)
+            -> CPP_ret(counted_iterator &)( //
+                requires convertible_to<I2, I>)
+        {
+            current_ = _counted_iterator_::access::current(i);
+            cnt_ = i.count();
+        }
+
+        constexpr I base() const
+        {
+            return current_;
+        }
+
+        constexpr iter_difference_t<I> count() const
+        {
+            return cnt_;
+        }
+
+        constexpr iter_reference_t<I> operator*() noexcept(
+            noexcept(iter_reference_t<I>(*current_)))
+        {
+            RANGES_EXPECT(cnt_ > 0);
+            return *current_;
+        }
+        template<typename I2 = I>
+        constexpr auto operator*() const
+            noexcept(noexcept(iter_reference_t<I>(*current_)))
+                -> CPP_ret(iter_reference_t<I2>)( //
+                    requires readable<I2 const>)
+        {
+            RANGES_EXPECT(cnt_ > 0);
+            return *current_;
+        }
+
+        constexpr counted_iterator & operator++()
+        {
+            RANGES_EXPECT(cnt_ > 0);
+            ++current_;
+            --cnt_;
+            return *this;
+        }
+
+#ifdef RANGES_WORKAROUND_MSVC_677925
+        template<typename I2 = I>
+        constexpr auto operator++(int) -> CPP_ret(decltype(std::declval<I2 &>()++))( //
+            requires(!forward_iterator<I2>))
+#else  // ^^^ workaround ^^^ / vvv no workaround vvv
+        CPP_member
+        constexpr auto operator++(int) -> CPP_ret(decltype(std::declval<I &>()++))( //
+            requires(!forward_iterator<I>))
+#endif // RANGES_WORKAROUND_MSVC_677925
+        {
+            RANGES_EXPECT(cnt_ > 0);
+            return post_increment_(std::is_void<decltype(current_++)>());
+        }
+
+        CPP_member
+        constexpr auto operator++(int) -> CPP_ret(counted_iterator)( //
+            requires forward_iterator<I>)
+        {
+            auto tmp(*this);
+            ++*this;
+            return tmp;
+        }
+
+        CPP_member
+        constexpr auto operator--() -> CPP_ret(counted_iterator &)( //
+            requires bidirectional_iterator<I>)
+        {
+            --current_;
+            ++cnt_;
+            return *this;
+        }
+
+        CPP_member
+        constexpr auto operator--(int) -> CPP_ret(counted_iterator)( //
+            requires bidirectional_iterator<I>)
+        {
+            auto tmp(*this);
+            --*this;
+            return tmp;
+        }
+
+        CPP_member
+        constexpr auto operator+=(difference_type n) -> CPP_ret(counted_iterator &)( //
+            requires random_access_iterator<I>)
+        {
+            RANGES_EXPECT(cnt_ >= n);
+            current_ += n;
+            cnt_ -= n;
+            return *this;
+        }
+
+        CPP_member
+        constexpr auto operator+(difference_type n) const -> CPP_ret(counted_iterator)( //
+            requires random_access_iterator<I>)
+        {
+            auto tmp(*this);
+            tmp += n;
+            return tmp;
+        }
+
+        CPP_member
+        constexpr auto operator-=(difference_type n) -> CPP_ret(counted_iterator &)( //
+            requires random_access_iterator<I>)
+        {
+            RANGES_EXPECT(cnt_ >= -n);
+            current_ -= n;
+            cnt_ += n;
+            return *this;
+        }
+
+        CPP_member
+        constexpr auto operator-(difference_type n) const -> CPP_ret(counted_iterator)( //
+            requires random_access_iterator<I>)
+        {
+            auto tmp(*this);
+            tmp -= n;
+            return tmp;
+        }
+
+        CPP_member
+        constexpr auto operator[](difference_type n) const
+            -> CPP_ret(iter_reference_t<I>)( //
+                requires random_access_iterator<I>)
+        {
+            RANGES_EXPECT(cnt_ >= n);
+            return current_[n];
+        }
+
+#if !RANGES_BROKEN_CPO_LOOKUP
+        CPP_broken_friend_member
+        friend constexpr auto iter_move(counted_iterator const & i) noexcept(
+            detail::has_nothrow_iter_move_v<I>)
+            -> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)( //
+                requires input_iterator<I>)
+        {
+            return ranges::iter_move(i.current_);
+        }
+        template<typename I2, typename S2>
+        friend constexpr auto iter_swap(counted_iterator const & x,
+                                        counted_iterator<I2> const & y) //
+            noexcept(is_nothrow_indirectly_swappable<I, I2>::value)
+                -> CPP_broken_friend_ret(void)( //
+                    requires indirectly_swappable<I2, I>)
+        {
+            return ranges::iter_swap(x.current_, _counted_iterator_::access::current(y));
+        }
+#endif
+    };
+
+    /// \cond
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _counted_iterator_
+    {
+        template<typename I>
+        constexpr auto iter_move(counted_iterator<I> const & i) noexcept(
+            detail::has_nothrow_iter_move_v<I>)
+            -> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)( //
+                requires input_iterator<I>)
+        {
+            return ranges::iter_move(_counted_iterator_::access::current(i));
+        }
+        template<typename I1, typename I2>
+        constexpr auto iter_swap(
+            counted_iterator<I1> const & x,
+            counted_iterator<I2> const &
+                y) noexcept(is_nothrow_indirectly_swappable<I1, I2>::value)
+            -> CPP_broken_friend_ret(void)( //
+                requires indirectly_swappable<I2, I1>)
+        {
+            return ranges::iter_swap(_counted_iterator_::access::current(x),
+                                     _counted_iterator_::access::current(y));
+        }
+    } // namespace _counted_iterator_
+#endif
+    /// endcond
+
+    template<typename I1, typename I2>
+    constexpr auto operator==(counted_iterator<I1> const & x,
+                              counted_iterator<I2> const & y) -> CPP_ret(bool)( //
+        requires common_with<I1, I2>)
+    {
+        return x.count() == y.count();
+    }
+
+    template<typename I>
+    constexpr bool operator==(counted_iterator<I> const & x, default_sentinel_t)
+    {
+        return x.count() == 0;
+    }
+
+    template<typename I>
+    constexpr bool operator==(default_sentinel_t, counted_iterator<I> const & x)
+    {
+        return x.count() == 0;
+    }
+
+    template<typename I1, typename I2>
+    constexpr auto operator!=(counted_iterator<I1> const & x,
+                              counted_iterator<I2> const & y) -> CPP_ret(bool)( //
+        requires common_with<I1, I2>)
+    {
+        return !(x == y);
+    }
+
+    template<typename I>
+    constexpr bool operator!=(counted_iterator<I> const & x, default_sentinel_t y)
+    {
+        return !(x == y);
+    }
+
+    template<typename I>
+    constexpr bool operator!=(default_sentinel_t x, counted_iterator<I> const & y)
+    {
+        return !(x == y);
+    }
+
+    template<typename I1, typename I2>
+    constexpr auto operator<(counted_iterator<I1> const & x,
+                             counted_iterator<I2> const & y) -> CPP_ret(bool)( //
+        requires common_with<I1, I2>)
+    {
+        return y.count() < x.count();
+    }
+
+    template<typename I1, typename I2>
+    constexpr auto operator<=(counted_iterator<I1> const & x,
+                              counted_iterator<I2> const & y) -> CPP_ret(bool)( //
+        requires common_with<I1, I2>)
+    {
+        return !(y < x);
+    }
+
+    template<typename I1, typename I2>
+    constexpr auto operator>(counted_iterator<I1> const & x,
+                             counted_iterator<I2> const & y) -> CPP_ret(bool)( //
+        requires common_with<I1, I2>)
+    {
+        return y < x;
+    }
+
+    template<typename I1, typename I2>
+    constexpr auto operator>=(counted_iterator<I1> const & x,
+                              counted_iterator<I2> const & y) -> CPP_ret(bool)( //
+        requires common_with<I1, I2>)
+    {
+        return !(x < y);
+    }
+
+    template<typename I1, typename I2>
+    constexpr auto operator-(counted_iterator<I1> const & x,
+                             counted_iterator<I2> const & y)
+        -> CPP_ret(iter_difference_t<I2>)( //
+            requires common_with<I1, I2>)
+    {
+        return y.count() - x.count();
+    }
+
+    template<typename I>
+    constexpr iter_difference_t<I> operator-(counted_iterator<I> const & x,
+                                             default_sentinel_t)
+    {
+        return -x.count();
+    }
+
+    template<typename I>
+    constexpr iter_difference_t<I> operator-(default_sentinel_t,
+                                             counted_iterator<I> const & y)
+    {
+        return y.count();
+    }
+
+    template<typename I>
+    constexpr auto operator+(iter_difference_t<I> n, counted_iterator<I> const & x)
+        -> CPP_ret(counted_iterator<I>)( //
+            requires random_access_iterator<I>)
+    {
+        return x + n;
+    }
+
+    template<typename I>
+    constexpr auto make_counted_iterator(I i, iter_difference_t<I> n)
+        -> CPP_ret(counted_iterator<I>)( //
+            requires input_or_output_iterator<I>)
+    {
+        return {std::move(i), n};
+    }
+
+    template<typename I>
+    struct readable_traits<counted_iterator<I>>
+      : detail::if_then_t<(bool)readable<I>, readable_traits<I>, meta::nil_>
+    {};
+
+    template<typename I>
+    constexpr auto advance_fn::operator()(counted_iterator<I> & i,
+                                          iter_difference_t<I> n) const
+        -> CPP_ret(void)( //
+            requires input_or_output_iterator<I>)
+    {
+        RANGES_EXPECT(n <= i.cnt_);
+        advance(i.current_, n);
+        i.cnt_ -= n;
+    }
+
+    namespace cpp20
+    {
+        using ranges::counted_iterator;
+    }
+    /// @}
+} // namespace ranges
+
+/// \cond
+namespace ranges
+{
+    namespace _counted_iterator_
+    {
+        template<typename I, typename = void>
+        struct iterator_traits_
+        {
+            using difference_type = iter_difference_t<I>;
+            using value_type = void;
+            using reference = void;
+            using pointer = void;
+            using iterator_category = std::output_iterator_tag;
+        };
+
+        template<typename I>
+        struct iterator_traits_<I, meta::if_c<input_iterator<I>>>
+          : std::iterator_traits<I>
+        {
+            using pointer = void;
+        };
+    } // namespace _counted_iterator_
+} // namespace ranges
+
+namespace std
+{
+    template<typename I>
+    struct iterator_traits<::ranges::counted_iterator<I>>
+      : ::ranges::_counted_iterator_::iterator_traits_<I>
+    {};
+} // namespace std
+/// \endcond
+
+#endif
diff --git a/inst/include/range/v3/iterator/default_sentinel.hpp b/inst/include/range/v3/iterator/default_sentinel.hpp
new file mode 100644
index 0000000..b62e931
--- /dev/null
+++ b/inst/include/range/v3/iterator/default_sentinel.hpp
@@ -0,0 +1,37 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_DEFAULT_SENTINEL_HPP
+#define RANGES_V3_ITERATOR_DEFAULT_SENTINEL_HPP
+
+#include <range/v3/detail/config.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+    struct default_sentinel_t
+    {};
+
+    // Default sentinel
+    RANGES_INLINE_VARIABLE(default_sentinel_t, default_sentinel)
+
+    namespace cpp20
+    {
+        using ranges::default_sentinel;
+        using ranges::default_sentinel_t;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/iterator/diffmax_t.hpp b/inst/include/range/v3/iterator/diffmax_t.hpp
new file mode 100644
index 0000000..27a293f
--- /dev/null
+++ b/inst/include/range/v3/iterator/diffmax_t.hpp
@@ -0,0 +1,461 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2019-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_DIFFMAX_T_HPP
+#define RANGES_V3_ITERATOR_DIFFMAX_T_HPP
+
+#include <cstdint>
+#include <iosfwd>
+#include <limits>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        struct diffmax_t
+        {
+        private:
+            bool neg_;
+            std::uintmax_t val_;
+            struct tag
+            {};
+
+            constexpr diffmax_t(tag, bool neg, std::uintmax_t val)
+              : neg_(val && neg)
+              , val_(val)
+            {}
+
+            /// \cond
+            constexpr void _check()
+            {
+                RANGES_ENSURE(!neg_ || val_);
+            }
+            static constexpr diffmax_t _normalize(bool neg, std::uintmax_t val)
+            {
+                return diffmax_t{tag{}, val && neg, val};
+            }
+            /// \endcond
+
+        public:
+            diffmax_t() = default;
+
+            template<typename T>
+            constexpr CPP_ctor(diffmax_t)(T val)(noexcept(true) //
+                                                 requires integral<T>)
+              : neg_(0 > val)
+              , val_(0 > val ? static_cast<std::uintmax_t>(-val)
+                             : static_cast<std::uintmax_t>(val))
+            {}
+
+            friend constexpr bool operator<(diffmax_t a, diffmax_t b) noexcept
+            {
+                a._check();
+                b._check();
+                return a.neg_ ? (b.neg_ ? a.val_ > b.val_ : true)
+                              : (b.neg_ ? false : a.val_ < b.val_);
+            }
+            friend constexpr bool operator>(diffmax_t a, diffmax_t b) noexcept
+            {
+                return b < a;
+            }
+            friend constexpr bool operator<=(diffmax_t a, diffmax_t b) noexcept
+            {
+                return !(b < a);
+            }
+            friend constexpr bool operator>=(diffmax_t a, diffmax_t b) noexcept
+            {
+                return !(a < b);
+            }
+            friend constexpr bool operator==(diffmax_t a, diffmax_t b) noexcept
+            {
+                a._check();
+                b._check();
+                return a.val_ == b.val_ && a.neg_ == b.neg_;
+            }
+            friend constexpr bool operator!=(diffmax_t a, diffmax_t b) noexcept
+            {
+                return !(a == b);
+            }
+
+            friend constexpr diffmax_t operator+(diffmax_t a) noexcept
+            {
+                return a;
+            }
+            friend constexpr diffmax_t operator-(diffmax_t a) noexcept
+            {
+                return _normalize(!a.neg_, a.val_);
+            }
+
+            friend constexpr diffmax_t operator+(diffmax_t a, diffmax_t b) noexcept
+            {
+                return a.neg_ == b.neg_
+                           ? diffmax_t{tag{}, a.neg_, a.val_ + b.val_}
+                           : (a.neg_ ? (a.val_ > b.val_
+                                            ? diffmax_t{tag{}, true, a.val_ - b.val_}
+                                            : diffmax_t{tag{}, false, b.val_ - a.val_})
+                                     : (b.val_ > a.val_
+                                            ? diffmax_t{tag{}, true, b.val_ - a.val_}
+                                            : diffmax_t{tag{}, false, a.val_ - b.val_}));
+            }
+            friend constexpr diffmax_t operator-(diffmax_t a, diffmax_t b) noexcept
+            {
+                return a + -b;
+            }
+            friend constexpr diffmax_t operator*(diffmax_t a, diffmax_t b) noexcept
+            {
+                return _normalize(a.neg_ ^ b.neg_, a.val_ * b.val_);
+            }
+            friend constexpr diffmax_t operator/(diffmax_t a, diffmax_t b) noexcept
+            {
+                return _normalize(a.neg_ ^ b.neg_, a.val_ / b.val_);
+            }
+            friend constexpr diffmax_t operator%(diffmax_t a, diffmax_t b) noexcept
+            {
+                return _normalize(a.neg_, a.val_ % b.val_);
+            }
+            static constexpr std::uintmax_t compl_if(bool neg,
+                                                     std::uintmax_t val) noexcept
+            {
+                return neg ? ~val + 1 : val;
+            }
+            friend constexpr diffmax_t operator&(diffmax_t a, diffmax_t b) noexcept
+            {
+                return _normalize(
+                    a.neg_ && b.neg_,
+                    compl_if(a.neg_ && b.neg_,
+                             compl_if(a.neg_, a.val_) & compl_if(b.neg_, b.val_)));
+            }
+            friend constexpr diffmax_t operator|(diffmax_t a, diffmax_t b) noexcept
+            {
+                return _normalize(
+                    a.neg_ || b.neg_,
+                    compl_if(a.neg_ || b.neg_,
+                             compl_if(a.neg_, a.val_) | compl_if(b.neg_, b.val_)));
+            }
+            friend constexpr diffmax_t operator^(diffmax_t a, diffmax_t b) noexcept
+            {
+                return _normalize(
+                    bool(a.neg_ ^ b.neg_),
+                    compl_if(bool(a.neg_ ^ b.neg_),
+                             compl_if(a.neg_, a.val_) ^ compl_if(b.neg_, b.val_)));
+            }
+
+            friend constexpr diffmax_t operator<<(diffmax_t a, diffmax_t b) noexcept
+            {
+                RANGES_ENSURE(!a.neg_);
+                return b.neg_ ? diffmax_t{tag{}, false, a.val_ >> b.val_}
+                              : diffmax_t{tag{}, false, a.val_ << b.val_};
+            }
+            friend constexpr diffmax_t operator>>(diffmax_t a, diffmax_t b) noexcept
+            {
+                return b.neg_ ? diffmax_t{tag{}, a.neg_, a.val_ << b.val_}
+                              : diffmax_t{tag{}, a.neg_, a.val_ >> b.val_};
+            }
+
+            friend constexpr diffmax_t & operator+=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a + b);
+            }
+            friend constexpr diffmax_t & operator-=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a - b);
+            }
+            friend constexpr diffmax_t & operator*=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a * b);
+            }
+            friend constexpr diffmax_t & operator/=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a / b);
+            }
+            friend constexpr diffmax_t & operator%=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a % b);
+            }
+            friend constexpr diffmax_t & operator&=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a & b);
+            }
+            friend constexpr diffmax_t & operator|=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a | b);
+            }
+            friend constexpr diffmax_t & operator^=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                return (a = a ^ b);
+            }
+            friend constexpr diffmax_t & operator<<=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                a = (a << b);
+                return a;
+            }
+            friend constexpr diffmax_t & operator>>=(diffmax_t & a, diffmax_t b) noexcept
+            {
+                a = (a >> b);
+                return a;
+            }
+
+            template<typename T>
+            friend constexpr auto operator+=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} + b));
+            }
+            template<typename T>
+            friend constexpr auto operator-=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} - b));
+            }
+            template<typename T>
+            friend constexpr auto operator*=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} * b));
+            }
+            template<typename T>
+            friend constexpr auto operator/=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} / b));
+            }
+            template<typename T>
+            friend constexpr auto operator%=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} % b));
+            }
+            template<typename T>
+            friend constexpr auto operator&=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} & b));
+            }
+            template<typename T>
+            friend constexpr auto operator|=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} | b));
+            }
+            template<typename T>
+            friend constexpr auto operator^=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                return (a = static_cast<T>(diffmax_t{a} ^ b));
+            }
+            template<typename T>
+            friend constexpr auto operator<<=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                a = static_cast<T>(diffmax_t{a} << b);
+                return a;
+            }
+            template<typename T>
+            friend constexpr auto operator>>=(T & a, diffmax_t b) noexcept
+                -> CPP_broken_friend_ret(T &)( //
+                    requires integral<T>)
+            {
+                a = static_cast<T>(diffmax_t{a} >> b);
+                return a;
+            }
+
+            friend constexpr diffmax_t & operator++(diffmax_t & a) noexcept
+            {
+                a.neg_ = (a.neg_ ? --a.val_ : ++a.val_) && a.neg_;
+                return a;
+            }
+            friend constexpr diffmax_t & operator--(diffmax_t & a) noexcept
+            {
+                a.neg_ = (a.neg_ ? ++a.val_ : --a.val_) && a.neg_;
+                return a;
+            }
+            friend constexpr diffmax_t operator++(diffmax_t & a, int) noexcept
+            {
+                auto tmp = a;
+                ++a;
+                return tmp;
+            }
+            friend constexpr diffmax_t operator--(diffmax_t & a, int) noexcept
+            {
+                auto tmp = a;
+                --a;
+                return tmp;
+            }
+
+            CPP_template(typename T)( //
+                requires integral<T>) //
+                explicit constexpr
+                operator T() const noexcept
+            {
+                return neg_ ? -static_cast<T>(val_) : static_cast<T>(val_);
+            }
+            explicit constexpr operator bool() const noexcept
+            {
+                return val_ != 0;
+            }
+            constexpr bool operator!() const noexcept
+            {
+                return val_ == 0;
+            }
+
+            template<typename Ostream>
+            friend auto operator<<(Ostream & sout, diffmax_t a)
+                -> CPP_broken_friend_ret(std::ostream &)( //
+                    requires derived_from<
+                        Ostream, std::basic_ostream<typename Ostream::char_type,
+                                                    typename Ostream::traits_type>>)
+            {
+                return sout << (&"-"[!a.neg_]) << a.val_;
+            }
+        };
+
+        template<>
+        RANGES_INLINE_VAR constexpr bool _is_integer_like_<diffmax_t> = true;
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+/// \cond
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+
+namespace std
+{
+    template<>
+    struct numeric_limits<::ranges::detail::diffmax_t>
+    {
+        static constexpr bool is_specialized = true;
+        static constexpr bool is_signed = true;
+        static constexpr bool is_integer = true;
+        static constexpr bool is_exact = true;
+        static constexpr bool has_infinity = false;
+        static constexpr bool has_quiet_NaN = false;
+        static constexpr bool has_signaling_NaN = false;
+        static constexpr bool has_denorm = false;
+        static constexpr bool has_denorm_loss = false;
+        static constexpr std::float_round_style round_style = std::round_toward_zero;
+        static constexpr bool is_iec559 = false;
+        static constexpr bool is_bounded = true;
+        static constexpr bool is_modulo = false;
+        static constexpr int digits = CHAR_BIT * sizeof(std::uintmax_t) + 1;
+        static constexpr int digits10 =
+            static_cast<int>(digits * 0.301029996); // digits * std::log10(2)
+        static constexpr int max_digits10 = 0;
+        static constexpr int radix = 2;
+        static constexpr int min_exponent = 0;
+        static constexpr int min_exponent10 = 0;
+        static constexpr int max_exponent = 0;
+        static constexpr int max_exponent10 = 0;
+        static constexpr bool traps = true;
+        static constexpr bool tinyness_before = false;
+
+        static constexpr ::ranges::detail::diffmax_t max() noexcept
+        {
+            return std::uintmax_t(-1);
+        }
+        static constexpr ::ranges::detail::diffmax_t min() noexcept
+        {
+            return -max();
+        }
+        static constexpr ::ranges::detail::diffmax_t lowest() noexcept
+        {
+            return min();
+        }
+        static constexpr ::ranges::detail::diffmax_t epsilon() noexcept
+        {
+            return 0;
+        }
+        static constexpr ::ranges::detail::diffmax_t round_error() noexcept
+        {
+            return 0;
+        }
+        static constexpr ::ranges::detail::diffmax_t infinity() noexcept
+        {
+            return 0;
+        }
+        static constexpr ::ranges::detail::diffmax_t quiet_NaN() noexcept
+        {
+            return 0;
+        }
+        static constexpr ::ranges::detail::diffmax_t signaling_NaN() noexcept
+        {
+            return 0;
+        }
+        static constexpr ::ranges::detail::diffmax_t denorm_min() noexcept
+        {
+            return 0;
+        }
+    };
+    template<>
+    struct numeric_limits<::ranges::detail::diffmax_t const>
+      : numeric_limits<::ranges::detail::diffmax_t>
+    {};
+    template<>
+    struct numeric_limits<::ranges::detail::diffmax_t volatile>
+      : numeric_limits<::ranges::detail::diffmax_t>
+    {};
+    template<>
+    struct numeric_limits<::ranges::detail::diffmax_t const volatile>
+      : numeric_limits<::ranges::detail::diffmax_t>
+    {};
+
+#if RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_specialized;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_signed;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_integer;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_exact;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_infinity;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_quiet_NaN;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_signaling_NaN;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_denorm;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_denorm_loss;
+    inline constexpr std::float_round_style
+        numeric_limits<::ranges::detail::diffmax_t>::round_style;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_iec559;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_bounded;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_modulo;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::digits;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::digits10;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::max_digits10;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::radix;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::min_exponent;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::min_exponent10;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::max_exponent;
+    inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::max_exponent10;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::traps;
+    inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::tinyness_before;
+#endif
+} // namespace std
+
+RANGES_DIAGNOSTIC_POP
+/// \endcond
+
+#endif
diff --git a/inst/include/range/v3/iterator/insert_iterators.hpp b/inst/include/range/v3/iterator/insert_iterators.hpp
new file mode 100644
index 0000000..faca2b3
--- /dev/null
+++ b/inst/include/range/v3/iterator/insert_iterators.hpp
@@ -0,0 +1,209 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_INSERT_ITERATORS_HPP
+#define RANGES_V3_ITERATOR_INSERT_ITERATORS_HPP
+
+#include <cstddef>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/utility/addressof.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+    template<typename Container>
+    struct back_insert_iterator
+    {
+        using container_type = Container;
+        using difference_type = std::ptrdiff_t;
+
+        constexpr back_insert_iterator() = default;
+        explicit constexpr back_insert_iterator(Container & x)
+          : container_(detail::addressof(x))
+        {}
+        back_insert_iterator & operator=(typename Container::value_type const & value)
+        {
+            container_->push_back(value);
+            return *this;
+        }
+        back_insert_iterator & operator=(typename Container::value_type && value)
+        {
+            container_->push_back(std::move(value));
+            return *this;
+        }
+        back_insert_iterator & operator*()
+        {
+            return *this;
+        }
+        back_insert_iterator & operator++()
+        {
+            return *this;
+        }
+        back_insert_iterator operator++(int)
+        {
+            return *this;
+        }
+
+    private:
+        Container * container_ = nullptr;
+    };
+
+    struct back_inserter_fn
+    {
+        template<typename Container>
+        constexpr back_insert_iterator<Container> operator()(Container & x) const
+        {
+            return back_insert_iterator<Container>{x};
+        }
+    };
+
+    /// \sa `back_inserter_fn`
+    RANGES_INLINE_VARIABLE(back_inserter_fn, back_inserter)
+
+    template<typename Container>
+    struct front_insert_iterator
+    {
+        using container_type = Container;
+        using difference_type = std::ptrdiff_t;
+
+        constexpr front_insert_iterator() = default;
+        explicit constexpr front_insert_iterator(Container & x)
+          : container_(detail::addressof(x))
+        {}
+        front_insert_iterator & operator=(typename Container::value_type const & value)
+        {
+            container_->push_front(value);
+            return *this;
+        }
+        front_insert_iterator & operator=(typename Container::value_type && value)
+        {
+            container_->push_front(std::move(value));
+            return *this;
+        }
+        front_insert_iterator & operator*()
+        {
+            return *this;
+        }
+        front_insert_iterator & operator++()
+        {
+            return *this;
+        }
+        front_insert_iterator operator++(int)
+        {
+            return *this;
+        }
+
+    private:
+        Container * container_ = nullptr;
+    };
+
+    struct front_inserter_fn
+    {
+        template<typename Cont>
+        constexpr front_insert_iterator<Cont> operator()(Cont & cont) const
+        {
+            return front_insert_iterator<Cont>{cont};
+        }
+    };
+
+    /// \sa `front_inserter_fn`
+    RANGES_INLINE_VARIABLE(front_inserter_fn, front_inserter)
+
+    template<typename Container>
+    struct insert_iterator
+    {
+        using container_type = Container;
+        using difference_type = std::ptrdiff_t;
+
+        constexpr insert_iterator() = default;
+        explicit constexpr insert_iterator(Container & x, typename Container::iterator w)
+          : container_(detail::addressof(x))
+          , where_(w)
+        {}
+        insert_iterator & operator=(typename Container::value_type const & value)
+        {
+            where_ = ranges::next(container_->insert(where_, value));
+            return *this;
+        }
+        insert_iterator & operator=(typename Container::value_type && value)
+        {
+            where_ = ranges::next(container_->insert(where_, std::move(value)));
+            return *this;
+        }
+        insert_iterator & operator*()
+        {
+            return *this;
+        }
+        insert_iterator & operator++()
+        {
+            return *this;
+        }
+        insert_iterator & operator++(int)
+        {
+            return *this;
+        }
+
+    private:
+        Container * container_ = nullptr;
+        typename Container::iterator where_ = typename Container::iterator();
+    };
+
+    struct inserter_fn
+    {
+        template<typename Cont>
+        constexpr insert_iterator<Cont> operator()(Cont & cont,
+                                                   typename Cont::iterator where) const
+        {
+            return insert_iterator<Cont>{cont, std::move(where)};
+        }
+    };
+
+    /// \sa `inserter_fn`
+    RANGES_INLINE_VARIABLE(inserter_fn, inserter)
+
+    namespace cpp20
+    {
+        using ranges::back_insert_iterator;
+        using ranges::back_inserter;
+        using ranges::front_insert_iterator;
+        using ranges::front_inserter;
+        using ranges::insert_iterator;
+        using ranges::inserter;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+/// \cond
+namespace std
+{
+    template<typename Container>
+    struct iterator_traits<::ranges::back_insert_iterator<Container>>
+      : ::ranges::detail::std_output_iterator_traits<>
+    {};
+
+    template<typename Container>
+    struct iterator_traits<::ranges::front_insert_iterator<Container>>
+      : ::ranges::detail::std_output_iterator_traits<>
+    {};
+
+    template<typename Container>
+    struct iterator_traits<::ranges::insert_iterator<Container>>
+      : ::ranges::detail::std_output_iterator_traits<>
+    {};
+} // namespace std
+/// \endcond
+#endif // RANGES_V3_ITERATOR_INSERT_ITERATORS_HPP
diff --git a/inst/include/range/v3/iterator/move_iterators.hpp b/inst/include/range/v3/iterator/move_iterators.hpp
new file mode 100644
index 0000000..a57594a
--- /dev/null
+++ b/inst/include/range/v3/iterator/move_iterators.hpp
@@ -0,0 +1,424 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_MOVE_ITERATORS_HPP
+#define RANGES_V3_ITERATOR_MOVE_ITERATORS_HPP
+
+#include <cstddef>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/basic_iterator.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+    template<typename I>
+    struct move_iterator
+    {
+    private:
+        CPP_assert(input_iterator<I>);
+        I current_ = I{};
+
+    public:
+        using iterator_type = I;
+        using difference_type = iter_difference_t<I>;
+        using value_type = iter_value_t<I>;
+        using iterator_category = std::input_iterator_tag;
+        using reference = iter_rvalue_reference_t<I>;
+
+        constexpr move_iterator() = default;
+        explicit move_iterator(I i)
+          : current_(i)
+        {}
+        template<typename O>
+        CPP_ctor(move_iterator)(move_iterator<O> const & i)( //
+            requires convertible_to<O, I>)
+          : current_(i.base())
+        {}
+        template<typename O>
+        auto operator=(move_iterator<O> const & i) -> CPP_ret(move_iterator &)( //
+            requires convertible_to<O, I>)
+        {
+            current_ = i.base();
+            return *this;
+        }
+        I base() const
+        {
+            return current_;
+        }
+        // clang-format off
+        auto CPP_auto_fun(operator*)()(const)
+        (
+            return iter_move(current_)
+        )
+            // clang-format on
+            move_iterator &
+            operator++()
+        {
+            ++current_;
+            return *this;
+        }
+        CPP_member
+        auto operator++(int) -> CPP_ret(void)( //
+            requires(!forward_iterator<I>))
+        {
+            ++current_;
+        }
+        CPP_member
+        auto operator++(int) -> CPP_ret(move_iterator)( //
+            requires forward_iterator<I>)
+        {
+            return move_iterator(current_++);
+        }
+        CPP_member
+        auto operator--() -> CPP_ret(move_iterator &)( //
+            requires forward_iterator<I>)
+        {
+            --current_;
+            return *this;
+        }
+        CPP_member
+        auto operator--(int) -> CPP_ret(move_iterator)( //
+            requires bidirectional_iterator<I>)
+        {
+            return move_iterator(current_--);
+        }
+        CPP_member
+        auto operator+(difference_type n) const -> CPP_ret(move_iterator)( //
+            requires random_access_iterator<I>)
+        {
+            return move_iterator(current_ + n);
+        }
+        CPP_member
+        auto operator+=(difference_type n) -> CPP_ret(move_iterator &)( //
+            requires random_access_iterator<I>)
+        {
+            current_ += n;
+            return *this;
+        }
+        CPP_member
+        auto operator-(difference_type n) const -> CPP_ret(move_iterator)( //
+            requires random_access_iterator<I>)
+        {
+            return move_iterator(current_ - n);
+        }
+        CPP_member
+        auto operator-=(difference_type n) -> CPP_ret(move_iterator &)( //
+            requires random_access_iterator<I>)
+        {
+            current_ -= n;
+            return *this;
+        }
+        CPP_member
+        auto operator[](difference_type n) const -> CPP_ret(reference)( //
+            requires random_access_iterator<I>)
+        {
+            return iter_move(current_ + n);
+        }
+
+        template<typename I2>
+        friend auto operator==(move_iterator const & x, move_iterator<I2> const & y)
+            -> CPP_broken_friend_ret(bool)( //
+                requires equality_comparable_with<I, I2>)
+        {
+            return x.base() == y.base();
+        }
+        template<typename I2>
+        friend auto operator!=(move_iterator const & x, move_iterator<I2> const & y)
+            -> CPP_broken_friend_ret(bool)( //
+                requires equality_comparable_with<I, I2>)
+        {
+            return !(x == y);
+        }
+        template<typename I2>
+        friend auto operator<(move_iterator const & x, move_iterator<I2> const & y)
+            -> CPP_broken_friend_ret(bool)( //
+                requires totally_ordered_with<I, I2>)
+        {
+            return x.base() < y.base();
+        }
+        template<typename I2>
+        friend auto operator<=(move_iterator const & x, move_iterator<I2> const & y)
+            -> CPP_broken_friend_ret(bool)( //
+                requires totally_ordered_with<I, I2>)
+        {
+            return !(y < x);
+        }
+        template<typename I2>
+        friend auto operator>(move_iterator const & x, move_iterator<I2> const & y)
+            -> CPP_broken_friend_ret(bool)( //
+                requires totally_ordered_with<I, I2>)
+        {
+            return y < x;
+        }
+        template<typename I2>
+        friend auto operator>=(move_iterator const & x, move_iterator<I2> const & y)
+            -> CPP_broken_friend_ret(bool)( //
+                requires totally_ordered_with<I, I2>)
+        {
+            return !(x < y);
+        }
+
+        template<typename I2>
+        friend auto operator-(move_iterator const & x, move_iterator<I2> const & y)
+            -> CPP_broken_friend_ret(iter_difference_t<I2>)( //
+                requires sized_sentinel_for<I, I2>)
+        {
+            return x.base() - y.base();
+        }
+        CPP_broken_friend_member
+        friend auto operator+(iter_difference_t<I> n,
+                              move_iterator const & x)
+            -> CPP_broken_friend_ret(move_iterator)( //
+                requires random_access_iterator<I>)
+        {
+            return x + n;
+        }
+    };
+
+    struct make_move_iterator_fn
+    {
+        template<typename I>
+        constexpr auto operator()(I it) const -> CPP_ret(move_iterator<I>)( //
+            requires input_iterator<I>)
+        {
+            return move_iterator<I>{detail::move(it)};
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(make_move_iterator_fn, make_move_iterator)
+
+    template<typename S>
+    struct move_sentinel
+    {
+    private:
+        S sent_;
+
+    public:
+        constexpr move_sentinel()
+          : sent_{}
+        {}
+        constexpr explicit move_sentinel(S s)
+          : sent_(detail::move(s))
+        {}
+        template<typename OS>
+        constexpr explicit CPP_ctor(move_sentinel)(move_sentinel<OS> const & that)( //
+            requires convertible_to<OS, S>)
+          : sent_(that.base())
+        {}
+        template<typename OS>
+        auto operator=(move_sentinel<OS> const & that) -> CPP_ret(move_sentinel &)( //
+            requires convertible_to<OS, S>)
+        {
+            sent_ = that.base();
+            return *this;
+        }
+        S base() const
+        {
+            return sent_;
+        }
+
+        template<typename I>
+        friend auto operator==(move_iterator<I> const & i, move_sentinel const & s)
+            -> CPP_broken_friend_ret(bool)( //
+                requires sentinel_for<S, I>)
+        {
+            return i.base() == s.base();
+        }
+        template<typename I>
+        friend auto operator==(move_sentinel const & s, move_iterator<I> const & i)
+            -> CPP_broken_friend_ret(bool)( //
+                requires sentinel_for<S, I>)
+        {
+            return s.base() == i.base();
+        }
+        template<typename I>
+        friend auto operator!=(move_iterator<I> const & i, move_sentinel const & s)
+            -> CPP_broken_friend_ret(bool)( //
+                requires sentinel_for<S, I>)
+        {
+            return i.base() != s.base();
+        }
+        template<typename I>
+        friend auto operator!=(move_sentinel const & s, move_iterator<I> const & i)
+            -> CPP_broken_friend_ret(bool)( //
+                requires sentinel_for<S, I>)
+        {
+            return s.base() != i.base();
+        }
+    };
+
+    struct make_move_sentinel_fn
+    {
+        template<typename I>
+        constexpr auto operator()(I i) const -> CPP_ret(move_iterator<I>)( //
+            requires input_iterator<I>)
+        {
+            return move_iterator<I>{detail::move(i)};
+        }
+
+        template<typename S>
+        constexpr auto operator()(S s) const -> CPP_ret(move_sentinel<S>)( //
+            requires semiregular<S> && (!input_iterator<S>))
+        {
+            return move_sentinel<S>{detail::move(s)};
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(make_move_sentinel_fn, make_move_sentinel)
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, bool IsReadable>
+        struct move_into_cursor_types_
+        {};
+
+        template<typename I>
+        struct move_into_cursor_types_<I, true>
+        {
+            using value_type = iter_value_t<I>;
+            using single_pass = meta::bool_<(bool)single_pass_iterator_<I>>;
+        };
+
+        template<typename I>
+        using move_into_cursor_types = move_into_cursor_types_<I, (bool)readable<I>>;
+
+        template<typename I>
+        struct move_into_cursor : move_into_cursor_types<I>
+        {
+        private:
+            friend range_access;
+            struct mixin : basic_mixin<move_into_cursor>
+            {
+                mixin() = default;
+                using basic_mixin<move_into_cursor>::basic_mixin;
+                explicit mixin(I it)
+                  : mixin{move_into_cursor{std::move(it)}}
+                {}
+                I base() const
+                {
+                    return this->get().it_;
+                }
+            };
+
+            I it_ = I();
+
+            explicit move_into_cursor(I it)
+              : it_(std::move(it))
+            {}
+            void next()
+            {
+                ++it_;
+            }
+            template<typename T>
+            auto write(T && t) noexcept(noexcept(*it_ = std::move(t)))
+                -> CPP_ret(void)( //
+                    requires writable<I, aux::move_t<T>>)
+            {
+                *it_ = std::move(t);
+            }
+            template<typename T>
+            auto write(T && t) const noexcept(noexcept(*it_ = std::move(t)))
+                -> CPP_ret(void)( //
+                    requires writable<I, aux::move_t<T>>)
+            {
+                *it_ = std::move(t);
+            }
+            CPP_member
+            auto read() const noexcept(noexcept(*std::declval<I const &>()))
+                -> CPP_ret(iter_reference_t<I>)( //
+                    requires readable<I>)
+            {
+                return *it_;
+            }
+            CPP_member
+            auto equal(move_into_cursor const & that) const -> CPP_ret(bool)( //
+                requires input_iterator<I>)
+            {
+                return it_ == that.it_;
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires bidirectional_iterator<I>)
+            {
+                --it_;
+            }
+            CPP_member
+            auto advance(iter_difference_t<I> n) -> CPP_ret(void)( //
+                requires random_access_iterator<I>)
+            {
+                it_ += n;
+            }
+            CPP_member
+            auto distance_to(move_into_cursor const & that) const
+                -> CPP_ret(iter_difference_t<I>)( //
+                    requires sized_sentinel_for<I, I>)
+            {
+                return that.it_ - it_;
+            }
+            template<typename II = I const>
+            constexpr auto move() const noexcept(has_nothrow_iter_move_v<II>)
+                -> CPP_ret(iter_rvalue_reference_t<II>)( //
+                    requires same_as<I const, II> && readable<II>)
+            {
+                return iter_move(it_);
+            }
+
+        public:
+            constexpr move_into_cursor() = default;
+        };
+    } // namespace detail
+    /// \endcond
+
+    struct move_into_fn
+    {
+        template<typename I>
+        constexpr move_into_iterator<I> operator()(I it) const
+        {
+            return move_into_iterator<I>{std::move(it)};
+        }
+    };
+
+    /// \sa `move_into_fn`
+    RANGES_INLINE_VARIABLE(move_into_fn, move_into)
+
+    namespace cpp20
+    {
+        using ranges::make_move_iterator;
+        using ranges::move_iterator;
+        using ranges::move_sentinel;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+/// \cond
+namespace std
+{
+    template<typename I>
+    struct iterator_traits<::ranges::move_iterator<I>>
+    {
+        using iterator_category = std::input_iterator_tag;
+        using difference_type = typename ::ranges::move_iterator<I>::difference_type;
+        using value_type = typename ::ranges::move_iterator<I>::value_type;
+        using reference = typename ::ranges::move_iterator<I>::reference;
+        using pointer = meta::_t<std::add_pointer<reference>>;
+    };
+} // namespace std
+/// \endcond
+
+#endif // RANGES_V3_ITERATOR_MOVE_ITERATORS_HPP
diff --git a/inst/include/range/v3/iterator/operations.hpp b/inst/include/range/v3/iterator/operations.hpp
new file mode 100644
index 0000000..f1cc010
--- /dev/null
+++ b/inst/include/range/v3/iterator/operations.hpp
@@ -0,0 +1,655 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_OPERATIONS_HPP
+#define RANGES_V3_ITERATOR_OPERATIONS_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    /// \cond
+    CPP_template(typename I)(                 //
+        requires input_or_output_iterator<I>) //
+        struct counted_iterator;
+    /// \endcond
+
+    struct advance_fn
+    {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+        template<typename I>
+        constexpr auto operator()(I & i, iter_difference_t<I> n) const
+            -> CPP_ret(void)( //
+                requires input_or_output_iterator<I>)
+        // [[expects: n >= 0 || bidirectional_iterator<I>]]
+        {
+            if constexpr(random_access_iterator<I>)
+            {
+                i += n;
+            }
+            else
+            {
+                if constexpr(bidirectional_iterator<I>)
+                    for(; 0 > n; ++n)
+                        --i;
+                RANGES_EXPECT(0 <= n);
+                for(; 0 < n; --n)
+                    ++i;
+            }
+        }
+
+        template<typename I, typename S>
+        constexpr auto operator()(I & i, S bound) const -> CPP_ret(void)( //
+            requires sentinel_for<S, I>)
+        // [[expects axiom: reachable(i, bound)]]
+        {
+            if constexpr(assignable_from<I &, S>)
+            {
+                i = std::move(bound);
+            }
+            else if constexpr(sized_sentinel_for<S, I>)
+            {
+                iter_difference_t<I> d = bound - i;
+                RANGES_EXPECT(0 <= d);
+                (*this)(i, d);
+            }
+            else
+                while(i != bound)
+                    ++i;
+        }
+
+        template<typename I, typename S>
+        constexpr auto operator()(I & i, iter_difference_t<I> n, S bound) const
+            -> CPP_ret(iter_difference_t<I>)( //
+                requires sentinel_for<S, I>)
+        // [[expects axiom: 0 == n ||
+        //     (0 < n && reachable(i, bound)) ||
+        //     (0 > n && same_as<I, S> && bidirectional_iterator<I> && reachable(bound,
+        //     i))]]
+        {
+            if constexpr(sized_sentinel_for<S, I>)
+            {
+                if(0 == n)
+                    return 0;
+                const auto d = bound - i;
+                if constexpr(bidirectional_iterator<I> && same_as<I, S>)
+                {
+                    RANGES_EXPECT(0 <= n ? 0 <= d : 0 >= d);
+                    if(0 <= n ? d <= n : d >= n)
+                    {
+                        i = std::move(bound);
+                        return n - d;
+                    }
+                }
+                else
+                {
+                    RANGES_EXPECT(0 <= n && 0 <= d);
+                    if(d <= n)
+                    {
+                        (*this)(i, std::move(bound));
+                        return n - d;
+                    }
+                }
+                (*this)(i, n);
+                return 0;
+            }
+            else
+            {
+                if constexpr(bidirectional_iterator<I> && same_as<I, S>)
+                {
+                    if(0 > n)
+                    {
+                        do
+                        {
+                            --i;
+                            ++n;
+                        } while(0 != n && i != bound);
+                        return n;
+                    }
+                }
+                RANGES_EXPECT(0 <= n);
+                while(0 != n && i != bound)
+                {
+                    ++i;
+                    --n;
+                }
+                return n;
+            }
+        }
+#else
+    private:
+        template<typename I>
+        static constexpr void n_(I & i, iter_difference_t<I> n, std::input_iterator_tag);
+        template<typename I>
+        static constexpr void n_(I & i, iter_difference_t<I> n,
+                                 std::bidirectional_iterator_tag);
+        template<typename I>
+        static constexpr void n_(I & i, iter_difference_t<I> n,
+                                 std::random_access_iterator_tag);
+        template<typename I, typename S>
+        static constexpr void to_impl_(I & i, S s, sentinel_tag);
+        template<typename I, typename S>
+        static constexpr void to_impl_(I & i, S s, sized_sentinel_tag);
+        template<typename I, typename S>
+        static constexpr void to_(I & i, S s, std::true_type); // assignable
+        template<typename I, typename S>
+        static constexpr void to_(I & i, S s, std::false_type); // !assignable
+        template<typename I, typename S>
+        static constexpr iter_difference_t<I> bounded_(I & it, iter_difference_t<I> n,
+                                                       S bound, sentinel_tag,
+                                                       std::input_iterator_tag);
+        template<typename I>
+        static constexpr iter_difference_t<I> bounded_(I & it, iter_difference_t<I> n,
+                                                       I bound, sentinel_tag,
+                                                       std::bidirectional_iterator_tag);
+        template<typename I, typename S, typename Concept>
+        static constexpr iter_difference_t<I> bounded_(I & it, iter_difference_t<I> n,
+                                                       S bound, sized_sentinel_tag,
+                                                       Concept);
+
+    public:
+        // Advance a certain number of steps:
+        template<typename I>
+        constexpr auto operator()(I & i, iter_difference_t<I> n) const
+            -> CPP_ret(void)( //
+                requires input_or_output_iterator<I>)
+        {
+            advance_fn::n_(i, n, iterator_tag_of<I>{});
+        }
+        // Advance to a certain position:
+        template<typename I, typename S>
+        constexpr auto operator()(I & i, S s) const -> CPP_ret(void)( //
+            requires sentinel_for<S, I>)
+        {
+            advance_fn::to_(
+                i, static_cast<S &&>(s), meta::bool_<assignable_from<I &, S>>());
+        }
+        // Advance a certain number of times, with a bound:
+        template<typename I, typename S>
+        constexpr auto operator()(I & it, iter_difference_t<I> n, S bound) const
+            -> CPP_ret(iter_difference_t<I>)( //
+                requires sentinel_for<S, I>)
+        {
+            return advance_fn::bounded_(it,
+                                        n,
+                                        static_cast<S &&>(bound),
+                                        sentinel_tag_of<S, I>(),
+                                        iterator_tag_of<I>());
+        }
+#endif
+
+        template<typename I>
+        constexpr auto operator()(counted_iterator<I> & i, iter_difference_t<I> n) const
+            -> CPP_ret(void)( //
+                requires input_or_output_iterator<I>);
+    };
+
+    /// \sa `advance_fn`
+    RANGES_INLINE_VARIABLE(advance_fn, advance)
+
+#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
+    template<typename I>
+    constexpr void advance_fn::n_(I & i, iter_difference_t<I> n, std::input_iterator_tag)
+    {
+        RANGES_EXPECT(n >= 0);
+        for(; n > 0; --n)
+            ++i;
+    }
+    template<typename I>
+    constexpr void advance_fn::n_(I & i, iter_difference_t<I> n,
+                                  std::bidirectional_iterator_tag)
+    {
+        if(n > 0)
+            for(; n > 0; --n)
+                ++i;
+        else
+            for(; n < 0; ++n)
+                --i;
+    }
+    template<typename I>
+    constexpr void advance_fn::n_(I & i, iter_difference_t<I> n,
+                                  std::random_access_iterator_tag)
+    {
+        i += n;
+    }
+    template<typename I, typename S>
+    constexpr void advance_fn::to_impl_(I & i, S s, sentinel_tag)
+    {
+        while(i != s)
+            ++i;
+    }
+    template<typename I, typename S>
+    constexpr void advance_fn::to_impl_(I & i, S s, sized_sentinel_tag)
+    {
+        iter_difference_t<I> d = s - i;
+        RANGES_EXPECT(0 <= d);
+        advance(i, d);
+    }
+    // Advance to a certain position:
+    template<typename I, typename S>
+    constexpr void advance_fn::to_(I & i, S s, std::true_type)
+    {
+        i = static_cast<S &&>(s);
+    }
+    template<typename I, typename S>
+    constexpr void advance_fn::to_(I & i, S s, std::false_type)
+    {
+        advance_fn::to_impl_(i, static_cast<S &&>(s), sentinel_tag_of<S, I>());
+    }
+    template<typename I, typename S>
+    constexpr iter_difference_t<I> advance_fn::bounded_(I & it, iter_difference_t<I> n,
+                                                        S bound, sentinel_tag,
+                                                        std::input_iterator_tag)
+    {
+        RANGES_EXPECT(0 <= n);
+        for(; 0 != n && it != bound; --n)
+            ++it;
+        return n;
+    }
+    template<typename I>
+    constexpr iter_difference_t<I> advance_fn::bounded_(I & it, iter_difference_t<I> n,
+                                                        I bound, sentinel_tag,
+                                                        std::bidirectional_iterator_tag)
+    {
+        if(0 <= n)
+            for(; 0 != n && it != bound; --n)
+                ++it;
+        else
+            for(; 0 != n && it != bound; ++n)
+                --it;
+        return n;
+    }
+    template<typename I, typename S, typename Concept>
+    constexpr iter_difference_t<I> advance_fn::bounded_(I & it, iter_difference_t<I> n,
+                                                        S bound, sized_sentinel_tag,
+                                                        Concept)
+    {
+        RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
+        if(n == 0)
+            return 0;
+        iter_difference_t<I> d = bound - it;
+        RANGES_EXPECT(0 <= n ? 0 <= d : 0 >= d);
+        if(0 <= n ? n >= d : n <= d)
+        {
+            advance(it, static_cast<S &&>(bound));
+            return n - d;
+        }
+        advance(it, n);
+        return 0;
+    }
+#endif
+
+    struct next_fn
+    {
+        template<typename I>
+        constexpr auto operator()(I it) const
+            -> CPP_ret(I)(requires input_or_output_iterator<I>)
+        {
+            return ++it;
+        }
+        template<typename I>
+        constexpr auto operator()(I it, iter_difference_t<I> n) const
+            -> CPP_ret(I)(requires input_or_output_iterator<I>)
+        {
+            advance(it, n);
+            return it;
+        }
+        template<typename I, typename S>
+        constexpr auto operator()(I it, S s) const
+            -> CPP_ret(I)(requires sentinel_for<S, I>)
+        {
+            advance(it, static_cast<S &&>(s));
+            return it;
+        }
+        template<typename I, typename S>
+        constexpr auto operator()(I it, iter_difference_t<I> n, S bound) const
+            -> CPP_ret(I)(requires sentinel_for<S, I>)
+        {
+            advance(it, n, static_cast<S &&>(bound));
+            return it;
+        }
+    };
+
+    /// \sa `next_fn`
+    RANGES_INLINE_VARIABLE(next_fn, next)
+
+    struct prev_fn
+    {
+        template<typename I>
+        constexpr auto operator()(I it) const
+            -> CPP_ret(I)(requires bidirectional_iterator<I>)
+        {
+            return --it;
+        }
+        template<typename I>
+        constexpr auto operator()(I it, iter_difference_t<I> n) const
+            -> CPP_ret(I)(requires bidirectional_iterator<I>)
+        {
+            advance(it, -n);
+            return it;
+        }
+        template<typename I>
+        constexpr auto operator()(I it, iter_difference_t<I> n, I bound) const
+            -> CPP_ret(I)(requires bidirectional_iterator<I>)
+        {
+            advance(it, -n, static_cast<I &&>(bound));
+            return it;
+        }
+    };
+
+    /// \sa `prev_fn`
+    RANGES_INLINE_VARIABLE(prev_fn, prev)
+
+    struct iter_enumerate_fn
+    {
+    private:
+        template<typename I, typename S>
+        static constexpr auto impl_i(I first, S last, sentinel_tag)
+            -> CPP_ret(std::pair<iter_difference_t<I>, I>)( //
+                requires(!sized_sentinel_for<I, I>))
+        {
+            iter_difference_t<I> d = 0;
+            for(; first != last; ++first)
+                ++d;
+            return {d, first};
+        }
+        template<typename I, typename S>
+        static constexpr auto impl_i(I first, S end_, sentinel_tag)
+            -> CPP_ret(std::pair<iter_difference_t<I>, I>)( //
+                requires sized_sentinel_for<I, I>)
+        {
+            I last = ranges::next(first, end_);
+            auto n = static_cast<iter_difference_t<I>>(last - first);
+            RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
+            return {n, last};
+        }
+        template<typename I, typename S>
+        static constexpr std::pair<iter_difference_t<I>, I> impl_i(I first, S last,
+                                                                   sized_sentinel_tag)
+        {
+            auto n = static_cast<iter_difference_t<I>>(last - first);
+            RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
+            return {n, ranges::next(first, last)};
+        }
+
+    public:
+        template<typename I, typename S>
+        constexpr auto operator()(I first, S last) const
+            -> CPP_ret(std::pair<iter_difference_t<I>, I>)( //
+                requires sentinel_for<S, I>)
+        {
+            return iter_enumerate_fn::impl_i(static_cast<I &&>(first),
+                                             static_cast<S &&>(last),
+                                             sentinel_tag_of<S, I>());
+        }
+    };
+
+    /// \sa `iter_enumerate_fn`
+    RANGES_INLINE_VARIABLE(iter_enumerate_fn, iter_enumerate)
+
+    struct iter_distance_fn
+    {
+    private:
+        template<typename I, typename S>
+        static constexpr iter_difference_t<I> impl_i(I first, S last, sentinel_tag)
+        {
+            return iter_enumerate(static_cast<I &&>(first), static_cast<S &&>(last))
+                .first;
+        }
+        template<typename I, typename S>
+        static constexpr iter_difference_t<I> impl_i(I first, S last, sized_sentinel_tag)
+        {
+            auto n = static_cast<iter_difference_t<I>>(last - first);
+            RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
+            return n;
+        }
+
+    public:
+        template<typename I, typename S>
+        constexpr auto operator()(I first, S last) const
+            -> CPP_ret(iter_difference_t<I>)( //
+                requires input_or_output_iterator<I> && sentinel_for<S, I>)
+        {
+            return iter_distance_fn::impl_i(static_cast<I &&>(first),
+                                            static_cast<S &&>(last),
+                                            sentinel_tag_of<S, I>());
+        }
+    };
+
+    /// \sa `iter_distance_fn`
+    RANGES_INLINE_VARIABLE(iter_distance_fn, iter_distance)
+
+    struct iter_distance_compare_fn
+    {
+    private:
+        template<typename I, typename S>
+        static constexpr int impl_i(I first, S last, iter_difference_t<I> n, sentinel_tag)
+        {
+            if(n < 0)
+                return 1;
+            for(; n > 0; --n, ++first)
+            {
+                if(first == last)
+                    return -1;
+            }
+            return first == last ? 0 : 1;
+        }
+        template<typename I, typename S>
+        static constexpr int impl_i(I first, S last, iter_difference_t<I> n,
+                                    sized_sentinel_tag)
+        {
+            iter_difference_t<I> dist = last - first;
+            if(n < dist)
+                return 1;
+            if(dist < n)
+                return -1;
+            return 0;
+        }
+
+    public:
+        template<typename I, typename S>
+        constexpr auto operator()(I first, S last, iter_difference_t<I> n) const
+            -> CPP_ret(int)( //
+                requires input_iterator<I> && sentinel_for<S, I>)
+        {
+            return iter_distance_compare_fn::impl_i(static_cast<I &&>(first),
+                                                    static_cast<S &&>(last),
+                                                    n,
+                                                    sentinel_tag_of<S, I>());
+        }
+    };
+
+    /// \sa `iter_distance_compare_fn`
+    RANGES_INLINE_VARIABLE(iter_distance_compare_fn, iter_distance_compare)
+
+    // Like distance(b,e), but guaranteed to be O(1)
+    struct iter_size_fn
+    {
+        template<typename I, typename S>
+        constexpr auto operator()(I const & first, S last) const
+            -> CPP_ret(meta::_t<std::make_unsigned<iter_difference_t<I>>>)( //
+                requires sized_sentinel_for<S, I>)
+        {
+            using size_type = meta::_t<std::make_unsigned<iter_difference_t<I>>>;
+            iter_difference_t<I> n = last - first;
+            RANGES_EXPECT(0 <= n);
+            return static_cast<size_type>(n);
+        }
+    };
+
+    /// \sa `iter_size_fn`
+    RANGES_INLINE_VARIABLE(iter_size_fn, iter_size)
+
+    /// \cond
+    namespace adl_uncounted_recounted_detail
+    {
+        template<typename I>
+        constexpr I uncounted(I i)
+        {
+            return i;
+        }
+
+        template<typename I>
+        constexpr I recounted(I const &, I i, iter_difference_t<I>)
+        {
+            return i;
+        }
+
+        struct uncounted_fn
+        {
+            template<typename I>
+            constexpr auto operator()(I i) const -> decltype(uncounted((I &&) i))
+            {
+                return uncounted((I &&) i);
+            }
+        };
+
+        struct recounted_fn
+        {
+            template<typename I, typename J>
+            constexpr auto operator()(I i, J j, iter_difference_t<J> n) const
+                -> decltype(recounted((I &&) i, (J &&) j, n))
+            {
+                return recounted((I &&) i, (J &&) j, n);
+            }
+        };
+    } // namespace adl_uncounted_recounted_detail
+    /// \endcond
+
+    RANGES_INLINE_VARIABLE(adl_uncounted_recounted_detail::uncounted_fn, uncounted)
+    RANGES_INLINE_VARIABLE(adl_uncounted_recounted_detail::recounted_fn, recounted)
+
+    struct enumerate_fn : iter_enumerate_fn
+    {
+    private:
+        template<typename Rng>
+        static std::pair<range_difference_t<Rng>, iterator_t<Rng>> impl_r(Rng & rng,
+                                                                          range_tag,
+                                                                          range_tag)
+        {
+            return iter_enumerate(begin(rng), end(rng));
+        }
+        template<typename Rng>
+        static std::pair<range_difference_t<Rng>, iterator_t<Rng>> impl_r(
+            Rng & rng, common_range_tag, sized_range_tag)
+        {
+            return {static_cast<range_difference_t<Rng>>(size(rng)), end(rng)};
+        }
+
+    public:
+        using iter_enumerate_fn::operator();
+
+        template<typename Rng>
+        auto operator()(Rng && rng) const
+            -> CPP_ret(std::pair<range_difference_t<Rng>, iterator_t<Rng>>)( //
+                requires range<Rng>)
+        {
+            // Better not be trying to compute the distance of an infinite range:
+            RANGES_EXPECT(!is_infinite<Rng>::value);
+            return enumerate_fn::impl_r(
+                rng, common_range_tag_of<Rng>(), sized_range_tag_of<Rng>());
+        }
+    };
+
+    /// \sa `enumerate_fn`
+    RANGES_INLINE_VARIABLE(enumerate_fn, enumerate)
+
+    struct distance_fn : iter_distance_fn
+    {
+    private:
+        template<typename Rng>
+        static range_difference_t<Rng> impl_r(Rng & rng, range_tag)
+        {
+            return enumerate(rng).first;
+        }
+        template<typename Rng>
+        static constexpr range_difference_t<Rng> impl_r(Rng & rng, sized_range_tag)
+        {
+            return static_cast<range_difference_t<Rng>>(size(rng));
+        }
+
+    public:
+        using iter_distance_fn::operator();
+
+        template<typename Rng>
+        constexpr auto operator()(Rng && rng) const
+            -> CPP_ret(range_difference_t<Rng>)( //
+                requires range<Rng>)
+        {
+            // Better not be trying to compute the distance of an infinite range:
+            RANGES_EXPECT(!is_infinite<Rng>::value);
+            return distance_fn::impl_r(rng, sized_range_tag_of<Rng>());
+        }
+    };
+
+    /// \sa `distance_fn`
+    RANGES_INLINE_VARIABLE(distance_fn, distance)
+
+    // The interface of distance_compare is taken from Util.listLengthCmp in the GHC API.
+    struct distance_compare_fn : iter_distance_compare_fn
+    {
+    private:
+        template<typename Rng>
+        static int impl_r(Rng & rng, range_difference_t<Rng> n, range_tag)
+        {
+            // Infinite ranges are always compared to be larger than a finite number.
+            return is_infinite<Rng>::value
+                       ? 1
+                       : iter_distance_compare(begin(rng), end(rng), n);
+        }
+        template<typename Rng>
+        static int impl_r(Rng & rng, range_difference_t<Rng> n, sized_range_tag)
+        {
+            auto dist = distance(rng); // O(1) since rng is a sized_range
+            if(dist > n)
+                return 1;
+            else if(dist < n)
+                return -1;
+            else
+                return 0;
+        }
+
+    public:
+        using iter_distance_compare_fn::operator();
+
+        template<typename Rng>
+        auto operator()(Rng && rng, range_difference_t<Rng> n) const -> CPP_ret(int)( //
+            requires range<Rng>)
+        {
+            return distance_compare_fn::impl_r(rng, n, sized_range_tag_of<Rng>());
+        }
+    };
+
+    /// \sa `distance_compare_fn`
+    RANGES_INLINE_VARIABLE(distance_compare_fn, distance_compare)
+
+    namespace cpp20
+    {
+        using ranges::advance;
+        using ranges::distance;
+        using ranges::next;
+        using ranges::prev;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ITERATOR_OPERATIONS_HPP
diff --git a/inst/include/range/v3/iterator/reverse_iterator.hpp b/inst/include/range/v3/iterator/reverse_iterator.hpp
new file mode 100644
index 0000000..dda9640
--- /dev/null
+++ b/inst/include/range/v3/iterator/reverse_iterator.hpp
@@ -0,0 +1,139 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_REVERSE_ITERATOR_HPP
+#define RANGES_V3_ITERATOR_REVERSE_ITERATOR_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/basic_iterator.hpp>
+#include <range/v3/iterator/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        struct reverse_cursor
+        {
+        private:
+            CPP_assert(bidirectional_iterator<I>);
+            friend range_access;
+            template<typename OtherI>
+            friend struct reverse_cursor;
+            struct mixin : basic_mixin<reverse_cursor>
+            {
+                mixin() = default;
+                using basic_mixin<reverse_cursor>::basic_mixin;
+                constexpr mixin(I it)
+                  : mixin{reverse_cursor{it}}
+                {}
+                constexpr I base() const
+                {
+                    return this->get().base();
+                }
+            };
+
+            I it_;
+
+            constexpr reverse_cursor(I it)
+              : it_(std::move(it))
+            {}
+            constexpr auto read() const -> iter_reference_t<I>
+            {
+                return *arrow();
+            }
+            constexpr I arrow() const
+            {
+                auto tmp = it_;
+                --tmp;
+                return tmp;
+            }
+            constexpr I base() const
+            {
+                return it_;
+            }
+            template<typename J>
+            constexpr auto equal(reverse_cursor<J> const & that) const
+                -> CPP_ret(bool)( //
+                    requires sentinel_for<J, I>)
+            {
+                return it_ == that.it_;
+            }
+            constexpr void next()
+            {
+                --it_;
+            }
+            constexpr void prev()
+            {
+                ++it_;
+            }
+            CPP_member
+            constexpr auto advance(iter_difference_t<I> n) -> CPP_ret(void)( //
+                requires random_access_iterator<I>)
+            {
+                it_ -= n;
+            }
+            template<typename J>
+            constexpr auto distance_to(reverse_cursor<J> const & that) const
+                -> CPP_ret(iter_difference_t<I>)( //
+                    requires sized_sentinel_for<J, I>)
+            {
+                return it_ - that.base();
+            }
+            constexpr iter_rvalue_reference_t<I> move() const
+                noexcept(noexcept((void)I(I(it_)), (void)--const_cast<I &>(it_),
+                                  iter_move(it_)))
+            {
+                auto tmp = it_;
+                --tmp;
+                return iter_move(tmp);
+            }
+
+        public:
+            reverse_cursor() = default;
+            template<typename U>
+            constexpr CPP_ctor(reverse_cursor)(reverse_cursor<U> const & u)( //
+                requires convertible_to<U, I>)
+              : it_(u.base())
+            {}
+        };
+    } // namespace detail
+    /// \endcond
+
+    struct make_reverse_iterator_fn
+    {
+        template<typename I>
+        constexpr auto operator()(I i) const -> CPP_ret(reverse_iterator<I>)( //
+            requires bidirectional_iterator<I>)
+        {
+            return reverse_iterator<I>(i);
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(make_reverse_iterator_fn, make_reverse_iterator)
+
+    namespace cpp20
+    {
+        using ranges::make_reverse_iterator;
+        using ranges::reverse_iterator;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ITERATOR_REVERSE_ITERATOR_HPP
diff --git a/inst/include/range/v3/iterator/stream_iterators.hpp b/inst/include/range/v3/iterator/stream_iterators.hpp
new file mode 100644
index 0000000..ca8d4bf
--- /dev/null
+++ b/inst/include/range/v3/iterator/stream_iterators.hpp
@@ -0,0 +1,216 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_STREAM_ITERATORS_HPP
+#define RANGES_V3_ITERATOR_STREAM_ITERATORS_HPP
+
+#include <cstddef>
+#include <iosfwd>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+    template<typename T = void, typename Char = char,
+             typename Traits = std::char_traits<Char>>
+    struct ostream_iterator
+    {
+    private:
+        template<class U>
+        using value_t = meta::if_<std::is_void<T>, U, T>;
+
+    public:
+        using difference_type = std::ptrdiff_t;
+        using char_type = Char;
+        using traits_type = Traits;
+        using ostream_type = std::basic_ostream<Char, Traits>;
+
+        constexpr ostream_iterator() = default;
+        ostream_iterator(ostream_type & s, Char const * d = nullptr) noexcept
+          : sout_(&s)
+          , delim_(d)
+        {}
+        template<typename U>
+        auto operator=(U && value) -> CPP_ret(ostream_iterator &)( //
+            requires convertible_to<U, value_t<U> const &>)
+        {
+            RANGES_EXPECT(sout_);
+            *sout_ << value;
+            if(delim_)
+                *sout_ << delim_;
+            return *this;
+        }
+        ostream_iterator & operator*()
+        {
+            return *this;
+        }
+        ostream_iterator & operator++()
+        {
+            return *this;
+        }
+        ostream_iterator & operator++(int)
+        {
+            return *this;
+        }
+
+    private:
+        ostream_type * sout_;
+        Char const * delim_;
+    };
+
+    template<typename Delim, typename Char = char,
+             typename Traits = std::char_traits<Char>>
+    struct ostream_joiner
+    {
+        CPP_assert(semiregular<Delim>);
+        using difference_type = std::ptrdiff_t;
+        using char_type = Char;
+        using traits_type = Traits;
+        using ostream_type = std::basic_ostream<Char, Traits>;
+
+        constexpr ostream_joiner() = default;
+        ostream_joiner(ostream_type & s, Delim const & d)
+          : delim_(d)
+          , sout_(std::addressof(s))
+          , first_(true)
+        {}
+        ostream_joiner(ostream_type & s, Delim && d)
+          : delim_(std::move(d))
+          , sout_(std::addressof(s))
+          , first_(true)
+        {}
+        template<typename T>
+        ostream_joiner & operator=(T const & value)
+        {
+            RANGES_EXPECT(sout_);
+            if(!first_)
+                *sout_ << delim_;
+            first_ = false;
+            *sout_ << value;
+            return *this;
+        }
+        ostream_joiner & operator*() noexcept
+        {
+            return *this;
+        }
+        ostream_joiner & operator++() noexcept
+        {
+            return *this;
+        }
+        ostream_joiner & operator++(int) noexcept
+        {
+            return *this;
+        }
+
+    private:
+        Delim delim_;
+        ostream_type * sout_;
+        bool first_;
+    };
+
+    struct make_ostream_joiner_fn
+    {
+        template<typename Delim, typename Char, typename Traits>
+        auto operator()(std::basic_ostream<Char, Traits> & s, Delim && d) const
+            -> CPP_ret(ostream_joiner<detail::decay_t<Delim>, Char, Traits>)( //
+                requires semiregular<detail::decay_t<Delim>>)
+        {
+            return {s, std::forward<Delim>(d)};
+        }
+    };
+
+    /// \sa `make_ostream_joiner_fn`
+    RANGES_INLINE_VARIABLE(make_ostream_joiner_fn, make_ostream_joiner)
+
+    template<typename Char, typename Traits = std::char_traits<Char>>
+    struct ostreambuf_iterator
+    {
+    public:
+        typedef ptrdiff_t difference_type;
+        typedef Char char_type;
+        typedef Traits traits_type;
+        typedef std::basic_streambuf<Char, Traits> streambuf_type;
+        typedef std::basic_ostream<Char, Traits> ostream_type;
+
+        constexpr ostreambuf_iterator() = default;
+        ostreambuf_iterator(ostream_type & s) noexcept
+          : ostreambuf_iterator(s.rdbuf())
+        {}
+        ostreambuf_iterator(streambuf_type * s) noexcept
+          : sbuf_(s)
+        {
+            RANGES_ASSERT(s != nullptr);
+        }
+        ostreambuf_iterator & operator=(Char c)
+        {
+            RANGES_ASSERT(sbuf_ != nullptr);
+            if(!failed_)
+                failed_ = (sbuf_->sputc(c) == Traits::eof());
+            return *this;
+        }
+        ostreambuf_iterator & operator*()
+        {
+            return *this;
+        }
+        ostreambuf_iterator & operator++()
+        {
+            return *this;
+        }
+        ostreambuf_iterator & operator++(int)
+        {
+            return *this;
+        }
+        bool failed() const noexcept
+        {
+            return failed_;
+        }
+
+    private:
+        streambuf_type * sbuf_ = nullptr;
+        bool failed_ = false;
+    };
+
+    namespace cpp20
+    {
+        template<typename T, typename Char = char,
+                 typename Traits = std::char_traits<Char>>
+        using ostream_iterator = ranges::ostream_iterator<T, Char, Traits>;
+
+        using ranges::ostreambuf_iterator;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+/// \cond
+namespace std
+{
+    template<typename T, typename Char, typename Traits>
+    struct iterator_traits<::ranges::ostream_iterator<T, Char, Traits>>
+      : ::ranges::detail::std_output_iterator_traits<>
+    {};
+
+    template<typename Char, typename Traits>
+    struct iterator_traits<::ranges::ostreambuf_iterator<Char, Traits>>
+      : ::ranges::detail::std_output_iterator_traits<>
+    {};
+} // namespace std
+/// \endcond
+
+#endif // RANGES_V3_ITERATOR_STREAM_ITERATORS_HPP
diff --git a/inst/include/range/v3/iterator/traits.hpp b/inst/include/range/v3/iterator/traits.hpp
new file mode 100644
index 0000000..67be8b3
--- /dev/null
+++ b/inst/include/range/v3/iterator/traits.hpp
@@ -0,0 +1,172 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_TRAITS_HPP
+#define RANGES_V3_ITERATOR_TRAITS_HPP
+
+#include <iterator>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/access.hpp> // for iter_move, iter_swap
+#include <range/v3/utility/common_type.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    /// \cond
+    using input_iterator_tag RANGES_DEPRECATED(
+        "Please switch to the standard iterator tags") = std::input_iterator_tag;
+    using forward_iterator_tag RANGES_DEPRECATED(
+        "Please switch to the standard iterator tags") = std::forward_iterator_tag;
+    using bidirectional_iterator_tag RANGES_DEPRECATED(
+        "Please switch to the standard iterator tags") = std::bidirectional_iterator_tag;
+    using random_access_iterator_tag RANGES_DEPRECATED(
+        "Please switch to the standard iterator tags") = std::random_access_iterator_tag;
+    /// \endcond
+
+    struct contiguous_iterator_tag : std::random_access_iterator_tag
+    {};
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename = iter_reference_t<I>,
+                 typename R = decltype(iter_move(std::declval<I &>())), typename = R &>
+        using iter_rvalue_reference_t = R;
+
+        template<typename I>
+        RANGES_INLINE_VAR constexpr bool has_nothrow_iter_move_v =
+            noexcept(iter_rvalue_reference_t<I>(ranges::iter_move(std::declval<I &>())));
+    } // namespace detail
+    /// \endcond
+
+    template<typename I>
+    using iter_rvalue_reference_t = detail::iter_rvalue_reference_t<I>;
+
+    template<typename I>
+    using iter_common_reference_t =
+        common_reference_t<iter_reference_t<I>, iter_value_t<I> &>;
+
+#if defined(RANGES_DEEP_STL_INTEGRATION) && RANGES_DEEP_STL_INTEGRATION && \
+    !defined(RANGES_DOXYGEN_INVOKED)
+    template<typename T>
+    using iter_difference_t =
+        typename detail::if_then_t<detail::is_std_iterator_traits_specialized_v<T>,
+                                   std::iterator_traits<T>,
+                                   incrementable_traits<T>>::difference_type;
+#else
+    template<typename T>
+    using iter_difference_t = typename incrementable_traits<T>::difference_type;
+#endif
+
+    // Defined in <range/v3/iterator/access.hpp>
+    // template<typename T>
+    // using iter_value_t = ...
+
+    // Defined in <range/v3/iterator/access.hpp>
+    // template<typename R>
+    // using iter_reference_t = detail::iter_reference_t_<R>;
+
+    // Defined in <range/v3/range_fwd.hpp>:
+    // template<typename S, typename I>
+    // inline constexpr bool disable_sized_sentinel = false;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        using iter_size_t =
+            meta::_t<if_then_t<std::is_integral<iter_difference_t<I>>::value,
+                               std::make_unsigned<iter_difference_t<I>>,
+                               meta::id<iter_difference_t<I>>>>;
+
+        template<typename I>
+        using iter_arrow_t = decltype(std::declval<I &>().operator->());
+
+        template<typename I>
+        using iter_pointer_t =
+            meta::_t<if_then_t<meta::is_trait<meta::defer<iter_arrow_t, I>>::value,
+                               meta::defer<iter_arrow_t, I>,
+                               std::add_pointer<iter_reference_t<I>>>>;
+
+        template<typename T>
+        struct difference_type_ : meta::defer<iter_difference_t, T>
+        {};
+
+        template<typename T>
+        struct value_type_ : meta::defer<iter_value_t, T>
+        {};
+
+        template<typename T>
+        struct size_type_ : meta::defer<iter_size_t, T>
+        {};
+    } // namespace detail
+
+    template<typename T>
+    using difference_type_t RANGES_DEPRECATED(
+        "ranges::difference_type_t is deprecated. Please use "
+        "ranges::iter_difference_t instead.") = iter_difference_t<T>;
+
+    template<typename T>
+    using value_type_t RANGES_DEPRECATED(
+        "ranges::value_type_t is deprecated. Please use "
+        "ranges::iter_value_t instead.") = iter_value_t<T>;
+
+    template<typename R>
+    using reference_t RANGES_DEPRECATED(
+        "ranges::reference_t is deprecated. Use ranges::iter_reference_t "
+        "instead.") = iter_reference_t<R>;
+
+    template<typename I>
+    using rvalue_reference_t RANGES_DEPRECATED(
+        "rvalue_reference_t is deprecated; "
+        "use iter_rvalue_reference_t instead") = iter_rvalue_reference_t<I>;
+
+    template<typename T>
+    struct RANGES_DEPRECATED(
+        "ranges::size_type is deprecated. Iterators do not have an associated "
+        "size_type.") size_type : detail::size_type_<T>
+    {};
+
+    template<typename I>
+    using size_type_t RANGES_DEPRECATED("size_type_t is deprecated.") =
+        detail::iter_size_t<I>;
+    /// \endcond
+
+    namespace cpp20
+    {
+        using ranges::iter_common_reference_t;
+        using ranges::iter_difference_t;
+        using ranges::iter_reference_t;
+        using ranges::iter_rvalue_reference_t;
+        using ranges::iter_value_t;
+
+        // Specialize these in the ranges:: namespace
+        using ranges::disable_sized_sentinel;
+        template<typename T>
+        using incrementable_traits = ranges::incrementable_traits<T>;
+        template<typename T>
+        using readable_traits = ranges::readable_traits<T>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ITERATOR_TRAITS_HPP
diff --git a/inst/include/range/v3/iterator/unreachable_sentinel.hpp b/inst/include/range/v3/iterator/unreachable_sentinel.hpp
new file mode 100644
index 0000000..ecdb0a5
--- /dev/null
+++ b/inst/include/range/v3/iterator/unreachable_sentinel.hpp
@@ -0,0 +1,66 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_ITERATOR_UNREACHABLE_SENTINEL_HPP
+#define RANGES_V3_ITERATOR_UNREACHABLE_SENTINEL_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+    struct unreachable_sentinel_t
+    {
+        template<typename I>
+        friend constexpr auto operator==(I const &, unreachable_sentinel_t) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires weakly_incrementable<I>)
+        {
+            return false;
+        }
+        template<typename I>
+        friend constexpr auto operator==(unreachable_sentinel_t, I const &) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires weakly_incrementable<I>)
+        {
+            return false;
+        }
+        template<typename I>
+        friend constexpr auto operator!=(I const &, unreachable_sentinel_t) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires weakly_incrementable<I>)
+        {
+            return true;
+        }
+        template<typename I>
+        friend constexpr auto operator!=(unreachable_sentinel_t, I const &) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires weakly_incrementable<I>)
+        {
+            return true;
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(unreachable_sentinel_t, unreachable)
+
+    namespace cpp20
+    {
+        using ranges::unreachable;
+        using ranges::unreachable_sentinel_t;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_ITERATOR_UNREACHABLE_SENTINEL_HPP
diff --git a/inst/include/range/v3/iterator_range.hpp b/inst/include/range/v3/iterator_range.hpp
new file mode 100644
index 0000000..06e0b34
--- /dev/null
+++ b/inst/include/range/v3/iterator_range.hpp
@@ -0,0 +1,382 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_RANGE_HPP
+#define RANGES_V3_ITERATOR_RANGE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/interface.hpp>
+
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please switch to subrange in "
+    "<range/v3/view/subrange.hpp>.")
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    /// \cond
+    namespace _iterator_range_
+    {
+        struct adl_hook_
+        {};
+
+        // A temporary iterator_range can be safely passed to ranges::begin and
+        // ranges::end.
+        template<class I, class S>
+        constexpr I begin(iterator_range<I, S> && r) noexcept(
+            std::is_nothrow_copy_constructible<I>::value)
+        {
+            return r.begin();
+        }
+        template<class I, class S>
+        constexpr I begin(iterator_range<I, S> const && r) noexcept(
+            std::is_nothrow_copy_constructible<I>::value)
+        {
+            return r.begin();
+        }
+        template<class I, class S>
+        constexpr S end(iterator_range<I, S> && r) noexcept(
+            std::is_nothrow_copy_constructible<S>::value)
+        {
+            return r.end();
+        }
+        template<class I, class S>
+        constexpr S end(iterator_range<I, S> const && r) noexcept(
+            std::is_nothrow_copy_constructible<S>::value)
+        {
+            return r.end();
+        }
+
+        // A temporary sized_iterator_range can be safely passed to ranges::begin and
+        // ranges::end.
+        template<class I, class S>
+        constexpr I begin(sized_iterator_range<I, S> && r) noexcept(
+            std::is_nothrow_copy_constructible<I>::value)
+        {
+            return r.begin();
+        }
+        template<class I, class S>
+        constexpr I begin(sized_iterator_range<I, S> const && r) noexcept(
+            std::is_nothrow_copy_constructible<I>::value)
+        {
+            return r.begin();
+        }
+        template<class I, class S>
+        constexpr S end(sized_iterator_range<I, S> && r) noexcept(
+            std::is_nothrow_copy_constructible<S>::value)
+        {
+            return r.end();
+        }
+        template<class I, class S>
+        constexpr S end(sized_iterator_range<I, S> const && r) noexcept(
+            std::is_nothrow_copy_constructible<S>::value)
+        {
+            return r.end();
+        }
+    } // namespace _iterator_range_
+    /// \endcond
+
+    template<typename I, typename S /*= I*/>
+    struct RANGES_EMPTY_BASES iterator_range
+      : view_interface<iterator_range<I, S>,
+                       same_as<S, unreachable_sentinel_t> ? infinite : unknown>
+      , compressed_pair<I, S>
+      , _iterator_range_::adl_hook_
+    {
+    private:
+        template<typename, typename>
+        friend struct iterator_range;
+        template<typename, typename>
+        friend struct sized_iterator_range;
+        compressed_pair<I, S> & base() noexcept
+        {
+            return *this;
+        }
+        compressed_pair<I, S> const & base() const noexcept
+        {
+            return *this;
+        }
+        using compressed_pair<I, S>::first;
+        using compressed_pair<I, S>::second;
+
+    public:
+        using iterator = I;
+        using sentinel = S;
+        /// \cond
+        using const_iterator = I; // Mostly to avoid spurious errors in Boost.Range
+        /// \endcond
+
+        constexpr I & begin() &
+        {
+            return this->first();
+        }
+        constexpr I const & begin() const &
+        {
+            return this->first();
+        }
+
+        constexpr S & end() &
+        {
+            return this->second();
+        }
+        constexpr S const & end() const &
+        {
+            return this->second();
+        }
+
+        iterator_range() = default;
+        constexpr iterator_range(I first, S last)
+          : compressed_pair<I, S>{detail::move(first), detail::move(last)}
+        {}
+        template<typename X, typename Y>
+        constexpr CPP_ctor(iterator_range)(iterator_range<X, Y> rng)( //
+            requires constructible_from<I, X> && constructible_from<S, Y>)
+          : compressed_pair<I, S>{detail::move(rng.begin()), detail::move(rng.end())}
+        {}
+        template<typename X, typename Y>
+        explicit constexpr CPP_ctor(iterator_range)(std::pair<X, Y> rng)( //
+            requires constructible_from<I, X> && constructible_from<S, Y>)
+          : compressed_pair<I, S>{detail::move(rng.first), detail::move(rng.second)}
+        {}
+        template<typename X, typename Y>
+        auto operator=(iterator_range<X, Y> rng) -> CPP_ret(iterator_range &)( //
+            requires assignable_from<I &, X> && assignable_from<S &, Y>)
+        {
+            base().first() = std::move(rng.base()).first();
+            base().second() = std::move(rng.base()).second();
+            return *this;
+        }
+        CPP_template(typename X, typename Y)(                      //
+            requires convertible_to<I, X> && convertible_to<S, Y>) //
+            constexpr
+            operator std::pair<X, Y>() const
+        {
+            return {base().first(), base().second()};
+        }
+        constexpr bool empty() const
+        {
+            return base().first() == base().second();
+        }
+    };
+
+    // Like iterator_range, but with a known size. The first and second members
+    // are private to prevent inadvertent violations of the class invariant.
+    //
+    // Class invariant:
+    //   distance(begin(), end()) == size()
+    //
+    template<typename I, typename S /* = I */>
+    struct sized_iterator_range
+      : view_interface<sized_iterator_range<I, S>, finite>
+      , _iterator_range_::adl_hook_
+    {
+        using size_type = detail::iter_size_t<I>;
+        using iterator = I;
+        using sentinel = S;
+#ifndef RANGES_DOXYGEN_INVOKED
+        using const_iterator = I; // Mostly to avoid spurious errors in Boost.Range
+#endif
+
+    private:
+        template<typename X, typename Y>
+        friend struct sized_iterator_range;
+        iterator_range<I, S> rng_;
+        size_type size_;
+
+    public:
+        sized_iterator_range() = default;
+        RANGES_NDEBUG_CONSTEXPR sized_iterator_range(I first, S last, size_type size)
+          : rng_{detail::move(first), detail::move(last)}
+          , size_(size)
+        {
+#ifndef NDEBUG
+            RANGES_ASSERT(!(bool)forward_iterator<I> ||
+                          static_cast<size_type>(ranges::distance(rng_)) == size_);
+#endif
+        }
+        template<typename X, typename Y>
+        RANGES_NDEBUG_CONSTEXPR CPP_ctor(sized_iterator_range)(std::pair<X, Y> rng,
+                                                               size_type size)( //
+            requires constructible_from<I, X> && constructible_from<S, Y>)
+          : sized_iterator_range{detail::move(rng).first, detail::move(rng).second, size}
+        {}
+        template<typename X, typename Y>
+        RANGES_NDEBUG_CONSTEXPR CPP_ctor(sized_iterator_range)(iterator_range<X, Y> rng,
+                                                               size_type size)( //
+            requires constructible_from<I, X> && constructible_from<S, Y>)
+          : sized_iterator_range{detail::move(rng).first(),
+                                 detail::move(rng).second,
+                                 size}
+        {}
+        template<typename X, typename Y>
+        RANGES_NDEBUG_CONSTEXPR CPP_ctor(sized_iterator_range)(
+            sized_iterator_range<X, Y> rng)( //
+            requires constructible_from<I, X> && constructible_from<S, Y>)
+          : sized_iterator_range{detail::move(rng).rng_.first(),
+                                 detail::move(rng).rng_.second,
+                                 rng.size_}
+        {}
+        template<typename X, typename Y>
+        auto operator=(sized_iterator_range<X, Y> rng)
+            -> CPP_ret(sized_iterator_range &)( //
+                requires assignable_from<I &, X> && assignable_from<S &, Y>)
+        {
+            rng_ = detail::move(rng).rng_;
+            size_ = rng.size_;
+            return *this;
+        }
+        I begin() const
+        {
+            return rng_.begin();
+        }
+        S end() const
+        {
+            return rng_.end();
+        }
+        size_type size() const noexcept
+        {
+            return size_;
+        }
+        CPP_template(typename X, typename Y)(                      //
+            requires convertible_to<I, X> && convertible_to<S, Y>) //
+            constexpr
+            operator std::pair<X, Y>() const
+        {
+            return rng_;
+        }
+        CPP_template(typename X, typename Y)(                      //
+            requires convertible_to<I, X> && convertible_to<S, Y>) //
+            constexpr
+            operator iterator_range<X, Y>() const
+        {
+            return rng_;
+        }
+        constexpr operator iterator_range<I, S> const &() const & noexcept
+        {
+            return rng_;
+        }
+        // clang-format off
+        /// Tuple-like access for `sized_iterator_range`
+        CPP_template(std::size_t N)( //
+            requires (N < 2))        //
+        friend constexpr auto CPP_auto_fun(get)(sized_iterator_range const &p)
+        (
+            // return ranges::get<N>(p.rng_)
+            return ranges::get<N>(p.*&sized_iterator_range::rng_) // makes clang happy
+        )
+            // clang-format on
+            /// \overload
+            template<std::size_t N>
+            friend constexpr auto get(sized_iterator_range const & p) noexcept
+            -> CPP_ret(size_type)( //
+                requires(N == 2))
+        {
+            return p.size();
+        }
+    };
+
+    struct make_iterator_range_fn
+    {
+        /// \return `{first, last}`
+        template<typename I, typename S>
+        constexpr auto operator()(I first, S last) const
+            -> CPP_ret(iterator_range<I, S>)( //
+                requires sentinel_for<S, I>)
+        {
+            return {detail::move(first), detail::move(last)};
+        }
+
+        /// \return `{first, last, size}`
+        template<typename I, typename S>
+        constexpr auto operator()(I first, S last, detail::iter_size_t<I> sz) const
+            -> CPP_ret(sized_iterator_range<I, S>)( //
+                requires sentinel_for<S, I>)
+        {
+            return {detail::move(first), detail::move(last), sz};
+        }
+    };
+
+    /// \sa `make_iterator_range_fn`
+    RANGES_INLINE_VARIABLE(make_iterator_range_fn, make_iterator_range)
+
+    // TODO add specialization of range_cardinality for when we can determine the range is
+    // infinite
+
+    /// @}
+} // namespace ranges
+
+// The standard is inconsistent about whether these are classes or structs
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+
+/// \cond
+namespace std
+{
+    template<typename I, typename S>
+    struct tuple_size<::ranges::iterator_range<I, S>> : std::integral_constant<size_t, 2>
+    {};
+
+    template<typename I, typename S>
+    struct tuple_element<0, ::ranges::iterator_range<I, S>>
+    {
+        using type = I;
+    };
+
+    template<typename I, typename S>
+    struct tuple_element<1, ::ranges::iterator_range<I, S>>
+    {
+        using type = S;
+    };
+
+    template<typename I, typename S>
+    struct tuple_size<::ranges::sized_iterator_range<I, S>>
+      : std::integral_constant<size_t, 3>
+    {};
+
+    template<typename I, typename S>
+    struct tuple_element<0, ::ranges::sized_iterator_range<I, S>>
+    {
+        using type = I;
+    };
+
+    template<typename I, typename S>
+    struct tuple_element<1, ::ranges::sized_iterator_range<I, S>>
+    {
+        using type = S;
+    };
+
+    template<typename I, typename S>
+    struct tuple_element<2, ::ranges::sized_iterator_range<I, S>>
+    {
+        using type = typename ::ranges::sized_iterator_range<I, S>::size_type;
+    };
+} // namespace std
+/// \endcond
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/numeric.hpp b/inst/include/range/v3/numeric.hpp
new file mode 100644
index 0000000..2320240
--- /dev/null
+++ b/inst/include/range/v3/numeric.hpp
@@ -0,0 +1,20 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file numeric.hpp
+///   Contains range-based versions of the numeric algorithms
+//
+// Copyright Eric Niebler 2014-present
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef RANGES_V3_NUMERIC_HPP
+#define RANGES_V3_NUMERIC_HPP
+
+#include <range/v3/numeric/accumulate.hpp>
+#include <range/v3/numeric/adjacent_difference.hpp>
+#include <range/v3/numeric/inner_product.hpp>
+#include <range/v3/numeric/iota.hpp>
+#include <range/v3/numeric/partial_sum.hpp>
+
+#endif
diff --git a/inst/include/range/v3/numeric/accumulate.hpp b/inst/include/range/v3/numeric/accumulate.hpp
new file mode 100644
index 0000000..e489730
--- /dev/null
+++ b/inst/include/range/v3/numeric/accumulate.hpp
@@ -0,0 +1,64 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_NUMERIC_ACCUMULATE_HPP
+#define RANGES_V3_NUMERIC_ACCUMULATE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-numerics
+    /// @{
+    struct accumulate_fn
+    {
+        template<typename I, typename S, typename T, typename Op = plus,
+                 typename P = identity>
+        auto operator()(I first, S last, T init, Op op = Op{},
+                        P proj = P{}) const -> CPP_ret(T)( //
+            requires sentinel_for<S, I> && input_iterator<I> &&
+                indirectly_binary_invocable_<Op, T *, projected<I, P>> &&
+                    assignable_from<T &, indirect_result_t<Op &, T *, projected<I, P>>>)
+        {
+            for(; first != last; ++first)
+                init = invoke(op, init, invoke(proj, *first));
+            return init;
+        }
+
+        template<typename Rng, typename T, typename Op = plus, typename P = identity>
+        auto operator()(Rng && rng, T init, Op op = Op{},
+                        P proj = P{}) const -> CPP_ret(T)( //
+            requires input_range<Rng> &&
+                indirectly_binary_invocable_<Op, T *, projected<iterator_t<Rng>, P>> &&
+                    assignable_from<
+                        T &, indirect_result_t<Op &, T *, projected<iterator_t<Rng>, P>>>)
+        {
+            return (*this)(
+                begin(rng), end(rng), std::move(init), std::move(op), std::move(proj));
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(accumulate_fn, accumulate)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/numeric/adjacent_difference.hpp b/inst/include/range/v3/numeric/adjacent_difference.hpp
new file mode 100644
index 0000000..a5e205b
--- /dev/null
+++ b/inst/include/range/v3/numeric/adjacent_difference.hpp
@@ -0,0 +1,135 @@
+/// \file
+// Range v3 library
+//
+// Copyright Eric Niebler 2004
+// Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// Implementation based on the code in libc++
+//   http://http://libcxx.llvm.org/
+
+#ifndef RANGES_V3_NUMERIC_ADJACENT_DIFFERENCE_HPP
+#define RANGES_V3_NUMERIC_ADJACENT_DIFFERENCE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-numerics
+    /// @{
+    // clang-format off
+    CPP_def
+    (
+        template(typename I, typename O, typename BOp = minus, typename P = identity)
+        (concept differenceable)(I, O, BOp, P),
+            input_iterator<I> &&
+            invocable<P&, iter_value_t<I>> &&
+            copy_constructible<uncvref_t<invoke_result_t<P&, iter_value_t<I>>>> &&
+            movable<uncvref_t<invoke_result_t<P&, iter_value_t<I>>>> &&
+            output_iterator<O, invoke_result_t<P&, iter_value_t<I>>> &&
+            invocable<BOp&, invoke_result_t<P&, iter_value_t<I>>, invoke_result_t<P&, iter_value_t<I>>> &&
+            output_iterator<O, invoke_result_t<BOp&, invoke_result_t<P&, iter_value_t<I>>, invoke_result_t<P&, iter_value_t<I>>>>
+    );
+    // clang-format on
+
+    template<typename I, typename O>
+    using adjacent_difference_result = detail::in_out_result<I, O>;
+
+    struct adjacent_difference_fn
+    {
+        template<typename I, typename S, typename O, typename S2, typename BOp = minus,
+                 typename P = identity>
+        auto operator()(I first, S last, O result, S2 end_result, BOp bop = BOp{},
+                        P proj = P{}) const
+            -> CPP_ret(adjacent_difference_result<I, O>)( //
+                requires sentinel_for<S, I> && sentinel_for<S2, O> &&
+                    differenceable<I, O, BOp, P>)
+        {
+            // BUGBUG think about the use of coerce here.
+            using V = iter_value_t<I>;
+            using X = invoke_result_t<P &, V>;
+            coerce<V> v;
+            coerce<X> x;
+
+            if(first != last && result != end_result)
+            {
+                auto t1(x(invoke(proj, v(*first))));
+                *result = t1;
+                for(++first, ++result; first != last && result != end_result;
+                    ++first, ++result)
+                {
+                    auto t2(x(invoke(proj, v(*first))));
+                    *result = invoke(bop, t2, t1);
+                    t1 = std::move(t2);
+                }
+            }
+            return {first, result};
+        }
+
+        template<typename I, typename S, typename O, typename BOp = minus,
+                 typename P = identity>
+        auto operator()(I first, S last, O result, BOp bop = BOp{}, P proj = P{}) const
+            -> CPP_ret(adjacent_difference_result<I, O>)( //
+                requires sentinel_for<S, I> && differenceable<I, O, BOp, P>)
+        {
+            return (*this)(std::move(first),
+                           std::move(last),
+                           std::move(result),
+                           unreachable,
+                           std::move(bop),
+                           std::move(proj));
+        }
+
+        template<typename Rng, typename ORef, typename BOp = minus, typename P = identity,
+                 typename I = iterator_t<Rng>, typename O = uncvref_t<ORef>>
+        auto operator()(Rng && rng, ORef && result, BOp bop = BOp{}, P proj = P{}) const
+            -> CPP_ret(adjacent_difference_result<safe_iterator_t<Rng>, O>)( //
+                requires range<Rng> && differenceable<I, O, BOp, P>)
+        {
+            return (*this)(begin(rng),
+                           end(rng),
+                           static_cast<ORef &&>(result),
+                           std::move(bop),
+                           std::move(proj));
+        }
+
+        template<typename Rng, typename ORng, typename BOp = minus, typename P = identity,
+                 typename I = iterator_t<Rng>, typename O = iterator_t<ORng>>
+        auto operator()(Rng && rng, ORng && result, BOp bop = BOp{}, P proj = P{}) const
+            -> CPP_ret(adjacent_difference_result<safe_iterator_t<Rng>,
+                                                  safe_iterator_t<ORng>>)( //
+                requires range<Rng> && range<ORng> && differenceable<I, O, BOp, P>)
+        {
+            return (*this)(begin(rng),
+                           end(rng),
+                           begin(result),
+                           end(result),
+                           std::move(bop),
+                           std::move(proj));
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(adjacent_difference_fn, adjacent_difference)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/numeric/inner_product.hpp b/inst/include/range/v3/numeric/inner_product.hpp
new file mode 100644
index 0000000..f75ff6b
--- /dev/null
+++ b/inst/include/range/v3/numeric/inner_product.hpp
@@ -0,0 +1,153 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_NUMERIC_INNER_PRODUCT_HPP
+#define RANGES_V3_NUMERIC_INNER_PRODUCT_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-numerics
+    /// @{
+    // clang-format off
+    CPP_def
+    (
+        template(typename I1, typename I2, typename T, typename BOp1 = plus,
+            typename BOp2 = multiplies, typename P1 = identity, typename P2 = identity)
+        (concept inner_product_constraints)(I1, I2, T, BOp1, BOp2, P1, P2),
+            input_iterator<I1> &&
+            input_iterator<I2> &&
+            invocable<P1&, iter_value_t<I1>> &&
+            invocable<P2&, iter_value_t<I2>> &&
+            invocable<
+                BOp2&,
+                invoke_result_t<P1&, iter_value_t<I1>>,
+                invoke_result_t<P2&, iter_value_t<I2>>> &&
+            invocable<
+                BOp1&,
+                T,
+                invoke_result_t<
+                    BOp2&,
+                    invoke_result_t<P1&, iter_value_t<I1>>,
+                    invoke_result_t<P2&, iter_value_t<I2>>>> &&
+            assignable_from<
+                T&,
+                invoke_result_t<
+                    BOp1&,
+                    T,
+                    invoke_result_t<
+                        BOp2&,
+                        invoke_result_t<P1&, iter_value_t<I1>>,
+                        invoke_result_t<P2&, iter_value_t<I2>>>>>
+    );
+    // clang-format on
+
+    struct inner_product_fn
+    {
+        template<typename I1, typename S1, typename I2, typename S2, typename T,
+                 typename BOp1 = plus, typename BOp2 = multiplies, typename P1 = identity,
+                 typename P2 = identity>
+        auto operator()(I1 begin1, S1 end1, I2 begin2, S2 end2, T init,
+                        BOp1 bop1 = BOp1{}, BOp2 bop2 = BOp2{}, P1 proj1 = P1{},
+                        P2 proj2 = P2{}) const -> CPP_ret(T)( //
+            requires sentinel_for<S1, I1> && sentinel_for<S2, I2> &&
+                inner_product_constraints<I1, I2, T, BOp1, BOp2, P1, P2>)
+        {
+            for(; begin1 != end1 && begin2 != end2; ++begin1, ++begin2)
+                init =
+                    invoke(bop1,
+                           init,
+                           invoke(bop2, invoke(proj1, *begin1), invoke(proj2, *begin2)));
+            return init;
+        }
+
+        template<typename I1, typename S1, typename I2, typename T, typename BOp1 = plus,
+                 typename BOp2 = multiplies, typename P1 = identity,
+                 typename P2 = identity>
+        auto operator()(I1 begin1, S1 end1, I2 begin2, T init, BOp1 bop1 = BOp1{},
+                        BOp2 bop2 = BOp2{}, P1 proj1 = P1{}, P2 proj2 = P2{}) const
+            -> CPP_ret(T)( //
+                requires sentinel_for<S1, I1> &&
+                    inner_product_constraints<I1, I2, T, BOp1, BOp2, P1, P2>)
+        {
+            return (*this)(std::move(begin1),
+                           std::move(end1),
+                           std::move(begin2),
+                           unreachable,
+                           std::move(init),
+                           std::move(bop1),
+                           std::move(bop2),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+        template<typename Rng1, typename I2Ref, typename T, typename BOp1 = plus,
+                 typename BOp2 = multiplies, typename P1 = identity,
+                 typename P2 = identity, typename I1 = iterator_t<Rng1>,
+                 typename I2 = uncvref_t<I2Ref>>
+        auto operator()(Rng1 && rng1, I2Ref && begin2, T init, BOp1 bop1 = BOp1{},
+                        BOp2 bop2 = BOp2{}, P1 proj1 = P1{}, P2 proj2 = P2{}) const
+            -> CPP_ret(T)( //
+                requires range<Rng1> &&
+                    inner_product_constraints<I1, I2, T, BOp1, BOp2, P1, P2>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           static_cast<I2Ref &&>(begin2),
+                           std::move(init),
+                           std::move(bop1),
+                           std::move(bop2),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+
+        template<typename Rng1, typename Rng2, typename T, typename BOp1 = plus,
+                 typename BOp2 = multiplies, typename P1 = identity,
+                 typename P2 = identity, typename I1 = iterator_t<Rng1>,
+                 typename I2 = iterator_t<Rng2>>
+        auto operator()(Rng1 && rng1, Rng2 && rng2, T init, BOp1 bop1 = BOp1{},
+                        BOp2 bop2 = BOp2{}, P1 proj1 = P1{}, P2 proj2 = P2{}) const
+            -> CPP_ret(T)( //
+                requires range<Rng1> && range<Rng2> &&
+                    inner_product_constraints<I1, I2, T, BOp1, BOp2, P1, P2>)
+        {
+            return (*this)(begin(rng1),
+                           end(rng1),
+                           begin(rng2),
+                           end(rng2),
+                           std::move(init),
+                           std::move(bop1),
+                           std::move(bop2),
+                           std::move(proj1),
+                           std::move(proj2));
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(inner_product_fn, inner_product)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/numeric/iota.hpp b/inst/include/range/v3/numeric/iota.hpp
new file mode 100644
index 0000000..637c558
--- /dev/null
+++ b/inst/include/range/v3/numeric/iota.hpp
@@ -0,0 +1,51 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_NUMERIC_IOTA_HPP
+#define RANGES_V3_NUMERIC_IOTA_HPP
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-numerics
+    /// @{
+    struct iota_fn
+    {
+        template<typename O, typename S, typename T>
+        auto operator()(O first, S last, T val) const -> CPP_ret(O)( //
+            requires output_iterator<O, T const &> && sentinel_for<S, O> &&
+                weakly_incrementable<T>)
+        {
+            for(; first != last; ++first, ++val)
+                *first = detail::as_const(val);
+            return first;
+        }
+
+        template<typename Rng, typename T>
+        auto operator()(Rng && rng, T val) const -> CPP_ret(safe_iterator_t<Rng>)( //
+            requires output_range<Rng, T const &> && weakly_incrementable<T>)
+        {
+            return (*this)(begin(rng), end(rng), detail::move(val));
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(iota_fn, iota)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/numeric/partial_sum.hpp b/inst/include/range/v3/numeric/partial_sum.hpp
new file mode 100644
index 0000000..4b799db
--- /dev/null
+++ b/inst/include/range/v3/numeric/partial_sum.hpp
@@ -0,0 +1,162 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi 2014
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_NUMERIC_PARTIAL_SUM_HPP
+#define RANGES_V3_NUMERIC_PARTIAL_SUM_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/algorithm/result_types.hpp>
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-numerics
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        // Only needed for type-checking purposes:
+        struct as_lvalue_fn
+        {
+            template<typename T>
+            constexpr T & operator()(T && t) const noexcept
+            {
+                return t;
+            }
+        };
+        template<typename I>
+        using as_value_type_t = composed<as_lvalue_fn, coerce<iter_value_t<I>>>;
+    } // namespace detail
+      /// \endcond
+
+    // axiom: BOp is associative over values of I.
+    // clang-format off
+    CPP_def
+    (
+        template(typename I, typename BOp)
+        concept indirect_semigroup,
+            readable<I> &&
+            copyable<iter_value_t<I>> &&
+            indirectly_regular_binary_invocable_<
+                composed<coerce<iter_value_t<I>>, BOp>,
+                iter_value_t<I>*, I>
+    );
+
+    CPP_def
+    (
+        template(typename I, typename O, typename BOp = plus, typename P = identity)
+        (concept partial_sum_constraints)(I, O, BOp, P),
+            input_iterator<I> &&
+            indirect_semigroup<
+                projected<projected<I, detail::as_value_type_t<I>>, P>,
+                BOp> &&
+            output_iterator<
+                O,
+                iter_value_t<
+                    projected<projected<I, detail::as_value_type_t<I>>, P>> const &>
+    );
+    // clang-format on
+
+    template<typename I, typename O>
+    using partial_sum_result = detail::in_out_result<I, O>;
+
+    struct partial_sum_fn
+    {
+        template<typename I, typename S1, typename O, typename S2, typename BOp = plus,
+                 typename P = identity>
+        auto operator()(I first, S1 last, O result, S2 end_result, BOp bop = BOp{},
+                        P proj = P{}) const -> CPP_ret(partial_sum_result<I, O>)( //
+            requires sentinel_for<S1, I> && sentinel_for<S2, O> &&
+                partial_sum_constraints<I, O, BOp, P>)
+        {
+            using X = projected<projected<I, detail::as_value_type_t<I>>, P>;
+            coerce<iter_value_t<I>> val_i;
+            coerce<iter_value_t<X>> val_x;
+            if(first != last && result != end_result)
+            {
+                auto && cur1 = val_i(*first);
+                iter_value_t<X> t(invoke(proj, cur1));
+                *result = t;
+                for(++first, ++result; first != last && result != end_result;
+                    ++first, ++result)
+                {
+                    auto && cur2 = val_i(*first);
+                    t = val_x(invoke(bop, t, invoke(proj, cur2)));
+                    *result = t;
+                }
+            }
+            return {first, result};
+        }
+
+        template<typename I, typename S, typename O, typename BOp = plus,
+                 typename P = identity>
+        auto operator()(I first, S last, O result, BOp bop = BOp{}, P proj = P{}) const
+            -> CPP_ret(partial_sum_result<I, O>)( //
+                requires sentinel_for<S, I> && partial_sum_constraints<I, O, BOp, P>)
+        {
+            return (*this)(std::move(first),
+                           std::move(last),
+                           std::move(result),
+                           unreachable,
+                           std::move(bop),
+                           std::move(proj));
+        }
+
+        template<typename Rng, typename ORef, typename BOp = plus, typename P = identity,
+                 typename I = iterator_t<Rng>, typename O = uncvref_t<ORef>>
+        auto operator()(Rng && rng, ORef && result, BOp bop = BOp{}, P proj = P{}) const
+            -> CPP_ret(partial_sum_result<safe_iterator_t<Rng>, O>)( //
+                requires range<Rng> && partial_sum_constraints<I, O, BOp, P>)
+        {
+            return (*this)(begin(rng),
+                           end(rng),
+                           static_cast<ORef &&>(result),
+                           std::move(bop),
+                           std::move(proj));
+        }
+
+        template<typename Rng, typename ORng, typename BOp = plus, typename P = identity,
+                 typename I = iterator_t<Rng>, typename O = iterator_t<ORng>>
+        auto operator()(Rng && rng, ORng && result, BOp bop = BOp{}, P proj = P{}) const
+            -> CPP_ret(
+                partial_sum_result<safe_iterator_t<Rng>, safe_iterator_t<ORng>>)( //
+                requires range<Rng> && range<ORng> &&
+                    partial_sum_constraints<I, O, BOp, P>)
+        {
+            return (*this)(begin(rng),
+                           end(rng),
+                           begin(result),
+                           end(result),
+                           std::move(bop),
+                           std::move(proj));
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(partial_sum_fn, partial_sum)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range.hpp b/inst/include/range/v3/range.hpp
new file mode 100644
index 0000000..e1239dd
--- /dev/null
+++ b/inst/include/range/v3/range.hpp
@@ -0,0 +1,30 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2019-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_HPP
+#define RANGES_V3_ITERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DISABLE_WARNINGS
+
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/range/operations.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/range/access.hpp b/inst/include/range/v3/range/access.hpp
new file mode 100644
index 0000000..e4037b8
--- /dev/null
+++ b/inst/include/range/v3/range/access.hpp
@@ -0,0 +1,719 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_ACCESS_HPP
+#define RANGES_V3_RANGE_ACCESS_HPP
+
+#include <functional> // for reference_wrapper (whose use with begin/end is deprecated)
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#ifdef __has_include
+#if __has_include(<string_view>)
+#include <string_view>
+#endif
+#endif
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/reverse_iterator.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace _begin_
+    {
+        // Poison pill for std::begin. (See the detailed discussion at
+        // https://github.com/ericniebler/stl2/issues/139)
+        template<typename T>
+        void begin(T &&) = delete;
+
+#ifdef RANGES_WORKAROUND_MSVC_895622
+        void begin();
+#endif
+
+        template<typename T>
+        void begin(std::initializer_list<T>) = delete;
+
+        template<class I>
+        auto is_iterator(I) -> CPP_ret(void)(requires input_or_output_iterator<I>);
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename T)
+            concept has_member_begin,
+                requires (T &t)
+                (
+                    _begin_::is_iterator(t.begin())
+                ) &&
+                std::is_lvalue_reference<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept has_non_member_begin,
+                requires (T &&t)
+                (
+                    _begin_::is_iterator(begin((T &&) t))
+                )
+        );
+        // clang-format on
+
+        struct fn
+        {
+        private:
+            template<bool>
+            struct impl_
+            {
+                // has_member_begin == true
+                template<typename R>
+                constexpr auto operator()(R && r) const noexcept(noexcept(r.begin()))
+                {
+                    return r.begin();
+                }
+            };
+
+            template<typename R>
+            using impl = impl_<has_member_begin<R>>;
+
+#ifdef RANGES_WORKAROUND_GCC_89953
+            template<typename R>
+            static constexpr impl<R> impl_v{};
+#endif
+
+        public:
+            template<typename R, std::size_t N>
+            void operator()(R(&&)[N]) const = delete;
+
+            template<typename R, std::size_t N>
+            constexpr R * operator()(R (&array)[N]) const noexcept
+            {
+                return array;
+            }
+
+            template<typename R>
+#ifdef RANGES_WORKAROUND_GCC_89953
+            constexpr auto CPP_fun(operator())(R && r)(
+                const                                   //
+                noexcept(noexcept(impl_v<R>((R &&) r))) //
+                requires(has_member_begin<R> || has_non_member_begin<R>))
+#else
+            constexpr auto CPP_fun(operator())(R && r)(
+                const                                   //
+                noexcept(noexcept(impl<R>{}((R &&) r))) //
+                requires(has_member_begin<R> || has_non_member_begin<R>))
+#endif
+            {
+                return impl<R>{}((R &&) r);
+            }
+
+#if defined(__cpp_lib_string_view) && __cpp_lib_string_view > 0
+            template<class CharT, class Traits>
+            constexpr auto operator()(std::basic_string_view<CharT, Traits> r) const
+                noexcept
+            {
+                return r.begin();
+            }
+#endif
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(std::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(ranges::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+        };
+
+        // has_member_begin == false
+        template<>
+        struct fn::impl_<false>
+        {
+            template<typename R>
+            constexpr auto operator()(R && r) const noexcept(noexcept(begin((R &&) r)))
+            {
+                return begin((R &&) r);
+            }
+        };
+
+        template<typename R>
+        using _t = decltype(fn{}(std::declval<R>()));
+    } // namespace _begin_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return \c r, if \c r is an array. Otherwise, `r.begin()` if that expression is
+    ///   well-formed and returns an input_or_output_iterator. Otherwise, `begin(r)` if
+    ///   that expression returns an input_or_output_iterator.
+    RANGES_DEFINE_CPO(_begin_::fn, begin)
+
+    /// \cond
+    namespace _end_
+    {
+        // Poison pill for std::end. (See the detailed discussion at
+        // https://github.com/ericniebler/stl2/issues/139)
+        template<typename T>
+        void end(T &&) = delete;
+
+#ifdef RANGES_WORKAROUND_MSVC_895622
+        void end();
+#endif
+
+        template<typename T>
+        void end(std::initializer_list<T>) = delete;
+
+        template<typename I, typename S>
+        auto is_sentinel(S) -> CPP_ret(void)(requires sentinel_for<S, I>);
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename T)
+            concept has_member_end,
+                requires (T &t)
+                (
+                    _end_::is_sentinel<_begin_::_t<T>>(t.end())
+                ) &&
+                std::is_lvalue_reference<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept has_non_member_end,
+                requires (T &&t)
+                (
+                    _end_::is_sentinel<_begin_::_t<T>>(end((T &&) t))
+                )
+        );
+        // clang-format on
+
+        struct fn
+        {
+        private:
+            template<bool>
+            struct impl_
+            {
+                // has_member_end == true
+                template<typename R>
+                constexpr auto operator()(R && r) const noexcept(noexcept(r.end()))
+                {
+                    return r.end();
+                }
+            };
+
+            template<typename Int>
+            using iter_diff_t =
+                meta::_t<detail::if_then_t<std::is_integral<Int>::value,
+                                           std::make_signed<Int>, meta::id<Int>>>;
+
+            template<typename R>
+            using impl = impl_<has_member_end<R>>;
+
+#ifdef RANGES_WORKAROUND_GCC_89953
+            template<typename R>
+            static constexpr impl<R> impl_v{};
+#endif
+
+        public:
+            template<typename R, std::size_t N>
+            void operator()(R(&&)[N]) const = delete;
+
+            template<typename R, std::size_t N>
+            constexpr R * operator()(R (&array)[N]) const noexcept
+            {
+                return array + N;
+            }
+
+            template<typename R>
+#ifdef RANGES_WORKAROUND_GCC_89953
+            constexpr auto CPP_fun(operator())(R && r)(
+                const noexcept(noexcept(impl_v<R>((R &&) r))) //
+                requires(has_member_end<R> || has_non_member_end<R>))
+#else
+            constexpr auto CPP_fun(operator())(R && r)(
+                const noexcept(noexcept(impl<R>{}((R &&) r))) //
+                requires(has_member_end<R> || has_non_member_end<R>))
+#endif
+            {
+                return impl<R>{}((R &&) r);
+            }
+
+#if defined(__cpp_lib_string_view) && __cpp_lib_string_view > 0
+            template<class CharT, class Traits>
+            constexpr auto operator()(std::basic_string_view<CharT, Traits> r) const
+                noexcept
+            {
+                return r.end();
+            }
+#endif
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(std::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(ranges::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+
+            template<typename Int>
+            auto operator-(Int dist) const
+                -> CPP_ret(detail::from_end_<iter_diff_t<Int>>)( //
+                    requires detail::integer_like_<Int>)
+            {
+                using SInt = iter_diff_t<Int>;
+                RANGES_EXPECT(0 <= dist);
+                RANGES_EXPECT(dist <=
+                              static_cast<Int>((std::numeric_limits<SInt>::max)()));
+                return detail::from_end_<SInt>{-static_cast<SInt>(dist)};
+            }
+        };
+
+        // has_member_end == false
+        template<>
+        struct fn::impl_<false>
+        {
+            template<typename R>
+            constexpr auto operator()(R && r) const noexcept(noexcept(end((R &&) r)))
+            {
+                return end((R &&) r);
+            }
+        };
+
+        template<typename R>
+        using _t = decltype(fn{}(std::declval<R>()));
+    } // namespace _end_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return \c r+size(r), if \c r is an array. Otherwise, `r.end()` if that expression
+    /// is
+    ///   well-formed and returns an input_or_output_iterator. Otherwise, `end(r)` if that
+    ///   expression returns an input_or_output_iterator.
+    RANGES_DEFINE_CPO(_end_::fn, end)
+
+    /// \cond
+    namespace _cbegin_
+    {
+        struct fn
+        {
+            template<typename R>
+            constexpr _begin_::_t<detail::as_const_t<R>> operator()(R && r) const
+                noexcept(noexcept(ranges::begin(detail::as_const((R &&) r))))
+            {
+                return ranges::begin(detail::as_const((R &&) r));
+            }
+        };
+    } // namespace _cbegin_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return The result of calling `ranges::begin` with a const-qualified
+    ///    reference to r.
+    RANGES_INLINE_VARIABLE(_cbegin_::fn, cbegin)
+
+    /// \cond
+    namespace _cend_
+    {
+        struct fn
+        {
+            template<typename R>
+            constexpr _end_::_t<detail::as_const_t<R>> operator()(R && r) const
+                noexcept(noexcept(ranges::end(detail::as_const((R &&) r))))
+            {
+                return ranges::end(detail::as_const((R &&) r));
+            }
+        };
+    } // namespace _cend_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return The result of calling `ranges::end` with a const-qualified
+    ///    reference to r.
+    RANGES_INLINE_VARIABLE(_cend_::fn, cend)
+
+    /// \cond
+    namespace _rbegin_
+    {
+        template<typename R>
+        void rbegin(R &&) = delete;
+        // Non-standard, to keep unqualified rbegin(r) from finding std::rbegin
+        // and returning a std::reverse_iterator.
+        template<typename T>
+        void rbegin(std::initializer_list<T>) = delete;
+        template<typename T, std::size_t N>
+        void rbegin(T (&)[N]) = delete;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename T)
+            concept has_member_rbegin,
+                requires (T &t)
+                (
+                    _begin_::is_iterator(t.rbegin())
+                ) &&
+                std::is_lvalue_reference<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept has_non_member_rbegin,
+                requires (T &&t)
+                (
+                    _begin_::is_iterator(rbegin((T &&) t))
+                )
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept can_reverse_end,
+                requires (T &&t)
+                (
+                    // make_reverse_iterator is constrained with
+                    // bidirectional_iterator.
+                    ranges::make_reverse_iterator(ranges::end((T &&) t))
+                ) &&
+                same_as<_begin_::_t<T>, _end_::_t<T>>
+        );
+        // clang-format on
+
+        struct fn
+        {
+        private:
+            // has_member_rbegin == true
+            template<int>
+            struct impl_
+            {
+                template<typename R>
+                constexpr auto operator()(R && r) const noexcept(noexcept(r.rbegin()))
+                {
+                    return r.rbegin();
+                }
+            };
+
+            template<typename R>
+            using impl =
+                impl_<has_member_rbegin<R> ? 0 : has_non_member_rbegin<R> ? 1 : 2>;
+
+        public:
+            template<typename R>
+            constexpr auto CPP_fun(operator())(R && r)(
+                const noexcept(noexcept(impl<R>{}((R &&) r))) //
+                requires(has_member_rbegin<R> || has_non_member_rbegin<R> ||
+                         can_reverse_end<R>))
+            {
+                return impl<R>{}((R &&) r);
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(std::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(ranges::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+        };
+
+        // has_non_member_rbegin == true
+        template<>
+        struct fn::impl_<1>
+        {
+            template<typename R>
+            constexpr auto operator()(R && r) const noexcept(noexcept(rbegin((R &&) r)))
+            {
+                return rbegin((R &&) r);
+            }
+        };
+
+        // can_reverse_end
+        template<>
+        struct fn::impl_<2>
+        {
+            template<typename R>
+            constexpr auto operator()(R && r) const
+                noexcept(noexcept(ranges::make_reverse_iterator(ranges::end((R &&) r))))
+            {
+                return ranges::make_reverse_iterator(ranges::end((R &&) r));
+            }
+        };
+
+        template<typename R>
+        using _t = decltype(fn{}(std::declval<R>()));
+    } // namespace _rbegin_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return `make_reverse_iterator(r+size(r))` if r is an array. Otherwise,
+    ///   `r.rbegin()` if that expression is well-formed and returns an
+    ///   input_or_output_iterator. Otherwise, `make_reverse_iterator(ranges::end(r))` if
+    ///   `ranges::begin(r)` and `ranges::end(r)` are both well-formed and have the same
+    ///   type that satisfies bidirectional_iterator.
+    RANGES_DEFINE_CPO(_rbegin_::fn, rbegin)
+
+    /// \cond
+    namespace _rend_
+    {
+        template<typename R>
+        void rend(R &&) = delete;
+        // Non-standard, to keep unqualified rend(r) from finding std::rend
+        // and returning a std::reverse_iterator.
+        template<typename T>
+        void rend(std::initializer_list<T>) = delete;
+        template<typename T, std::size_t N>
+        void rend(T (&)[N]) = delete;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename T)
+            concept has_member_rend,
+                requires (T &t)
+                (
+                    _end_::is_sentinel<_rbegin_::_t<T &>>(t.rend())
+                ) &&
+                std::is_lvalue_reference<T>::value
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept has_non_member_rend,
+                requires (T &&t)
+                (
+                    _end_::is_sentinel<_rbegin_::_t<T &>>(rend((T &&) t))
+                )
+        );
+
+        CPP_def
+        (
+            template(typename T)
+            concept can_reverse_begin,
+                requires (T &&t)
+                (
+                    // make_reverse_iterator is constrained with
+                    // bidirectional_iterator.
+                    ranges::make_reverse_iterator(ranges::begin((T &&) t))
+                ) &&
+                same_as<_begin_::_t<T>, _end_::_t<T>>
+        );
+        // clang-format on
+
+        struct fn
+        {
+        private:
+            // has_member_rbegin == true
+            template<int>
+            struct impl_
+            {
+                template<typename R>
+                constexpr auto operator()(R && r) const noexcept(noexcept(r.rend()))
+                {
+                    return r.rend();
+                }
+            };
+
+            template<typename R>
+            using impl = impl_<has_member_rend<R> ? 0 : has_non_member_rend<R> ? 1 : 2>;
+
+        public:
+            template<typename R>
+            constexpr auto CPP_fun(operator())(R && r)(
+                const noexcept(noexcept(impl<R>{}((R &&) r))) //
+                requires(has_member_rend<R> || has_non_member_rend<R> ||
+                         can_reverse_begin<R>))
+            {
+                return impl<R>{}((R &&) r);
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(std::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(ranges::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+        };
+
+        // has_non_member_rend == true
+        template<>
+        struct fn::impl_<1>
+        {
+            template<typename R>
+            constexpr auto operator()(R && r) const noexcept(noexcept(rend((R &&) r)))
+            {
+                return rend((R &&) r);
+            }
+        };
+
+        // can_reverse_begin
+        template<>
+        struct fn::impl_<2>
+        {
+            template<typename R>
+            constexpr auto operator()(R && r) const
+                noexcept(noexcept(ranges::make_reverse_iterator(ranges::begin((R &&) r))))
+            {
+                return ranges::make_reverse_iterator(ranges::begin((R &&) r));
+            }
+        };
+
+        template<typename R>
+        using _t = decltype(fn{}(std::declval<R>()));
+    } // namespace _rend_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return `make_reverse_iterator(r))` if r is an array. Otherwise,
+    ///   `r.rend()` if that expression is well-formed and returns a type that
+    ///   satisfies `sentinel_for<S, I>` where `I` is the type of `ranges::rbegin(r)`.
+    ///   Otherwise, `make_reverse_iterator(ranges::begin(r))` if `ranges::begin(r)`
+    ///   and `ranges::end(r)` are both well-formed and have the same type that
+    ///   satisfies bidirectional_iterator.
+    RANGES_DEFINE_CPO(_rend_::fn, rend)
+
+    /// \cond
+    namespace _crbegin_
+    {
+        struct fn
+        {
+            template<typename R>
+            constexpr _rbegin_::_t<detail::as_const_t<R>> operator()(R && r) const
+                noexcept(noexcept(ranges::rbegin(detail::as_const((R &&) r))))
+            {
+                return ranges::rbegin(detail::as_const((R &&) r));
+            }
+        };
+    } // namespace _crbegin_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return The result of calling `ranges::rbegin` with a const-qualified
+    ///    reference to r.
+    RANGES_INLINE_VARIABLE(_crbegin_::fn, crbegin)
+
+    /// \cond
+    namespace _crend_
+    {
+        struct fn
+        {
+            template<typename R>
+            constexpr _rend_::_t<detail::as_const_t<R>> operator()(R && r) const
+                noexcept(noexcept(ranges::rend(detail::as_const((R &&) r))))
+            {
+                return ranges::rend(detail::as_const((R &&) r));
+            }
+        };
+    } // namespace _crend_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return The result of calling `ranges::rend` with a const-qualified
+    ///    reference to r.
+    RANGES_INLINE_VARIABLE(_crend_::fn, crend)
+
+    template<typename Rng>
+    using iterator_t = decltype(begin(std::declval<Rng &>()));
+
+    template<typename Rng>
+    using sentinel_t = decltype(end(std::declval<Rng &>()));
+
+    namespace cpp20
+    {
+        using ranges::begin;
+        using ranges::cbegin;
+        using ranges::cend;
+        using ranges::crbegin;
+        using ranges::crend;
+        using ranges::end;
+        using ranges::rbegin;
+        using ranges::rend;
+
+        using ranges::iterator_t;
+        using ranges::sentinel_t;
+    } // namespace cpp20
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range/concepts.hpp b/inst/include/range/v3/range/concepts.hpp
new file mode 100644
index 0000000..40aaf19
--- /dev/null
+++ b/inst/include/range/v3/range/concepts.hpp
@@ -0,0 +1,450 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_CONCEPTS_HPP
+#define RANGES_V3_RANGE_CONCEPTS_HPP
+
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+
+#ifndef RANGES_NO_STD_FORWARD_DECLARATIONS
+// Non-portable forward declarations of standard containers
+RANGES_BEGIN_NAMESPACE_STD
+    RANGES_BEGIN_NAMESPACE_CONTAINER
+        template<typename Key,
+                 typename Compare /*= less<Key>*/,
+                 typename Alloc /*= allocator<Key>*/>
+        class set;
+
+        template<typename Key,
+                 typename Compare /*= less<Key>*/,
+                 typename Alloc /*= allocator<Key>*/>
+        class multiset;
+
+        template<typename Key,
+                 typename Hash /*= hash<Key>*/,
+                 typename Pred /*= equal_to<Key>*/,
+                 typename Alloc /*= allocator<Key>*/>
+        class unordered_set;
+
+        template<typename Key,
+                 typename Hash /*= hash<Key>*/,
+                 typename Pred /*= equal_to<Key>*/,
+                 typename Alloc /*= allocator<Key>*/>
+        class unordered_multiset;
+    RANGES_END_NAMESPACE_CONTAINER
+RANGES_END_NAMESPACE_STD
+#else
+#include <set>
+#include <unordered_set>
+#endif
+
+namespace ranges
+{
+    /// \addtogroup group-range
+    /// @{
+
+    ///
+    /// Range concepts below
+    ///
+
+    /// \cond
+    // clang-format off
+    CPP_def
+    (
+        template(typename T)
+        concept range_impl_,
+            requires(T &&t) (
+                ranges::begin(static_cast<T &&>(t)), // not necessarily equality-preserving
+                ranges::end(static_cast<T &&>(t))
+            )
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept range,
+            range_impl_<T &>
+    );
+
+    /// \cond
+    CPP_def
+    (
+        template(typename T)
+        concept forwarding_range_,
+            range<T> && range_impl_<T>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T, typename V)
+        concept output_range,
+            range<T> && output_iterator<iterator_t<T>, V>
+    );
+
+    /// \cond
+    // Needed to work around a bug in GCC
+    CPP_def
+    (
+        template(typename T)
+        concept input_range_,
+            input_iterator<iterator_t<T>>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept input_range,
+            range<T> && input_range_<T>
+    );
+
+    /// \cond
+    // Needed to work around a bug in GCC
+    CPP_def
+    (
+        template(typename T)
+        concept forward_range_,
+            forward_iterator<iterator_t<T>>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept forward_range,
+            input_range<T> && forward_range_<T>
+    );
+
+    /// \cond
+    // Needed to work around a bug in GCC
+    CPP_def
+    (
+        template(typename T)
+        concept bidirectional_range_,
+            bidirectional_iterator<iterator_t<T>>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept bidirectional_range,
+            forward_range<T> && bidirectional_range_<T>
+    );
+
+    /// \cond
+    // Needed to work around a bug in GCC
+    CPP_def
+    (
+        template(typename T)
+        concept random_access_range_,
+            random_access_iterator<iterator_t<T>>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept random_access_range,
+            bidirectional_range<T> && random_access_range_<T>
+    );
+    // clang-format on
+
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng>
+        using data_t = decltype(ranges::data(std::declval<Rng &>()));
+
+        template<typename Rng>
+        using element_t = meta::_t<std::remove_pointer<data_t<Rng>>>;
+    } // namespace detail
+      /// \endcond
+
+    /// \cond
+    // Needed to work around a bug in GCC
+    // clang-format off
+    CPP_def
+    (
+        template(typename T)
+        concept contiguous_range_,
+            contiguous_iterator<iterator_t<T>> &&
+            same_as<detail::data_t<T>, meta::_t<std::add_pointer<iter_reference_t<iterator_t<T>>>>>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept contiguous_range,
+            random_access_range<T> && contiguous_range_<T>
+    );
+
+    /// \cond
+    // Needed to work around a bug in GCC
+    CPP_def
+    (
+        template(typename T)
+        concept common_range_,
+            same_as<iterator_t<T>, sentinel_t<T>>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept common_range,
+            range<T> && common_range_<T>
+    );
+
+    /// \cond
+    CPP_def
+    (
+        template(typename T)
+        concept bounded_range,
+            common_range<T>
+    );
+    /// \endcond
+
+    CPP_def
+    (
+        template(typename T)
+        concept sized_range,
+            requires (T &t)
+            (
+                ranges::size(t)
+            ) &&
+            range<T> &&
+            detail::integer_like_<range_size_t<T>> &&
+            !disable_sized_range<uncvref_t<T>>
+    );
+    // clang-format on
+
+    /// \cond
+    namespace detail
+    {
+        struct enable_view_helper_
+        {
+            bool result_;
+
+            template<typename T>
+            static constexpr auto test(T const *) -> CPP_ret(bool)( //
+                requires range<T> && range<T const>)
+            {
+                return RANGES_IS_SAME(iter_reference_t<iterator_t<T>>,
+                                      iter_reference_t<iterator_t<T const>>);
+            }
+            static constexpr auto test(void const *) -> bool
+            {
+                return true;
+            }
+            template<typename T>
+            constexpr enable_view_helper_(T const * p)
+              : result_(enable_view_helper_::test(p))
+            {}
+        };
+        constexpr bool enable_view_impl_(...)
+        {
+            return false;
+        }
+        constexpr bool enable_view_impl_(view_base const *)
+        {
+            return true;
+        }
+        constexpr bool enable_view_impl_(enable_view_helper_ ev)
+        {
+            return ev.result_;
+        }
+        template<typename T>
+        constexpr bool enable_view_impl_(std::initializer_list<T> const *)
+        {
+            return false;
+        }
+        template<typename Key, typename Compare, typename Alloc>
+        constexpr bool enable_view_impl_(std::set<Key, Compare, Alloc> const *)
+        {
+            return false;
+        }
+        template<typename Key, typename Compare, typename Alloc>
+        constexpr bool enable_view_impl_(std::multiset<Key, Compare, Alloc> const *)
+        {
+            return false;
+        }
+        template<typename Key, typename Hash, typename Pred, typename Alloc>
+        constexpr bool enable_view_impl_(
+            std::unordered_set<Key, Hash, Pred, Alloc> const *)
+        {
+            return false;
+        }
+        template<typename Key, typename Hash, typename Pred, typename Alloc>
+        constexpr bool enable_view_impl_(
+            std::unordered_multiset<Key, Hash, Pred, Alloc> const *)
+        {
+            return false;
+        }
+        // BUGBUG TODO
+        // template<typename BidiIter, typename Alloc>
+        // constexpr bool enable_view_impl_(std::match_results<BidiIter, Alloc> const *)
+        // {
+        //     return false;
+        // }
+        template<typename T>
+        constexpr T const * nullptr_(int)
+        {
+            return nullptr;
+        }
+        template<typename T>
+        constexpr int nullptr_(long)
+        {
+            return 0;
+        }
+    } // namespace detail
+    /// \endcond
+
+    // Specialize this if the default is wrong.
+    template<typename T>
+    RANGES_INLINE_VAR constexpr bool enable_view =
+        detail::enable_view_impl_(detail::nullptr_<T>(0));
+
+    ///
+    /// View concepts below
+    ///
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename T)
+        concept view_,
+            range<T> &&
+            semiregular<T> &&
+            enable_view<T>
+    );
+
+    CPP_def
+    (
+        template(typename T)
+        concept viewable_range,
+            range<T> &&
+            (forwarding_range_<T> || view_<detail::decay_t<T>>)
+    );
+    // clang-format on
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // range_tag
+    struct range_tag
+    {};
+
+    struct input_range_tag : range_tag
+    {};
+    struct forward_range_tag : input_range_tag
+    {};
+    struct bidirectional_range_tag : forward_range_tag
+    {};
+    struct random_access_range_tag : bidirectional_range_tag
+    {};
+    struct contiguous_range_tag : random_access_range_tag
+    {};
+
+    template<typename Rng>
+    using range_tag_of =                          //
+        std::enable_if_t<                         //
+            range<Rng>,                           //
+            detail::if_then_t<                    //
+                contiguous_range<Rng>,            //
+                contiguous_range_tag,             //
+                detail::if_then_t<                //
+                    random_access_range<Rng>,     //
+                    random_access_range_tag,      //
+                    detail::if_then_t<            //
+                        bidirectional_range<Rng>, //
+                        bidirectional_range_tag,  //
+                        detail::if_then_t<        //
+                            forward_range<Rng>,   //
+                            forward_range_tag,    //
+                            detail::if_then_t<    //
+                                input_range<Rng>, //
+                                input_range_tag,  //
+                                range_tag>>>>>>;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // common_range_tag_of
+    struct common_range_tag : range_tag
+    {};
+
+    template<typename Rng>
+    using common_range_tag_of = //
+        std::enable_if_t<       //
+            range<Rng>,         //
+            detail::if_then_t<common_range<Rng>, common_range_tag, range_tag>>;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    // sized_range_concept
+    struct sized_range_tag : range_tag
+    {};
+
+    template<typename Rng>
+    using sized_range_tag_of = //
+        std::enable_if_t<      //
+            range<Rng>,        //
+            detail::if_then_t<sized_range<Rng>, sized_range_tag, range_tag>>;
+
+    /// \cond
+    namespace view_detail_
+    {
+        // clang-format off
+        CPP_def
+        (
+            template(typename T)
+            concept view,
+                ranges::view_<T>
+        );
+        // clang-format on
+    } // namespace view_detail_
+    /// \endcond
+
+    namespace cpp20
+    {
+        using ranges::bidirectional_range;
+        using ranges::common_range;
+        using ranges::contiguous_range;
+        using ranges::enable_view;
+        using ranges::forward_range;
+        using ranges::input_range;
+        using ranges::output_range;
+        using ranges::random_access_range;
+        using ranges::range;
+        using ranges::sized_range;
+        using ranges::viewable_range;
+        using ranges::view_detail_::view;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range/conversion.hpp b/inst/include/range/v3/range/conversion.hpp
new file mode 100644
index 0000000..6854131
--- /dev/null
+++ b/inst/include/range/v3/range/conversion.hpp
@@ -0,0 +1,510 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_CONVERSION_HPP
+#define RANGES_V3_RANGE_CONVERSION_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/action/concepts.hpp>
+#include <range/v3/functional/pipeable.hpp>
+#include <range/v3/iterator/common_iterator.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+#ifndef RANGES_NO_STD_FORWARD_DECLARATIONS
+// Non-portable forward declarations of standard containers
+RANGES_BEGIN_NAMESPACE_STD
+    RANGES_BEGIN_NAMESPACE_CONTAINER
+        template<typename Value, typename Alloc /*= allocator<Value>*/>
+        class vector;
+    RANGES_END_NAMESPACE_CONTAINER
+RANGES_END_NAMESPACE_STD
+#else
+#include <vector>
+#endif
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        struct to_container
+        {
+            template<typename MetaFn>
+            struct fn;
+
+            template<typename MetaFn, typename Fn>
+            struct closure;
+
+            template<typename MetaFn, typename Rng>
+            using container_t = meta::invoke<MetaFn, Rng>;
+
+            template<typename Rng, typename MetaFn>
+            friend auto operator|(Rng && rng,
+                                  closure<MetaFn, fn<MetaFn>> (*)(to_container))
+                -> CPP_broken_friend_ret(container_t<MetaFn, Rng>)( //
+                    requires invocable<fn<MetaFn>, Rng>)
+            {
+                return fn<MetaFn>{}(static_cast<Rng &&>(rng));
+            }
+
+            template<typename MetaFn, typename Pipeable>
+            friend auto operator|(closure<MetaFn, fn<MetaFn>> (*)(to_container),
+                                  Pipeable pipe)
+                -> CPP_broken_friend_ret(
+                    closure<MetaFn, composed<Pipeable, fn<MetaFn>>>)( //
+                    requires(is_pipeable_v<Pipeable>))
+            {
+                return closure<MetaFn, composed<Pipeable, fn<MetaFn>>>{
+                    compose(static_cast<Pipeable &&>(pipe), fn<MetaFn>{})};
+            }
+        };
+
+        // A simple, light-weight transform iterator that applies ranges::to
+        // to each element in the range. Used by ranges::to to convert a range
+        // of ranges into a container of containers.
+        template<typename Rng, typename Cont>
+        struct to_container_iterator
+        {
+        private:
+            using I = range_cpp17_iterator_t<Rng>;
+            using ValueType = range_value_t<Cont>;
+            I it_;
+
+        public:
+            using difference_type = typename std::iterator_traits<I>::difference_type;
+            using value_type = ValueType;
+            using reference = ValueType;
+            using pointer = typename std::iterator_traits<I>::pointer;
+            using iterator_category = typename std::iterator_traits<I>::iterator_category;
+
+            to_container_iterator() = default;
+            template<typename OtherIt>
+            to_container_iterator(OtherIt it)
+              : it_(std::move(it))
+            {}
+            friend bool operator==(to_container_iterator const & a,
+                                   to_container_iterator const & b)
+            {
+                return a.it_ == b.it_;
+            }
+            friend bool operator!=(to_container_iterator const & a,
+                                   to_container_iterator const & b)
+            {
+                return !(a == b);
+            }
+            reference operator*() const
+            {
+                return to_container::fn<meta::id<ValueType>>{}(*it_);
+            }
+            to_container_iterator & operator++()
+            {
+                ++it_;
+                return *this;
+            }
+            to_container_iterator operator++(int)
+            {
+                auto tmp = *this;
+                ++it_;
+                return tmp;
+            }
+            CPP_member
+            auto operator--() -> CPP_ret(to_container_iterator &)(
+                requires derived_from<iterator_category, std::bidirectional_iterator_tag>)
+            {
+                --it_;
+                return *this;
+            }
+            CPP_member
+            auto operator--(int) -> CPP_ret(to_container_iterator &)(
+                requires derived_from<iterator_category, std::bidirectional_iterator_tag>)
+            {
+                auto tmp = *this;
+                ++it_;
+                return tmp;
+            }
+            CPP_member
+            auto operator+=(difference_type n) -> CPP_ret(to_container_iterator &)(
+                requires derived_from<iterator_category, std::random_access_iterator_tag>)
+            {
+                it_ += n;
+                return *this;
+            }
+            CPP_member
+            auto operator-=(difference_type n) -> CPP_ret(to_container_iterator &)(
+                requires derived_from<iterator_category, std::random_access_iterator_tag>)
+            {
+                it_ -= n;
+                return *this;
+            }
+            CPP_broken_friend_member
+            friend auto operator+(to_container_iterator i, difference_type n) //
+                -> CPP_broken_friend_ret(to_container_iterator)(
+                    requires derived_from<iterator_category,
+                                          std::random_access_iterator_tag>)
+            {
+                return i += n;
+            }
+            CPP_broken_friend_member
+            friend auto operator-(to_container_iterator i, difference_type n) //
+                -> CPP_broken_friend_ret(to_container_iterator)(
+                    requires derived_from<iterator_category,
+                                          std::random_access_iterator_tag>)
+            {
+                return i -= n;
+            }
+            CPP_broken_friend_member
+            friend auto operator-(difference_type n, to_container_iterator i) //
+                -> CPP_broken_friend_ret(to_container_iterator)(
+                    requires derived_from<iterator_category,
+                                          std::random_access_iterator_tag>)
+            {
+                return i -= n;
+            }
+            CPP_broken_friend_member
+            friend auto operator-(to_container_iterator const & i,
+                                  to_container_iterator const & j) //
+                -> CPP_broken_friend_ret(difference_type)(
+                    requires derived_from<iterator_category,
+                                          std::random_access_iterator_tag>)
+            {
+                return i.it_ - j.it_;
+            }
+            CPP_member
+            auto operator[](difference_type n) const -> CPP_ret(reference)(
+                requires derived_from<iterator_category, std::random_access_iterator_tag>)
+            {
+                return *(*this + n);
+            }
+        };
+
+        template<typename Rng, typename Cont>
+        using to_container_iterator_t =
+            enable_if_t<(bool)range<Rng>, to_container_iterator<Rng, Cont>>;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename Cont)
+            concept has_allocator_type,
+                ranges::type<typename Cont::allocator_type>
+        );
+
+        CPP_def
+        (
+            template(typename Rng, typename Cont)
+            concept convertible_to_cont_impl_,
+                range<Cont> && (!view_<Cont>) && move_constructible<Cont> &&
+                constructible_from<range_value_t<Cont>, range_reference_t<Rng>> &&
+                constructible_from<
+                    Cont,
+                    range_cpp17_iterator_t<Rng>,
+                    range_cpp17_iterator_t<Rng>>
+        );
+
+        CPP_def
+        (
+            template(typename Rng, typename Cont)
+            concept convertible_to_cont_cont_impl_,
+                range<Cont> && (!view_<Cont>) && move_constructible<Cont> &&
+                (bool(ranges::defer::range<range_value_t<Cont>> &&
+                    !ranges::defer::view_<range_value_t<Cont>>)) &&
+                // Test that each element of the input range can be ranges::to<>
+                // to the output container.
+                invocable<
+                    to_container::fn<meta::id<range_value_t<Cont>>>,
+                    range_reference_t<Rng>> &&
+                constructible_from<
+                    Cont,
+                    to_container_iterator_t<Rng, Cont>,
+                    to_container_iterator_t<Rng, Cont>>
+        );
+
+        CPP_def
+        (
+            template(typename Rng, typename Cont)
+            concept convertible_to_cont,
+                defer::has_allocator_type<Cont> && // HACKHACK
+                defer::convertible_to_cont_impl_<Rng, Cont>
+        );
+
+        CPP_def
+        (
+            template(typename Rng, typename Cont)
+            concept convertible_to_cont_cont,
+                defer::has_allocator_type<Cont> && // HACKHACK
+                defer::convertible_to_cont_cont_impl_<Rng, Cont>
+        );
+
+        CPP_def
+        (
+            template(typename C, typename I, typename R)
+            concept to_container_reserve,
+                reservable_with_assign<C, I> &&
+                sized_range<R>
+        );
+        // clang-format on
+
+        struct RANGES_STRUCT_WITH_ADL_BARRIER(to_container_closure_base)
+        {
+            template<typename MetaFn, typename Rng>
+            using container_t = meta::invoke<MetaFn, Rng>;
+
+            CPP_template(typename Rng, typename MetaFn, typename Fn)(              //
+                requires input_range<Rng> &&                                       //
+                (bool(defer::convertible_to_cont_cont<Rng,                         //
+                                                      container_t<MetaFn, Rng>> || //
+                      defer::convertible_to_cont<Rng, container_t<MetaFn, Rng>>))) //
+                friend constexpr auto
+                operator|(Rng && rng, to_container::closure<MetaFn, Fn> fn)
+            {
+                return static_cast<Fn &&>(fn)(static_cast<Rng &&>(rng));
+            }
+
+            template<typename MetaFn, typename Fn, typename Pipeable>
+            friend constexpr auto operator|(to_container::closure<MetaFn, Fn> sh,
+                                            Pipeable pipe)
+                -> CPP_broken_friend_ret(
+                    to_container::closure<MetaFn, composed<Pipeable, Fn>>)(
+                    requires(is_pipeable_v<Pipeable>))
+            {
+                return to_container::closure<MetaFn, composed<Pipeable, Fn>>{
+                    compose(static_cast<Pipeable &&>(pipe), static_cast<Fn &&>(sh))};
+            }
+        };
+
+        template<typename MetaFn, typename Fn>
+        struct to_container::closure
+          : to_container_closure_base
+          , Fn
+        {
+            closure() = default;
+            constexpr explicit closure(Fn fn)
+              : Fn(static_cast<Fn &&>(fn))
+            {}
+        };
+
+        template<typename ToContainer>
+        struct to_container::fn
+        {
+        private:
+            template<typename Cont, typename I, typename Rng>
+            static Cont impl(Rng && rng, std::false_type)
+            {
+                return Cont(I{ranges::begin(rng)}, I{ranges::end(rng)});
+            }
+            template<typename Cont, typename I, typename Rng>
+            static auto impl(Rng && rng, std::true_type)
+            {
+                Cont c;
+                auto const rng_size = ranges::size(rng);
+                using size_type = decltype(c.max_size());
+                using C = common_type_t<range_size_t<Rng>, size_type>;
+                RANGES_EXPECT(static_cast<C>(rng_size) <= static_cast<C>(c.max_size()));
+                c.reserve(static_cast<size_type>(rng_size));
+                c.assign(I{ranges::begin(rng)}, I{ranges::end(rng)});
+                return c;
+            }
+            template<typename Rng>
+            using container_t = meta::invoke<ToContainer, Rng>;
+
+        public:
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(container_t<Rng>)( //
+                requires input_range<Rng> &&                                //
+                (bool(!defer::convertible_to_cont_cont<Rng,                 //
+                                                       container_t<Rng>> && //
+                      defer::convertible_to_cont<Rng, container_t<Rng>>)))
+            {
+                static_assert(!is_infinite<Rng>::value,
+                              "Attempt to convert an infinite range to a container.");
+                using cont_t = container_t<Rng>;
+                using iter_t = range_cpp17_iterator_t<Rng>;
+                using use_reserve_t =
+                    meta::bool_<(bool)to_container_reserve<cont_t, iter_t, Rng>>;
+                return impl<cont_t, iter_t>(static_cast<Rng &&>(rng), use_reserve_t{});
+            }
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(container_t<Rng>)( //
+                requires input_range<Rng> &&                                //
+                    convertible_to_cont_cont<Rng, container_t<Rng>>)
+            {
+                static_assert(!is_infinite<Rng>::value,
+                              "Attempt to convert an infinite range to a container.");
+                using cont_t = container_t<Rng>;
+                using iter_t = to_container_iterator<Rng, cont_t>;
+                using use_reserve_t =
+                    meta::bool_<(bool)to_container_reserve<cont_t, iter_t, Rng>>;
+                return impl<cont_t, iter_t>(static_cast<Rng &&>(rng), use_reserve_t{});
+            }
+        };
+
+        template<typename MetaFn, typename Fn>
+        using to_container_closure = to_container::closure<MetaFn, Fn>;
+
+        template<typename MetaFn>
+        using to_container_fn = to_container_closure<MetaFn, to_container::fn<MetaFn>>;
+
+        template<template<typename...> class ContT>
+        struct from_range
+        {
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+            // Attempt to use a deduction guide first...
+            template<typename Rng>
+            static auto from_rng_(int) -> decltype(ContT(range_cpp17_iterator_t<Rng>{},
+                                                         range_cpp17_iterator_t<Rng>{}));
+            // No deduction guide. Fallback to instantiating with the
+            // iterator's value type.
+            template<typename Rng>
+            static auto from_rng_(long)
+                -> meta::invoke<meta::quote<ContT>, range_value_t<Rng>>;
+
+            template<typename Rng>
+            using invoke = decltype(from_range::from_rng_<Rng>(0));
+#else
+            template<typename Rng>
+            using invoke = meta::invoke<meta::quote<ContT>, range_value_t<Rng>>;
+#endif
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-range
+    /// @{
+
+    /// \ingroup group-range
+    RANGES_INLINE_VARIABLE(detail::to_container_fn<detail::from_range<std::vector>>,
+                           to_vector)
+
+    /// \cond
+    namespace _to_
+    {
+        /// \endcond
+
+        /// \brief For initializing a container of the specified type with the elements of
+        /// an Range
+        template<template<typename...> class ContT>
+        auto to(RANGES_HIDDEN_DETAIL(detail::to_container = {}))
+            -> detail::to_container_fn<detail::from_range<ContT>>
+        {
+            return {};
+        }
+
+        /// \overload
+        template<template<typename...> class ContT, typename Rng>
+        auto to(Rng && rng) -> CPP_ret(ContT<range_value_t<Rng>>)( //
+            requires range<Rng> &&
+                detail::convertible_to_cont<Rng, ContT<range_value_t<Rng>>>)
+        {
+            return detail::to_container_fn<detail::from_range<ContT>>{}(
+                static_cast<Rng &&>(rng));
+        }
+
+        /// \overload
+        template<typename Cont>
+        auto to(RANGES_HIDDEN_DETAIL(detail::to_container = {}))
+            -> detail::to_container_fn<meta::id<Cont>>
+        {
+            return {};
+        }
+
+        /// \overload
+        template<typename Cont, typename Rng>
+        auto to(Rng && rng) -> CPP_ret(Cont)( //
+            requires range<Rng> && detail::convertible_to_cont<Rng, Cont>)
+        {
+            return detail::to_container_fn<meta::id<Cont>>{}(static_cast<Rng &&>(rng));
+        }
+
+        /// \cond
+        // Slightly odd initializer_list overloads, undocumented for now.
+        template<template<typename...> class ContT, typename T>
+        auto to(std::initializer_list<T> il) -> CPP_ret(ContT<T>)( //
+            requires detail::convertible_to_cont<std::initializer_list<T>, ContT<T>>)
+        {
+            return detail::to_container_fn<detail::from_range<ContT>>{}(il);
+        }
+        template<typename Cont, typename T>
+        auto to(std::initializer_list<T> il) -> CPP_ret(Cont)( //
+            requires detail::convertible_to_cont<std::initializer_list<T>, Cont>)
+        {
+            return detail::to_container_fn<meta::id<Cont>>{}(il);
+        }
+        /// \endcond
+
+        /// \cond
+    } // namespace _to_
+    using namespace _to_;
+    /// \endcond
+    /// @}
+
+    ////////////////////////////////////////////////////////////////////////////
+    /// \cond
+    namespace _to_
+    {
+        // The old name "ranges::to_" is now deprecated:
+        template<template<typename...> class ContT>
+        RANGES_DEPRECATED("Please use ranges::to (no underscore) instead.")
+        auto to_(detail::to_container = {})
+            -> detail::to_container_fn<detail::from_range<ContT>>
+        {
+            return {};
+        }
+        template<template<typename...> class ContT, typename Rng>
+        RANGES_DEPRECATED("Please use ranges::to (no underscore) instead.")
+        auto to_(Rng && rng) -> CPP_ret(ContT<range_value_t<Rng>>)( //
+            requires range<Rng> &&
+                detail::convertible_to_cont<Rng, ContT<range_value_t<Rng>>>)
+        {
+            return static_cast<Rng &&>(rng) | ranges::to_<ContT>();
+        }
+        template<template<typename...> class ContT, typename T>
+        RANGES_DEPRECATED("Please use ranges::to (no underscore) instead.")
+        auto to_(std::initializer_list<T> il) -> CPP_ret(ContT<T>)( //
+            requires detail::convertible_to_cont<std::initializer_list<T>, ContT<T>>)
+        {
+            return il | ranges::to_<ContT>();
+        }
+        template<typename Cont>
+        RANGES_DEPRECATED("Please use ranges::to (no underscore) instead.")
+        auto to_(detail::to_container = {}) -> detail::to_container_fn<meta::id<Cont>>
+        {
+            return {};
+        }
+        template<typename Cont, typename Rng>
+        RANGES_DEPRECATED("Please use ranges::to (no underscore) instead.")
+        auto to_(Rng && rng) -> CPP_ret(Cont)( //
+            requires range<Rng> && detail::convertible_to_cont<Rng, Cont>)
+        {
+            return static_cast<Rng &&>(rng) | ranges::to_<Cont>();
+        }
+        template<typename Cont, typename T>
+        RANGES_DEPRECATED("Please use ranges::to (no underscore) instead.")
+        auto to_(std::initializer_list<T> list) -> CPP_ret(Cont)( //
+            requires detail::convertible_to_cont<std::initializer_list<T>, Cont>)
+        {
+            return list | ranges::to_<Cont>();
+        }
+    } // namespace _to_
+    /// \endcond
+
+    template<typename MetaFn, typename Fn>
+    RANGES_INLINE_VAR constexpr bool
+        is_pipeable_v<detail::to_container_closure<MetaFn, Fn>> = true;
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range/dangling.hpp b/inst/include/range/v3/range/dangling.hpp
new file mode 100644
index 0000000..66935bc
--- /dev/null
+++ b/inst/include/range/v3/range/dangling.hpp
@@ -0,0 +1,80 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_DANGLING_HPP
+#define RANGES_V3_RANGE_DANGLING_HPP
+
+#include <utility>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \ingroup group-range
+    /// A placeholder for an iterator or a sentinel into a range that may
+    /// no longer be valid.
+    struct dangling
+    {
+        dangling() = default;
+        /// Implicit converting constructor; ignores argument
+        template<typename T>
+        constexpr CPP_ctor(dangling)(T &&)( //
+            requires not_same_as_<T, dangling>)
+        {}
+    };
+
+    /// \cond
+    namespace detail
+    {
+        CPP_template(class R, class U)( //
+            requires range<R>)          //
+            using maybe_dangling_ = if_then_t<forwarding_range_<R>, U, dangling>;
+    }
+    /// \endcond
+
+    template<typename Rng>
+    using safe_iterator_t = detail::maybe_dangling_<Rng, iterator_t<Rng>>;
+
+    /// \cond
+    struct _sanitize_fn
+    {
+        template<typename T>
+        constexpr T && operator()(T && t) const noexcept
+        {
+            return static_cast<T &&>(t);
+        }
+    };
+
+    using sanitize_fn RANGES_DEPRECATED(
+        "The sanitize function is unneeded and deprecated.") = _sanitize_fn;
+
+    namespace
+    {
+        RANGES_DEPRECATED("The sanitize function is unneeded and deprecated.")
+        constexpr auto & sanitize = static_const<_sanitize_fn>::value;
+    } // namespace
+    /// \endcond
+
+    namespace cpp20
+    {
+        using ranges::dangling;
+        using ranges::safe_iterator_t;
+    } // namespace cpp20
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range/operations.hpp b/inst/include/range/v3/range/operations.hpp
new file mode 100644
index 0000000..1ab16f6
--- /dev/null
+++ b/inst/include/range/v3/range/operations.hpp
@@ -0,0 +1,121 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Gonzalo Brito Gadeschi 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_OPERATIONS_HPP
+#define RANGES_V3_RANGE_OPERATIONS_HPP
+
+#include <stdexcept>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// Checked indexed range access.
+    ///
+    /// \ingroup group-range
+    struct at_fn
+    {
+        /// \return `begin(rng)[n]`
+        template<typename Rng>
+        constexpr auto operator()(Rng && rng, range_difference_t<Rng> n) const
+            -> CPP_ret(range_reference_t<Rng>)( //
+                requires random_access_range<Rng> && sized_range<Rng> &&
+                    forwarding_range_<Rng>)
+        {
+            // Workaround https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371 in GCC 5
+            check_throw(rng, n);
+            return ranges::begin(rng)[n];
+        }
+
+    private:
+        template<typename Rng>
+        static constexpr void check_throw(Rng && rng, range_difference_t<Rng> n)
+        {
+            (n < 0 || n >= ranges::distance(rng)) ? throw std::out_of_range("ranges::at")
+                                                  : void(0);
+        }
+    };
+
+    /// Checked indexed range access.
+    ///
+    /// \ingroup group-range
+    /// \sa `at_fn`
+    RANGES_INLINE_VARIABLE(at_fn, at)
+
+    /// Unchecked indexed range access.
+    ///
+    /// \ingroup group-range
+    struct index_fn
+    {
+        /// \return `begin(rng)[n]`
+        template<typename Rng, typename Int>
+        constexpr auto operator()(Rng && rng,
+                                  Int n) const -> CPP_ret(range_reference_t<Rng>)( //
+            requires random_access_range<Rng> && integral<Int> && forwarding_range_<Rng>)
+        {
+            using D = range_difference_t<Rng>;
+            RANGES_EXPECT(0 <= static_cast<D>(n));
+            RANGES_EXPECT(!(bool)sized_range<Rng> ||
+                          static_cast<D>(n) < ranges::distance(rng));
+            return ranges::begin(rng)[static_cast<D>(n)];
+        }
+    };
+
+    /// Unchecked indexed range access.
+    ///
+    /// \ingroup group-range
+    /// \sa `index_fn`
+    RANGES_INLINE_VARIABLE(index_fn, index)
+
+    /// \ingroup group-range
+    struct back_fn
+    {
+        /// \return `*prev(end(rng))`
+        template<typename Rng>
+        constexpr auto operator()(Rng && rng) const -> CPP_ret(range_reference_t<Rng>)( //
+            requires common_range<Rng> && bidirectional_range<Rng> &&
+                forwarding_range_<Rng>)
+        {
+            return *prev(end(rng));
+        }
+    };
+
+    /// \ingroup group-range
+    /// \sa `back_fn`
+    RANGES_INLINE_VARIABLE(back_fn, back)
+
+    /// \ingroup group-range
+    struct front_fn
+    {
+        /// \return `*begin(rng)`
+        template<typename Rng>
+        constexpr auto operator()(Rng && rng) const -> CPP_ret(range_reference_t<Rng>)( //
+            requires forward_range<Rng> && forwarding_range_<Rng>)
+        {
+            return *begin(rng);
+        }
+    };
+
+    /// \ingroup group-range
+    /// \sa `front_fn`
+    RANGES_INLINE_VARIABLE(front_fn, front)
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range/primitives.hpp b/inst/include/range/v3/range/primitives.hpp
new file mode 100644
index 0000000..7f46959
--- /dev/null
+++ b/inst/include/range/v3/range/primitives.hpp
@@ -0,0 +1,324 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_PRIMITIVES_HPP
+#define RANGES_V3_RANGE_PRIMITIVES_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-range
+    // Specialize this if the default is wrong.
+    template<typename T>
+    RANGES_INLINE_VAR constexpr bool disable_sized_range = false;
+
+    /// \cond
+    namespace _size_
+    {
+        template<typename T>
+        void size(T &&) = delete;
+
+#ifdef RANGES_WORKAROUND_MSVC_895622
+        void size();
+#endif
+
+        struct fn
+        {
+        private:
+            template<typename R>
+            using member_size_t = decltype(+(std::declval<R>()).size());
+            template<typename R>
+            using non_member_size_t = decltype(+size(std::declval<R>()));
+
+            template<typename R, std::size_t N>
+            static constexpr std::size_t impl_(R (&)[N], int) noexcept
+            {
+                return N;
+            }
+
+            template<typename R, std::size_t N>
+            static constexpr std::size_t impl_(R(&&)[N], int) noexcept
+            {
+                return N;
+            }
+
+            // Prefer member if it returns integral.
+            template<typename R>
+            static constexpr auto impl_(R && r, int) noexcept(noexcept(((R &&) r).size()))
+                -> CPP_ret(member_size_t<R>)( //
+                    requires integral<member_size_t<R>> &&
+                    (!disable_sized_range<uncvref_t<R>>))
+            {
+                return ((R &&) r).size();
+            }
+
+            // Use ADL if it returns integral.
+            template<typename R>
+            static constexpr auto impl_(R && r, long) noexcept(noexcept(size((R &&) r)))
+                -> CPP_ret(non_member_size_t<R>)( //
+                    requires integral<non_member_size_t<R>> &&
+                    (!disable_sized_range<uncvref_t<R>>))
+            {
+                return size((R &&) r);
+            }
+
+            template<typename R>
+            static constexpr auto impl_(R && r, ...)
+                -> CPP_ret(detail::iter_size_t<_begin_::_t<R>>)( //
+                    requires forward_iterator<_begin_::_t<R>> &&
+                        sized_sentinel_for<_end_::_t<R>, _begin_::_t<R>>)
+            {
+                using size_type = detail::iter_size_t<_begin_::_t<R>>;
+                return static_cast<size_type>(ranges::end((R &&) r) -
+                                              ranges::begin((R &&) r));
+            }
+
+        public:
+            template<typename R>
+            constexpr auto operator()(R && r) const
+                noexcept(noexcept(fn::impl_((R &&) r, 0)))
+                    -> decltype(fn::impl_((R &&) r, 0))
+            {
+                return fn::impl_((R &&) r, 0);
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(std::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(ranges::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+        };
+    } // namespace _size_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \return For a given expression `E` of type `T`, `ranges::size(E)` is equivalent
+    /// to:
+    ///   * `+extent_v<T>` if `T` is an array type.
+    ///   * Otherwise, `+E.size()` if it is a valid expression and its type `I` models
+    ///     `integral` and `disable_sized_range<std::remove_cvref_t<T>>` is false.
+    ///   * Otherwise, `+size(E)` if it is a valid expression and its type `I` models
+    ///     `integral` with overload resolution performed in a context that includes the
+    ///     declaration:
+    ///     \code
+    ///     template<class T> void size(T&&) = delete;
+    ///     \endcode
+    ///     and does not include a declaration of `ranges::size`, and
+    ///     `disable_sized_range<std::remove_cvref_t<T>>` is false.
+    ///   * Otherwise, `static_cast<U>(ranges::end(E) - ranges::begin(E))` where `U` is
+    ///     `std::make_unsigned_t<iter_difference_t<iterator_t<T>>>` if
+    ///     `iter_difference_t<iterator_t<T>>` satisfies `integral` and
+    ///     `iter_difference_t<iterator_t<T>>` otherwise; except that `E` is
+    ///     evaluated once, if it is a valid expression and the types `I` and `S` of
+    ///     `ranges::begin(E)` and `ranges::end(E)` model `sized_sentinel_for<S, I>` and
+    ///     `forward_iterator<I>`.
+    ///   * Otherwise, `ranges::size(E)` is ill-formed.
+    RANGES_DEFINE_CPO(_size_::fn, size)
+
+    // Customization point data
+    /// \cond
+    namespace _data_
+    {
+        struct fn
+        {
+        private:
+            template<typename R>
+            using member_data_t = detail::decay_t<decltype(std::declval<R>().data())>;
+
+            template<typename R>
+            static constexpr auto impl_(R & r, detail::priority_tag<2>) noexcept(
+                noexcept(r.data())) -> CPP_ret(member_data_t<R &>)( //
+                requires std::is_pointer<member_data_t<R &>>::value)
+            {
+                return r.data();
+            }
+            template<typename R>
+            static constexpr auto impl_(R && r, detail::priority_tag<1>) noexcept(
+                noexcept(ranges::begin((R &&) r))) -> CPP_ret(_begin_::_t<R>)( //
+                requires std::is_pointer<_begin_::_t<R>>::value)
+            {
+                return ranges::begin((R &&) r);
+            }
+            template<typename R>
+            static constexpr auto impl_(R && r, detail::priority_tag<0>) noexcept(
+                noexcept(ranges::begin((R &&) r) == ranges::end((R &&) r)
+                             ? nullptr
+                             : detail::addressof(*ranges::begin((R &&) r))))
+                -> CPP_ret(decltype(detail::addressof(*ranges::begin((R &&) r))))( //
+                    requires contiguous_iterator<_begin_::_t<R>>)
+            {
+                return ranges::begin((R &&) r) == ranges::end((R &&) r)
+                           ? nullptr
+                           : detail::addressof(*ranges::begin((R &&) r));
+            }
+
+        public:
+            template<typename charT, typename Traits, typename Alloc>
+            constexpr charT * operator()(
+                std::basic_string<charT, Traits, Alloc> & s) const noexcept
+            {
+                // string doesn't have non-const data before C++17
+                return const_cast<charT *>(detail::as_const(s).data());
+            }
+
+            template<typename R>
+            constexpr auto operator()(R && r) const
+                noexcept(noexcept(fn::impl_((R &&) r, detail::priority_tag<2>{})))
+                    -> decltype(fn::impl_((R &&) r, detail::priority_tag<2>{}))
+            {
+                return fn::impl_((R &&) r, detail::priority_tag<2>{});
+            }
+        };
+
+        template<typename R>
+        using _t = decltype(fn{}(std::declval<R>()));
+    } // namespace _data_
+    /// \endcond
+
+    RANGES_INLINE_VARIABLE(_data_::fn, data)
+
+    /// \cond
+    namespace _cdata_
+    {
+        struct fn
+        {
+            template<typename R>
+            constexpr _data_::_t<R const &> operator()(R const & r) const
+                noexcept(noexcept(ranges::data(r)))
+            {
+                return ranges::data(r);
+            }
+            template<typename R>
+            constexpr _data_::_t<R const> operator()(R const && r) const
+                noexcept(noexcept(ranges::data((R const &&)r)))
+            {
+                return ranges::data((R const &&)r);
+            }
+        };
+    } // namespace _cdata_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \param r
+    /// \return The result of calling `ranges::data` with a const-qualified
+    ///    (lvalue or rvalue) reference to `r`.
+    RANGES_INLINE_VARIABLE(_cdata_::fn, cdata)
+
+    /// \cond
+    namespace _empty_
+    {
+        struct fn
+        {
+        private:
+            // Prefer member if it is valid.
+            template<typename R>
+            static constexpr auto impl_(R && r, detail::priority_tag<2>) noexcept(
+                noexcept(bool(((R &&) r).empty()))) -> decltype(bool(((R &&) r).empty()))
+            {
+                return bool(((R &&) r).empty());
+            }
+
+            // Fall back to size == 0.
+            template<typename R>
+            static constexpr auto impl_(R && r, detail::priority_tag<1>) noexcept(
+                noexcept(bool(ranges::size((R &&) r) == 0)))
+                -> decltype(bool(ranges::size((R &&) r) == 0))
+            {
+                return bool(ranges::size((R &&) r) == 0);
+            }
+
+            // Fall further back to begin == end.
+            template<typename R>
+            static constexpr auto impl_(R && r, detail::priority_tag<0>) noexcept(
+                noexcept(bool(ranges::begin((R &&) r) == ranges::end((R &&) r))))
+                -> CPP_ret(decltype(bool(ranges::begin((R &&) r) ==
+                                         ranges::end((R &&) r))))( //
+                    requires forward_iterator<_begin_::_t<R>>)
+            {
+                return bool(ranges::begin((R &&) r) == ranges::end((R &&) r));
+            }
+
+        public:
+            template<typename R>
+            constexpr auto operator()(R && r) const
+                noexcept(noexcept(fn::impl_((R &&) r, detail::priority_tag<2>{})))
+                    -> decltype(fn::impl_((R &&) r, detail::priority_tag<2>{}))
+            {
+                return fn::impl_((R &&) r, detail::priority_tag<2>{});
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(std::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+
+            template<typename T, typename Fn = fn>
+            RANGES_DEPRECATED(
+                "Using a reference_wrapper as a Range is deprecated. Use views::ref "
+                "instead.")
+            constexpr auto
+            operator()(ranges::reference_wrapper<T> ref) const
+                noexcept(noexcept(Fn{}(ref.get()))) -> decltype(Fn{}(ref.get()))
+            {
+                return Fn{}(ref.get());
+            }
+        };
+    } // namespace _empty_
+    /// \endcond
+
+    /// \ingroup group-range
+    /// \return true if and only if range contains no elements.
+    RANGES_INLINE_VARIABLE(_empty_::fn, empty)
+
+    namespace cpp20
+    {
+        // Specialize this is namespace ranges::
+        using ranges::cdata;
+        using ranges::data;
+        using ranges::disable_sized_range;
+        using ranges::empty;
+        using ranges::size;
+    } // namespace cpp20
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range/traits.hpp b/inst/include/range/v3/range/traits.hpp
new file mode 100644
index 0000000..3cce88b
--- /dev/null
+++ b/inst/include/range/v3/range/traits.hpp
@@ -0,0 +1,138 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_TRAITS_HPP
+#define RANGES_V3_RANGE_TRAITS_HPP
+
+#include <array>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S>
+        using common_iterator_impl_t =
+            enable_if_t<(bool)(input_or_output_iterator<I> && sentinel_for<S, I>),
+                        common_iterator<I, S>>;
+    }
+    /// \endcond
+
+    /// \addtogroup group-range
+    /// @{
+    template<typename I, typename S>
+    using common_iterator_t = detail::if_then_t<std::is_same<I, S>::value, I,
+                                                detail::common_iterator_impl_t<I, S>>;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I, typename S>
+        using cpp17_iterator_t =
+            if_then_t<std::is_integral<iter_difference_t<I>>::value,
+                      common_iterator_t<I, S>, cpp17_iterator<common_iterator_t<I, S>>>;
+    }
+    /// \endcond
+
+    // Aliases (SFINAE-able)
+    template<typename Rng>
+    using range_difference_t = iter_difference_t<iterator_t<Rng>>;
+
+    template<typename Rng>
+    using range_value_t = iter_value_t<iterator_t<Rng>>;
+
+    template<typename Rng>
+    using range_reference_t = iter_reference_t<iterator_t<Rng>>;
+
+    template<typename Rng>
+    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<Rng>>;
+
+    template<typename Rng>
+    using range_common_reference_t = iter_common_reference_t<iterator_t<Rng>>;
+
+    template<typename Rng>
+    using range_size_t = decltype(ranges::size(std::declval<Rng &>()));
+
+    /// \cond
+    template<typename Rng>
+    using range_difference_type_t RANGES_DEPRECATED(
+        "range_difference_type_t is deprecated. Use the range_difference_t instead.") =
+        iter_difference_t<iterator_t<Rng>>;
+
+    template<typename Rng>
+    using range_value_type_t RANGES_DEPRECATED(
+        "range_value_type_t is deprecated. Use the range_value_t instead.") =
+        iter_value_t<iterator_t<Rng>>;
+
+    template<typename Rng>
+    using range_category_t RANGES_DEPRECATED(
+        "range_category_t is deprecated. Use the range concepts instead.") =
+        meta::_t<detail::iterator_category<iterator_t<Rng>>>;
+
+    template<typename Rng>
+    using range_size_type_t RANGES_DEPRECATED(
+        "range_size_type_t is deprecated. Use range_size_t instead.") =
+        detail::iter_size_t<iterator_t<Rng>>;
+    /// \endcond
+
+    template<typename Rng>
+    using range_common_iterator_t = common_iterator_t<iterator_t<Rng>, sentinel_t<Rng>>;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng>
+        using range_cpp17_iterator_t = cpp17_iterator_t<iterator_t<Rng>, sentinel_t<Rng>>;
+
+        std::integral_constant<cardinality, finite> test_cardinality(void *);
+        template<cardinality Card>
+        std::integral_constant<cardinality, Card> test_cardinality(basic_view<Card> *);
+        template<typename T, std::size_t N>
+        std::integral_constant<cardinality, static_cast<cardinality>(N)> test_cardinality(
+            T (*)[N]);
+        template<typename T, std::size_t N>
+        std::integral_constant<cardinality, static_cast<cardinality>(N)> test_cardinality(
+            std::array<T, N> *);
+    } // namespace detail
+    /// \endcond
+
+    // User customization point for specifying the cardinality of ranges:
+    template<typename Rng, typename Void /*= void*/>
+    struct range_cardinality
+      : detail::if_then_t<RANGES_IS_SAME(Rng, uncvref_t<Rng>),
+                          decltype(detail::test_cardinality(
+                              static_cast<uncvref_t<Rng> *>(nullptr))),
+                          range_cardinality<uncvref_t<Rng>>>
+    {};
+
+    /// @}
+    namespace cpp20
+    {
+        using ranges::range_difference_t;
+        using ranges::range_reference_t;
+        using ranges::range_rvalue_reference_t;
+        using ranges::range_value_t;
+    } // namespace cpp20
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/range_access.hpp b/inst/include/range/v3/range_access.hpp
new file mode 100644
index 0000000..0d8184c
--- /dev/null
+++ b/inst/include/range/v3/range_access.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_OLD_RANGE_ACCESS_HPP
+#define RANGES_V3_OLD_RANGE_ACCESS_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/operations.hpp> instead.")
+
+#include <range/v3/range/operations.hpp>
+
+#endif
diff --git a/inst/include/range/v3/range_concepts.hpp b/inst/include/range/v3/range_concepts.hpp
new file mode 100644
index 0000000..5ccb293
--- /dev/null
+++ b/inst/include/range/v3/range_concepts.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_DEPRECATED_RANGE_CONCEPTS_HPP
+#define RANGES_V3_DEPRECATED_RANGE_CONCEPTS_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/concepts.hpp> instead.")
+
+#include <range/v3/range/concepts.hpp>
+
+#endif
diff --git a/inst/include/range/v3/range_for.hpp b/inst/include/range/v3/range_for.hpp
new file mode 100644
index 0000000..e60bb5f
--- /dev/null
+++ b/inst/include/range/v3/range_for.hpp
@@ -0,0 +1,50 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_FOR_HPP
+#define RANGES_V3_RANGE_FOR_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/access.hpp>
+
+#if RANGES_CXX_RANGE_BASED_FOR < RANGES_CXX_RANGE_BASED_FOR_17
+/// A range-based for macro, basically a hack until the built-in range-for can handle
+/// Ranges that have a different type for begin and end. \ingroup range-core
+#define RANGES_FOR(VAR_DECL, ...)                                              \
+    if(bool CPP_PP_CAT(_range_v3_done, __LINE__) = false) {}                   \
+    else                                                                       \
+        for(auto && CPP_PP_CAT(_range_v3_rng, __LINE__) = (__VA_ARGS__);       \
+            !CPP_PP_CAT(_range_v3_done, __LINE__);)                            \
+            for(auto CPP_PP_CAT(_range_v3_begin, __LINE__) =                   \
+                    ranges::begin(CPP_PP_CAT(_range_v3_rng, __LINE__));        \
+                !CPP_PP_CAT(_range_v3_done, __LINE__);                         \
+                CPP_PP_CAT(_range_v3_done, __LINE__) = true)                   \
+                for(auto CPP_PP_CAT(_range_v3_end, __LINE__) =                 \
+                        ranges::end(CPP_PP_CAT(_range_v3_rng, __LINE__));      \
+                    !CPP_PP_CAT(_range_v3_done, __LINE__) &&                   \
+                    CPP_PP_CAT(_range_v3_begin, __LINE__) !=                   \
+                        CPP_PP_CAT(_range_v3_end, __LINE__);                   \
+                    ++CPP_PP_CAT(_range_v3_begin, __LINE__))                   \
+                    if(!(CPP_PP_CAT(_range_v3_done, __LINE__) = true)) {}      \
+                    else                                                       \
+                        for(VAR_DECL = *CPP_PP_CAT(_range_v3_begin, __LINE__); \
+                            CPP_PP_CAT(_range_v3_done, __LINE__);              \
+                            CPP_PP_CAT(_range_v3_done, __LINE__) = false)      \
+    /**/
+
+#else
+#define RANGES_FOR(VAR_DECL, ...) for(VAR_DECL : (__VA_ARGS__))
+#endif
+
+#endif
diff --git a/inst/include/range/v3/range_fwd.hpp b/inst/include/range/v3/range_fwd.hpp
new file mode 100644
index 0000000..6ed33e8
--- /dev/null
+++ b/inst/include/range/v3/range_fwd.hpp
@@ -0,0 +1,813 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_RANGE_FWD_HPP
+#define RANGES_V3_RANGE_FWD_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/detail/config.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/version.hpp>
+
+/// \defgroup group-iterator Iterator
+/// Iterator functionality
+
+/// \defgroup group-range Range
+/// Core range functionality
+
+/// \defgroup group-algorithms Algorithms
+/// Iterator- and range-based algorithms, like the standard algorithms
+
+/// \defgroup group-views Views
+/// Lazy, non-owning, non-mutating, composable range views
+
+/// \defgroup group-actions Actions
+/// Eager, mutating, composable algorithms
+
+/// \defgroup group-utility Utility
+/// Utility classes
+
+/// \defgroup group-functional Functional
+/// Function and function object utilities
+
+/// \defgroup group-numerics Numerics
+/// Numeric utilities
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
+
+namespace ranges
+{
+    /// \cond
+    namespace views
+    {
+    }
+
+    namespace actions
+    {
+    }
+
+// GCC either fails to accept an attribute on a namespace, or else
+// it ignores the deprecation attribute. Frustrating.
+#if(RANGES_CXX_VER < RANGES_CXX_STD_17 || defined(__GNUC__) && !defined(__clang__))
+    inline namespace v3
+    {
+        using namespace ranges;
+    }
+
+    namespace view = views;
+    namespace action = actions;
+#else
+    inline namespace RANGES_DEPRECATED(
+        "The name ranges::v3 namespace is deprecated. "
+        "Please discontinue using it.") v3
+    {
+        using namespace ranges;
+    }
+
+    namespace RANGES_DEPRECATED(
+        "The ranges::view namespace has been renamed to ranges::views. "
+        "(Sorry!)") view
+    {
+        using namespace views;
+    }
+
+    namespace RANGES_DEPRECATED(
+        "The ranges::action namespace has been renamed to ranges::actions. "
+        "(Sorry!)") action
+    {
+        using namespace actions;
+    }
+#endif
+
+    namespace _end_
+    {
+        struct fn;
+    }
+    using end_fn = _end_::fn;
+
+    namespace _size_
+    {
+        struct fn;
+    }
+
+    template<typename>
+    struct result_of;
+
+    template<typename Sig>
+    using result_of_t RANGES_DEPRECATED(
+        "ranges::result_of_t is deprecated. "
+        "Please use ranges::invoke_result_t") = meta::_t<result_of<Sig>>;
+    /// \endcond
+
+    template<typename...>
+    struct variant;
+
+    struct dangling;
+
+    struct make_pipeable_fn;
+
+    struct pipeable_base;
+
+    template<typename First, typename Second>
+    struct composed;
+
+    template<typename... Fns>
+    struct overloaded;
+
+    namespace actions
+    {
+        template<typename ActionFn>
+        struct action_closure;
+    }
+
+    namespace views
+    {
+        template<typename ViewFn>
+        struct view_closure;
+    }
+
+    struct advance_fn;
+
+    struct advance_to_fn;
+
+    struct advance_bounded_fn;
+
+    struct next_fn;
+
+    struct prev_fn;
+
+    struct distance_fn;
+
+    struct iter_size_fn;
+
+    template<typename T>
+    struct readable_traits;
+
+    template<typename T>
+    struct incrementable_traits;
+
+    struct view_base
+    {};
+
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        struct difference_type_;
+
+        template<typename T>
+        struct value_type_;
+    } // namespace detail
+
+    template<typename T>
+    using difference_type RANGES_DEPRECATED(
+        "ranges::difference_type<T>::type is deprecated. Use "
+        "ranges::incrementable_traits<T>::difference_type instead.") =
+        detail::difference_type_<T>;
+
+    template<typename T>
+    using value_type RANGES_DEPRECATED(
+        "ranges::value_type<T>::type is deprecated. Use "
+        "ranges::readable_traits<T>::value_type instead.") = detail::value_type_<T>;
+
+    template<typename T>
+    struct size_type;
+    /// \endcond
+
+    /// \cond
+    namespace detail
+    {
+        struct ignore_t
+        {
+            ignore_t() = default;
+            template<typename T>
+            constexpr ignore_t(T &&) noexcept
+            {}
+            template<typename T>
+            constexpr ignore_t const & operator=(T &&) const noexcept
+            {
+                return *this;
+            }
+        };
+
+        struct value_init
+        {
+            template<typename T>
+            operator T() const
+            {
+                return T{};
+            }
+        };
+
+        struct make_compressed_pair_fn;
+
+        template<typename T>
+        constexpr meta::_t<std::remove_reference<T>> && move(T && t) noexcept
+        {
+            return static_cast<meta::_t<std::remove_reference<T>> &&>(t);
+        }
+
+        struct as_const_fn
+        {
+            template<typename T>
+            constexpr T const & operator()(T & t) const noexcept
+            {
+                return t;
+            }
+            template<typename T>
+            constexpr T const && operator()(T && t) const noexcept
+            {
+                return (T &&) t;
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(as_const_fn, as_const)
+
+        template<typename T>
+        using as_const_t = decltype(as_const(std::declval<T>()));
+
+        template<typename T>
+        using decay_t = meta::_t<std::decay<T>>;
+
+        template<typename T, typename R = meta::_t<std::remove_reference<T>>>
+        using as_ref_t =
+            meta::_t<std::add_lvalue_reference<meta::_t<std::remove_const<R>>>>;
+
+        template<typename T, typename R = meta::_t<std::remove_reference<T>>>
+        using as_cref_t = meta::_t<std::add_lvalue_reference<R const>>;
+
+        struct get_first;
+        struct get_second;
+
+        template<typename Val1, typename Val2>
+        struct replacer_fn;
+
+        template<typename Pred, typename Val>
+        struct replacer_if_fn;
+
+        template<typename I>
+        struct move_into_cursor;
+
+        template<typename Int>
+        struct from_end_;
+
+        template<typename... Ts>
+        constexpr int ignore_unused(Ts &&...)
+        {
+            return 42;
+        }
+
+        template<int I>
+        struct priority_tag : priority_tag<I - 1>
+        {};
+
+        template<>
+        struct priority_tag<0>
+        {};
+
+        template<typename T>
+        using is_trivial = meta::bool_<
+#if META_CXX_TRAIT_VARIABLE_TEMPLATES
+            std::is_trivially_copyable_v<T> &&
+            std::is_trivially_default_constructible_v<T>>;
+#else
+            std::is_trivially_copyable<T>::value &&
+            std::is_trivially_default_constructible<T>::value>;
+#endif
+
+#if defined(__clang__) && !defined(_LIBCPP_VERSION)
+        template<typename T, typename... Args>
+        using is_trivially_constructible =
+            meta::bool_<__is_trivially_constructible(T, Args...)>;
+        template<typename T>
+        using is_trivially_default_constructible = is_trivially_constructible<T>;
+        template<typename T>
+        using is_trivially_copy_constructible = is_trivially_constructible<T, T const &>;
+        template<typename T>
+        using is_trivially_move_constructible = is_trivially_constructible<T, T>;
+        template<typename T, typename U>
+        using is_trivially_assignable = meta::bool_<__is_trivially_assignable(T, U)>;
+        template<typename T>
+        using is_trivially_copy_assignable = is_trivially_assignable<T &, T const &>;
+        template<typename T>
+        using is_trivially_move_assignable = is_trivially_assignable<T &, T>;
+        template<typename T>
+        using is_trivially_copyable = meta::bool_<__is_trivially_copyable(T)>;
+#else
+        template<typename T>
+        using is_trivially_default_constructible = std::is_trivially_constructible<T>;
+        using std::is_trivially_copy_assignable;
+        using std::is_trivially_copy_constructible;
+        using std::is_trivially_copyable;
+        using std::is_trivially_move_assignable;
+        using std::is_trivially_move_constructible;
+#endif
+
+#if RANGES_CXX_LIB_IS_FINAL > 0
+#if defined(__clang__) && !defined(_LIBCPP_VERSION)
+        template<typename T>
+        using is_final = meta::bool_<__is_final(T)>;
+#else
+        using std::is_final;
+#endif
+#else
+        template<typename T>
+        using is_final = std::false_type;
+#endif
+
+        // Work around libc++'s buggy std::is_function
+        // Function types here:
+        template<typename T>
+        char (&is_function_impl_(priority_tag<0>))[1];
+
+        // Array types here:
+        template<typename T, typename = decltype((*(T *)0)[0])>
+        char (&is_function_impl_(priority_tag<1>))[2];
+
+        // Anything that can be returned from a function here (including
+        // void and reference types):
+        template<typename T, typename = T (*)()>
+        char (&is_function_impl_(priority_tag<2>))[3];
+
+        // Classes and unions (including abstract types) here:
+        template<typename T, typename = int T::*>
+        char (&is_function_impl_(priority_tag<3>))[4];
+
+        template<typename T>
+        RANGES_INLINE_VAR constexpr bool is_function_v =
+            sizeof(detail::is_function_impl_<T>(priority_tag<3>{})) == 1;
+
+        template<typename T>
+        struct remove_rvalue_reference
+        {
+            using type = T;
+        };
+
+        template<typename T>
+        struct remove_rvalue_reference<T &&>
+        {
+            using type = T;
+        };
+
+        template<typename T>
+        using remove_rvalue_reference_t = meta::_t<remove_rvalue_reference<T>>;
+
+        // Workaround bug in the Standard Library:
+        // From cannot be an incomplete class type despite that
+        // is_convertible<X, Y> should be equivalent to is_convertible<X&&, Y>
+        // in such a case.
+        template<typename From, typename To>
+        using is_convertible =
+            std::is_convertible<meta::_t<std::add_rvalue_reference<From>>, To>;
+    } // namespace detail
+    /// \endcond
+
+    struct begin_tag
+    {};
+    struct end_tag
+    {};
+    struct copy_tag
+    {};
+    struct move_tag
+    {};
+
+    template<typename T>
+    using uncvref_t = meta::_t<std::remove_cv<meta::_t<std::remove_reference<T>>>>;
+
+    struct not_equal_to;
+    struct equal_to;
+    struct less;
+    struct identity;
+    template<typename Pred>
+    struct logical_negate;
+
+    enum cardinality : std::ptrdiff_t
+    {
+        infinite = -3,
+        unknown = -2,
+        finite = -1
+    };
+
+    template<typename Rng, typename Void = void>
+    struct range_cardinality;
+
+    template<typename Rng>
+    using is_finite = meta::bool_<range_cardinality<Rng>::value >= finite>;
+
+    template<typename Rng>
+    using is_infinite = meta::bool_<range_cardinality<Rng>::value == infinite>;
+
+    template<typename S, typename I>
+    RANGES_INLINE_VAR constexpr bool disable_sized_sentinel = false;
+
+    template<typename Cur>
+    struct basic_mixin;
+
+    template<typename Cur>
+    struct RANGES_EMPTY_BASES basic_iterator;
+
+    template<cardinality>
+    struct basic_view : view_base
+    {};
+
+    template<typename Derived, cardinality C = finite>
+    struct view_facade;
+
+    template<typename Derived, typename BaseRng,
+             cardinality C = range_cardinality<BaseRng>::value>
+    struct view_adaptor;
+
+    template<typename I, typename S>
+    struct common_iterator;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        struct cpp17_iterator_cursor;
+
+        template<typename I>
+        using cpp17_iterator = basic_iterator<cpp17_iterator_cursor<I>>;
+    } // namespace detail
+    /// \endcond
+
+    template<typename First, typename Second>
+    struct compressed_pair;
+
+    template<typename T>
+    struct bind_element;
+
+    template<typename T>
+    using bind_element_t = meta::_t<bind_element<T>>;
+
+    template<typename Derived, cardinality = finite>
+    struct view_interface;
+
+    template<typename T>
+    struct istream_view;
+
+    template<typename I, typename S = I>
+    struct RANGES_EMPTY_BASES iterator_range;
+
+    template<typename I, typename S = I>
+    struct sized_iterator_range;
+
+    template<typename T>
+    struct reference_wrapper;
+
+    // Views
+    //
+    template<typename Rng, typename Pred>
+    struct RANGES_EMPTY_BASES adjacent_filter_view;
+
+    namespace views
+    {
+        struct adjacent_filter_fn;
+    }
+
+    template<typename Rng, typename Pred>
+    struct RANGES_EMPTY_BASES adjacent_remove_if_view;
+
+    namespace views
+    {
+        struct adjacent_remove_if_fn;
+    }
+
+    namespace views
+    {
+        struct all_fn;
+    }
+
+    template<typename Rng>
+    struct const_view;
+
+    namespace views
+    {
+        struct const_fn;
+    }
+
+    template<typename I>
+    struct counted_view;
+
+    namespace views
+    {
+        struct counted_fn;
+    }
+
+    struct default_sentinel_t;
+
+    template<typename I>
+    struct move_iterator;
+
+    template<typename I>
+    using move_into_iterator = basic_iterator<detail::move_into_cursor<I>>;
+
+    template<typename Rng, bool = (bool)is_infinite<Rng>()>
+    struct RANGES_EMPTY_BASES cycled_view;
+
+    namespace views
+    {
+        struct cycle_fn;
+    }
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        struct reverse_cursor;
+    }
+    /// \endcond
+
+    template<typename I>
+    using reverse_iterator = basic_iterator<detail::reverse_cursor<I>>;
+
+    template<typename T>
+    struct empty_view;
+
+    namespace views
+    {
+        struct empty_fn;
+    }
+
+    template<typename Rng, typename Fun>
+    struct group_by_view;
+
+    namespace views
+    {
+        struct group_by_fn;
+    }
+
+    template<typename Rng>
+    struct indirect_view;
+
+    namespace views
+    {
+        struct indirect_fn;
+    }
+
+    struct unreachable_sentinel_t;
+
+    template<typename From, typename To = unreachable_sentinel_t>
+    struct iota_view;
+
+    template<typename From, typename To = From>
+    struct closed_iota_view;
+
+    namespace views
+    {
+        struct iota_fn;
+        struct closed_iota_fn;
+    } // namespace views
+
+    template<typename Rng>
+    struct join_view;
+
+    template<typename Rng, typename ValRng>
+    struct join_with_view;
+
+    namespace views
+    {
+        struct join_fn;
+    }
+
+    template<typename... Rngs>
+    struct concat_view;
+
+    namespace views
+    {
+        struct concat_fn;
+    }
+
+    template<typename Rng, typename Fun>
+    struct partial_sum_view;
+
+    namespace views
+    {
+        struct partial_sum_fn;
+    }
+
+    template<typename Rng>
+    struct move_view;
+
+    namespace views
+    {
+        struct move_fn;
+    }
+
+    template<typename Rng>
+    struct ref_view;
+
+    namespace views
+    {
+        struct ref_fn;
+    }
+
+    template<typename Val>
+    struct repeat_view;
+
+    namespace views
+    {
+        struct repeat_fn;
+    }
+
+    template<typename Rng>
+    struct RANGES_EMPTY_BASES reverse_view;
+
+    namespace views
+    {
+        struct reverse_fn;
+    }
+
+    template<typename Rng>
+    struct slice_view;
+
+    namespace views
+    {
+        struct slice_fn;
+    }
+
+    // template<typename Rng, typename Fun>
+    // struct split_view;
+
+    // namespace views
+    // {
+    //     struct split_fn;
+    // }
+
+    template<typename Rng>
+    struct single_view;
+
+    namespace views
+    {
+        struct single_fn;
+    }
+
+    template<typename Rng>
+    struct stride_view;
+
+    namespace views
+    {
+        struct stride_fn;
+    }
+
+    template<typename Rng>
+    struct take_view;
+
+    namespace views
+    {
+        struct take_fn;
+    }
+
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng>
+        struct is_random_access_common_;
+
+        template<typename Rng,
+                 bool IsRandomAccessCommon = is_random_access_common_<Rng>::value>
+        struct take_exactly_view_;
+    } // namespace detail
+    /// \endcond
+
+    template<typename Rng>
+    using take_exactly_view = detail::take_exactly_view_<Rng>;
+
+    namespace views
+    {
+        struct take_exactly_fn;
+    }
+
+    template<typename Rng, typename Pred>
+    struct iter_take_while_view;
+
+    template<typename Rng, typename Pred>
+    struct take_while_view;
+
+    namespace views
+    {
+        struct iter_take_while_fn;
+        struct take_while_fn;
+    } // namespace views
+
+    template<typename Rng, typename Regex, typename SubMatchRange>
+    struct tokenize_view;
+
+    namespace views
+    {
+        struct tokenize_fn;
+    }
+
+    template<typename Rng, typename Fun>
+    struct iter_transform_view;
+
+    template<typename Rng, typename Fun>
+    struct transform_view;
+
+    namespace views
+    {
+        struct transform_fn;
+    }
+
+    template<typename Rng, typename Val1, typename Val2>
+    using replace_view = iter_transform_view<Rng, detail::replacer_fn<Val1, Val2>>;
+
+    template<typename Rng, typename Pred, typename Val>
+    using replace_if_view = iter_transform_view<Rng, detail::replacer_if_fn<Pred, Val>>;
+
+    namespace views
+    {
+        struct replace_fn;
+
+        struct replace_if_fn;
+    } // namespace views
+
+    template<typename Rng, typename Pred>
+    struct trim_view;
+
+    namespace views
+    {
+        struct trim_fn;
+    }
+
+    template<typename I>
+    struct unbounded_view;
+
+    namespace views
+    {
+        struct unbounded_fn;
+    }
+
+    template<typename Rng>
+    using unique_view = adjacent_filter_view<Rng, logical_negate<equal_to>>;
+
+    namespace views
+    {
+        struct unique_fn;
+    }
+
+    template<typename Rng>
+    using keys_range_view = transform_view<Rng, detail::get_first>;
+
+    template<typename Rng>
+    using values_view = transform_view<Rng, detail::get_second>;
+
+    namespace views
+    {
+        struct keys_fn;
+
+        struct values_fn;
+    } // namespace views
+
+    template<typename Fun, typename... Rngs>
+    struct iter_zip_with_view;
+
+    template<typename Fun, typename... Rngs>
+    struct zip_with_view;
+
+    template<typename... Rngs>
+    struct zip_view;
+
+    namespace views
+    {
+        struct iter_zip_with_fn;
+
+        struct zip_with_fn;
+
+        struct zip_fn;
+    } // namespace views
+} // namespace ranges
+
+namespace ranges
+{
+    namespace concepts = ::concepts;
+    using namespace ::concepts::defs;
+    using ::concepts::and_v;
+    namespace defer
+    {
+        using namespace ::concepts::defs::defer;
+    }
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_POP
+
+/// \endcond
+
+#endif
diff --git a/inst/include/range/v3/range_traits.hpp b/inst/include/range/v3/range_traits.hpp
new file mode 100644
index 0000000..9b56743
--- /dev/null
+++ b/inst/include/range/v3/range_traits.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_OLD_RANGE_TRAITS_HPP
+#define RANGES_V3_OLD_RANGE_TRAITS_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/traits.hpp> instead.")
+
+#include <range/v3/range/traits.hpp>
+
+#endif
diff --git a/inst/include/range/v3/size.hpp b/inst/include/range/v3/size.hpp
new file mode 100644
index 0000000..3b70b89
--- /dev/null
+++ b/inst/include/range/v3/size.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_SIZE_HPP
+#define RANGES_V3_SIZE_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/primitives.hpp> instead.")
+
+#include <range/v3/range/primitives.hpp>
+
+#endif
diff --git a/inst/include/range/v3/span.hpp b/inst/include/range/v3/span.hpp
new file mode 100644
index 0000000..2412a62
--- /dev/null
+++ b/inst/include/range/v3/span.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Casey Carter 2016-2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_SPAN_HPP
+#define RANGES_V3_SPAN_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/view/span.hpp> instead.")
+
+#include <range/v3/view/span.hpp>
+
+#endif // RANGES_V3_SPAN_HPP
diff --git a/inst/include/range/v3/to_container.hpp b/inst/include/range/v3/to_container.hpp
new file mode 100644
index 0000000..85ac20b
--- /dev/null
+++ b/inst/include/range/v3/to_container.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_TO_CONTAINER_HPP
+#define RANGES_V3_TO_CONTAINER_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/conversion.hpp> instead.")
+
+#include <range/v3/range/conversion.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility.hpp b/inst/include/range/v3/utility.hpp
new file mode 100644
index 0000000..bd9d01d
--- /dev/null
+++ b/inst/include/range/v3/utility.hpp
@@ -0,0 +1,42 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2019-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_ITERATOR_HPP
+#define RANGES_V3_ITERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DISABLE_WARNINGS
+
+#include <range/v3/utility/any.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/common_tuple.hpp>
+#include <range/v3/utility/common_type.hpp>
+#include <range/v3/utility/compressed_pair.hpp>
+#include <range/v3/utility/copy.hpp>
+#include <range/v3/utility/get.hpp>
+#include <range/v3/utility/in_place.hpp>
+#include <range/v3/utility/memory.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/polymorphic_cast.hpp>
+#include <range/v3/utility/random.hpp>
+#include <range/v3/utility/scope_exit.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+#include <range/v3/utility/tuple_algorithm.hpp>
+#include <range/v3/utility/variant.hpp>
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/utility/addressof.hpp b/inst/include/range/v3/utility/addressof.hpp
new file mode 100644
index 0000000..d47032c
--- /dev/null
+++ b/inst/include/range/v3/utility/addressof.hpp
@@ -0,0 +1,73 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTLITY_ADDRESSOF_HPP
+#define RANGES_V3_UTLITY_ADDRESSOF_HPP
+
+#include <memory>
+#include <type_traits>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/detail/config.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+#ifdef __cpp_lib_addressof_constexpr
+        using std::addressof;
+#else
+        namespace check_addressof
+        {
+            inline ignore_t operator&(ignore_t)
+            {
+                return {};
+            }
+            template<typename T>
+            auto addressof(T & t)
+            {
+                return &t;
+            }
+        } // namespace check_addressof
+
+        template<typename T>
+        constexpr bool has_bad_addressof()
+        {
+            return !std::is_scalar<T>::value &&
+                   !RANGES_IS_SAME(decltype(check_addressof::addressof(*(T *)nullptr)),
+                                   ignore_t);
+        }
+
+        template<typename T>
+        auto addressof(T & arg) noexcept -> CPP_ret(T *)(requires(has_bad_addressof<T>()))
+        {
+            return std::addressof(arg);
+        }
+
+        template<typename T>
+        constexpr auto addressof(T & arg) noexcept
+            -> CPP_ret(T *)(requires(!has_bad_addressof<T>()))
+        {
+            return &arg;
+        }
+
+        template<typename T>
+        T const * addressof(T const &&) = delete;
+#endif
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/any.hpp b/inst/include/range/v3/utility/any.hpp
new file mode 100644
index 0000000..3354aaf
--- /dev/null
+++ b/inst/include/range/v3/utility/any.hpp
@@ -0,0 +1,230 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2015-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_ANY_HPP
+#define RANGES_V3_UTILITY_ANY_HPP
+
+#include <memory>
+#include <type_traits>
+#include <typeinfo>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/swap.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+
+namespace ranges
+{
+    struct bad_any_cast : std::bad_cast
+    {
+        virtual const char * what() const noexcept override
+        {
+            return "bad any_cast";
+        }
+    };
+
+    struct RANGES_DEPRECATED(
+        "ranges::any will be going away in the not-too-distant future. "
+        "We suggest you use std::any or boost::any instead (or simply steal "
+        "this header and maintain it yourself).") any;
+
+    template<typename T>
+    meta::if_c<std::is_reference<T>() || copyable<T>, T> any_cast(any &);
+
+    template<typename T>
+    meta::if_c<std::is_reference<T>() || copyable<T>, T> any_cast(any const &);
+
+    template<typename T>
+    meta::if_c<std::is_reference<T>() || copyable<T>, T> any_cast(any &&);
+
+    template<typename T>
+    T * any_cast(any *) noexcept;
+
+    template<typename T>
+    T const * any_cast(any const *) noexcept;
+
+    struct any
+    {
+    private:
+        template<typename T>
+        friend meta::if_c<std::is_reference<T>() || (bool)copyable<T>, T> any_cast(any &);
+
+        template<typename T>
+        friend meta::if_c<std::is_reference<T>() || (bool)copyable<T>, T> any_cast(
+            any const &);
+
+        template<typename T>
+        friend meta::if_c<std::is_reference<T>() || (bool)copyable<T>, T> any_cast(
+            any &&);
+
+        template<typename T>
+        friend T * any_cast(any *) noexcept;
+
+        template<typename T>
+        friend T const * any_cast(any const *) noexcept;
+
+        struct interface
+        {
+            virtual ~interface()
+            {}
+            virtual interface * clone() const = 0;
+            virtual std::type_info const & type() const noexcept = 0;
+        };
+
+        template<typename T>
+        struct impl final : interface
+        {
+        private:
+            T obj;
+
+        public:
+            impl() = default;
+            impl(T o)
+              : obj(std::move(o))
+            {}
+            T & get()
+            {
+                return obj;
+            }
+            T const & get() const
+            {
+                return obj;
+            }
+            impl * clone() const override
+            {
+                return new impl{obj};
+            }
+            std::type_info const & type() const noexcept override
+            {
+                return typeid(T);
+            }
+        };
+
+        std::unique_ptr<interface> ptr_;
+
+    public:
+        any() noexcept = default;
+        template<typename TRef, typename T = detail::decay_t<TRef>>
+        CPP_ctor(any)(TRef && t)( //
+            requires copyable<T> && (!same_as<T, any>))
+          : ptr_(new impl<T>(static_cast<TRef &&>(t)))
+        {}
+        any(any &&) noexcept = default;
+        any(any const & that)
+          : ptr_{that.ptr_ ? that.ptr_->clone() : nullptr}
+        {}
+        any & operator=(any &&) noexcept = default;
+        any & operator=(any const & that)
+        {
+            ptr_.reset(that.ptr_ ? that.ptr_->clone() : nullptr);
+            return *this;
+        }
+        template<typename TRef, typename T = detail::decay_t<TRef>>
+        auto operator=(TRef && t) -> CPP_ret(any &)( //
+            requires copyable<T> && (!same_as<T, any>))
+        {
+            any{static_cast<TRef &&>(t)}.swap(*this);
+            return *this;
+        }
+        void clear() noexcept
+        {
+            ptr_.reset();
+        }
+        bool empty() const noexcept
+        {
+            return !ptr_;
+        }
+        std::type_info const & type() const noexcept
+        {
+            return ptr_ ? ptr_->type() : typeid(void);
+        }
+        void swap(any & that) noexcept
+        {
+            ptr_.swap(that.ptr_);
+        }
+
+#if !RANGES_BROKEN_CPO_LOOKUP
+        friend void swap(any & x, any & y) noexcept
+        {
+            x.swap(y);
+        }
+#endif
+    };
+
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _any_
+    {
+        inline void swap(any & x, any & y) noexcept
+        {
+            x.swap(y);
+        }
+    } // namespace _any_
+#endif
+
+    /// \throw bad_any_cast
+    template<typename T>
+    meta::if_c<std::is_reference<T>() || copyable<T>, T> any_cast(any & x)
+    {
+        if(x.type() != typeid(detail::decay_t<T>))
+            throw bad_any_cast{};
+        return static_cast<any::impl<detail::decay_t<T>> *>(x.ptr_.get())->get();
+    }
+
+    /// \overload
+    template<typename T>
+    meta::if_c<std::is_reference<T>() || copyable<T>, T> any_cast(any const & x)
+    {
+        if(x.type() != typeid(detail::decay_t<T>))
+            throw bad_any_cast{};
+        return static_cast<any::impl<detail::decay_t<T>> const *>(x.ptr_.get())->get();
+    }
+
+    /// \overload
+    template<typename T>
+    meta::if_c<std::is_reference<T>() || copyable<T>, T> any_cast(any && x)
+    {
+        if(x.type() != typeid(detail::decay_t<T>))
+            throw bad_any_cast{};
+        return static_cast<any::impl<detail::decay_t<T>> *>(x.ptr_.get())->get();
+    }
+
+    /// \overload
+    template<typename T>
+    T * any_cast(any * p) noexcept
+    {
+        if(p && p->ptr_)
+            if(any::impl<T> * q = dynamic_cast<any::impl<T> *>(p->ptr_.get()))
+                return &q->get();
+        return nullptr;
+    }
+
+    /// \overload
+    template<typename T>
+    T const * any_cast(any const * p) noexcept
+    {
+        if(p && p->ptr_)
+            if(any::impl<T> const * q = dynamic_cast<any::impl<T> const *>(p->ptr_.get()))
+                return &q->get();
+        return nullptr;
+    }
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/utility/associated_types.hpp b/inst/include/range/v3/utility/associated_types.hpp
new file mode 100644
index 0000000..d6ab188
--- /dev/null
+++ b/inst/include/range/v3/utility/associated_types.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-2014, 2016
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_ASSOCIATED_TYPES_HPP
+#define RANGES_V3_UTILITY_ASSOCIATED_TYPES_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/iterator/traits.hpp> instead.")
+
+#include <range/v3/iterator/traits.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/basic_iterator.hpp b/inst/include/range/v3/utility/basic_iterator.hpp
new file mode 100644
index 0000000..8591d1c
--- /dev/null
+++ b/inst/include/range/v3/utility/basic_iterator.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTILITY_BASIC_ITERATOR_HPP
+#define RANGES_V3_UTILITY_BASIC_ITERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/iterator/basic_iterator.hpp> "
+    "instead.")
+
+#include <range/v3/iterator/basic_iterator.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/box.hpp b/inst/include/range/v3/utility/box.hpp
new file mode 100644
index 0000000..16b2703
--- /dev/null
+++ b/inst/include/range/v3/utility/box.hpp
@@ -0,0 +1,333 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_BOX_HPP
+#define RANGES_V3_UTILITY_BOX_HPP
+
+#include <cstdlib>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/get.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+
+namespace ranges
+{
+    /// \addtogroup group-utility Utility
+    /// @{
+    ///
+
+    /// \cond
+    template<typename T>
+    struct RANGES_DEPRECATED("The ranges::mutable_ class template is deprecated") mutable_
+    {
+        mutable T value;
+
+        CPP_member
+        constexpr CPP_ctor(mutable_)()( //
+            requires std::is_default_constructible<T>::value)
+          : value{}
+        {}
+        constexpr explicit mutable_(T const & t)
+          : value(t)
+        {}
+        constexpr explicit mutable_(T && t)
+          : value(detail::move(t))
+        {}
+        mutable_ const & operator=(T const & t) const
+        {
+            value = t;
+            return *this;
+        }
+        mutable_ const & operator=(T && t) const
+        {
+            value = detail::move(t);
+            return *this;
+        }
+        constexpr operator T &() const &
+        {
+            return value;
+        }
+    };
+
+    template<typename T, T v>
+    struct RANGES_DEPRECATED("The ranges::constant class template is deprecated") constant
+    {
+        constant() = default;
+        constexpr explicit constant(T const &)
+        {}
+        constant & operator=(T const &)
+        {
+            return *this;
+        }
+        constant const & operator=(T const &) const
+        {
+            return *this;
+        }
+        constexpr operator T() const
+        {
+            return v;
+        }
+        constexpr T exchange(T const &) const
+        {
+            return v;
+        }
+    };
+    /// \endcond
+
+    /// \cond
+    namespace detail
+    {
+        // "box" has three different implementations that store a T differently:
+        enum class box_compress
+        {
+            none, // Nothing special: get() returns a reference to a T member subobject
+            ebo,  // Apply Empty Base Optimization: get() returns a reference to a T base
+                  // subobject
+            coalesce // Coalesce all Ts into one T: get() returns a reference to a static
+                     // T singleton
+        };
+
+        // Per N4582, lambda closures are *not*:
+        // - aggregates             ([expr.prim.lambda]/4)
+        // - default constructible_from  ([expr.prim.lambda]/p21)
+        // - copy assignable        ([expr.prim.lambda]/p21)
+        template<typename Fn>
+        using could_be_lambda = meta::bool_<!std::is_default_constructible<Fn>::value &&
+                                            !std::is_copy_assignable<Fn>::value>;
+
+        template<typename>
+        constexpr box_compress box_compression_(...)
+        {
+            return box_compress::none;
+        }
+        template<typename T, typename = meta::if_<meta::strict_and<
+                                 std::is_empty<T>,
+                                 meta::not_<detail::is_final<T>>
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 6 && __GNUC_MINOR__ < 2
+                                 // GCC 6.0 & 6.1 find empty lambdas' implicit conversion
+                                 // to function pointer when doing overload resolution
+                                 // for function calls. That causes hard errors.
+                                 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71117
+                                 ,
+                                 meta::not_<could_be_lambda<T>>
+#endif
+                                 >>>
+        constexpr box_compress box_compression_(long)
+        {
+            return box_compress::ebo;
+        }
+#ifndef RANGES_WORKAROUND_MSVC_249830
+        // MSVC pukes passing non-constant-expression objects to constexpr
+        // functions, so do not coalesce.
+        template<typename T,
+                 typename =
+                     meta::if_<meta::strict_and<std::is_empty<T>, detail::is_trivial<T>>>>
+        constexpr box_compress box_compression_(int)
+        {
+            return box_compress::coalesce;
+        }
+#endif
+        template<typename T>
+        constexpr box_compress box_compression()
+        {
+            return box_compression_<T>(0);
+        }
+    } // namespace detail
+    /// \endcond
+
+    template<typename Element, typename Tag = void,
+             detail::box_compress = detail::box_compression<Element>()>
+    class box
+    {
+        Element value;
+
+    public:
+        CPP_member
+        constexpr CPP_ctor(box)()(                                          //
+            noexcept(std::is_nothrow_default_constructible<Element>::value) //
+            requires std::is_default_constructible<Element>::value)
+          : value{}
+        {}
+        template<typename E>
+        constexpr CPP_ctor(box)(E && e)(                               //
+            noexcept(std::is_nothrow_constructible<Element, E>::value) //
+            requires(!defer::same_as<box, detail::decay_t<E>>) &&
+            defer::constructible_from<Element, E> && defer::convertible_to<E, Element>)
+          : value(static_cast<E &&>(e))
+        {}
+        template<typename E>
+        constexpr explicit CPP_ctor(box)(E && e)(                      //
+            noexcept(std::is_nothrow_constructible<Element, E>::value) //
+            requires(!defer::same_as<box, detail::decay_t<E>>) &&
+            defer::constructible_from<Element, E> && (!defer::convertible_to<E, Element>))
+          : value(static_cast<E &&>(e))
+        {}
+
+        constexpr Element & get() & noexcept
+        {
+            return value;
+        }
+        constexpr Element const & get() const & noexcept
+        {
+            return value;
+        }
+        constexpr Element && get() && noexcept
+        {
+            return detail::move(value);
+        }
+        constexpr Element const && get() const && noexcept
+        {
+            return detail::move(value);
+        }
+    };
+
+    template<typename Element, typename Tag>
+    class box<Element, Tag, detail::box_compress::ebo> : Element
+    {
+    public:
+        CPP_member
+        constexpr CPP_ctor(box)()(                                          //
+            noexcept(std::is_nothrow_default_constructible<Element>::value) //
+            requires std::is_default_constructible<Element>::value)
+          : Element{}
+        {}
+        template<typename E>
+        constexpr CPP_ctor(box)(E && e)(                               //
+            noexcept(std::is_nothrow_constructible<Element, E>::value) //
+            requires(!defer::same_as<box, detail::decay_t<E>>) &&
+            defer::constructible_from<Element, E> && defer::convertible_to<E, Element>)
+          : Element(static_cast<E &&>(e))
+        {}
+        template<typename E>
+        constexpr explicit CPP_ctor(box)(E && e)(                      //
+            noexcept(std::is_nothrow_constructible<Element, E>::value) //
+            requires(!defer::same_as<box, detail::decay_t<E>>) &&
+            defer::constructible_from<Element, E> && (!defer::convertible_to<E, Element>))
+          : Element(static_cast<E &&>(e))
+        {}
+
+        constexpr Element & get() & noexcept
+        {
+            return *this;
+        }
+        constexpr Element const & get() const & noexcept
+        {
+            return *this;
+        }
+        constexpr Element && get() && noexcept
+        {
+            return detail::move(*this);
+        }
+        constexpr Element const && get() const && noexcept
+        {
+            return detail::move(*this);
+        }
+    };
+
+    template<typename Element, typename Tag>
+    class box<Element, Tag, detail::box_compress::coalesce>
+    {
+        static Element value;
+
+    public:
+        constexpr box() noexcept = default;
+        template<typename E>
+        constexpr CPP_ctor(box)(E &&)( //
+            noexcept(true)             //
+            requires(!defer::same_as<box, detail::decay_t<E>>) &&
+            defer::constructible_from<Element, E> && defer::convertible_to<E, Element>)
+        {}
+        template<typename E>
+        constexpr explicit CPP_ctor(box)(E &&)( //
+            noexcept(true)                      //
+            requires(!defer::same_as<box, detail::decay_t<E>>) &&
+            defer::constructible_from<Element, E> && (!defer::convertible_to<E, Element>))
+        {}
+
+        constexpr Element & get() & noexcept
+        {
+            return value;
+        }
+        constexpr Element const & get() const & noexcept
+        {
+            return value;
+        }
+        constexpr Element && get() && noexcept
+        {
+            return detail::move(value);
+        }
+        constexpr Element const && get() const && noexcept
+        {
+            return detail::move(value);
+        }
+    };
+
+    template<typename Element, typename Tag>
+    Element box<Element, Tag, detail::box_compress::coalesce>::value{};
+
+    /// \cond
+    namespace _get_
+    {
+        /// \endcond
+        // Get by tag type
+        template<typename Tag, typename Element, detail::box_compress BC>
+        constexpr Element & get(box<Element, Tag, BC> & b) noexcept
+        {
+            return b.get();
+        }
+        template<typename Tag, typename Element, detail::box_compress BC>
+        constexpr Element const & get(box<Element, Tag, BC> const & b) noexcept
+        {
+            return b.get();
+        }
+        template<typename Tag, typename Element, detail::box_compress BC>
+        constexpr Element && get(box<Element, Tag, BC> && b) noexcept
+        {
+            return detail::move(b).get();
+        }
+        // Get by index
+        template<std::size_t I, typename Element, detail::box_compress BC>
+        constexpr Element & get(box<Element, meta::size_t<I>, BC> & b) noexcept
+        {
+            return b.get();
+        }
+        template<std::size_t I, typename Element, detail::box_compress BC>
+        constexpr Element const & get(
+            box<Element, meta::size_t<I>, BC> const & b) noexcept
+        {
+            return b.get();
+        }
+        template<std::size_t I, typename Element, detail::box_compress BC>
+        constexpr Element && get(box<Element, meta::size_t<I>, BC> && b) noexcept
+        {
+            return detail::move(b).get();
+        }
+        /// \cond
+    } // namespace _get_
+    /// \endcond
+    /// @}
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/utility/common_iterator.hpp b/inst/include/range/v3/utility/common_iterator.hpp
new file mode 100644
index 0000000..1e0885b
--- /dev/null
+++ b/inst/include/range/v3/utility/common_iterator.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTILITY_COMMON_ITERATOR_HPP
+#define RANGES_V3_UTILITY_COMMON_ITERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/iterator/common_iterator.hpp> "
+    "instead.")
+
+#include <range/v3/iterator/common_iterator.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/common_tuple.hpp b/inst/include/range/v3/utility/common_tuple.hpp
new file mode 100644
index 0000000..c9ac7bd
--- /dev/null
+++ b/inst/include/range/v3/utility/common_tuple.hpp
@@ -0,0 +1,716 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_COMMON_TUPLE_HPP
+#define RANGES_V3_UTILITY_COMMON_TUPLE_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/detail/adl_get.hpp>
+#include <range/v3/functional/bind.hpp>
+#include <range/v3/functional/reference_wrapper.hpp>
+#include <range/v3/utility/common_type.hpp>
+#include <range/v3/utility/tuple_algorithm.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename... Us, typename Tup, std::size_t... Is>
+        std::tuple<Us...> to_std_tuple(Tup && tup, meta::index_sequence<Is...>)
+        {
+            return std::tuple<Us...>{adl_get<Is>(static_cast<Tup &&>(tup))...};
+        }
+
+#ifdef RANGES_WORKAROUND_MSVC_786312
+        template<std::size_t, typename...>
+        struct args_;
+
+        template<typename, typename>
+        inline constexpr bool argstructible = false;
+        template<std::size_t N, typename... Ts, typename... Us>
+        inline constexpr bool argstructible<args_<N, Ts...>, args_<N, Us...>> =
+            (META_IS_CONSTRUCTIBLE(Ts, Us) && ...);
+
+        template<typename, typename>
+        inline constexpr bool argsignable = false;
+        template<std::size_t N, typename... Ts, typename... Us>
+        inline constexpr bool argsignable<args_<N, Ts...>, args_<N, Us...>> =
+            (std::is_assignable_v<Ts &, Us> && ...);
+#endif // RANGES_WORKAROUND_MSVC_786312
+
+        template<std::size_t N, typename... Ts>
+        struct args_
+        {
+            template<typename... Us>
+            args_(args_<N, Us...>, meta::if_c<
+#ifdef RANGES_WORKAROUND_MSVC_786312
+                                       argstructible<args_, args_<N, Us...>>
+#else  // ^^^ workaround / no workaround vvv
+                                       meta::and_c<META_IS_CONSTRUCTIBLE(Ts,
+                                                                         Us)...>::value
+#endif // RANGES_WORKAROUND_MSVC_786312
+                                       > * = nullptr)
+            {}
+            template<typename... Us>
+            meta::if_c<
+#ifdef RANGES_WORKAROUND_MSVC_786312
+                argsignable<args_, args_<N, Us...>>,
+#else  // ^^^ workaround / no workaround vvv
+                meta::and_c<std::is_assignable<Ts &, Us>::value...>::value,
+#endif // RANGES_WORKAROUND_MSVC_786312
+                args_ &>
+            operator=(args_<N, Us...>)
+            {
+                return *this;
+            }
+        };
+        template<typename... Ts>
+        using args = args_<sizeof...(Ts), Ts...>;
+        template<typename... Ts>
+        using rargs = args_<sizeof...(Ts), Ts &...>;
+    } // namespace detail
+    /// \endcond
+
+    template<typename... Ts>
+    struct common_tuple : _tuple_wrapper_::forward_tuple_interface<std::tuple<Ts...>>
+    {
+    private:
+        template<typename That, std::size_t... Is>
+        common_tuple(That && that, meta::index_sequence<Is...>)
+          : common_tuple::forward_tuple_interface{
+                detail::adl_get<Is>(static_cast<That &&>(that))...}
+        {}
+        struct element_assign_
+        {
+            template<typename T, typename U>
+            int operator()(T & t, U && u) const
+            {
+                t = static_cast<U &&>(u);
+                return 0;
+            }
+        };
+
+    public:
+        // Construction
+        CPP_member
+        CPP_ctor(common_tuple)()( //
+            noexcept(meta::and_c<
+                     std::is_nothrow_default_constructible<Ts>::value...>::value) //
+            requires default_constructible<std::tuple<Ts...>>)
+          : common_tuple::forward_tuple_interface{}
+        {}
+        CPP_template(typename... Us)(                                              //
+            requires constructible_from<detail::args<Ts...>, detail::args<Us...>>) //
+            explicit common_tuple(Us &&... us) noexcept(
+                meta::and_c<std::is_nothrow_constructible<Ts, Us>::value...>::value)
+          : common_tuple::forward_tuple_interface{static_cast<Us &&>(us)...}
+        {}
+        template<typename... Us>
+        CPP_ctor(common_tuple)(std::tuple<Us...> & that)( //
+            noexcept(
+                meta::and_c<std::is_nothrow_constructible<Ts, Us &>::value...>::value) //
+            requires constructible_from<detail::args<Ts...>, detail::rargs<Us...>>)
+          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
+        {}
+        template<typename... Us>
+        CPP_ctor(common_tuple)(std::tuple<Us...> const & that)( //
+            noexcept(meta::and_c<
+                     std::is_nothrow_constructible<Ts, Us const &>::value...>::value) //
+            requires constructible_from<detail::args<Ts...>, detail::rargs<Us const...>>)
+          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
+        {}
+        template<typename... Us>
+        CPP_ctor(common_tuple)(std::tuple<Us...> && that)( //
+            noexcept(
+                meta::and_c<std::is_nothrow_constructible<Ts, Us>::value...>::value) //
+            requires constructible_from<detail::args<Ts...>, detail::args<Us...>>)
+          : common_tuple(std::move(that), meta::make_index_sequence<sizeof...(Ts)>{})
+        {}
+        template<typename... Us>
+        CPP_ctor(common_tuple)(common_tuple<Us...> & that)( //
+            noexcept(
+                meta::and_c<std::is_nothrow_constructible<Ts, Us &>::value...>::value) //
+            requires constructible_from<detail::args<Ts...>, detail::rargs<Us...>>)
+          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
+        {}
+        template<typename... Us>
+        CPP_ctor(common_tuple)(common_tuple<Us...> const & that)( //
+            noexcept(meta::and_c<
+                     std::is_nothrow_constructible<Ts, Us const &>::value...>::value) //
+            requires constructible_from<detail::args<Ts...>, detail::rargs<Us const...>>)
+          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
+        {}
+        template<typename... Us>
+        CPP_ctor(common_tuple)(common_tuple<Us...> && that)( //
+            noexcept(
+                meta::and_c<std::is_nothrow_constructible<Ts, Us>::value...>::value) //
+            requires constructible_from<detail::args<Ts...>, detail::args<Us...>>)
+          : common_tuple(std::move(that), meta::make_index_sequence<sizeof...(Ts)>{})
+        {}
+
+        std::tuple<Ts...> & base() noexcept
+        {
+            return *this;
+        }
+        std::tuple<Ts...> const & base() const noexcept
+        {
+            return *this;
+        }
+
+        // Assignment
+        template<typename... Us>
+        auto operator=(std::tuple<Us...> & that) noexcept(
+            meta::and_c<std::is_nothrow_assignable<Ts &, Us &>::value...>::value)
+            -> CPP_ret(common_tuple &)( //
+                requires assignable_from<detail::args<Ts...> &, detail::rargs<Us...>>)
+        {
+            (void)tuple_transform(base(), that, element_assign_{});
+            return *this;
+        }
+        template<typename... Us>
+        auto operator=(std::tuple<Us...> const & that) noexcept(
+            meta::and_c<std::is_nothrow_assignable<Ts &, Us const &>::value...>::value)
+            -> CPP_ret(common_tuple &)( //
+                requires assignable_from<detail::args<Ts...> &,
+                                         detail::rargs<Us const...>>)
+        {
+            (void)tuple_transform(base(), that, element_assign_{});
+            return *this;
+        }
+        template<typename... Us>
+        auto operator=(std::tuple<Us...> && that) noexcept(
+            meta::and_c<std::is_nothrow_assignable<Ts &, Us>::value...>::value)
+            -> CPP_ret(common_tuple &)( //
+                requires assignable_from<detail::args<Ts...> &, detail::args<Us...>>)
+        {
+            (void)tuple_transform(base(), std::move(that), element_assign_{});
+            return *this;
+        }
+
+        template<typename... Us>
+        auto operator=(std::tuple<Us...> & that) const noexcept(
+            meta::and_c<std::is_nothrow_assignable<Ts const &, Us &>::value...>::value)
+            -> CPP_ret(common_tuple const &)( //
+                requires assignable_from<detail::args<Ts const...> &,
+                                         detail::rargs<Us...>>)
+        {
+            (void)tuple_transform(base(), that, element_assign_{});
+            return *this;
+        }
+        template<typename... Us>
+        auto operator=(std::tuple<Us...> const & that) const
+            noexcept(meta::and_c<
+                     std::is_nothrow_assignable<Ts const &, Us const &>::value...>::value)
+                -> CPP_ret(common_tuple const &)( //
+                    requires assignable_from<detail::args<Ts const...> &,
+                                             detail::rargs<Us const...>>)
+        {
+            (void)tuple_transform(base(), that, element_assign_{});
+            return *this;
+        }
+        template<typename... Us>
+        auto operator=(std::tuple<Us...> && that) const noexcept(
+            meta::and_c<std::is_nothrow_assignable<Ts const &, Us &&>::value...>::value)
+            -> CPP_ret(common_tuple const &)( //
+                requires assignable_from<detail::args<Ts const...> &,
+                                         detail::args<Us...>>)
+        {
+            (void)tuple_transform(base(), std::move(that), element_assign_{});
+            return *this;
+        }
+
+        // Conversion
+        CPP_template(typename... Us)(                                               //
+            requires constructible_from<detail::args<Us...>, detail::rargs<Ts...>>) //
+        operator std::tuple<Us...>() & noexcept(
+            meta::and_c<std::is_nothrow_constructible<Us, Ts &>::value...>::value)
+        {
+            return detail::to_std_tuple<Us...>(
+                *this, meta::make_index_sequence<sizeof...(Ts)>{});
+        }
+        CPP_template(typename... Us)( //
+            requires constructible_from<detail::args<Us...>,
+                                        detail::rargs<Ts const...>>) //
+        operator std::tuple<Us...>() const & noexcept(
+            meta::and_c<std::is_nothrow_constructible<Us, Ts const &>::value...>::value)
+        {
+            return detail::to_std_tuple<Us...>(
+                *this, meta::make_index_sequence<sizeof...(Ts)>{});
+        }
+        CPP_template(typename... Us)(                                              //
+            requires constructible_from<detail::args<Us...>, detail::args<Ts...>>) //
+        operator std::tuple<Us...>() &&
+            noexcept(meta::and_c<std::is_nothrow_constructible<Us, Ts>::value...>::value)
+        {
+            return detail::to_std_tuple<Us...>(
+                std::move(*this), meta::make_index_sequence<sizeof...(Ts)>{});
+        }
+    };
+
+    // Logical operators
+#define LOGICAL_OP(OP, CONCEPT)                                                    \
+    template<typename... Ts, typename... Us>                                       \
+    auto operator OP(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) \
+        ->CPP_ret(bool)(requires and_v<CONCEPT<Ts, Us>...>)                        \
+    {                                                                              \
+        return a.base() OP b.base();                                               \
+    }                                                                              \
+    template<typename... Ts, typename... Us>                                       \
+    auto operator OP(std::tuple<Ts...> const & a, common_tuple<Us...> const & b)   \
+        ->CPP_ret(bool)(requires and_v<CONCEPT<Ts, Us>...>)                        \
+    {                                                                              \
+        return a OP b.base();                                                      \
+    }                                                                              \
+    template<typename... Ts, typename... Us>                                       \
+    auto operator OP(common_tuple<Ts...> const & a, std::tuple<Us...> const & b)   \
+        ->CPP_ret(bool)(requires and_v<CONCEPT<Ts, Us>...>)                        \
+    {                                                                              \
+        return a.base() OP b;                                                      \
+    }                                                                              \
+    /**/
+    LOGICAL_OP(==, equality_comparable_with)
+    LOGICAL_OP(!=, equality_comparable_with)
+    LOGICAL_OP(<, totally_ordered_with)
+    LOGICAL_OP(<=, totally_ordered_with)
+    LOGICAL_OP(>, totally_ordered_with)
+    LOGICAL_OP(>=, totally_ordered_with)
+#undef LOGICAL_OP
+
+    struct make_common_tuple_fn
+    {
+        template<typename... Args>
+        common_tuple<bind_element_t<Args>...> operator()(Args &&... args) const noexcept(
+            meta::and_c<std::is_nothrow_constructible<
+                bind_element_t<Args>, unwrap_reference_t<Args>>::value...>::value)
+        {
+            return common_tuple<bind_element_t<Args>...>{
+                unwrap_reference(static_cast<Args &&>(args))...};
+        }
+    };
+
+    /// \ingroup group-utility
+    /// \sa `make_common_tuple_fn`
+    RANGES_INLINE_VARIABLE(make_common_tuple_fn, make_common_tuple)
+
+    template<typename F, typename S>
+    struct common_pair : std::pair<F, S>
+    {
+    private:
+        std::pair<F, S> const & base() const noexcept
+        {
+            return *this;
+        }
+
+    public:
+        // Construction
+        CPP_member
+        CPP_ctor(common_pair)()( //
+            noexcept(std::is_nothrow_default_constructible<F>::value &&
+                         std::is_nothrow_default_constructible<S>::value) //
+            requires default_constructible<F> && default_constructible<S>)
+          : std::pair<F, S>{}
+        {}
+        template<typename F2, typename S2>
+        CPP_ctor(common_pair)(F2 && f2, S2 && s2)( //
+            noexcept(std::is_nothrow_constructible<F, F2>::value &&
+                         std::is_nothrow_constructible<S, S2>::value) //
+            requires constructible_from<F, F2> && constructible_from<S, S2>)
+          : std::pair<F, S>{static_cast<F2 &&>(f2), static_cast<S2 &&>(s2)}
+        {}
+        template<typename F2, typename S2>
+        CPP_ctor(common_pair)(std::pair<F2, S2> & that)( //
+            noexcept(std::is_nothrow_constructible<F, F2 &>::value &&
+                         std::is_nothrow_constructible<S, S2 &>::value) //
+            requires constructible_from<F, F2 &> && constructible_from<S, S2 &>)
+          : std::pair<F, S>{that.first, that.second}
+        {}
+        template<typename F2, typename S2>
+        CPP_ctor(common_pair)(std::pair<F2, S2> const & that)( //
+            noexcept(std::is_nothrow_constructible<F, F2 const &>::value &&
+                         std::is_nothrow_constructible<S, S2 const &>::value) //
+            requires constructible_from<F, F2 const &> &&
+                constructible_from<S, S2 const &>)
+          : std::pair<F, S>{that.first, that.second}
+        {}
+        template<typename F2, typename S2>
+        CPP_ctor(common_pair)(std::pair<F2, S2> && that)( //
+            noexcept(std::is_nothrow_constructible<F, F2>::value &&
+                         std::is_nothrow_constructible<S, S2>::value) //
+            requires constructible_from<F, F2> && constructible_from<S, S2>)
+          : std::pair<F, S>{std::forward<F2>(that.first), std::forward<S2>(that.second)}
+        {}
+
+        // Conversion
+        CPP_template(typename F2, typename S2)(                                  //
+            requires constructible_from<F2, F &> && constructible_from<S2, S &>) //
+        operator std::pair<F2, S2>() &
+            noexcept(std::is_nothrow_constructible<F2, F &>::value &&
+                         std::is_nothrow_constructible<S2, S &>::value)
+        {
+            return {this->first, this->second};
+        }
+        CPP_template(typename F2, typename S2)( //
+            requires constructible_from<F2, F const &> &&
+                constructible_from<S2, S const &>) //
+        operator std::pair<F2, S2>() const &
+            noexcept(std::is_nothrow_constructible<F2, F const &>::value &&
+                         std::is_nothrow_constructible<S2, S const &>::value)
+        {
+            return {this->first, this->second};
+        }
+        CPP_template(typename F2, typename S2)(                              //
+            requires constructible_from<F2, F> && constructible_from<S2, S>) //
+        operator std::pair<F2, S2>() &&
+            noexcept(std::is_nothrow_constructible<F2, F>::value &&
+                         std::is_nothrow_constructible<S2, S>::value)
+        {
+            return {std::forward<F>(this->first), std::forward<S>(this->second)};
+        }
+
+        // Assignment
+        template<typename F2, typename S2>
+        auto operator=(std::pair<F2, S2> & that) noexcept(
+            std::is_nothrow_assignable<F &, F2 &>::value &&
+                std::is_nothrow_assignable<S &, S2 &>::value)
+            -> CPP_ret(common_pair &)( //
+                requires assignable_from<F &, F2 &> && assignable_from<S &, S2 &>)
+        {
+            this->first = that.first;
+            this->second = that.second;
+            return *this;
+        }
+        template<typename F2, typename S2>
+        auto operator=(std::pair<F2, S2> const & that) noexcept(
+            std::is_nothrow_assignable<F &, F2 const &>::value &&
+                std::is_nothrow_assignable<S &, S2 const &>::value)
+            -> CPP_ret(common_pair &)( //
+                requires assignable_from<F &, F2 const &> &&
+                    assignable_from<S &, S2 const &>)
+        {
+            this->first = that.first;
+            this->second = that.second;
+            return *this;
+        }
+        template<typename F2, typename S2>
+        auto operator=(std::pair<F2, S2> && that) noexcept(
+            std::is_nothrow_assignable<F &, F2>::value &&
+                std::is_nothrow_assignable<S &, S2>::value) -> CPP_ret(common_pair &)( //
+            requires assignable_from<F &, F2> && assignable_from<S &, S2>)
+        {
+            this->first = static_cast<F2 &&>(that.first);
+            this->second = static_cast<S2 &&>(that.second);
+            return *this;
+        }
+
+        template<typename F2, typename S2>
+        auto operator=(std::pair<F2, S2> & that) const
+            noexcept(std::is_nothrow_assignable<F const &, F2 &>::value &&
+                         std::is_nothrow_assignable<S const &, S2 &>::value)
+                -> CPP_ret(common_pair const &)( //
+                    requires assignable_from<F const &, F2 &> &&
+                        assignable_from<S const &, S2 &>)
+        {
+            this->first = that.first;
+            this->second = that.second;
+            return *this;
+        }
+        template<typename F2, typename S2>
+        auto operator=(std::pair<F2, S2> const & that) const
+            noexcept(std::is_nothrow_assignable<F const &, F2 const &>::value &&
+                         std::is_nothrow_assignable<S const &, S2 const &>::value)
+                -> CPP_ret(common_pair const &)( //
+                    requires assignable_from<F const &, F2 const &> &&
+                        assignable_from<S const &, S2 const &>)
+        {
+            this->first = that.first;
+            this->second = that.second;
+            return *this;
+        }
+        template<typename F2, typename S2>
+        auto operator=(std::pair<F2, S2> && that) const noexcept(
+            std::is_nothrow_assignable<F const &, F2 &&>::value &&
+                std::is_nothrow_assignable<S const &, S2 &&>::value)
+            -> CPP_ret(common_pair const &)( //
+                requires assignable_from<F const &, F2> && assignable_from<S const &, S2>)
+        {
+            this->first = static_cast<F2 &&>(that.first);
+            this->second = static_cast<S2 &&>(that.second);
+            return *this;
+        }
+    };
+
+    // Logical operators
+    template<typename F1, typename S1, typename F2, typename S2>
+    auto operator==(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b)
+        -> CPP_ret(bool)( //
+            requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>)
+    {
+        return a.first == b.first && a.second == b.second;
+    }
+    template<typename F1, typename S1, typename F2, typename S2>
+    auto operator==(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b)
+        -> CPP_ret(bool)( //
+            requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>)
+    {
+        return a.first == b.first && a.second == b.second;
+    }
+    template<typename F1, typename S1, typename F2, typename S2>
+    auto operator==(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b)
+        -> CPP_ret(bool)( //
+            requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>)
+    {
+        return a.first == b.first && a.second == b.second;
+    }
+    template<typename F1, typename S1, typename F2, typename S2>
+    auto operator<(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b)
+        -> CPP_ret(bool)( //
+            requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>)
+    {
+        return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
+    }
+    template<typename F1, typename S1, typename F2, typename S2>
+    auto operator<(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b)
+        -> CPP_ret(bool)( //
+            requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>)
+    {
+        return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
+    }
+    template<typename F1, typename S1, typename F2, typename S2>
+    auto operator<(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b)
+        -> CPP_ret(bool)( //
+            requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>)
+    {
+        return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
+    }
+#define LOGICAL_OP(OP, CONCEPT, RET)                                               \
+    template<typename F1, typename S1, typename F2, typename S2>                   \
+    auto operator OP(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b) \
+        ->CPP_ret(bool)(requires CONCEPT<F1, F2> && CONCEPT<S1, S2>)               \
+    {                                                                              \
+        return RET;                                                                \
+    }                                                                              \
+    template<typename F1, typename S1, typename F2, typename S2>                   \
+    auto operator OP(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b)   \
+        ->CPP_ret(bool)(requires CONCEPT<F1, F2> && CONCEPT<S1, S2>)               \
+    {                                                                              \
+        return RET;                                                                \
+    }                                                                              \
+    template<typename F1, typename S1, typename F2, typename S2>                   \
+    auto operator OP(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b)   \
+        ->CPP_ret(bool)(requires CONCEPT<F1, F2> && CONCEPT<S1, S2>)               \
+    {                                                                              \
+        return RET;                                                                \
+    }                                                                              \
+    /**/
+    LOGICAL_OP(!=, equality_comparable_with, !(a == b))
+    LOGICAL_OP(<=, totally_ordered_with, !(b < a))
+    LOGICAL_OP(>, totally_ordered_with, (b < a))
+    LOGICAL_OP(>=, totally_ordered_with, !(a < b))
+#undef LOGICAL_OP
+
+    struct make_common_pair_fn
+    {
+        template<typename First, typename Second, typename F = bind_element_t<First>,
+                 typename S = bind_element_t<Second>>
+        common_pair<F, S> operator()(First && f, Second && s) const noexcept(
+            std::is_nothrow_constructible<F, unwrap_reference_t<First>>::value &&
+                std::is_nothrow_constructible<F, unwrap_reference_t<Second>>::value)
+        {
+            return {unwrap_reference(static_cast<First &&>(f)),
+                    unwrap_reference(static_cast<Second &&>(s))};
+        }
+    };
+
+    /// \ingroup group-utility
+    /// \sa `make_common_pair_fn`
+    RANGES_INLINE_VARIABLE(make_common_pair_fn, make_common_pair)
+
+    /// \cond
+    namespace detail
+    {
+        template<typename, typename, typename, typename = void>
+        struct common_type_tuple_like
+        {};
+
+        template<template<typename...> class T0, typename... Ts,
+                 template<typename...> class T1, typename... Us, typename TupleLike>
+        struct common_type_tuple_like<T0<Ts...>, T1<Us...>, TupleLike,
+                                      meta::if_c<sizeof...(Ts) == sizeof...(Us)>>
+          : meta::lazy::let<
+                meta::lazy::invoke<TupleLike, meta::lazy::_t<common_type<Ts, Us>>...>>
+        {};
+
+        template<typename T, typename U>
+        using make_common_pair =
+            meta::if_<meta::or_<std::is_reference<T>, std::is_reference<U>>,
+                      common_pair<T, U>, std::pair<T, U>>;
+
+        template<typename... Ts>
+        using make_common_tuple =
+            meta::if_<meta::any_of<meta::list<Ts...>, meta::quote<std::is_reference>>,
+                      common_tuple<Ts...>, std::tuple<Ts...>>;
+
+        template<typename, typename, typename, typename = void>
+        struct common_ref_tuple_like
+        {};
+
+        template<template<typename...> class T0, typename... Ts,
+                 template<typename...> class T1, typename... Us, typename TupleLike>
+        struct common_ref_tuple_like<T0<Ts...>, T1<Us...>, TupleLike,
+                                     meta::if_c<sizeof...(Ts) == sizeof...(Us)>>
+          : meta::lazy::let<meta::lazy::invoke<
+                TupleLike, meta::lazy::_t<common_reference<Ts, Us>>...>>
+        {};
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+/// \cond
+namespace concepts
+{
+    // common_type for pairs
+    template<typename F1, typename S1, typename F2, typename S2>
+    struct common_type<std::pair<F1, S1>, ranges::common_pair<F2, S2>>
+      : ranges::detail::common_type_tuple_like<
+            std::pair<F1, S1>, ranges::common_pair<F2, S2>,
+            meta::quote<ranges::detail::make_common_pair>>
+    {};
+    template<typename F1, typename S1, typename F2, typename S2>
+    struct common_type<ranges::common_pair<F1, S1>, std::pair<F2, S2>>
+      : ranges::detail::common_type_tuple_like<
+            ranges::common_pair<F1, S1>, std::pair<F2, S2>,
+            meta::quote<ranges::detail::make_common_pair>>
+    {};
+    template<typename F1, typename S1, typename F2, typename S2>
+    struct common_type<ranges::common_pair<F1, S1>, ranges::common_pair<F2, S2>>
+      : ranges::detail::common_type_tuple_like<ranges::common_pair<F1, S1>,
+                                               ranges::common_pair<F2, S2>,
+                                               meta::quote<ranges::common_pair>>
+    {};
+    // common_type for tuples
+    template<typename... Ts, typename... Us>
+    struct common_type<ranges::common_tuple<Ts...>, std::tuple<Us...>>
+      : ranges::detail::common_type_tuple_like<
+            ranges::common_tuple<Ts...>, std::tuple<Us...>,
+            meta::quote<ranges::detail::make_common_tuple>>
+    {};
+    template<typename... Ts, typename... Us>
+    struct common_type<std::tuple<Ts...>, ranges::common_tuple<Us...>>
+      : ranges::detail::common_type_tuple_like<
+            std::tuple<Ts...>, ranges::common_tuple<Us...>,
+            meta::quote<ranges::detail::make_common_tuple>>
+    {};
+    template<typename... Ts, typename... Us>
+    struct common_type<ranges::common_tuple<Ts...>, ranges::common_tuple<Us...>>
+      : ranges::detail::common_type_tuple_like<ranges::common_tuple<Ts...>,
+                                               ranges::common_tuple<Us...>,
+                                               meta::quote<ranges::common_tuple>>
+    {};
+
+    // common reference for pairs
+    template<typename F1, typename S1, typename F2, typename S2,
+             template<typename> class Qual1, template<typename> class Qual2>
+    struct basic_common_reference<ranges::common_pair<F1, S1>, std::pair<F2, S2>, Qual1,
+                                  Qual2>
+      : ranges::detail::common_ref_tuple_like<
+            ranges::common_pair<Qual1<F1>, Qual1<S1>>, std::pair<Qual2<F2>, Qual2<S2>>,
+            meta::quote<ranges::detail::make_common_pair>>
+    {};
+    template<typename F1, typename S1, typename F2, typename S2,
+             template<typename> class Qual1, template<typename> class Qual2>
+    struct basic_common_reference<std::pair<F1, S1>, ranges::common_pair<F2, S2>, Qual1,
+                                  Qual2>
+      : ranges::detail::common_ref_tuple_like<
+            std::pair<Qual1<F1>, Qual1<S1>>, ranges::common_pair<Qual2<F2>, Qual2<S2>>,
+            meta::quote<ranges::detail::make_common_pair>>
+    {};
+    template<typename F1, typename S1, typename F2, typename S2,
+             template<typename> class Qual1, template<typename> class Qual2>
+    struct basic_common_reference<ranges::common_pair<F1, S1>,
+                                  ranges::common_pair<F2, S2>, Qual1, Qual2>
+      : ranges::detail::common_ref_tuple_like<ranges::common_pair<Qual1<F1>, Qual1<S1>>,
+                                              ranges::common_pair<Qual2<F2>, Qual2<S2>>,
+                                              meta::quote<ranges::common_pair>>
+    {};
+    // common reference for tuples
+    template<typename... Ts, typename... Us, template<typename> class Qual1,
+             template<typename> class Qual2>
+    struct basic_common_reference<ranges::common_tuple<Ts...>, std::tuple<Us...>, Qual1,
+                                  Qual2>
+      : ranges::detail::common_ref_tuple_like<
+            ranges::common_tuple<Qual1<Ts>...>, std::tuple<Qual2<Us>...>,
+            meta::quote<ranges::detail::make_common_tuple>>
+    {};
+    template<typename... Ts, typename... Us, template<typename> class Qual1,
+             template<typename> class Qual2>
+    struct basic_common_reference<std::tuple<Ts...>, ranges::common_tuple<Us...>, Qual1,
+                                  Qual2>
+      : ranges::detail::common_ref_tuple_like<
+            std::tuple<Qual1<Ts>...>, ranges::common_tuple<Qual2<Us>...>,
+            meta::quote<ranges::detail::make_common_tuple>>
+    {};
+    template<typename... Ts, typename... Us, template<typename> class Qual1,
+             template<typename> class Qual2>
+    struct basic_common_reference<ranges::common_tuple<Ts...>,
+                                  ranges::common_tuple<Us...>, Qual1, Qual2>
+      : ranges::detail::common_ref_tuple_like<ranges::common_tuple<Qual1<Ts>...>,
+                                              ranges::common_tuple<Qual2<Us>...>,
+                                              meta::quote<ranges::common_tuple>>
+    {};
+} // namespace concepts
+/// \endcond
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+
+namespace std
+{
+    template<typename First, typename Second>
+    struct tuple_size<::ranges::common_pair<First, Second>>
+      : std::integral_constant<size_t, 2>
+    {};
+
+    template<typename First, typename Second>
+    struct tuple_element<0, ::ranges::common_pair<First, Second>>
+    {
+        using type = First;
+    };
+
+    template<typename First, typename Second>
+    struct tuple_element<1, ::ranges::common_pair<First, Second>>
+    {
+        using type = Second;
+    };
+
+    template<typename... Ts>
+    struct tuple_size<::ranges::common_tuple<Ts...>>
+      : std::integral_constant<size_t, sizeof...(Ts)>
+    {};
+
+    template<size_t N, typename... Ts>
+    struct tuple_element<N, ::ranges::common_tuple<Ts...>>
+      : tuple_element<N, tuple<Ts...>>
+    {};
+} // namespace std
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/utility/common_type.hpp b/inst/include/range/v3/utility/common_type.hpp
new file mode 100644
index 0000000..ab417dd
--- /dev/null
+++ b/inst/include/range/v3/utility/common_type.hpp
@@ -0,0 +1,117 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_COMMON_TYPE_HPP
+#define RANGES_V3_UTILITY_COMMON_TYPE_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/type_traits.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+// Sadly, this is necessary because of:
+//  - std::common_type is !SFINAE-friendly, and
+//  - The specification of std::common_type makes it impossibly
+//    difficult to specialize on user-defined types without spamming
+//    out a bajillion copies to handle all combinations of cv and ref
+//    qualifiers.
+
+#ifndef RANGES_NO_STD_FORWARD_DECLARATIONS
+// Non-portable forward declarations of standard containers
+RANGES_BEGIN_NAMESPACE_STD
+    RANGES_BEGIN_NAMESPACE_VERSION
+        template<typename... Ts>
+        class tuple;
+    RANGES_END_NAMESPACE_VERSION
+RANGES_END_NAMESPACE_STD
+#else
+#include <tuple>
+#endif
+
+namespace ranges
+{
+    template<typename... Ts>
+    using common_type = concepts::common_type<Ts...>;
+
+    template<typename... Ts>
+    using common_type_t = concepts::common_type_t<Ts...>;
+
+    template<typename... Ts>
+    using common_reference = concepts::common_reference<Ts...>;
+
+    template<typename... Ts>
+    using common_reference_t = concepts::common_reference_t<Ts...>;
+} // namespace ranges
+
+namespace concepts
+{
+    /// \cond
+    // Specializations for pair and tuple
+    template<typename F, typename S>
+    struct common_pair;
+
+    template<typename... Ts>
+    struct common_tuple;
+
+    // common_type for std::pairs
+    template<typename F1, typename S1, typename F2, typename S2>
+    struct common_type<std::pair<F1, S1>, common_pair<F2, S2>>;
+
+    template<typename F1, typename S1, typename F2, typename S2>
+    struct common_type<common_pair<F1, S1>, std::pair<F2, S2>>;
+
+    template<typename F1, typename S1, typename F2, typename S2>
+    struct common_type<common_pair<F1, S1>, common_pair<F2, S2>>;
+
+    // common_type for std::tuples
+    template<typename... Ts, typename... Us>
+    struct common_type<common_tuple<Ts...>, std::tuple<Us...>>;
+
+    template<typename... Ts, typename... Us>
+    struct common_type<std::tuple<Ts...>, common_tuple<Us...>>;
+
+    template<typename... Ts, typename... Us>
+    struct common_type<common_tuple<Ts...>, common_tuple<Us...>>;
+
+    // A common reference for std::pairs
+    template<typename F1, typename S1, typename F2, typename S2,
+             template<typename> class Qual1, template<typename> class Qual2>
+    struct basic_common_reference<common_pair<F1, S1>, std::pair<F2, S2>, Qual1, Qual2>;
+
+    template<typename F1, typename S1, typename F2, typename S2,
+             template<typename> class Qual1, template<typename> class Qual2>
+    struct basic_common_reference<std::pair<F1, S1>, common_pair<F2, S2>, Qual1, Qual2>;
+
+    template<typename F1, typename S1, typename F2, typename S2,
+             template<typename> class Qual1, template<typename> class Qual2>
+    struct basic_common_reference<common_pair<F1, S1>, common_pair<F2, S2>, Qual1, Qual2>;
+
+    // A common reference for std::tuples
+    template<typename... Ts, typename... Us, template<typename> class Qual1,
+             template<typename> class Qual2>
+    struct basic_common_reference<common_tuple<Ts...>, std::tuple<Us...>, Qual1, Qual2>;
+
+    template<typename... Ts, typename... Us, template<typename> class Qual1,
+             template<typename> class Qual2>
+    struct basic_common_reference<std::tuple<Ts...>, common_tuple<Us...>, Qual1, Qual2>;
+
+    template<typename... Ts, typename... Us, template<typename> class Qual1,
+             template<typename> class Qual2>
+    struct basic_common_reference<common_tuple<Ts...>, common_tuple<Us...>, Qual1, Qual2>;
+    /// \endcond
+} // namespace concepts
+
+#endif
diff --git a/inst/include/range/v3/utility/compressed_pair.hpp b/inst/include/range/v3/utility/compressed_pair.hpp
new file mode 100644
index 0000000..2c6b047
--- /dev/null
+++ b/inst/include/range/v3/utility/compressed_pair.hpp
@@ -0,0 +1,226 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_COMPRESSED_PAIR_HPP
+#define RANGES_V3_UTILITY_COMPRESSED_PAIR_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace compressed_tuple_detail
+    {
+        // tagging individual elements with the complete type list disambiguates
+        // base classes when composing compressed_tuples recursively.
+        template<typename T, std::size_t I, typename... Ts>
+        using storage = box<T, meta::list<meta::size_t<I>, Ts...>>;
+
+        template<typename List, typename Indices>
+        struct compressed_tuple_;
+        template<typename... Ts, std::size_t... Is>
+        struct RANGES_EMPTY_BASES
+            compressed_tuple_<meta::list<Ts...>, meta::index_sequence<Is...>>
+          : storage<Ts, Is, Ts...>...
+        {
+            static_assert(same_as<meta::index_sequence<Is...>,
+                                  meta::make_index_sequence<sizeof...(Is)>>,
+                          "What madness is this?!?");
+
+            compressed_tuple_() = default;
+
+            template<typename... Args,
+                     meta::if_<meta::and_c<META_IS_CONSTRUCTIBLE(Ts, Args)...>, int> = 0>
+            constexpr compressed_tuple_(Args &&... args) noexcept(
+                meta::strict_and<std::is_nothrow_constructible<storage<Ts, Is, Ts...>,
+                                                               Args>...>::value)
+              : storage<Ts, Is, Ts...>{static_cast<Args &&>(args)}...
+            {}
+
+            template<
+                typename... Us,
+                meta::if_<meta::and_c<META_IS_CONSTRUCTIBLE(Us, Ts const &)...>, int> = 0>
+            constexpr operator std::tuple<Us...>() const noexcept(
+                meta::strict_and<std::is_nothrow_constructible<Us, Ts const &>...>::value)
+            {
+                return std::tuple<Us...>{get<Is>(*this)...};
+            }
+
+            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
+            friend constexpr T & get(compressed_tuple_ & tuple) noexcept
+            {
+                return static_cast<storage<T, I, Ts...> &>(tuple).get();
+            }
+            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
+            friend constexpr T const & get(compressed_tuple_ const & tuple) noexcept
+            {
+                return static_cast<storage<T, I, Ts...> const &>(tuple).get();
+            }
+            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
+            friend constexpr T && get(compressed_tuple_ && tuple) noexcept
+            {
+                return static_cast<storage<T, I, Ts...> &&>(tuple).get();
+            }
+            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
+            friend constexpr T const && get(compressed_tuple_ const && tuple) noexcept
+            {
+                return static_cast<storage<T, I, Ts...> const &&>(tuple).get();
+            }
+        };
+
+        template<typename... Ts>
+        using compressed_tuple RANGES_DEPRECATED(
+            "ranges::compressed_tuple is deprecated.") =
+            compressed_tuple_<meta::list<Ts...>,
+                              meta::make_index_sequence<sizeof...(Ts)>>;
+    } // namespace compressed_tuple_detail
+    /// \endcond
+
+    using compressed_tuple_detail::compressed_tuple;
+
+    struct make_compressed_tuple_fn
+    {
+        // clang-format off
+        template<typename... Args>
+        constexpr auto CPP_auto_fun(operator())(Args &&... args) (const)
+        (
+            return compressed_tuple<bind_element_t<Args>...>{static_cast<Args &&>(args)...}
+        )
+        // clang-format on
+    };
+
+    /// \ingroup group-utility
+    /// \sa `make_compressed_tuple_fn`
+    RANGES_INLINE_VARIABLE(make_compressed_tuple_fn, make_compressed_tuple)
+
+    template<typename First, typename Second>
+    struct RANGES_EMPTY_BASES compressed_pair
+      : box<First, meta::size_t<0>>
+      , box<Second, meta::size_t<1>>
+    {
+        using first_type = First;
+        using second_type = Second;
+
+        compressed_pair() = default;
+
+        CPP_template(typename U, typename V)(                                       //
+            requires constructible_from<First, U> && constructible_from<Second, V>) //
+            constexpr compressed_pair(U && u,
+                                      V && v) noexcept(noexcept(First((U &&) u)) &&
+                                                       noexcept(Second((V &&) v)))
+          : box<First, meta::size_t<0>>{(U &&) u}
+          , box<Second, meta::size_t<1>>{(V &&) v}
+        {}
+
+        constexpr First & first() &
+        {
+            return this->box<First, meta::size_t<0>>::get();
+        }
+        constexpr First const & first() const &
+        {
+            return this->box<First, meta::size_t<0>>::get();
+        }
+        constexpr First && first() &&
+        {
+            return static_cast<First &&>(this->box<First, meta::size_t<0>>::get());
+        }
+
+        constexpr Second & second() &
+        {
+            return this->box<Second, meta::size_t<1>>::get();
+        }
+        constexpr Second const & second() const &
+        {
+            return this->box<Second, meta::size_t<1>>::get();
+        }
+        constexpr Second && second() &&
+        {
+            return static_cast<Second &&>(this->box<Second, meta::size_t<1>>::get());
+        }
+
+        CPP_template(typename F, typename S)( //
+            requires convertible_to<First const &, F> &&
+                convertible_to<Second const &, S>) //
+            constexpr
+            operator std::pair<F, S>() const
+        {
+            return std::pair<F, S>{first(), second()};
+        }
+    };
+
+    struct make_compressed_pair_fn
+    {
+        // clang-format off
+        template<typename First, typename Second>
+        constexpr auto CPP_auto_fun(operator())(First &&f, Second &&s) (const)
+        (
+            return compressed_pair<bind_element_t<First>, bind_element_t<Second>>{
+                static_cast<First &&>(f), static_cast<Second &&>(s)
+            }
+        )
+        // clang-format on
+    };
+
+    /// \ingroup group-utility
+    /// \sa `make_compressed_pair_fn`
+    RANGES_INLINE_VARIABLE(make_compressed_pair_fn, make_compressed_pair)
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+namespace std
+{
+    template<typename... Ts, size_t... Is>
+    struct tuple_size<::ranges::compressed_tuple_detail::compressed_tuple_<
+        ::meta::list<Ts...>, ::meta::index_sequence<Is...>>>
+      : integral_constant<size_t, sizeof...(Ts)>
+    {};
+
+    template<size_t I, typename... Ts, size_t... Is>
+    struct tuple_element<I, ::ranges::compressed_tuple_detail::compressed_tuple_<
+                                ::meta::list<Ts...>, ::meta::index_sequence<Is...>>>
+    {
+        using type = ::meta::at_c<::meta::list<Ts...>, I>;
+    };
+
+    template<typename First, typename Second>
+    struct tuple_size<::ranges::compressed_pair<First, Second>>
+      : integral_constant<size_t, 2>
+    {};
+
+    template<typename First, typename Second>
+    struct tuple_element<0, ::ranges::compressed_pair<First, Second>>
+    {
+        using type = First;
+    };
+
+    template<typename First, typename Second>
+    struct tuple_element<1, ::ranges::compressed_pair<First, Second>>
+    {
+        using type = Second;
+    };
+} // namespace std
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/utility/concepts.hpp b/inst/include/range/v3/utility/concepts.hpp
new file mode 100644
index 0000000..b8a1c91
--- /dev/null
+++ b/inst/include/range/v3/utility/concepts.hpp
@@ -0,0 +1,27 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_CONCEPTS_HPP
+#define RANGES_V3_UTILITY_CONCEPTS_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <concepts/concepts.hpp> instead.")
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/common_type.hpp>
+#include <range/v3/utility/swap.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/copy.hpp b/inst/include/range/v3/utility/copy.hpp
new file mode 100644
index 0000000..8abf955
--- /dev/null
+++ b/inst/include/range/v3/utility/copy.hpp
@@ -0,0 +1,56 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_COPY_HPP
+#define RANGES_V3_UTILITY_COPY_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-utility
+    /// @{
+    namespace aux
+    {
+        struct copy_fn : copy_tag
+        {
+            template<typename T>
+            constexpr auto operator()(T && t) const -> CPP_ret(detail::decay_t<T>)( //
+                requires constructible_from<detail::decay_t<T>, T>)
+            {
+                return static_cast<T &&>(t);
+            }
+
+            /// \ingroup group-utility
+            /// \sa `copy_fn`
+            template<typename T>
+            friend constexpr auto operator|(T && t, copy_fn)
+                -> CPP_broken_friend_ret(detail::decay_t<T>)( //
+                    requires constructible_from<detail::decay_t<T>, T>)
+            {
+                return static_cast<T &&>(t);
+            }
+        };
+
+        /// \ingroup group-utility
+        /// \sa `copy_fn`
+        RANGES_INLINE_VARIABLE(copy_fn, copy)
+    } // namespace aux
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/counted_iterator.hpp b/inst/include/range/v3/utility/counted_iterator.hpp
new file mode 100644
index 0000000..1564e27
--- /dev/null
+++ b/inst/include/range/v3/utility/counted_iterator.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTILITY_COUNTED_ITERATOR_HPP
+#define RANGES_V3_UTILITY_COUNTED_ITERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/iterator/counted_iterator.hpp> "
+    "instead.")
+
+#include <range/v3/iterator/counted_iterator.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/dangling.hpp b/inst/include/range/v3/utility/dangling.hpp
new file mode 100644
index 0000000..60eed25
--- /dev/null
+++ b/inst/include/range/v3/utility/dangling.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_DANGLING_HPP
+#define RANGES_V3_UTILITY_DANGLING_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/range/dangling.hpp> instead.")
+
+#include <range/v3/range/dangling.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/functional.hpp b/inst/include/range/v3/utility/functional.hpp
new file mode 100644
index 0000000..243d55c
--- /dev/null
+++ b/inst/include/range/v3/utility/functional.hpp
@@ -0,0 +1,42 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTILITY_FUNCTIONAL_HPP
+#define RANGES_V3_UTILITY_FUNCTIONAL_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header has been deprecated. Please find what you are looking for in the "
+    "range/v3/functional/ directory.")
+
+#include <range/v3/detail/with_braced_init_args.hpp>
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/bind.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/indirect.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/not_fn.hpp>
+#include <range/v3/functional/on.hpp>
+#include <range/v3/functional/overload.hpp>
+#include <range/v3/functional/pipeable.hpp>
+#include <range/v3/functional/reference_wrapper.hpp>
+
+namespace ranges
+{
+    using detail::with_braced_init_args;
+}
+
+#endif
diff --git a/inst/include/range/v3/utility/get.hpp b/inst/include/range/v3/utility/get.hpp
new file mode 100644
index 0000000..9fdf6dc
--- /dev/null
+++ b/inst/include/range/v3/utility/get.hpp
@@ -0,0 +1,69 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_GET_HPP
+#define RANGES_V3_UTILITY_GET_HPP
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/detail/adl_get.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-utility Utility
+    /// @{
+    ///
+
+    /// \cond
+    namespace _get_
+    {
+        /// \endcond
+        // clang-format off
+        template<std::size_t I, typename TupleLike>
+        constexpr auto CPP_auto_fun(get)(TupleLike &&t)
+        (
+            return detail::adl_get<I>(static_cast<TupleLike &&>(t))
+        )
+        template<typename T, typename TupleLike>
+        constexpr auto CPP_auto_fun(get)(TupleLike &&t)
+        (
+            return detail::adl_get<T>(static_cast<TupleLike &&>(t))
+        )
+            // clang-format on
+
+            template<typename T>
+            T & get(meta::id_t<T> & value) noexcept
+        {
+            return value;
+        }
+        template<typename T>
+        T const & get(meta::id_t<T> const & value) noexcept
+        {
+            return value;
+        }
+        template<typename T>
+        T && get(meta::id_t<T> && value) noexcept
+        {
+            return static_cast<T &&>(value);
+        }
+        /// \cond
+    } // namespace _get_
+    using namespace _get_;
+    /// \endcond
+
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/in_place.hpp b/inst/include/range/v3/utility/in_place.hpp
new file mode 100644
index 0000000..149d2e1
--- /dev/null
+++ b/inst/include/range/v3/utility/in_place.hpp
@@ -0,0 +1,29 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_IN_PLACE_HPP
+#define RANGES_V3_UTILITY_IN_PLACE_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \ingroup group-utility
+    struct in_place_t
+    {};
+    RANGES_INLINE_VARIABLE(in_place_t, in_place)
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/infinity.hpp b/inst/include/range/v3/utility/infinity.hpp
new file mode 100644
index 0000000..b780839
--- /dev/null
+++ b/inst/include/range/v3/utility/infinity.hpp
@@ -0,0 +1,67 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_INFINITY_HPP
+#define RANGES_V3_UTILITY_INFINITY_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated and will be removed from a future version of range-v3.")
+
+namespace ranges
+{
+    /// \cond
+    struct infinity
+    {
+        friend constexpr bool operator==(infinity, infinity)
+        {
+            return true;
+        }
+        friend constexpr bool operator!=(infinity, infinity)
+        {
+            return false;
+        }
+        template<typename Integer>
+        friend constexpr auto operator==(Integer, infinity) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires integral<Integer>)
+        {
+            return false;
+        }
+        template<typename Integer>
+        friend constexpr auto operator==(infinity, Integer) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires integral<Integer>)
+        {
+            return false;
+        }
+        template<typename Integer>
+        friend constexpr auto operator!=(Integer, infinity) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires integral<Integer>)
+        {
+            return true;
+        }
+        template<typename Integer>
+        friend constexpr auto operator!=(infinity, Integer) noexcept
+            -> CPP_broken_friend_ret(bool)( //
+                requires integral<Integer>)
+        {
+            return true;
+        }
+    };
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/invoke.hpp b/inst/include/range/v3/utility/invoke.hpp
new file mode 100644
index 0000000..a88f421
--- /dev/null
+++ b/inst/include/range/v3/utility/invoke.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTILITY_INVOKE_HPP
+#define RANGES_V3_UTILITY_INVOKE_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This file has been deprecated. Please #include <range/v3/functional/invoke.hpp> "
+    "instead.")
+
+#include <range/v3/functional/invoke.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/iterator.hpp b/inst/include/range/v3/utility/iterator.hpp
new file mode 100644
index 0000000..b9848e2
--- /dev/null
+++ b/inst/include/range/v3/utility/iterator.hpp
@@ -0,0 +1,31 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_ITERATOR_HPP
+#define RANGES_V3_UTILITY_ITERATOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    R"(This header is deprecated. Please include one of the following depending on your need:
+    <range/v3/iterator/operations.hpp>,
+    <range/v3/iterator/insert_iterators.hpp>,
+    <range/v3/iterator/move_iterators.hpp>,
+    <range/v3/iterator/reverse_iterator.hpp>,
+    <range/v3/iterator/stream_iterators.hpp>)")
+
+#include <range/v3/iterator/insert_iterators.hpp>
+#include <range/v3/iterator/move_iterators.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/reverse_iterator.hpp>
+#include <range/v3/iterator/stream_iterators.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/iterator_concepts.hpp b/inst/include/range/v3/utility/iterator_concepts.hpp
new file mode 100644
index 0000000..619d0d5
--- /dev/null
+++ b/inst/include/range/v3/utility/iterator_concepts.hpp
@@ -0,0 +1,23 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_ITERATOR_CONCEPTS_HPP
+#define RANGES_V3_UTILITY_ITERATOR_CONCEPTS_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/iterator/concepts.hpp> "
+    "instead.")
+
+#include <range/v3/iterator/concepts.hpp>
+
+#endif // RANGES_V3_UTILITY_ITERATOR_CONCEPTS_HPP
diff --git a/inst/include/range/v3/utility/iterator_traits.hpp b/inst/include/range/v3/utility/iterator_traits.hpp
new file mode 100644
index 0000000..feaf30e
--- /dev/null
+++ b/inst/include/range/v3/utility/iterator_traits.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_ITERATOR_TRAITS_HPP
+#define RANGES_V3_UTILITY_ITERATOR_TRAITS_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/iterator/traits.hpp> instead.")
+
+#include <range/v3/iterator/traits.hpp>
+
+#endif // RANGES_V3_UTILITY_ITERATOR_TRAITS_HPP
diff --git a/inst/include/range/v3/utility/memory.hpp b/inst/include/range/v3/utility/memory.hpp
new file mode 100644
index 0000000..8192f6e
--- /dev/null
+++ b/inst/include/range/v3/utility/memory.hpp
@@ -0,0 +1,251 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+//===-------------------------- algorithm ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RANGES_V3_UTILITY_MEMORY_HPP
+#define RANGES_V3_UTILITY_MEMORY_HPP
+
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/detail/config.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/polymorphic_cast.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        std::pair<T *, std::ptrdiff_t> get_temporary_buffer_impl(
+            std::size_t count) noexcept
+        {
+            RANGES_EXPECT(count >= 0);
+            std::size_t n = static_cast<std::size_t>(count);
+            if(n > PTRDIFF_MAX / sizeof(T))
+                n = PTRDIFF_MAX / sizeof(T);
+
+            void * ptr = nullptr;
+            for(; ptr == nullptr && n > 0; n /= 2)
+            {
+#if RANGES_CXX_ALIGNED_NEW < RANGES_CXX_ALIGNED_NEW_17
+                static_assert(alignof(T) <= alignof(std::max_align_t),
+                              "Sorry: over-aligned types are supported only with C++17.");
+#else  // RANGES_CXX_ALIGNED_NEW
+                if(RANGES_CONSTEXPR_IF(alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__))
+                    ptr = ::operator new(
+                        sizeof(T) * n, std::align_val_t{alignof(T)}, std::nothrow);
+                else
+#endif // RANGES_CXX_ALIGNED_NEW
+                ptr = ::operator new(sizeof(T) * n, std::nothrow);
+            }
+
+            return {static_cast<T *>(ptr), static_cast<std::ptrdiff_t>(n)};
+        }
+
+        template<typename T, typename D>
+        std::pair<T *, std::ptrdiff_t> get_temporary_buffer(D count) noexcept
+        {
+            RANGES_EXPECT(count >= 0);
+            return detail::get_temporary_buffer_impl<T>(static_cast<std::size_t>(count));
+        }
+
+        struct return_temporary_buffer
+        {
+            template<typename T>
+            void operator()(T * p) const
+            {
+#if RANGES_CXX_ALIGNED_NEW < RANGES_CXX_ALIGNED_NEW_17
+                static_assert(alignof(T) <= alignof(std::max_align_t),
+                              "Sorry: over-aligned types are supported only with C++17.");
+#else  // RANGES_CXX_ALIGNED_NEW
+                if(RANGES_CONSTEXPR_IF(alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__))
+                    ::operator delete(p, std::align_val_t{alignof(T)});
+                else
+#endif // RANGES_CXX_ALIGNED_NEW
+                ::operator delete(p);
+            }
+        };
+
+        template<typename T, typename... Args>
+        auto make_unique(Args &&... args) -> CPP_ret(std::unique_ptr<T>)( //
+            requires(!std::is_array<T>::value))
+        {
+            return std::unique_ptr<T>{new T(static_cast<Args &&>(args)...)};
+        }
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-utility
+    /// @{
+    template<typename O, typename Val>
+    struct raw_storage_iterator
+    {
+    private:
+        CPP_assert(output_iterator<O, Val>);
+        CPP_assert(std::is_lvalue_reference<iter_reference_t<O>>());
+        O out_;
+
+    public:
+        using difference_type = iter_difference_t<O>;
+        raw_storage_iterator() = default;
+        explicit raw_storage_iterator(O out)
+          : out_(std::move(out))
+        {}
+        raw_storage_iterator & operator*() noexcept
+        {
+            return *this;
+        }
+        CPP_member
+        auto operator=(Val const & val) -> CPP_ret(raw_storage_iterator &)( //
+            requires copy_constructible<Val>)
+        {
+            ::new((void *)std::addressof(*out_)) Val(val);
+            return *this;
+        }
+        CPP_member
+        auto operator=(Val && val) -> CPP_ret(raw_storage_iterator &)( //
+            requires move_constructible<Val>)
+        {
+            ::new((void *)std::addressof(*out_)) Val(std::move(val));
+            return *this;
+        }
+        raw_storage_iterator & operator++()
+        {
+            ++out_;
+            return *this;
+        }
+        CPP_member
+        auto operator++(int) -> CPP_ret(void)( //
+            requires(!forward_iterator<O>))
+        {
+            ++out_;
+        }
+        CPP_member
+        auto operator++(int) -> CPP_ret(raw_storage_iterator)( //
+            requires forward_iterator<O>)
+        {
+            auto tmp = *this;
+            ++out_;
+            return tmp;
+        }
+        O base() const
+        {
+            return out_;
+        }
+    };
+
+    template<typename I>
+    struct iterator_wrapper
+    {
+    private:
+        CPP_assert(input_or_output_iterator<I>);
+        mutable I * i_ = nullptr;
+
+    public:
+        using difference_type = iter_difference_t<I>;
+        iterator_wrapper() = default;
+        iterator_wrapper(iterator_wrapper const & that)
+          : i_(that.i_)
+        {
+            that.i_ = nullptr;
+        }
+        iterator_wrapper & operator=(iterator_wrapper const & that)
+        {
+            i_ = that.i_;
+            that.i_ = nullptr;
+            return *this;
+        }
+        iterator_wrapper(I & i)
+          : i_(std::addressof(i))
+        {}
+        // clang-format off
+        auto CPP_auto_fun(operator*)()(const)
+        (
+            return **i_
+        )
+            // clang-format on
+            iterator_wrapper &
+            operator++()
+        {
+            ++*i_;
+            return *this;
+        }
+        void operator++(int)
+        {
+            ++*i_;
+        }
+        I base() const
+        {
+            return *i_;
+        }
+    };
+
+    template<typename I>
+    auto iter_ref(I & i) -> CPP_ret(iterator_wrapper<I>)( //
+        requires input_or_output_iterator<I>)
+    {
+        return i;
+    }
+
+    template<typename I>
+    struct readable_traits<iterator_wrapper<I>>
+      : meta::if_c<(bool)input_iterator<I>, readable_traits<I>, meta::nil_>
+    {};
+
+    template<typename Val>
+    struct raw_buffer
+    {
+    private:
+        Val * begin_;
+        raw_storage_iterator<Val *, Val> rsi_;
+
+    public:
+        explicit raw_buffer(Val * first)
+          : begin_(first)
+          , rsi_(first)
+        {}
+        raw_buffer(raw_buffer &&) = default;
+        raw_buffer(raw_buffer const &) = delete;
+        ~raw_buffer()
+        {
+            for(; begin_ != rsi_.base(); ++begin_)
+                begin_->~Val();
+        }
+        iterator_wrapper<raw_storage_iterator<Val *, Val>> begin()
+        {
+            return ranges::iter_ref(rsi_);
+        }
+    };
+
+    template<typename Val>
+    raw_buffer<Val> make_raw_buffer(Val * val)
+    {
+        return raw_buffer<Val>(val);
+    }
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/move.hpp b/inst/include/range/v3/utility/move.hpp
new file mode 100644
index 0000000..2c3ea34
--- /dev/null
+++ b/inst/include/range/v3/utility/move.hpp
@@ -0,0 +1,61 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_MOVE_HPP
+#define RANGES_V3_UTILITY_MOVE_HPP
+
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    namespace aux
+    {
+        /// \ingroup group-utility
+        struct move_fn : move_tag
+        {
+            template<typename T>
+            constexpr auto operator()(T && t) const noexcept
+                -> meta::_t<std::remove_reference<T>> &&
+            {
+                return static_cast<meta::_t<std::remove_reference<T>> &&>(t);
+            }
+
+            /// \ingroup group-utility
+            /// \sa `move_fn`
+            template<typename T>
+            friend constexpr decltype(auto) operator|(T && t, move_fn move) noexcept
+            {
+                return move(t);
+            }
+        };
+
+        /// \ingroup group-utility
+        /// \sa `move_fn`
+        RANGES_INLINE_VARIABLE(move_fn, move)
+
+        /// \ingroup group-utility
+        /// \sa `move_fn`
+        template<typename R>
+        using move_t =
+            meta::if_c<std::is_reference<R>::value, meta::_t<std::remove_reference<R>> &&,
+                       detail::decay_t<R>>;
+    } // namespace aux
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/nullptr_v.hpp b/inst/include/range/v3/utility/nullptr_v.hpp
new file mode 100644
index 0000000..ec8b270
--- /dev/null
+++ b/inst/include/range/v3/utility/nullptr_v.hpp
@@ -0,0 +1,36 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013,2014.
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_NULLPTR_V_HPP
+#define RANGES_V3_UTILITY_NULLPTR_V_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated and will be removed from a future version of range-v3.")
+
+namespace ranges
+{
+    /// \ingroup group-utility
+    template<typename T>
+    constexpr T * _nullptr_v()
+    {
+        return nullptr;
+    }
+
+#if RANGES_CXX_VARIABLE_TEMPLATES
+    /// \ingroup group-utility
+    template<typename T>
+    constexpr T * nullptr_v = nullptr;
+#endif
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/optional.hpp b/inst/include/range/v3/utility/optional.hpp
new file mode 100644
index 0000000..1b865b7
--- /dev/null
+++ b/inst/include/range/v3/utility/optional.hpp
@@ -0,0 +1,948 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Casey Carter 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_OPTIONAL_HPP
+#define RANGES_V3_UTILITY_OPTIONAL_HPP
+
+#include <exception>
+#include <initializer_list>
+#include <memory>
+#include <new>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/detail/config.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/utility/in_place.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/swap.hpp>
+
+namespace ranges
+{
+    template<typename>
+    struct optional;
+
+    struct bad_optional_access : std::exception
+    {
+        virtual const char * what() const noexcept override
+        {
+            return "bad optional access";
+        }
+    };
+
+    struct nullopt_t
+    {
+        struct tag
+        {};
+        explicit constexpr nullopt_t(tag) noexcept
+        {}
+    };
+#if RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
+    inline constexpr nullopt_t nullopt{nullopt_t::tag{}};
+#else
+    /// \cond
+    namespace detail
+    {
+        template<typename>
+        struct nullopt_holder
+        {
+            static constexpr nullopt_t nullopt{nullopt_t::tag{}};
+        };
+        template<typename T>
+        constexpr nullopt_t nullopt_holder<T>::nullopt;
+    } // namespace detail
+    /// \endcond
+    namespace
+    {
+        constexpr auto & nullopt = detail::nullopt_holder<void>::nullopt;
+    }
+#endif
+
+    /// \cond
+    namespace detail
+    {
+        template<typename = void>
+        [[noreturn]] bool throw_bad_optional_access()
+        {
+            throw bad_optional_access{};
+        }
+
+        namespace optional_adl
+        {
+            template<typename T, bool = std::is_trivially_destructible<T>::value>
+            struct optional_storage
+            {
+                union
+                {
+                    char dummy_;
+                    meta::_t<std::remove_cv<T>> data_;
+                };
+                bool engaged_;
+
+                constexpr optional_storage() noexcept
+                  : optional_storage(
+                        tag{},
+                        meta::strict_and<detail::is_trivially_default_constructible<T>,
+                                         detail::is_trivially_copyable<T>>{})
+                {}
+                CPP_template(typename... Args)(              //
+                    requires constructible_from<T, Args...>) //
+                    constexpr explicit optional_storage(in_place_t,
+                                                        Args &&... args) //
+                    noexcept(std::is_nothrow_constructible<T, Args...>::value)
+                  : data_(static_cast<Args &&>(args)...)
+                  , engaged_{true}
+                {}
+
+                constexpr void reset() noexcept
+                {
+                    engaged_ = false;
+                }
+
+            private:
+                struct tag
+                {};
+                constexpr optional_storage(tag, std::false_type) noexcept
+                  : dummy_{}
+                  , engaged_{false}
+                {}
+                constexpr optional_storage(tag, std::true_type) noexcept
+                  : data_{}
+                  , engaged_{false}
+                {}
+            };
+
+            template<typename T>
+            struct optional_storage<T, false>
+            {
+                union
+                {
+                    char dummy_;
+                    meta::_t<std::remove_cv<T>> data_;
+                };
+                bool engaged_;
+
+                ~optional_storage()
+                {
+                    reset();
+                }
+                constexpr optional_storage() noexcept
+                  : dummy_{}
+                  , engaged_{false}
+                {}
+                CPP_template(typename... Args)(              //
+                    requires constructible_from<T, Args...>) //
+                    constexpr explicit optional_storage(in_place_t,
+                                                        Args &&... args) //
+                    noexcept(std::is_nothrow_constructible<T, Args...>::value)
+                  : data_(static_cast<Args &&>(args)...)
+                  , engaged_{true}
+                {}
+                optional_storage(optional_storage const &) = default;
+                optional_storage(optional_storage &&) = default;
+                optional_storage & operator=(optional_storage const &) = default;
+                optional_storage & operator=(optional_storage &&) = default;
+
+                void reset() noexcept
+                {
+                    if(engaged_)
+                    {
+                        data_.~T();
+                        engaged_ = false;
+                    }
+                }
+            };
+
+            template<typename T>
+            struct optional_base : private optional_storage<T>
+            {
+                using optional_storage<T>::optional_storage;
+                using optional_storage<T>::reset;
+
+                constexpr bool has_value() const noexcept
+                {
+                    return engaged_;
+                }
+                constexpr T & operator*() & noexcept
+                {
+                    return RANGES_EXPECT(engaged_), data_;
+                }
+                constexpr T const & operator*() const & noexcept
+                {
+                    return RANGES_EXPECT(engaged_), data_;
+                }
+                constexpr T && operator*() && noexcept
+                {
+                    return RANGES_EXPECT(engaged_), detail::move(data_);
+                }
+                constexpr T const && operator*() const && noexcept
+                {
+                    return RANGES_EXPECT(engaged_), detail::move(data_);
+                }
+                constexpr T * operator->() noexcept
+                {
+                    return RANGES_EXPECT(engaged_), detail::addressof(data_);
+                }
+                constexpr T const * operator->() const noexcept
+                {
+                    return RANGES_EXPECT(engaged_), detail::addressof(data_);
+                }
+                CPP_member
+                constexpr auto swap(optional_base & that) noexcept(
+                    std::is_nothrow_move_constructible<T>::value &&
+                        is_nothrow_swappable<T>::value) -> CPP_ret(void)( //
+                    requires move_constructible<T> && swappable<T>)
+                {
+                    constexpr bool can_swap_trivially =
+                        !::concepts::adl_swap_detail::is_adl_swappable_v<T> &&
+                        detail::is_trivially_move_constructible<T>::value &&
+                        detail::is_trivially_move_assignable<T>::value;
+
+                    swap_(meta::bool_<can_swap_trivially>{}, that);
+                }
+
+            protected:
+                template<typename... Args>
+                auto construct_from(Args &&... args) noexcept(
+                    std::is_nothrow_constructible<T, Args...>::value) -> CPP_ret(T &)( //
+                    requires constructible_from<T, Args...>)
+                {
+                    RANGES_EXPECT(!engaged_);
+                    auto const address = static_cast<void *>(std::addressof(data_));
+                    ::new(address) T(static_cast<Args &&>(args)...);
+                    engaged_ = true;
+                    return data_;
+                }
+                template<typename U>
+                constexpr void assign_from(U && that) noexcept(
+                    std::is_nothrow_constructible<T, decltype(*static_cast<U &&>(that))>::
+                        value && std::is_nothrow_assignable<
+                            T &, decltype(*static_cast<U &&>(that))>::value)
+                {
+                    if(!that.has_value())
+                        reset();
+                    else if(engaged_)
+                        data_ = *static_cast<U &&>(that);
+                    else
+                    {
+                        auto const address =
+                            static_cast<void *>(detail::addressof(data_));
+                        ::new(address) T(*static_cast<U &&>(that));
+                        engaged_ = true;
+                    }
+                }
+
+            private:
+                constexpr void swap_(std::true_type, optional_base & that) noexcept
+                {
+                    ranges::swap(static_cast<optional_storage<T> &>(*this),
+                                 static_cast<optional_storage<T> &>(that));
+                }
+                constexpr void swap_(std::false_type, optional_base & that) noexcept(
+                    std::is_nothrow_move_constructible<T>::value &&
+                        is_nothrow_swappable<T>::value)
+                {
+                    if(that.engaged_ == engaged_)
+                    {
+                        if(engaged_)
+                            ranges::swap(data_, that.data_);
+                    }
+                    else
+                    {
+                        auto & src = engaged_ ? *this : that;
+                        auto & dst = engaged_ ? that : *this;
+                        dst.construct_from(detail::move(src.data_));
+                        src.reset();
+                    }
+                }
+
+                using optional_storage<T>::engaged_;
+                using optional_storage<T>::data_;
+            };
+
+            template<typename T>
+            struct optional_base<T &>
+            {
+                optional_base() = default;
+                template<typename Arg>
+                constexpr explicit CPP_ctor(optional_base)(in_place_t, Arg && arg)( //
+                    noexcept(true)                                                  //
+                    requires constructible_from<T &, Arg>)
+                  : ptr_(detail::addressof(arg))
+                {}
+                constexpr bool has_value() const noexcept
+                {
+                    return ptr_;
+                }
+                constexpr T & operator*() const noexcept
+                {
+                    return RANGES_EXPECT(ptr_), *ptr_;
+                }
+                constexpr T * operator->() const noexcept
+                {
+                    return RANGES_EXPECT(ptr_), ptr_;
+                }
+                constexpr void reset() noexcept
+                {
+                    ptr_ = nullptr;
+                }
+                CPP_member
+                constexpr auto swap(optional_base & that) noexcept(
+                    is_nothrow_swappable<T>::value) -> CPP_ret(void)( //
+                    requires swappable<T>)
+                {
+                    if(ptr_ && that.ptr_)
+                        ranges::swap(*ptr_, *that.ptr_);
+                    else
+                        ranges::swap(ptr_, that.ptr_);
+                }
+
+            protected:
+                template<typename U>
+                constexpr auto construct_from(U && ref) noexcept -> CPP_ret(T &)( //
+                    requires convertible_to<U &, T &>)
+                {
+                    RANGES_EXPECT(!ptr_);
+                    ptr_ = detail::addressof(ref);
+                    return *ptr_;
+                }
+                template<typename U>
+                constexpr void assign_from(U && that)
+                {
+                    if(ptr_ && that.ptr_)
+                        *ptr_ = *that.ptr_;
+                    else
+                        ptr_ = that.ptr_;
+                }
+
+            private:
+                T * ptr_ = nullptr;
+            };
+
+            template<typename T>
+            struct optional_copy : optional_base<T>
+            {
+                optional_copy() = default;
+                optional_copy(optional_copy const & that) noexcept(
+                    std::is_nothrow_copy_constructible<T>::value)
+                {
+                    if(that.has_value())
+                        this->construct_from(*that);
+                }
+                optional_copy(optional_copy &&) = default;
+                optional_copy & operator=(optional_copy const &) = default;
+                optional_copy & operator=(optional_copy &&) = default;
+
+                using optional_base<T>::optional_base;
+            };
+
+            template<typename T>
+            using copy_construct_layer =
+                meta::if_c<std::is_copy_constructible<T>::value &&
+                               !detail::is_trivially_copy_constructible<T>::value,
+                           optional_copy<T>, optional_base<T>>;
+
+            template<typename T>
+            struct optional_move : copy_construct_layer<T>
+            {
+                optional_move() = default;
+                optional_move(optional_move const &) = default;
+                optional_move(optional_move && that) noexcept(
+                    std::is_nothrow_move_constructible<T>::value)
+                {
+                    if(that.has_value())
+                        this->construct_from(std::move(*that));
+                }
+                optional_move & operator=(optional_move const &) = default;
+                optional_move & operator=(optional_move &&) = default;
+
+                using copy_construct_layer<T>::copy_construct_layer;
+            };
+
+            template<typename T>
+            using move_construct_layer =
+                meta::if_c<std::is_move_constructible<T>::value &&
+                               !detail::is_trivially_move_constructible<T>::value,
+                           optional_move<T>, copy_construct_layer<T>>;
+
+            template<typename T>
+            struct optional_copy_assign : move_construct_layer<T>
+            {
+                optional_copy_assign() = default;
+                optional_copy_assign(optional_copy_assign const &) = default;
+                optional_copy_assign(optional_copy_assign &&) = default;
+                optional_copy_assign & operator=(optional_copy_assign const & that) //
+                    noexcept(std::is_nothrow_copy_constructible<T>::value &&
+                                 std::is_nothrow_copy_assignable<T>::value)
+                {
+                    this->assign_from(that);
+                    return *this;
+                }
+                optional_copy_assign & operator=(optional_copy_assign &&) = default;
+
+                using move_construct_layer<T>::move_construct_layer;
+            };
+
+            template<typename T>
+            struct deleted_copy_assign : move_construct_layer<T>
+            {
+                deleted_copy_assign() = default;
+                deleted_copy_assign(deleted_copy_assign const &) = default;
+                deleted_copy_assign(deleted_copy_assign &&) = default;
+                deleted_copy_assign & operator=(deleted_copy_assign const &) = delete;
+                deleted_copy_assign & operator=(deleted_copy_assign &&) = default;
+
+                using move_construct_layer<T>::move_construct_layer;
+            };
+
+            template<typename T>
+            using copy_assign_layer = meta::if_c<
+                std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
+                meta::if_c<std::is_reference<T>::value ||
+                               !(detail::is_trivially_copy_constructible<T>::value &&
+                                 detail::is_trivially_copy_assignable<T>::value),
+                           optional_copy_assign<T>, move_construct_layer<T>>,
+                deleted_copy_assign<T>>;
+
+            template<typename T>
+            struct optional_move_assign : copy_assign_layer<T>
+            {
+                optional_move_assign() = default;
+                optional_move_assign(optional_move_assign const &) = default;
+                optional_move_assign(optional_move_assign &&) = default;
+                optional_move_assign & operator=(optional_move_assign const &) = default;
+                optional_move_assign & operator=(optional_move_assign && that) noexcept(
+                    std::is_nothrow_move_constructible<T>::value &&
+                        std::is_nothrow_move_assignable<T>::value)
+                {
+                    this->assign_from(std::move(that));
+                    return *this;
+                }
+
+                using copy_assign_layer<T>::copy_assign_layer;
+            };
+
+            template<typename T>
+            struct deleted_move_assign : copy_assign_layer<T>
+            {
+                deleted_move_assign() = default;
+                deleted_move_assign(deleted_move_assign const &) = default;
+                deleted_move_assign(deleted_move_assign &&) = default;
+                deleted_move_assign & operator=(deleted_move_assign const &) = default;
+                deleted_move_assign & operator=(deleted_move_assign &&) = delete;
+
+                using copy_assign_layer<T>::copy_assign_layer;
+            };
+
+            template<typename T>
+            using move_assign_layer = meta::if_c<
+                std::is_move_constructible<T>::value && std::is_move_assignable<T>::value,
+                meta::if_c<std::is_reference<T>::value ||
+                               !(detail::is_trivially_move_constructible<T>::value &&
+                                 detail::is_trivially_move_assignable<T>::value),
+                           optional_move_assign<T>, copy_assign_layer<T>>,
+                deleted_move_assign<T>>;
+        } // namespace optional_adl
+    }     // namespace detail
+    /// \endcond
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename U, typename T)
+        concept optional_should_convert,
+            requires(int)(void()) && !(
+                constructible_from<T, optional<U> &       > ||
+                constructible_from<T, optional<U> &&      > ||
+                constructible_from<T, optional<U> const & > ||
+                constructible_from<T, optional<U> const &&> ||
+                convertible_to<optional<U> &,        T> ||
+                convertible_to<optional<U> &&,       T> ||
+                convertible_to<optional<U> const &,  T> ||
+                convertible_to<optional<U> const &&, T>
+            )
+    );
+
+    CPP_def
+    (
+        template(typename U, typename T)
+        concept optional_should_convert_assign,
+            optional_should_convert<U, T> &&
+            !(assignable_from<T &, optional<U> &> ||
+            assignable_from<T &, optional<U> &&> ||
+            assignable_from<T &, optional<U> const &> ||
+            assignable_from<T &, optional<U> const &&>)
+    );
+    // clang-format on
+
+    template<typename T>
+    struct optional : detail::optional_adl::move_assign_layer<T>
+    {
+    private:
+        using base_t = detail::optional_adl::move_assign_layer<T>;
+
+    public:
+        CPP_assert(destructible<T>);
+        static_assert(std::is_object<T>::value || std::is_lvalue_reference<T>::value, "");
+        static_assert((bool)!same_as<nullopt_t, uncvref_t<T>>, "");
+        static_assert((bool)!same_as<in_place_t, uncvref_t<T>>, "");
+        using value_type = meta::_t<std::remove_cv<T>>;
+
+        constexpr optional() noexcept
+        {}
+        constexpr optional(nullopt_t) noexcept
+          : optional{}
+        {}
+        optional(optional const &) = default;
+        optional(optional &&) = default;
+
+        using base_t::base_t;
+
+        CPP_template(typename E, typename... Args)(                              //
+            requires constructible_from<T, std::initializer_list<E> &, Args...>) //
+            constexpr explicit optional(in_place_t, std::initializer_list<E> il,
+                                        Args &&... args) //
+            noexcept(std::is_nothrow_constructible<T, std::initializer_list<E> &,
+                                                   Args...>::value)
+          : base_t(in_place, il, static_cast<Args &&>(args)...)
+        {}
+
+        template<typename U = T>
+        constexpr CPP_ctor(optional)(U && v)( //
+            requires(!defer::same_as<detail::decay_t<U>, in_place_t>) &&
+            (!defer::same_as<detail::decay_t<U>,
+                             optional>)&&defer::constructible_from<T, U> &&
+            defer::convertible_to<U, T>)
+          : base_t(in_place, static_cast<U &&>(v))
+        {}
+        template<typename U = T>
+        explicit constexpr CPP_ctor(optional)(U && v)( //
+            requires(!defer::same_as<detail::decay_t<U>, in_place_t>) &&
+            (!defer::same_as<detail::decay_t<U>,
+                             optional>)&&defer::constructible_from<T, U> &&
+            (!defer::convertible_to<U, T>))
+          : base_t(in_place, static_cast<U &&>(v))
+        {}
+
+        template<typename U>
+        CPP_ctor(optional)(optional<U> const & that)( //
+            requires optional_should_convert<U, T> && constructible_from<T, U const &> &&
+                convertible_to<U const &, T>)
+        {
+            if(that.has_value())
+                base_t::construct_from(*that);
+        }
+        template<typename U>
+        explicit CPP_ctor(optional)(optional<U> const & that)( //
+            requires optional_should_convert<U, T> && constructible_from<T, U const &> &&
+            (!convertible_to<U const &, T>))
+        {
+            if(that.has_value())
+                base_t::construct_from(*that);
+        }
+
+        template<typename U>
+        CPP_ctor(optional)(optional<U> && that)( //
+            requires optional_should_convert<U, T> && constructible_from<T, U> &&
+                convertible_to<U, T>)
+        {
+            if(that.has_value())
+                base_t::construct_from(detail::move(*that));
+        }
+        template<typename U>
+        explicit CPP_ctor(optional)(optional<U> && that)( //
+            requires optional_should_convert<U, T> && constructible_from<T, U> &&
+            (!convertible_to<U, T>))
+        {
+            if(that.has_value())
+                base_t::construct_from(detail::move(*that));
+        }
+
+        constexpr optional & operator=(nullopt_t) noexcept
+        {
+            reset();
+            return *this;
+        }
+
+        optional & operator=(optional const &) = default;
+        optional & operator=(optional &&) = default;
+
+        template<typename U = T>
+        constexpr auto operator=(U && u) noexcept(
+            std::is_nothrow_constructible<T, U>::value &&
+                std::is_nothrow_assignable<T &, U>::value) -> CPP_ret(optional &)( //
+            requires(!defer::same_as<optional, detail::decay_t<U>>) &&
+            (!(defer::satisfies<T, std::is_scalar> &&
+               defer::same_as<T, detail::decay_t<U>>)) &&
+            defer::constructible_from<T, U> && defer::assignable_from<T &, U>)
+        {
+            if(has_value())
+                **this = static_cast<U &&>(u);
+            else
+                base_t::construct_from(static_cast<U &&>(u));
+            return *this;
+        }
+
+        template<typename U>
+        constexpr auto operator=(optional<U> const & that) -> CPP_ret(optional &)( //
+            requires optional_should_convert_assign<U, T> &&
+                constructible_from<T, const U &> && assignable_from<T &, const U &>)
+        {
+            base_t::assign_from(that);
+            return *this;
+        }
+
+        template<typename U>
+        constexpr auto operator=(optional<U> && that) -> CPP_ret(optional &)( //
+            requires optional_should_convert_assign<U, T> && constructible_from<T, U> &&
+                assignable_from<T &, U>)
+        {
+            base_t::assign_from(std::move(that));
+            return *this;
+        }
+
+        template<typename... Args>
+        auto emplace(Args &&... args) noexcept(
+            std::is_nothrow_constructible<T, Args...>::value) -> CPP_ret(T &)( //
+            requires constructible_from<T, Args...>)
+        {
+            reset();
+            return base_t::construct_from(static_cast<Args &&>(args)...);
+        }
+        template<typename E, typename... Args>
+        auto emplace(std::initializer_list<E> il, Args &&... args) noexcept(
+            std::is_nothrow_constructible<T, std::initializer_list<E> &, Args...>::value)
+            -> CPP_ret(T &)( //
+                requires constructible_from<T, std::initializer_list<E> &, Args &&...>)
+        {
+            reset();
+            return base_t::construct_from(il, static_cast<Args &&>(args)...);
+        }
+
+        using base_t::swap;
+        using base_t::operator->;
+        using base_t::operator*;
+
+        constexpr explicit operator bool() const noexcept
+        {
+            return has_value();
+        }
+        using base_t::has_value;
+
+        constexpr T const & value() const &
+        {
+            return (has_value() || detail::throw_bad_optional_access()), **this;
+        }
+        constexpr T & value() &
+        {
+            return (has_value() || detail::throw_bad_optional_access()), **this;
+        }
+        constexpr T const && value() const &&
+        {
+            return (has_value() || detail::throw_bad_optional_access()),
+                   detail::move(**this);
+        }
+        constexpr T && value() &&
+        {
+            return (has_value() || detail::throw_bad_optional_access()),
+                   detail::move(**this);
+        }
+
+        CPP_template(typename U)(                                   //
+            requires copy_constructible<T> && convertible_to<U, T>) //
+            constexpr T value_or(U && u) const &
+        {
+            return has_value() ? **this : static_cast<T>((U &&) u);
+        }
+        CPP_template(typename U)(                                   //
+            requires move_constructible<T> && convertible_to<U, T>) //
+            constexpr T value_or(U && u) &&
+        {
+            return has_value() ? detail::move(**this) : static_cast<T>((U &&) u);
+        }
+
+        using base_t::reset;
+    };
+
+    /// \cond
+    namespace detail
+    {
+        namespace optional_adl
+        {
+            constexpr bool convert_bool(bool b) noexcept
+            {
+                return b;
+            }
+
+            // Relational operators [optional.relops]
+            template<typename T, typename U>
+            constexpr auto operator==(optional<T> const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(*x == *y)))
+                    -> decltype(convert_bool(*x == *y))
+            {
+                return x.has_value() == y.has_value() && (!x || convert_bool(*x == *y));
+            }
+            template<typename T, typename U>
+            constexpr auto operator!=(optional<T> const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(*x != *y)))
+                    -> decltype(convert_bool(*x != *y))
+            {
+                return x.has_value() != y.has_value() || (x && convert_bool(*x != *y));
+            }
+            template<typename T, typename U>
+            constexpr auto operator<(optional<T> const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(*x < *y)))
+                    -> decltype(convert_bool(*x < *y))
+            {
+                return y && (!x || convert_bool(*x < *y));
+            }
+            template<typename T, typename U>
+            constexpr auto operator>(optional<T> const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(*x > *y)))
+                    -> decltype(convert_bool(*x > *y))
+            {
+                return x && (!y || convert_bool(*x > *y));
+            }
+            template<typename T, typename U>
+            constexpr auto operator<=(optional<T> const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(*x <= *y)))
+                    -> decltype(convert_bool(*x <= *y))
+            {
+                return !x || (y && convert_bool(*x <= *y));
+            }
+            template<typename T, typename U>
+            constexpr auto operator>=(optional<T> const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(*x >= *y)))
+                    -> decltype(convert_bool(*x >= *y))
+            {
+                return !y || (x && convert_bool(*x >= *y));
+            }
+
+            // Comparisons with nullopt [optional.nullops]
+            template<typename T>
+            constexpr bool operator==(optional<T> const & x, nullopt_t) noexcept
+            {
+                return !x;
+            }
+            template<typename T>
+            constexpr bool operator==(nullopt_t, optional<T> const & x) noexcept
+            {
+                return !x;
+            }
+            template<typename T>
+            constexpr bool operator!=(optional<T> const & x, nullopt_t) noexcept
+            {
+                return !!x;
+            }
+            template<typename T>
+            constexpr bool operator!=(nullopt_t, optional<T> const & x) noexcept
+            {
+                return !!x;
+            }
+            template<typename T>
+            constexpr bool operator<(optional<T> const &, nullopt_t) noexcept
+            {
+                return false;
+            }
+            template<typename T>
+            constexpr bool operator<(nullopt_t, optional<T> const & x) noexcept
+            {
+                return !!x;
+            }
+            template<typename T>
+            constexpr bool operator>(optional<T> const & x, nullopt_t) noexcept
+            {
+                return !!x;
+            }
+            template<typename T>
+            constexpr bool operator>(nullopt_t, optional<T> const &) noexcept
+            {
+                return false;
+            }
+            template<typename T>
+            constexpr bool operator<=(optional<T> const & x, nullopt_t) noexcept
+            {
+                return !x;
+            }
+            template<typename T>
+            constexpr bool operator<=(nullopt_t, optional<T> const &) noexcept
+            {
+                return true;
+            }
+            template<typename T>
+            constexpr bool operator>=(optional<T> const &, nullopt_t) noexcept
+            {
+                return true;
+            }
+            template<typename T>
+            constexpr bool operator>=(nullopt_t, optional<T> const & x) noexcept
+            {
+                return !x;
+            }
+
+            // Comparisons with T [optional.comp_with_t]
+            template<typename T, typename U>
+            constexpr auto operator==(optional<T> const & x, U const & y) //
+                noexcept(noexcept(convert_bool(*x == y)))                 //
+                -> decltype(convert_bool(*x == y))
+            {
+                return x && convert_bool(*x == y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator==(T const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(x == *y)))                 //
+                -> decltype(convert_bool(x == *y))
+            {
+                return y && convert_bool(x == *y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator!=(optional<T> const & x, U const & y) //
+                noexcept(noexcept(convert_bool(*x != y)))                 //
+                -> decltype(convert_bool(*x != y))
+            {
+                return !x || convert_bool(*x != y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator!=(T const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(x != *y)))                 //
+                -> decltype(convert_bool(x != *y))
+            {
+                return !y || convert_bool(x != *y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator<(optional<T> const & x, U const & y) //
+                noexcept(noexcept(convert_bool(*x < y)))                 //
+                -> decltype(convert_bool(*x < y))
+            {
+                return !x || convert_bool(*x < y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator<(T const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(x < *y)))                 //
+                -> decltype(convert_bool(x < *y))
+            {
+                return y && convert_bool(x < *y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator>(optional<T> const & x, U const & y) //
+                noexcept(noexcept(convert_bool(*x > y))) -> decltype(convert_bool(*x > y))
+            {
+                return x && convert_bool(*x > y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator>(T const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(x > *y)))                 //
+                -> decltype(convert_bool(x > *y))
+            {
+                return !y || convert_bool(x > *y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator<=(optional<T> const & x, U const & y) //
+                noexcept(noexcept(convert_bool(*x <= y)))                 //
+                -> decltype(convert_bool(*x <= y))
+            {
+                return !x || convert_bool(*x <= y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator<=(T const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(x <= *y)))                 //
+                -> decltype(convert_bool(x <= *y))
+            {
+                return y && convert_bool(x <= *y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator>=(optional<T> const & x, U const & y) //
+                noexcept(noexcept(convert_bool(*x >= y)))                 //
+                -> decltype(convert_bool(*x >= y))
+            {
+                return x && convert_bool(*x >= y);
+            }
+            template<typename T, typename U>
+            constexpr auto operator>=(T const & x, optional<U> const & y) //
+                noexcept(noexcept(convert_bool(x >= *y)))                 //
+                -> decltype(convert_bool(x >= *y))
+            {
+                return !y || convert_bool(x >= *y);
+            }
+
+            // clang-format off
+            template<typename T>
+            auto CPP_auto_fun(swap)(optional<T> &x, optional<T> &y)
+            (
+                return x.swap(y)
+            )
+            // clang-format on
+        } // namespace optional_adl
+    }     // namespace detail
+          /// \endcond
+
+    // clang-format off
+    template<typename T>
+    constexpr auto CPP_auto_fun(make_optional)(T &&t)
+    (
+        return optional<detail::decay_t<T>>{static_cast<T &&>(t)}
+    )
+    template<typename T, typename... Args>
+    constexpr auto CPP_auto_fun(make_optional)(Args &&... args)
+    (
+        return optional<T>{in_place, static_cast<Args &&>(args)...}
+    )
+    template<typename T, typename U, typename... Args>
+    constexpr auto CPP_auto_fun(make_optional)(std::initializer_list<U> il,
+                                               Args &&... args)
+    (
+        return optional<T>{in_place, il, static_cast<Args &&>(args)...}
+    )
+        // clang-format on
+
+        /// \cond
+        namespace detail
+    {
+        template<typename T, typename Tag = void, bool Enable = true>
+        struct non_propagating_cache : optional<T>
+        {
+            non_propagating_cache() = default;
+            constexpr non_propagating_cache(nullopt_t) noexcept
+            {}
+            constexpr non_propagating_cache(non_propagating_cache const &) noexcept
+              : optional<T>{}
+            {}
+            constexpr non_propagating_cache(non_propagating_cache && that) noexcept
+              : optional<T>{}
+            {
+                that.optional<T>::reset();
+            }
+            constexpr non_propagating_cache & operator=(
+                non_propagating_cache const &) noexcept
+            {
+                optional<T>::reset();
+                return *this;
+            }
+            constexpr non_propagating_cache & operator=(
+                non_propagating_cache && that) noexcept
+            {
+                that.optional<T>::reset();
+                optional<T>::reset();
+                return *this;
+            }
+            using optional<T>::operator=;
+        };
+
+        template<typename T, typename Tag>
+        struct non_propagating_cache<T, Tag, false>
+        {};
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/polymorphic_cast.hpp b/inst/include/range/v3/utility/polymorphic_cast.hpp
new file mode 100644
index 0000000..4fc9415
--- /dev/null
+++ b/inst/include/range/v3/utility/polymorphic_cast.hpp
@@ -0,0 +1,42 @@
+//  (C) Copyright Kevlin Henney and Dave Abrahams 1999.
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef RANGES_V3_UTILITY_POLYMORPHIC_CAST_HPP
+#define RANGES_V3_UTILITY_POLYMORPHIC_CAST_HPP
+
+#include <memory>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/detail/config.hpp>
+
+namespace ranges
+{
+    template<typename Target, typename Source>
+    auto polymorphic_downcast(Source * x) noexcept
+        -> meta::if_<std::is_pointer<Target>,
+                     decltype((static_cast<Target>(x), dynamic_cast<Target>(x)))>
+    {
+        auto result = static_cast<Target>(x);
+        RANGES_ASSERT(dynamic_cast<Target>(x) == result);
+        return result;
+    }
+    template<typename Target, typename Source>
+    auto polymorphic_downcast(Source && x) noexcept
+        -> meta::if_<std::is_reference<Target>,
+                     decltype((static_cast<Target>(std::declval<Source>()),
+                               dynamic_cast<Target>(std::declval<Source>())))>
+    {
+        auto && result = static_cast<Target>(static_cast<Source &&>(x));
+#ifndef NDEBUG
+        auto && dresult = dynamic_cast<Target>(static_cast<Source &&>(x));
+        RANGES_ASSERT(std::addressof(dresult) == std::addressof(result));
+#endif
+        return static_cast<Target>(result);
+    }
+} // namespace ranges
+
+#endif // RANGES_V3_UTILITY_POLYMORPHIC_CAST_HPP
diff --git a/inst/include/range/v3/utility/random.hpp b/inst/include/range/v3/utility/random.hpp
new file mode 100644
index 0000000..621a3b4
--- /dev/null
+++ b/inst/include/range/v3/utility/random.hpp
@@ -0,0 +1,485 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+/*
+ * Random-Number Utilities (randutil)
+ *     Addresses common issues with C++11 random number generation.
+ *     Makes good seeding easier, and makes using RNGs easy while retaining
+ *     all the power.
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Melissa E. O'Neill
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef RANGES_V3_UTILITY_RANDOM_HPP
+#define RANGES_V3_UTILITY_RANDOM_HPP
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <new>
+#include <random>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/copy.hpp>
+#include <range/v3/algorithm/generate.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/functional/reference_wrapper.hpp>
+#include <range/v3/iterator/concepts.hpp>
+
+#if !RANGES_CXX_THREAD_LOCAL
+#include <mutex>
+#endif
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
+
+namespace ranges
+{
+    /// \addtogroup group-numerics
+    /// @{
+    // clang-format off
+    CPP_def
+    (
+        template(typename Gen)
+        concept uniform_random_bit_generator,
+            requires(int)
+            (
+                Gen::min(),
+                Gen::max(),
+                concepts::requires_<same_as<invoke_result_t<Gen&>, decltype(Gen::min())>>,
+                concepts::requires_<same_as<invoke_result_t<Gen&>, decltype(Gen::max())>>
+            ) &&
+            invocable<Gen &> &&
+            unsigned_integral<invoke_result_t<Gen&>>
+    );
+    // clang-format on
+    /// @}
+
+    /// \cond
+    namespace detail
+    {
+        namespace randutils
+        {
+            inline std::array<std::uint32_t, 8> get_entropy()
+            {
+                std::array<std::uint32_t, 8> seeds;
+
+                // Hopefully high-quality entropy from random_device.
+#if defined(__GLIBCXX__) && defined(RANGES_WORKAROUND_VALGRIND_RDRAND)
+                std::random_device rd{"/dev/urandom"};
+#else
+                std::random_device rd;
+#endif
+                std::uniform_int_distribution<std::uint32_t> dist{};
+                ranges::generate(seeds, [&] { return dist(rd); });
+
+                return seeds;
+            }
+
+            template<typename I>
+            constexpr auto fast_exp(I x, I power, I result = I{1}) -> CPP_ret(I)( //
+                requires unsigned_integral<I>)
+            {
+                return power == I{0}
+                           ? result
+                           : randutils::fast_exp(
+                                 x * x, power >> 1, result * (power & I{1} ? x : 1));
+            }
+
+            //////////////////////////////////////////////////////////////////////////////
+            //
+            // seed_seq_fe
+            //
+            //////////////////////////////////////////////////////////////////////////////
+
+            /*
+             * seed_seq_fe implements a fixed-entropy seed sequence; it conforms to all
+             * the requirements of a Seed Sequence concept.
+             *
+             * seed_seq_fe<N> implements a seed sequence which seeds based on a store of
+             * N * 32 bits of entropy.  Typically, it would be initialized with N or more
+             * integers.
+             *
+             * seed_seq_fe128 and seed_seq_fe256 are provided as convenience typedefs for
+             * 128- and 256-bit entropy stores respectively.  These variants outperform
+             * std::seed_seq, while being better mixing the bits it is provided as
+             * entropy. In almost all common use cases, they serve as better drop-in
+             * replacements for seed_seq.
+             *
+             * Technical details
+             *
+             * Assuming it constructed with M seed integers as input, it exhibits the
+             * following properties
+             *
+             * * Diffusion/Avalanche:  A single-bit change in any of the M inputs has a
+             *   50% chance of flipping every bit in the bitstream produced by generate.
+             *   Initializing the N-word entropy store with M words requires O(N * M)
+             *   time precisely because of the avalanche requirements.  Once constructed,
+             *   calls to generate are linear in the number of words generated.
+             *
+             * * Bias freedom/Bijection: If M == N, the state of the entropy store is a
+             *   bijection from the M inputs (i.e., no states occur twice, none are
+             *   omitted). If M > N the number of times each state can occur is the same
+             *   (each state occurs 2**(32*(M-N)) times, where ** is the power function).
+             *   If M < N, some states cannot occur (bias) but no state occurs more
+             *   than once (it's impossible to avoid bias if M < N; ideally N should not
+             *   be chosen so that it is more than M).
+             *
+             *   Likewise, the generate function has similar properties (with the entropy
+             *   store as the input data).  If more outputs are requested than there is
+             *   entropy, some outputs cannot occur.  For example, the Mersenne Twister
+             *   will request 624 outputs, to initialize its 19937-bit state, which is
+             *   much larger than a 128-bit or 256-bit entropy pool.  But in practice,
+             *   limiting the Mersenne Twister to 2**128 possible initializations gives
+             *   us enough initializations to give a unique initialization to trillions
+             *   of computers for billions of years.  If you really have 624 words of
+             *   *real* high-quality entropy you want to use, you probably don't need
+             *   an entropy mixer like this class at all.  But if you *really* want to,
+             *   nothing is stopping you from creating a randutils::seed_seq_fe<624>.
+             *
+             * * As a consequence of the above properties, if all parts of the provided
+             *   seed data are kept constant except one, and the remaining part is varied
+             *   through K different states, K different output sequences will be
+             *   produced.
+             *
+             * * Also, because the amount of entropy stored is fixed, this class never
+             *   performs dynamic allocation and is free of the possibility of generating
+             *   an exception.
+             *
+             * Ideas used to implement this code include hashing, a simple PCG generator
+             * based on an MCG base with an XorShift output function and permutation
+             * functions on tuples.
+             *
+             * More detail at
+             *     http://www.pcg-random.org/posts/developing-a-seed_seq-alternative.html
+             */
+
+            template<std::size_t count, typename IntRep = std::uint32_t>
+            struct seed_seq_fe
+            {
+            public:
+                CPP_assert(unsigned_integral<IntRep>);
+                typedef IntRep result_type;
+
+            private:
+                static constexpr std::size_t mix_rounds = 1 + (count <= 2);
+
+                static constexpr std::uint32_t INIT_A = 0x43b0d7e5;
+                static constexpr std::uint32_t MULT_A = 0x931e8875;
+
+                static constexpr std::uint32_t INIT_B = 0x8b51f9dd;
+                static constexpr std::uint32_t MULT_B = 0x58f38ded;
+
+                static constexpr std::uint32_t MIX_MULT_L = 0xca01f9dd;
+                static constexpr std::uint32_t MIX_MULT_R = 0x4973f715;
+                static constexpr std::uint32_t XSHIFT = sizeof(IntRep) * 8 / 2;
+
+                std::array<IntRep, count> mixer_;
+
+                template<typename I, typename S>
+                auto mix_entropy(I first, S last) -> CPP_ret(void)( //
+                    requires input_iterator<I> && sentinel_for<S, I> &&
+                        convertible_to<iter_reference_t<I>, IntRep>)
+                {
+                    auto hash_const = INIT_A;
+                    auto hash = [&](IntRep value) RANGES_INTENDED_MODULAR_ARITHMETIC {
+                        value ^= hash_const;
+                        hash_const *= MULT_A;
+                        value *= hash_const;
+                        value ^= value >> XSHIFT;
+                        return value;
+                    };
+                    auto mix = [](IntRep x, IntRep y) RANGES_INTENDED_MODULAR_ARITHMETIC {
+                        IntRep result = MIX_MULT_L * x - MIX_MULT_R * y;
+                        result ^= result >> XSHIFT;
+                        return result;
+                    };
+
+                    for(auto & elem : mixer_)
+                    {
+                        if(first != last)
+                        {
+                            elem = hash(static_cast<IntRep>(*first));
+                            ++first;
+                        }
+                        else
+                            elem = hash(IntRep{0});
+                    }
+                    for(auto & src : mixer_)
+                        for(auto & dest : mixer_)
+                            if(&src != &dest)
+                                dest = mix(dest, hash(src));
+                    for(; first != last; ++first)
+                        for(auto & dest : mixer_)
+                            dest = mix(dest, hash(static_cast<IntRep>(*first)));
+                }
+
+            public:
+                seed_seq_fe(const seed_seq_fe &) = delete;
+                void operator=(const seed_seq_fe &) = delete;
+
+                template<typename T>
+                CPP_ctor(seed_seq_fe)(std::initializer_list<T> init)( //
+                    requires convertible_to<T const &, IntRep>)
+                {
+                    seed(init.begin(), init.end());
+                }
+
+                template<typename I, typename S>
+                CPP_ctor(seed_seq_fe)(I first, S last)( //
+                    requires input_iterator<I> && sentinel_for<S, I> &&
+                        convertible_to<iter_reference_t<I>, IntRep>)
+                {
+                    seed(first, last);
+                }
+
+                // generating functions
+                template<typename I, typename S>
+                RANGES_INTENDED_MODULAR_ARITHMETIC auto generate(I first,
+                                                                 S const last) const
+                    -> CPP_ret(void)( //
+                        requires random_access_iterator<I> && sentinel_for<S, I>)
+                {
+                    auto src_begin = mixer_.begin();
+                    auto src_end = mixer_.end();
+                    auto src = src_begin;
+                    auto hash_const = INIT_B;
+                    for(; first != last; ++first)
+                    {
+                        auto dataval = *src;
+                        if(++src == src_end)
+                            src = src_begin;
+                        dataval ^= hash_const;
+                        hash_const *= MULT_B;
+                        dataval *= hash_const;
+                        dataval ^= dataval >> XSHIFT;
+                        *first = dataval;
+                    }
+                }
+
+                constexpr std::size_t size() const
+                {
+                    return count;
+                }
+
+                template<typename O>
+                RANGES_INTENDED_MODULAR_ARITHMETIC auto param(O dest) const
+                    -> CPP_ret(void)( //
+                        requires weakly_incrementable<O> &&
+                            indirectly_copyable<decltype(mixer_.begin()), O>)
+                {
+                    constexpr IntRep INV_A = randutils::fast_exp(MULT_A, IntRep(-1));
+                    constexpr IntRep MIX_INV_L =
+                        randutils::fast_exp(MIX_MULT_L, IntRep(-1));
+
+                    auto mixer_copy = mixer_;
+                    for(std::size_t round = 0; round < mix_rounds; ++round)
+                    {
+                        // Advance to the final value.  We'll backtrack from that.
+                        auto hash_const =
+                            INIT_A * randutils::fast_exp(MULT_A, IntRep(count * count));
+
+                        for(auto src = mixer_copy.rbegin(); src != mixer_copy.rend();
+                            ++src)
+                            for(auto rdest = mixer_copy.rbegin();
+                                rdest != mixer_copy.rend();
+                                ++rdest)
+                                if(src != rdest)
+                                {
+                                    IntRep revhashed = *src;
+                                    auto mult_const = hash_const;
+                                    hash_const *= INV_A;
+                                    revhashed ^= hash_const;
+                                    revhashed *= mult_const;
+                                    revhashed ^= revhashed >> XSHIFT;
+                                    IntRep unmixed = *rdest;
+                                    unmixed ^= unmixed >> XSHIFT;
+                                    unmixed += MIX_MULT_R * revhashed;
+                                    unmixed *= MIX_INV_L;
+                                    *rdest = unmixed;
+                                }
+
+                        for(auto i = mixer_copy.rbegin(); i != mixer_copy.rend(); ++i)
+                        {
+                            IntRep unhashed = *i;
+                            unhashed ^= unhashed >> XSHIFT;
+                            unhashed *= randutils::fast_exp(hash_const, IntRep(-1));
+                            hash_const *= INV_A;
+                            unhashed ^= hash_const;
+                            *i = unhashed;
+                        }
+                    }
+                    ranges::copy(mixer_copy, dest);
+                }
+
+                template<typename I, typename S>
+                auto seed(I first, S last) -> CPP_ret(void)( //
+                    requires input_iterator<I> && sentinel_for<S, I> &&
+                        convertible_to<iter_reference_t<I>, IntRep>)
+                {
+                    mix_entropy(first, last);
+                    // For very small sizes, we do some additional mixing.  For normal
+                    // sizes, this loop never performs any iterations.
+                    for(std::size_t i = 1; i < mix_rounds; ++i)
+                        stir();
+                }
+
+                seed_seq_fe & stir()
+                {
+                    mix_entropy(mixer_.begin(), mixer_.end());
+                    return *this;
+                }
+            };
+
+            using seed_seq_fe128 = seed_seq_fe<4, std::uint32_t>;
+            using seed_seq_fe256 = seed_seq_fe<8, std::uint32_t>;
+
+            //////////////////////////////////////////////////////////////////////////////
+            //
+            // auto_seeded
+            //
+            //////////////////////////////////////////////////////////////////////////////
+
+            /*
+             * randutils::auto_seeded
+             *
+             *   Extends a seed sequence class with a nondeterministic default
+             * constructor. Uses a variety of local sources of entropy to portably
+             * initialize any seed sequence to a good default state.
+             *
+             *   In normal use, it's accessed via one of the following type aliases, which
+             *   use seed_seq_fe128 and seed_seq_fe256 above.
+             *
+             *       randutils::auto_seed_128
+             *       randutils::auto_seed_256
+             *
+             *   It's discussed in detail at
+             *       http://www.pcg-random.org/posts/simple-portable-cpp-seed-entropy.html
+             *   and its motivation (why you can't just use std::random_device) here
+             *       http://www.pcg-random.org/posts/cpps-random_device.html
+             */
+
+            template<typename SeedSeq>
+            struct auto_seeded : public SeedSeq
+            {
+                auto_seeded()
+                  : auto_seeded(randutils::get_entropy())
+                {}
+                template<std::size_t N>
+                auto_seeded(std::array<std::uint32_t, N> const & seeds)
+                  : SeedSeq(seeds.begin(), seeds.end())
+                {}
+                using SeedSeq::SeedSeq;
+
+                const SeedSeq & base() const
+                {
+                    return *this;
+                }
+                SeedSeq & base()
+                {
+                    return *this;
+                }
+            };
+
+            using auto_seed_128 = auto_seeded<seed_seq_fe128>;
+            using auto_seed_256 = auto_seeded<seed_seq_fe256>;
+        } // namespace randutils
+
+        using default_URNG = meta::if_c<(sizeof(void *) >= sizeof(long long)),
+                                        std::mt19937_64, std::mt19937>;
+
+#if !RANGES_CXX_THREAD_LOCAL
+        template<typename URNG>
+        class sync_URNG : private URNG
+        {
+            mutable std::mutex mtx_;
+
+        public:
+            using URNG::URNG;
+            sync_URNG() = default;
+            using typename URNG::result_type;
+            result_type operator()()
+            {
+                std::lock_guard<std::mutex> guard{mtx_};
+                return static_cast<URNG &>(*this)();
+            }
+            using URNG::max;
+            using URNG::min;
+        };
+        using default_random_engine = sync_URNG<default_URNG>;
+#else
+        using default_random_engine = default_URNG;
+#endif
+
+        template<typename T = void>
+        default_random_engine & get_random_engine()
+        {
+            using Seeder = meta::if_c<(sizeof(default_URNG) > 16),
+                                      randutils::auto_seed_256,
+                                      randutils::auto_seed_128>;
+
+#if RANGES_CXX_THREAD_LOCAL >= RANGES_CXX_THREAD_LOCAL_11
+            static thread_local default_random_engine engine{Seeder{}.base()};
+
+#elif RANGES_CXX_THREAD_LOCAL
+            static __thread bool initialized = false;
+            static __thread meta::_t<std::aligned_storage<sizeof(default_random_engine),
+                                                          alignof(default_random_engine)>>
+                storage;
+
+            if(!initialized)
+            {
+                ::new(static_cast<void *>(&storage))
+                    default_random_engine{Seeder{}.base()};
+                initialized = true;
+            }
+            auto & engine = reinterpret_cast<default_random_engine &>(storage);
+#else
+            static default_random_engine engine{Seeder{}.base()};
+#endif // RANGES_CXX_THREAD_LOCAL
+
+            return engine;
+        }
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/utility/scope_exit.hpp b/inst/include/range/v3/utility/scope_exit.hpp
new file mode 100644
index 0000000..644d809
--- /dev/null
+++ b/inst/include/range/v3/utility/scope_exit.hpp
@@ -0,0 +1,93 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2017-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTILITY_SCOPE_EXIT_HPP
+#define RANGES_V3_UTILITY_SCOPE_EXIT_HPP
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+namespace ranges
+{
+    template<typename Fun>
+    struct scope_exit
+    {
+    private:
+        using nothrow_move_t = std::is_nothrow_move_constructible<Fun>;
+        using nothrow_copy_t = std::is_nothrow_copy_constructible<Fun>;
+
+        Fun fun_;
+        bool dismissed_{false};
+
+        using ref_t = decltype(std::ref(std::declval<Fun const &>()));
+        using guard = scope_exit<ref_t>;
+
+        scope_exit(Fun const & fun, guard && g)
+          : fun_(fun)
+        {
+            g.dismiss();
+        }
+
+        scope_exit(Fun const & fun, std::false_type)
+          : scope_exit(fun, guard{std::ref(fun)})
+        {}
+
+        scope_exit(Fun const & fun, std::true_type) noexcept
+          : fun_(fun)
+        {}
+
+        scope_exit(Fun && fun, std::true_type) noexcept
+          : fun_(std::move(fun))
+        {}
+
+    public:
+        explicit scope_exit(Fun const & fun) noexcept(
+            noexcept(scope_exit(fun, nothrow_copy_t{})))
+          : scope_exit(fun, nothrow_copy_t{})
+        {}
+
+        explicit scope_exit(Fun && fun) noexcept(noexcept(scope_exit(std::move(fun),
+                                                                     nothrow_move_t{})))
+          : scope_exit(std::move(fun), nothrow_move_t{})
+        {}
+
+        scope_exit(scope_exit const &) = delete;
+
+        scope_exit(scope_exit && that) noexcept(
+            std::is_nothrow_move_constructible<Fun>::value)
+          : scope_exit(std::move((that.dismiss(), that)).fun_)
+        {}
+
+        ~scope_exit()
+        {
+            if(!dismissed_)
+                fun_();
+        }
+
+        void dismiss() noexcept
+        {
+            dismissed_ = true;
+        }
+    };
+
+    template<typename Fun, typename ScopeExit = scope_exit<meta::_t<std::decay<Fun>>>>
+    ScopeExit make_scope_exit(Fun && fun) noexcept(
+        noexcept(ScopeExit(ScopeExit((Fun &&) fun))))
+    {
+        return ScopeExit((Fun &&) fun);
+    }
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/semiregular.hpp b/inst/include/range/v3/utility/semiregular.hpp
new file mode 100644
index 0000000..8f481fc
--- /dev/null
+++ b/inst/include/range/v3/utility/semiregular.hpp
@@ -0,0 +1,24 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_SEMIREGULAR_HPP
+#define RANGES_V3_UTILITY_SEMIREGULAR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/utility/semiregular_box.hpp> "
+    "instead.")
+
+#include <range/v3/utility/semiregular_box.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/semiregular_box.hpp b/inst/include/range/v3/utility/semiregular_box.hpp
new file mode 100644
index 0000000..5e0a205
--- /dev/null
+++ b/inst/include/range/v3/utility/semiregular_box.hpp
@@ -0,0 +1,308 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_SEMIREGULAR_BOX_HPP
+#define RANGES_V3_UTILITY_SEMIREGULAR_BOX_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/get.hpp>
+#include <range/v3/utility/in_place.hpp>
+
+namespace ranges
+{
+    /// \cond
+    template<typename T>
+    struct semiregular_box;
+
+    namespace detail
+    {
+        struct semiregular_get
+        {
+            // clang-format off
+            template<typename T>
+            friend auto CPP_auto_fun(get)(meta::id_t<semiregular_box<T>> &t)
+            (
+                return t.get()
+            )
+            template<typename T>
+            friend auto CPP_auto_fun(get)(meta::id_t<semiregular_box<T>> const &t)
+            (
+                return t.get()
+            )
+            template<typename T>
+            friend auto CPP_auto_fun(get)(meta::id_t<semiregular_box<T>> &&t)
+            (
+                return detail::move(t).get()
+            )
+            // clang-format on
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-utility
+    /// @{
+    template<typename T>
+    struct semiregular_box : private detail::semiregular_get
+    {
+    private:
+        struct tag
+        {};
+        template<typename... Args>
+        void construct_from(Args &&... args)
+        {
+            new((void *)std::addressof(data_)) T(static_cast<Args &&>(args)...);
+            engaged_ = true;
+        }
+        void move_assign(T && t, std::true_type)
+        {
+            data_ = detail::move(t);
+        }
+        void move_assign(T && t, std::false_type)
+        {
+            reset();
+            construct_from(detail::move(t));
+        }
+        void copy_assign(T const & t, std::true_type)
+        {
+            data_ = t;
+        }
+        void copy_assign(T && t, std::false_type)
+        {
+            reset();
+            construct_from(t);
+        }
+        constexpr semiregular_box(tag, std::false_type) noexcept
+        {}
+        constexpr semiregular_box(tag, std::true_type) noexcept(
+            std::is_nothrow_default_constructible<T>::value)
+          : data_{}
+          , engaged_(true)
+        {}
+        void reset()
+        {
+            if(engaged_)
+            {
+                data_.~T();
+                engaged_ = false;
+            }
+        }
+        union
+        {
+            char ch_{};
+            T data_;
+        };
+        bool engaged_{false};
+
+    public:
+        constexpr semiregular_box() noexcept(
+            std::is_nothrow_default_constructible<T>::value ||
+            !std::is_default_constructible<T>::value)
+          : semiregular_box(tag{}, std::is_default_constructible<T>{})
+        {}
+        semiregular_box(semiregular_box && that) noexcept(
+            std::is_nothrow_move_constructible<T>::value)
+        {
+            if(that.engaged_)
+                this->construct_from(detail::move(that.data_));
+        }
+        semiregular_box(semiregular_box const & that) noexcept(
+            std::is_nothrow_copy_constructible<T>::value)
+        {
+            if(that.engaged_)
+                this->construct_from(that.data_);
+        }
+#if defined(__cpp_conditional_explicit) && 0 < __cpp_conditional_explicit
+        template<typename U>
+        explicit(!convertible_to<U, T>) constexpr CPP_ctor(semiregular_box)(U && u)( //
+            noexcept(std::is_nothrow_constructible<T, U>::value)                     //
+            requires(!defer::same_as<uncvref_t<U>, semiregular_box>) &&
+            defer::constructible_from<T, U>)
+          : semiregular_box(in_place, static_cast<U &&>(u))
+        {}
+#else
+        template<typename U>
+        explicit constexpr CPP_ctor(semiregular_box)(U && u)(    //
+            noexcept(std::is_nothrow_constructible<T, U>::value) //
+            requires(!defer::same_as<uncvref_t<U>, semiregular_box>) &&
+            defer::constructible_from<T, U> && (!defer::convertible_to<U, T>))
+          : semiregular_box(in_place, static_cast<U &&>(u))
+        {}
+        template<typename U>
+        constexpr CPP_ctor(semiregular_box)(U && u)(             //
+            noexcept(std::is_nothrow_constructible<T, U>::value) //
+            requires(!defer::same_as<uncvref_t<U>, semiregular_box>) &&
+            defer::constructible_from<T, U> && defer::convertible_to<U, T>)
+          : semiregular_box(in_place, static_cast<U &&>(u))
+        {}
+#endif
+        CPP_template(typename... Args)(                            //
+            requires constructible_from<T, Args...>)               //
+            constexpr semiregular_box(in_place_t, Args &&... args) //
+            noexcept(std::is_nothrow_constructible<T, Args...>::value)
+          : data_(static_cast<Args &&>(args)...)
+          , engaged_(true)
+        {}
+        ~semiregular_box()
+        {
+            reset();
+        }
+        semiregular_box & operator=(semiregular_box && that) noexcept(
+            std::is_nothrow_move_constructible<T>::value &&
+            (!std::is_move_assignable<T>::value ||
+             std::is_nothrow_move_assignable<T>::value))
+        {
+            if(engaged_ && that.engaged_)
+                this->move_assign(detail::move(that.data_), std::is_move_assignable<T>());
+            else if(that.engaged_)
+                this->construct_from(detail::move(that.data_));
+            else if(engaged_)
+                this->reset();
+            return *this;
+        }
+        semiregular_box & operator=(semiregular_box const & that) noexcept(
+            std::is_nothrow_copy_constructible<T>::value &&
+            (!std::is_copy_assignable<T>::value ||
+             std::is_nothrow_copy_assignable<T>::value))
+        {
+            if(engaged_ && that.engaged_)
+                this->copy_assign(that.data_, std::is_copy_assignable<T>());
+            else if(that.engaged_)
+                this->construct_from(that.data_);
+            else if(engaged_)
+                this->reset();
+            return *this;
+        }
+        constexpr T & get() & noexcept
+        {
+            return RANGES_ENSURE(engaged_), data_;
+        }
+        constexpr T const & get() const & noexcept
+        {
+            return RANGES_ENSURE(engaged_), data_;
+        }
+        constexpr T && get() && noexcept
+        {
+            return RANGES_ENSURE(engaged_), detail::move(data_);
+        }
+        T const && get() const && = delete;
+        constexpr operator T &() & noexcept
+        {
+            return get();
+        }
+        constexpr operator T const &() const & noexcept
+        {
+            return get();
+        }
+        constexpr operator T &&() && noexcept
+        {
+            return detail::move(get());
+        }
+        operator T const &&() const && = delete;
+        // clang-format off
+        CPP_template(typename... Args)(       //
+            requires invocable<T &, Args...>) //
+        constexpr decltype(auto) operator()(Args &&... args) &
+            noexcept(is_nothrow_invocable_v<T &, Args...>)
+        {
+            return invoke(data_, static_cast<Args &&>(args)...);
+        }
+        CPP_template(typename... Args)(             //
+            requires invocable<T const &, Args...>) //
+        constexpr decltype(auto) operator()(Args &&... args) const &
+            noexcept(is_nothrow_invocable_v<T const &, Args...>)
+        {
+            return invoke(data_, static_cast<Args &&>(args)...);
+        }
+        CPP_template(typename... Args)(     //
+            requires invocable<T, Args...>) //
+        constexpr decltype(auto) operator()(Args &&... args) &&
+            noexcept(is_nothrow_invocable_v<T, Args...>)
+        {
+            return invoke(static_cast<T &&>(data_), static_cast<Args &&>(args)...);
+        }
+        template<typename... Args>
+        void operator()(Args &&...) const && = delete;
+        // clang-format on
+    };
+
+    template<typename T>
+    struct semiregular_box<T &>
+      : private ranges::reference_wrapper<T &>
+      , private detail::semiregular_get
+    {
+        semiregular_box() = default;
+        template<typename Arg>
+        CPP_ctor(semiregular_box)(in_place_t, Arg & arg)( //
+            noexcept(true)                                //
+            requires constructible_from<ranges::reference_wrapper<T &>, Arg &>)
+          : ranges::reference_wrapper<T &>(arg)
+        {}
+        using ranges::reference_wrapper<T &>::reference_wrapper;
+        using ranges::reference_wrapper<T &>::get;
+        using ranges::reference_wrapper<T &>::operator T &;
+        using ranges::reference_wrapper<T &>::operator();
+    };
+
+    template<typename T>
+    struct semiregular_box<T &&>
+      : private ranges::reference_wrapper<T &&>
+      , private detail::semiregular_get
+    {
+        semiregular_box() = default;
+        template<typename Arg>
+        CPP_ctor(semiregular_box)(in_place_t, Arg && arg)( //
+            noexcept(true)                                 //
+            requires constructible_from<ranges::reference_wrapper<T &&>, Arg>)
+          : ranges::reference_wrapper<T &&>(static_cast<Arg &&>(arg))
+        {}
+        using ranges::reference_wrapper<T &&>::reference_wrapper;
+        using ranges::reference_wrapper<T &&>::get;
+        using ranges::reference_wrapper<T &&>::operator T &&;
+        using ranges::reference_wrapper<T &&>::operator();
+    };
+
+    template<typename T>
+    using semiregular_box_t = meta::if_c<(bool)semiregular<T>, T, semiregular_box<T>>;
+
+    template<typename T, bool IsConst = false>
+    using semiregular_box_ref_or_val_t = meta::if_c<
+        (bool)semiregular<T>,
+        meta::if_c<IsConst || std::is_empty<T>::value, T, reference_wrapper<T>>,
+        reference_wrapper<
+            meta::if_c<IsConst, semiregular_box<T> const, semiregular_box<T>>>>;
+    /// @}
+
+    /// \cond
+    template<typename T>
+    using semiregular_t RANGES_DEPRECATED("Please use semiregular_box_t instead.") =
+        semiregular_box_t<T>;
+
+    template<typename T, bool IsConst = false>
+    using semiregular_ref_or_val_t RANGES_DEPRECATED(
+        "Please use semiregular_box_ref_or_val_t instead.") =
+        semiregular_box_ref_or_val_t<T, IsConst>;
+    /// \endcond
+
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/static_const.hpp b/inst/include/range/v3/utility/static_const.hpp
new file mode 100644
index 0000000..690a142
--- /dev/null
+++ b/inst/include/range/v3/utility/static_const.hpp
@@ -0,0 +1,32 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_STATIC_CONST_HPP
+#define RANGES_V3_UTILITY_STATIC_CONST_HPP
+
+namespace ranges
+{
+    /// \ingroup group-utility
+
+    template<typename T>
+    struct static_const
+    {
+        static constexpr T value{};
+    };
+
+    /// \ingroup group-utility
+    /// \sa `static_const`
+    template<typename T>
+    constexpr T static_const<T>::value;
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/swap.hpp b/inst/include/range/v3/utility/swap.hpp
new file mode 100644
index 0000000..b622636
--- /dev/null
+++ b/inst/include/range/v3/utility/swap.hpp
@@ -0,0 +1,51 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+// The implementation of swap (see below) has been adapted from libc++
+// (http://libcxx.llvm.org).
+
+#ifndef RANGES_V3_UTILITY_SWAP_HPP
+#define RANGES_V3_UTILITY_SWAP_HPP
+
+#include <concepts/swap.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    template<typename T>
+    using is_swappable = concepts::is_swappable<T>;
+
+    template<typename T>
+    using is_nothrow_swappable = concepts::is_nothrow_swappable<T>;
+
+    template<typename T, typename U>
+    using is_swappable_with = concepts::is_swappable_with<T, U>;
+
+    template<typename T, typename U>
+    using is_nothrow_swappable_with = concepts::is_nothrow_swappable_with<T, U>;
+
+    using concepts::exchange;
+
+    /// \ingroup group-utility
+    /// \relates concepts::adl_swap_detail::swap_fn
+    RANGES_DEFINE_CPO(uncvref_t<decltype(concepts::swap)>, swap)
+
+    namespace cpp20
+    {
+        using ranges::swap;
+    }
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/tagged_pair.hpp b/inst/include/range/v3/utility/tagged_pair.hpp
new file mode 100644
index 0000000..1c91be3
--- /dev/null
+++ b/inst/include/range/v3/utility/tagged_pair.hpp
@@ -0,0 +1,245 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#ifndef RANGES_V3_UTILITY_TAGGED_PAIR_HPP
+#define RANGES_V3_UTILITY_TAGGED_PAIR_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/detail/adl_get.hpp>
+#include <range/v3/utility/swap.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        using tag_spec = meta::front<meta::as_list<T>>;
+
+        template<typename T>
+        using tag_elem = meta::back<meta::as_list<T>>;
+
+        template<typename Base, std::size_t, typename...>
+        struct tagged_chain
+        {
+            using type = _tuple_wrapper_::forward_tuple_interface<Base>;
+        };
+        template<typename Base, std::size_t I, typename First, typename... Rest>
+        struct tagged_chain<Base, I, First, Rest...>
+        {
+            using type = typename First::template getter<
+                Base, I, meta::_t<tagged_chain<Base, I + 1, Rest...>>>;
+        };
+    } // namespace detail
+
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _tagged_
+    {
+        struct adl_hook_
+        {};
+    } // namespace _tagged_
+#endif
+    /// \endcond
+
+    template<typename Base, typename... Tags>
+    class RANGES_EMPTY_BASES RANGES_DEPRECATED(
+        "Class template tagged is deprecated.") tagged
+      : public meta::_t<detail::tagged_chain<Base, 0, Tags...>>
+#if RANGES_BROKEN_CPO_LOOKUP
+      , private _tagged_::adl_hook_
+#endif
+    {
+        CPP_assert(same_as<Base, uncvref_t<Base>>);
+        using base_t = meta::_t<detail::tagged_chain<Base, 0, Tags...>>;
+
+        template<typename Other>
+        struct can_convert
+          : meta::bool_<!RANGES_IS_SAME(Other, Base) &&
+                        detail::is_convertible<Other, Base>::value>
+        {};
+
+    public:
+        tagged() = default;
+        using base_t::base_t;
+#if !defined(__clang__) || __clang_major__ > 3
+        template<typename Other>
+        constexpr CPP_ctor(tagged)(tagged<Other, Tags...> && that)(     //
+            noexcept(std::is_nothrow_constructible<Base, Other>::value) //
+            requires(can_convert<Other>::value))
+          : base_t(static_cast<Other &&>(that))
+        {}
+        template<typename Other>
+        constexpr CPP_ctor(tagged)(tagged<Other, Tags...> const & that)(        //
+            noexcept(std::is_nothrow_constructible<Base, Other const &>::value) //
+            requires(can_convert<Other>::value))
+          : base_t(static_cast<Other const &>(that))
+        {}
+#else
+        // Clang 3.x have a problem with inheriting constructors
+        // that causes the declarations in the preceeding PP block to get
+        // instantiated too early.
+        CPP_template(typename Other)(                        //
+            requires can_convert<Other>::value)              //
+            constexpr tagged(tagged<Other, Tags...> && that) //
+            noexcept(std::is_nothrow_constructible<Base, Other>::value)
+          : base_t(static_cast<Other &&>(that))
+        {}
+        CPP_template(typename Other)(                             //
+            requires can_convert<Other>::value)                   //
+            constexpr tagged(tagged<Other, Tags...> const & that) //
+            noexcept(std::is_nothrow_constructible<Base, Other const &>::value)
+          : base_t(static_cast<Other const &>(that))
+        {}
+#endif
+        template<typename Other>
+        constexpr auto operator=(tagged<Other, Tags...> && that) noexcept(
+            noexcept(std::declval<Base &>() = static_cast<Other &&>(that)))
+            -> CPP_ret(tagged &)( //
+                requires can_convert<Other>::value)
+        {
+            static_cast<Base &>(*this) = static_cast<Other &&>(that);
+            return *this;
+        }
+        template<typename Other>
+        constexpr auto operator=(tagged<Other, Tags...> const & that) noexcept(
+            noexcept(std::declval<Base &>() = static_cast<Other const &>(that)))
+            -> CPP_ret(tagged &)( //
+                requires can_convert<Other>::value)
+        {
+            static_cast<Base &>(*this) = static_cast<Other const &>(that);
+            return *this;
+        }
+        template<typename U>
+        constexpr auto operator=(U && u) noexcept(noexcept(
+            std::declval<Base &>() = static_cast<U &&>(u))) -> CPP_ret(tagged &)( //
+            requires(!defer::same_as<tagged, detail::decay_t<U>>) &&
+            defer::satisfies<Base &, std::is_assignable, U>)
+        {
+            static_cast<Base &>(*this) = static_cast<U &&>(u);
+            return *this;
+        }
+        template<typename B = Base>
+        constexpr auto swap(tagged & that) noexcept(is_nothrow_swappable<B>::value)
+            -> CPP_ret(void)( //
+                requires is_swappable<B>::value)
+        {
+            ranges::swap(static_cast<Base &>(*this), static_cast<Base &>(that));
+        }
+#if !RANGES_BROKEN_CPO_LOOKUP
+        template<typename B = Base>
+        friend constexpr auto swap(tagged & x,
+                                   tagged & y) noexcept(is_nothrow_swappable<B>::value)
+            -> CPP_broken_friend_ret(void)( //
+                requires is_swappable<B>::value)
+        {
+            x.swap(y);
+        }
+#endif
+    };
+
+#if RANGES_BROKEN_CPO_LOOKUP
+    namespace _tagged_
+    {
+        template<typename Base, typename... Tags>
+        constexpr auto swap(
+            tagged<Base, Tags...> & x,
+            tagged<Base, Tags...> & y) noexcept(is_nothrow_swappable<Base>::value)
+            -> CPP_ret(void)( //
+                requires is_swappable<Base>::value)
+        {
+            x.swap(y);
+        }
+    } // namespace _tagged_
+#endif
+
+    template<typename F, typename S>
+    using tagged_pair RANGES_DEPRECATED("ranges::tagged_pair is deprecated.") =
+        tagged<std::pair<detail::tag_elem<F>, detail::tag_elem<S>>, detail::tag_spec<F>,
+               detail::tag_spec<S>>;
+
+    template<typename Tag1, typename Tag2, typename T1, typename T2,
+             typename R = tagged_pair<Tag1(bind_element_t<T1>), Tag2(bind_element_t<T2>)>>
+    RANGES_DEPRECATED("ranges::make_tagged_pair is deprecated.")
+    constexpr R make_tagged_pair(T1 && t1, T2 && t2) noexcept(
+        std::is_nothrow_constructible<R, T1, T2>::value)
+    {
+        return {static_cast<T1 &&>(t1), static_cast<T2 &&>(t2)};
+    }
+} // namespace ranges
+
+#define RANGES_DEFINE_TAG_SPECIFIER(NAME)                                               \
+    namespace tag                                                                       \
+    {                                                                                   \
+        struct NAME                                                                     \
+        {                                                                               \
+            template<typename Untagged, std::size_t I, typename Next>                   \
+            class getter : public Next                                                  \
+            {                                                                           \
+            protected:                                                                  \
+                ~getter() = default;                                                    \
+                                                                                        \
+            public:                                                                     \
+                getter() = default;                                                     \
+                getter(getter &&) = default;                                            \
+                getter(getter const &) = default;                                       \
+                using Next::Next;                                                       \
+                getter & operator=(getter &&) = default;                                \
+                getter & operator=(getter const &) = default;                           \
+                constexpr meta::_t<std::tuple_element<I, Untagged>> & NAME() &          \
+                    noexcept(noexcept(detail::adl_get<I>(std::declval<Untagged &>())))  \
+                {                                                                       \
+                    return detail::adl_get<I>(static_cast<Untagged &>(*this));          \
+                }                                                                       \
+                constexpr meta::_t<std::tuple_element<I, Untagged>> && NAME() &&        \
+                    noexcept(noexcept(detail::adl_get<I>(std::declval<Untagged>())))    \
+                {                                                                       \
+                    return detail::adl_get<I>(static_cast<Untagged &&>(*this));         \
+                }                                                                       \
+                constexpr meta::_t<std::tuple_element<I, Untagged>> const & NAME()      \
+                    const & noexcept(                                                   \
+                        noexcept(detail::adl_get<I>(std::declval<Untagged const &>()))) \
+                {                                                                       \
+                    return detail::adl_get<I>(static_cast<Untagged const &>(*this));    \
+                }                                                                       \
+            };                                                                          \
+        };                                                                              \
+    }                                                                                   \
+    /**/
+
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+
+namespace std
+{
+    template<typename Untagged, typename... Tags>
+    struct tuple_size<::ranges::tagged<Untagged, Tags...>> : tuple_size<Untagged>
+    {};
+
+    template<size_t N, typename Untagged, typename... Tags>
+    struct tuple_element<N, ::ranges::tagged<Untagged, Tags...>>
+      : tuple_element<N, Untagged>
+    {};
+} // namespace std
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/utility/tagged_tuple.hpp b/inst/include/range/v3/utility/tagged_tuple.hpp
new file mode 100644
index 0000000..b5ffb3e
--- /dev/null
+++ b/inst/include/range/v3/utility/tagged_tuple.hpp
@@ -0,0 +1,41 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#ifndef RANGES_V3_UTILITY_TAGGED_TUPLE_HPP
+#define RANGES_V3_UTILITY_TAGGED_TUPLE_HPP
+
+#include <tuple>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/tagged_pair.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
+
+namespace ranges
+{
+    template<typename... Ts>
+    using tagged_tuple RANGES_DEPRECATED("ranges::tagged_tuple is deprecated.") =
+        tagged<std::tuple<detail::tag_elem<Ts>...>, detail::tag_spec<Ts>...>;
+
+    template<typename... Tags, typename... Ts>
+    RANGES_DEPRECATED("ranges::make_tagged_tuple is deprecated.")
+    constexpr tagged_tuple<Tags(bind_element_t<Ts>)...> make_tagged_tuple(Ts &&... ts)
+    {
+        return tagged_tuple<Tags(bind_element_t<Ts>)...>{static_cast<Ts &&>(ts)...};
+    }
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/utility/tuple_algorithm.hpp b/inst/include/range/v3/utility/tuple_algorithm.hpp
new file mode 100644
index 0000000..7d78628
--- /dev/null
+++ b/inst/include/range/v3/utility/tuple_algorithm.hpp
@@ -0,0 +1,190 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_TUPLE_ALGORITHM_HPP
+#define RANGES_V3_UTILITY_TUPLE_ALGORITHM_HPP
+
+#include <initializer_list>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/detail/adl_get.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-utility
+    /// @{
+    template<typename Tup>
+    using tuple_indices_t = meta::make_index_sequence<
+        std::tuple_size<typename std::remove_reference<Tup>::type>::value>;
+
+    struct tuple_apply_fn
+    {
+        // clang-format off
+    private:
+        template<typename Fun, typename Tup, std::size_t... Is>
+        static constexpr auto CPP_auto_fun(impl)(Fun &&fun, Tup &&tup, meta::index_sequence<Is...>)
+        (
+            return invoke(static_cast<Fun &&>(fun),
+                          detail::adl_get<Is>(static_cast<Tup &&>(tup))...)
+        )
+    public:
+        template<typename Fun, typename Tup>
+        constexpr auto CPP_auto_fun(operator())(Fun &&fun, Tup &&tup)(const)
+        (
+            return tuple_apply_fn::impl(static_cast<Fun &&>(fun),
+                                        static_cast<Tup &&>(tup),
+                                        tuple_indices_t<Tup>{})
+        )
+        // clang-format on
+    };
+
+    /// \ingroup group-utility
+    /// \sa `tuple_apply_fn`
+    RANGES_INLINE_VARIABLE(tuple_apply_fn, tuple_apply)
+
+    struct tuple_transform_fn
+    {
+        // clang-format off
+    private:
+        template<typename Tup, typename Fun, std::size_t... Is>
+        static constexpr auto CPP_auto_fun(impl1)(Tup &&tup, Fun &fun, meta::index_sequence<Is...>)
+        (
+            return std::tuple<
+                decltype(fun(detail::adl_get<Is>(static_cast<Tup &&>(tup))))...>{
+                fun(detail::adl_get<Is>(static_cast<Tup &&>(
+                    tup)))...}
+        )
+        template<typename Tup0, typename Tup1, typename Fun, std::size_t... Is>
+        static constexpr auto CPP_auto_fun(impl2)(Tup0 &&tup0, Tup1 &&tup1, Fun &fun,
+                                        meta::index_sequence<Is...>)
+        (
+            return std::tuple<
+                decltype(fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)),
+                             detail::adl_get<Is>(static_cast<Tup1 &&>(tup1))))...>{
+                fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)),
+                    detail::adl_get<Is>(static_cast<Tup1 &&>(tup1)))...}
+        )
+    public:
+        template<typename Tup, typename Fun>
+        constexpr auto CPP_auto_fun(operator())(Tup &&tup, Fun fun)(const)
+        (
+            return tuple_transform_fn::impl1(
+                static_cast<Tup &&>(tup), fun,
+                tuple_indices_t<Tup>{})
+        )
+        template<typename Tup0, typename Tup1, typename Fun>
+        constexpr auto CPP_auto_fun(operator())(Tup0 &&tup0, Tup1 &&tup1, Fun fun)(const)
+        (
+            return tuple_transform_fn::impl2(static_cast<Tup0 &&>(tup0),
+                                             static_cast<Tup1 &&>(tup1), fun,
+                                             tuple_indices_t<Tup0>{})
+        )
+        // clang-format on
+    };
+
+    /// \ingroup group-utility
+    /// \sa `tuple_transform_fn`
+    RANGES_INLINE_VARIABLE(tuple_transform_fn, tuple_transform)
+
+    struct tuple_foldl_fn
+    {
+    private:
+        template<typename Tup, typename Val, typename Fun>
+        static constexpr Val impl(Tup &&, Val val, Fun &)
+        {
+            return val;
+        }
+        // clang-format off
+        template<std::size_t I0, std::size_t... Is, typename Tup, typename Val,
+                 typename Fun, typename Impl = tuple_foldl_fn>
+        static constexpr auto CPP_auto_fun(impl)(Tup &&tup, Val val, Fun &fun)
+        (
+            return Impl::template impl<Is...>(
+                static_cast<Tup &&>(tup),
+                fun(std::move(val), detail::adl_get<I0>(static_cast<Tup &&>(tup))),
+                fun)
+        )
+        template<typename Tup, typename Val, typename Fun, std::size_t... Is>
+        static constexpr auto CPP_auto_fun(impl2)(Tup &&tup, Val val, Fun &fun,
+                                        meta::index_sequence<Is...>)
+        (
+            return tuple_foldl_fn::impl<Is...>(static_cast<Tup &&>(tup),
+                                               std::move(val),
+                                               fun)
+        )
+    public:
+        template<typename Tup, typename Val, typename Fun>
+        constexpr auto CPP_auto_fun(operator())(Tup &&tup, Val val, Fun fun)(const)
+        (
+            return tuple_foldl_fn::impl2(static_cast<Tup &&>(tup),
+                                         std::move(val),
+                                         fun,
+                                         tuple_indices_t<Tup>{})
+        )
+        // clang-format on
+    };
+
+    /// \ingroup group-utility
+    /// \sa `tuple_foldl_fn`
+    RANGES_INLINE_VARIABLE(tuple_foldl_fn, tuple_foldl)
+
+    struct tuple_for_each_fn
+    {
+    private:
+        template<typename Tup, typename Fun, std::size_t... Is>
+        static constexpr void impl(Tup && tup, Fun & fun, meta::index_sequence<Is...>)
+        {
+            (void)std::initializer_list<int>{
+                ((void)fun(detail::adl_get<Is>(static_cast<Tup &&>(tup))), 42)...};
+        }
+
+    public:
+        template<typename Tup, typename Fun>
+        constexpr Fun operator()(Tup && tup, Fun fun) const
+        {
+            return tuple_for_each_fn::impl(
+                       static_cast<Tup &&>(tup), fun, tuple_indices_t<Tup>{}),
+                   fun;
+        }
+    };
+
+    /// \ingroup group-utility
+    /// \sa `tuple_for_each_fn`
+    RANGES_INLINE_VARIABLE(tuple_for_each_fn, tuple_for_each)
+
+    struct make_tuple_fn
+    {
+        // clang-format off
+        template<typename... Ts>
+        constexpr auto CPP_auto_fun(operator())(Ts &&... ts)(const)
+        (
+            return std::make_tuple(static_cast<Ts &&>(ts)...)
+        )
+        // clang-format on
+    };
+
+    /// \ingroup group-utility
+    /// \sa `make_tuple_fn`
+    RANGES_INLINE_VARIABLE(make_tuple_fn, make_tuple)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/utility/unreachable.hpp b/inst/include/range/v3/utility/unreachable.hpp
new file mode 100644
index 0000000..f01aa35
--- /dev/null
+++ b/inst/include/range/v3/utility/unreachable.hpp
@@ -0,0 +1,22 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_UTILITY_UNREACHABLE_HPP
+#define RANGES_V3_UTILITY_UNREACHABLE_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include "
+    "<range/v3/iterator/unreachable_sentinel.hpp> instead.")
+
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+
+#endif
diff --git a/inst/include/range/v3/utility/variant.hpp b/inst/include/range/v3/utility/variant.hpp
new file mode 100644
index 0000000..904c75d
--- /dev/null
+++ b/inst/include/range/v3/utility/variant.hpp
@@ -0,0 +1,125 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_UTILITY_VARIANT_HPP
+#define RANGES_V3_UTILITY_VARIANT_HPP
+
+#include <range/v3/algorithm/copy.hpp>
+#include <range/v3/algorithm/move.hpp>
+#include <range/v3/detail/variant.hpp>
+#include <range/v3/iterator/move_iterators.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename T, std::size_t N, typename Index>
+        struct indexed_datum<T[N], Index>
+        {
+        private:
+            union
+            {
+                char c;
+                T data_[N];
+            };
+            void fill_default_(T * p, std::true_type)
+            {
+                for(; p != ranges::end(data_); ++p)
+                    ::new((void *)p) T{};
+            }
+            void fill_default_(T * p, std::false_type)
+            {
+                RANGES_EXPECT(p == ranges::end(data_));
+            }
+
+        public:
+            CPP_member
+            constexpr CPP_ctor(indexed_datum)(meta::nil_ = {})(
+                requires default_constructible<T>)
+              : data_{}
+            {}
+            CPP_member
+            CPP_ctor(indexed_datum)(indexed_datum && that)(requires move_constructible<T>)
+            {
+                std::uninitialized_copy_n(make_move_iterator(that.data_), N, data_);
+            }
+            CPP_member
+            CPP_ctor(indexed_datum)(indexed_datum const & that)(
+                requires copy_constructible<T>)
+            {
+                std::uninitialized_copy_n(that.data_, N, data_);
+            }
+            // \pre Requires distance(first, last) <= N
+            // \pre Requires default_constructible<T> || distance(first, last) == N
+            template<typename I, typename S>
+            CPP_ctor(indexed_datum)(I first, S last)( //
+                requires sentinel_for<S, I> && input_iterator<I> &&
+                    constructible_from<T, iter_reference_t<I>>)
+            {
+                T * p = detail::uninitialized_copy(first, last, data_);
+                this->fill_default_(p, meta::bool_<default_constructible<T>>{});
+            }
+            // \pre Requires distance(r) <= N
+            // \pre Requires default_constructible<T> || distance(r) == N
+            template<typename R>
+            explicit CPP_ctor(indexed_datum)(R && r)( //
+                requires input_range<R> && constructible_from<T, range_reference_t<R>>)
+              : indexed_datum{ranges::begin(r), ranges::end(r)}
+            {}
+            CPP_member
+            auto operator=(indexed_datum && that) -> CPP_ret(indexed_datum &)( //
+                requires assignable_from<T &, T>)
+            {
+                ranges::move(that.data_, data_);
+                return *this;
+            }
+            CPP_member
+            auto operator=(indexed_datum const & that) -> CPP_ret(indexed_datum &)( //
+                requires assignable_from<T &, T const &>)
+            {
+                ranges::copy(that.data_, data_);
+                return *this;
+            }
+            // \pre Requires ranges::distance(r) <= N
+            template<typename R>
+            auto operator=(R && r) -> CPP_ret(indexed_datum &)( //
+                requires input_range<R> && assignable_from<T &, range_reference_t<R>>)
+            {
+                ranges::copy(r, data_);
+                return *this;
+            }
+            constexpr indexed_element<T[N], Index::value> ref()
+            {
+                return {data_};
+            }
+            constexpr indexed_element<T const [N], Index::value> ref() const {
+                return {data_};
+            } constexpr T (&get() noexcept)[N]
+            {
+                return data_;
+            }
+            constexpr T const (&get() const noexcept)[N]
+            {
+                return data_;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/version.hpp b/inst/include/range/v3/version.hpp
new file mode 100644
index 0000000..b040648
--- /dev/null
+++ b/inst/include/range/v3/version.hpp
@@ -0,0 +1,24 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2017-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VERSION_HPP
+#define RANGES_V3_VERSION_HPP
+
+#define RANGE_V3_MAJOR 0
+#define RANGE_V3_MINOR 9
+#define RANGE_V3_PATCHLEVEL 1
+
+#define RANGE_V3_VERSION \
+    (RANGE_V3_MAJOR * 10000 + RANGE_V3_MINOR * 100 + RANGE_V3_PATCHLEVEL)
+
+#endif
diff --git a/inst/include/range/v3/view.hpp b/inst/include/range/v3/view.hpp
new file mode 100644
index 0000000..e7afc95
--- /dev/null
+++ b/inst/include/range/v3/view.hpp
@@ -0,0 +1,93 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_HPP
+#define RANGES_V3_VIEW_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DISABLE_WARNINGS
+
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/addressof.hpp>
+#include <range/v3/view/adjacent_filter.hpp>
+#include <range/v3/view/adjacent_remove_if.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/any_view.hpp>
+#include <range/v3/view/c_str.hpp>
+#include <range/v3/view/cache1.hpp>
+#include <range/v3/view/cartesian_product.hpp>
+#include <range/v3/view/chunk.hpp>
+#include <range/v3/view/common.hpp>
+#include <range/v3/view/concat.hpp>
+#include <range/v3/view/const.hpp>
+#include <range/v3/view/counted.hpp>
+#include <range/v3/view/cycle.hpp>
+#include <range/v3/view/delimit.hpp>
+#include <range/v3/view/drop.hpp>
+#include <range/v3/view/drop_exactly.hpp>
+#include <range/v3/view/drop_last.hpp>
+#include <range/v3/view/drop_while.hpp>
+#include <range/v3/view/empty.hpp>
+#include <range/v3/view/enumerate.hpp>
+#include <range/v3/view/exclusive_scan.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/filter.hpp>
+#include <range/v3/view/for_each.hpp>
+#include <range/v3/view/generate.hpp>
+#include <range/v3/view/generate_n.hpp>
+#include <range/v3/view/getlines.hpp>
+#include <range/v3/view/group_by.hpp>
+#include <range/v3/view/indices.hpp>
+#include <range/v3/view/indirect.hpp>
+#include <range/v3/view/intersperse.hpp>
+#include <range/v3/view/iota.hpp>
+#include <range/v3/view/istream.hpp>
+#include <range/v3/view/join.hpp>
+#include <range/v3/view/linear_distribute.hpp>
+#include <range/v3/view/map.hpp>
+#include <range/v3/view/move.hpp>
+#include <range/v3/view/partial_sum.hpp>
+#include <range/v3/view/ref.hpp>
+#include <range/v3/view/remove_if.hpp>
+#include <range/v3/view/repeat.hpp>
+#include <range/v3/view/repeat_n.hpp>
+#include <range/v3/view/replace.hpp>
+#include <range/v3/view/replace_if.hpp>
+#include <range/v3/view/reverse.hpp>
+#include <range/v3/view/sample.hpp>
+#include <range/v3/view/set_algorithm.hpp>
+#include <range/v3/view/single.hpp>
+#include <range/v3/view/slice.hpp>
+#include <range/v3/view/sliding.hpp>
+#include <range/v3/view/span.hpp>
+#include <range/v3/view/split.hpp>
+#include <range/v3/view/split_when.hpp>
+#include <range/v3/view/stride.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/tail.hpp>
+#include <range/v3/view/take.hpp>
+#include <range/v3/view/take_exactly.hpp>
+#include <range/v3/view/take_last.hpp>
+#include <range/v3/view/take_while.hpp>
+#include <range/v3/view/tokenize.hpp>
+#include <range/v3/view/transform.hpp>
+#include <range/v3/view/trim.hpp>
+#include <range/v3/view/unbounded.hpp>
+#include <range/v3/view/unique.hpp>
+#include <range/v3/view/view.hpp>
+#include <range/v3/view/zip.hpp>
+#include <range/v3/view/zip_with.hpp>
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/view/adaptor.hpp b/inst/include/range/v3/view/adaptor.hpp
new file mode 100644
index 0000000..d4d25d5
--- /dev/null
+++ b/inst/include/range/v3/view/adaptor.hpp
@@ -0,0 +1,563 @@
+/// \file
+// Range v3 library
+//
+// Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_ADAPTOR_HPP
+#define RANGES_V3_VIEW_ADAPTOR_HPP
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/compressed_pair.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Derived>
+        using begin_adaptor_t = detail::decay_t<decltype(
+            range_access::begin_adaptor(std::declval<Derived &>()))>;
+
+        template<typename Derived>
+        using end_adaptor_t = detail::decay_t<decltype(
+            range_access::end_adaptor(std::declval<Derived &>()))>;
+
+        template<typename Derived>
+        using adapted_iterator_t = detail::decay_t<decltype(
+            std::declval<begin_adaptor_t<Derived>>().begin(std::declval<Derived &>()))>;
+
+        template<typename Derived>
+        using adapted_sentinel_t = detail::decay_t<decltype(
+            std::declval<end_adaptor_t<Derived>>().end(std::declval<Derived &>()))>;
+
+        struct adaptor_base_current_mem_fn
+        {};
+
+        template<typename BaseIter, typename Adapt>
+        constexpr int which_adaptor_value_(priority_tag<0>)
+        {
+            return 0;
+        }
+        template<typename BaseIter, typename Adapt>
+        constexpr auto which_adaptor_value_(priority_tag<1>)
+            -> always_<int, decltype(Adapt::read(std::declval<BaseIter const &>(),
+                                                 adaptor_base_current_mem_fn{}))>
+        {
+            return 1;
+        }
+        template<typename BaseIter, typename Adapt>
+        constexpr auto which_adaptor_value_(priority_tag<2>)
+            -> always_<int, typename Adapt::value_type>
+        {
+            return 2;
+        }
+
+        template<typename BaseIter, typename Adapt,
+                 int = detail::which_adaptor_value_<BaseIter, Adapt>(priority_tag<2>{})>
+        struct adaptor_value_type_
+        {
+            compressed_pair<BaseIter, Adapt> data_;
+        };
+        template<typename BaseIter, typename Adapt>
+        struct adaptor_value_type_<BaseIter, Adapt, 1>
+        {
+            using value_type = iter_value_t<BaseIter>;
+            compressed_pair<BaseIter, Adapt> data_;
+        };
+        template<typename BaseIter, typename Adapt>
+        struct adaptor_value_type_<BaseIter, Adapt, 2>
+        {
+#ifdef RANGES_WORKAROUND_MSVC_688606
+            using value_type = typename readable_traits<Adapt>::value_type;
+#else  // ^^^ workaround ^^^ / vvv no workaround vvv
+            using value_type = typename Adapt::value_type;
+#endif // RANGES_WORKAROUND_MSVC_688606
+            compressed_pair<BaseIter, Adapt> data_;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename BaseIt, typename Adapt>
+    struct adaptor_cursor;
+
+    template<typename BaseSent, typename Adapt>
+    struct base_adaptor_sentinel;
+
+    struct adaptor_base
+    {
+        adaptor_base() = default;
+        adaptor_base(adaptor_base &&) = default;
+        adaptor_base(adaptor_base const &) = default;
+        adaptor_base & operator=(adaptor_base &&) = default;
+        adaptor_base & operator=(adaptor_base const &) = default;
+
+        adaptor_base(detail::ignore_t, detail::ignore_t = {}, detail::ignore_t = {})
+        {}
+        // clang-format off
+        template<typename Rng>
+        static constexpr auto CPP_auto_fun(begin)(Rng &rng)
+        (
+            return ranges::begin(rng.base())
+        )
+        template<typename Rng>
+        static constexpr auto CPP_auto_fun(end)(Rng &rng)
+        (
+            return ranges::end(rng.base())
+        )
+            // clang-format on
+            template<typename I>
+            static auto equal(I const & it0, I const & it1) -> CPP_ret(bool)( //
+                requires equality_comparable<I>)
+        {
+            return it0 == it1;
+        }
+        template<typename I>
+        static auto read(I const & it, detail::adaptor_base_current_mem_fn = {}) noexcept(
+            noexcept(iter_reference_t<I>(*it))) -> CPP_ret(iter_reference_t<I>)( //
+            requires input_or_output_iterator<I>)
+        {
+            return *it;
+        }
+        template<typename I>
+        static auto next(I & it) -> CPP_ret(void)( //
+            requires input_or_output_iterator<I>)
+        {
+            ++it;
+        }
+        template<typename I>
+        static auto prev(I & it) -> CPP_ret(void)( //
+            requires bidirectional_iterator<I>)
+        {
+            --it;
+        }
+        template<typename I>
+        static auto advance(I & it, iter_difference_t<I> n) -> CPP_ret(void)( //
+            requires random_access_iterator<I>)
+        {
+            it += n;
+        }
+        template<typename I>
+        static auto distance_to(I const & it0, I const & it1)
+            -> CPP_ret(iter_difference_t<I>)( //
+                requires sized_sentinel_for<I, I>)
+        {
+            return it1 - it0;
+        }
+        template<typename I, typename S>
+        static constexpr auto empty(I const & it, S const & last) -> CPP_ret(bool)( //
+            requires sentinel_for<S, I>)
+        {
+            return it == last;
+        }
+    };
+
+    // Build a sentinel out of a sentinel into the adapted range, and an
+    // adaptor that customizes behavior.
+    template<typename BaseSent, typename Adapt>
+    struct base_adaptor_sentinel
+    {
+    private:
+        template<typename, typename>
+        friend struct adaptor_cursor;
+        RANGES_NO_UNIQUE_ADDRESS compressed_pair<BaseSent, Adapt> data_;
+
+    public:
+        base_adaptor_sentinel() = default;
+        base_adaptor_sentinel(BaseSent sent, Adapt adapt)
+          : data_{std::move(sent), std::move(adapt)}
+        {}
+
+        // All sentinels into adapted ranges have a base() member for fetching
+        // the underlying sentinel.
+        BaseSent base() const
+        {
+            return data_.first();
+        }
+
+    protected:
+        // Adaptor accessor
+        Adapt & get()
+        {
+            return data_.second();
+        }
+        Adapt const & get() const
+        {
+            return data_.second();
+        }
+    };
+
+    /// \cond
+    namespace detail
+    {
+        template<typename BaseSent, typename Adapt>
+        meta::id<base_adaptor_sentinel<BaseSent, Adapt>> base_adaptor_sentinel_2_(long);
+
+        template<typename BaseSent, typename Adapt>
+        meta::id<typename Adapt::template mixin<base_adaptor_sentinel<BaseSent, Adapt>>>
+        base_adaptor_sentinel_2_(int);
+
+        template<typename BaseSent, typename Adapt>
+        struct base_adaptor_sentinel_
+          : decltype(base_adaptor_sentinel_2_<BaseSent, Adapt>(42))
+        {};
+
+        template<typename BaseSent, typename Adapt>
+        using adaptor_sentinel_ = meta::_t<base_adaptor_sentinel_<BaseSent, Adapt>>;
+    } // namespace detail
+    /// \endcond
+
+    template<typename BaseSent, typename Adapt>
+    struct adaptor_sentinel : detail::adaptor_sentinel_<BaseSent, Adapt>
+    {
+        using detail::adaptor_sentinel_<BaseSent, Adapt>::adaptor_sentinel_;
+    };
+
+    // Build a cursor out of an iterator into the adapted range, and an
+    // adaptor that customizes behavior.
+    template<typename BaseIter, typename Adapt>
+    struct adaptor_cursor : private detail::adaptor_value_type_<BaseIter, Adapt>
+    {
+    private:
+        friend range_access;
+        template<typename, typename>
+        friend struct adaptor_cursor;
+        using base_t = detail::adaptor_value_type_<BaseIter, Adapt>;
+        using single_pass = meta::bool_<(bool)range_access::single_pass_t<Adapt>() ||
+                                        (bool)single_pass_iterator_<BaseIter>>;
+
+        struct basic_adaptor_mixin : basic_mixin<adaptor_cursor>
+        {
+            basic_adaptor_mixin() = default;
+            using basic_mixin<adaptor_cursor>::basic_mixin;
+            // All iterators into adapted ranges have a base() member for fetching
+            // the underlying iterator.
+            BaseIter base() const
+            {
+                return basic_adaptor_mixin::basic_mixin::get().data_.first();
+            }
+
+        protected:
+            // Adaptor accessor
+            Adapt & get()
+            {
+                return basic_adaptor_mixin::basic_mixin::get().data_.second();
+            }
+            const Adapt & get() const
+            {
+                return basic_adaptor_mixin::basic_mixin::get().data_.second();
+            }
+        };
+
+        template<typename Adapt_>
+        static meta::id<basic_adaptor_mixin> basic_adaptor_mixin_2_(long);
+
+        template<typename Adapt_>
+        static meta::id<typename Adapt_::template mixin<basic_adaptor_mixin>>
+        basic_adaptor_mixin_2_(int);
+
+        using mixin = meta::_t<decltype(basic_adaptor_mixin_2_<Adapt>(42))>;
+
+        template<typename A = Adapt, typename R = decltype(std::declval<A const &>().read(
+                                         std::declval<BaseIter const &>()))>
+        R read() const noexcept(
+            noexcept(std::declval<A const &>().read(std::declval<BaseIter const &>())))
+        {
+            using V = range_access::cursor_value_t<adaptor_cursor>;
+            static_assert(common_reference_with<R &&, V &>,
+                          "In your adaptor, you've specified a value type that does not "
+                          "share a common reference type with the return type of read.");
+            return this->data_.second().read(this->data_.first());
+        }
+        template<typename A = Adapt, typename = decltype(std::declval<A &>().next(
+                                         std::declval<BaseIter &>()))>
+        void next()
+        {
+            this->data_.second().next(this->data_.first());
+        }
+        template<typename A = Adapt,
+                 typename = decltype(std::declval<A const &>().equal(
+                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>(),
+                     std::declval<A const &>()))>
+        bool equal_(adaptor_cursor const & that, int) const
+        {
+            return this->data_.second().equal(
+                this->data_.first(), that.data_.first(), that.data_.second());
+        }
+        template<typename A = Adapt,
+                 typename = decltype(std::declval<A const &>().equal(
+                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>()))>
+        bool equal_(adaptor_cursor const & that, long) const
+        {
+            return this->data_.second().equal(this->data_.first(), that.data_.first());
+        }
+        template<typename C = adaptor_cursor>
+        auto equal(adaptor_cursor const & that) const
+            -> decltype(std::declval<C const &>().equal_(that, 42))
+        {
+            return this->equal_(that, 42);
+        }
+        template<typename S, typename A,
+                 typename = decltype(std::declval<A const &>().empty(
+                     std::declval<BaseIter const &>(), std::declval<Adapt const &>(),
+                     std::declval<S const &>()))>
+        constexpr bool equal_(adaptor_sentinel<S, A> const & that, int) const
+        {
+            return that.data_.second().empty(
+                this->data_.first(), this->data_.second(), that.data_.first());
+        }
+        template<typename S, typename A,
+                 typename = decltype(std::declval<A const &>().empty(
+                     std::declval<BaseIter const &>(), std::declval<S const &>()))>
+        constexpr bool equal_(adaptor_sentinel<S, A> const & that, long) const
+        {
+            return that.data_.second().empty(this->data_.first(), that.data_.first());
+        }
+        template<typename S, typename A>
+        constexpr auto equal(adaptor_sentinel<S, A> const & that) const
+            -> decltype(std::declval<adaptor_cursor const &>().equal_(that, 42))
+        {
+            return this->equal_(that, 42);
+        }
+        template<typename A = Adapt, typename = decltype(std::declval<A &>().prev(
+                                         std::declval<BaseIter &>()))>
+        void prev()
+        {
+            this->data_.second().prev(this->data_.first());
+        }
+        template<typename A = Adapt, typename = decltype(std::declval<A &>().advance(
+                                         std::declval<BaseIter &>(), 0))>
+        void advance(iter_difference_t<BaseIter> n)
+        {
+            this->data_.second().advance(this->data_.first(), n);
+        }
+        template<typename A = Adapt,
+                 typename R = decltype(std::declval<A const &>().distance_to(
+                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>(),
+                     std::declval<A const &>()))>
+        R distance_to_(adaptor_cursor const & that, int) const
+        {
+            return this->data_.second().distance_to(
+                this->data_.first(), that.data_.first(), that.data_.second());
+        }
+        template<typename A = Adapt,
+                 typename R = decltype(std::declval<A const &>().distance_to(
+                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>()))>
+        R distance_to_(adaptor_cursor const & that, long) const
+        {
+            return this->data_.second().distance_to(this->data_.first(),
+                                                    that.data_.first());
+        }
+        template<typename C = adaptor_cursor>
+        auto distance_to(adaptor_cursor const & that) const
+            -> decltype(std::declval<C const &>().distance_to_(that, 42))
+        {
+            return this->distance_to_(that, 42);
+        }
+        // If the adaptor has an iter_move function, use it.
+        template<typename A = Adapt,
+                 typename X = decltype(std::declval<A const &>().iter_move(
+                     std::declval<BaseIter const &>()))>
+        X iter_move_(int) const noexcept(noexcept(
+            std::declval<A const &>().iter_move(std::declval<BaseIter const &>())))
+        {
+            using V = range_access::cursor_value_t<adaptor_cursor>;
+            using R = decltype(this->data_.second().read(this->data_.first()));
+            static_assert(
+                common_reference_with<X &&, V const &>,
+                "In your adaptor, the result of your iter_move member function does "
+                "not share a common reference with your value type.");
+            static_assert(
+                common_reference_with<R &&, X &&>,
+                "In your adaptor, the result of your iter_move member function does "
+                "not share a common reference with the result of your read member "
+                "function.");
+            return this->data_.second().iter_move(this->data_.first());
+        }
+        // If there is no iter_move member and the adaptor has not overridden the read
+        // member function, then dispatch to the base iterator's iter_move function.
+        template<typename A = Adapt,
+                 typename R = decltype(std::declval<A const &>().read(
+                     std::declval<BaseIter const &>(),
+                     detail::adaptor_base_current_mem_fn{})),
+                 typename X = iter_rvalue_reference_t<BaseIter>>
+        X iter_move_(long) const
+            noexcept(noexcept(X(ranges::iter_move(std::declval<BaseIter const &>()))))
+        {
+            return ranges::iter_move(this->data_.first());
+        }
+        // If the adaptor does not have an iter_move function but overrides the read
+        // member function, apply std::move to the result of calling read.
+        template<typename A = Adapt,
+                 typename R = decltype(
+                     std::declval<A const &>().read(std::declval<BaseIter const &>())),
+                 typename X = aux::move_t<R>>
+        X iter_move_(detail::ignore_t) const noexcept(noexcept(X(static_cast<X &&>(
+            std::declval<A const &>().read(std::declval<BaseIter const &>())))))
+        {
+            using V = range_access::cursor_value_t<adaptor_cursor>;
+            static_assert(
+                common_reference_with<X &&, V const &>,
+                "In your adaptor, you've specified a value type that does not share a "
+                "common "
+                "reference type with the result of moving the result of the read member "
+                "function. Consider defining an iter_move function in your adaptor.");
+            return static_cast<X &&>(this->data_.second().read(this->data_.first()));
+        }
+        // Gives users a way to override the default iter_move function in their adaptors.
+        auto move() const
+            noexcept(noexcept(std::declval<const adaptor_cursor &>().iter_move_(42)))
+                -> decltype(std::declval<const adaptor_cursor &>().iter_move_(42))
+        {
+            return iter_move_(42);
+        }
+
+    public:
+        adaptor_cursor() = default;
+        adaptor_cursor(BaseIter iter, Adapt adapt)
+          : base_t{{std::move(iter), std::move(adapt)}}
+        {}
+        template<typename OtherIter, typename OtherAdapt>
+        CPP_ctor(adaptor_cursor)(adaptor_cursor<OtherIter, OtherAdapt> that)(
+            requires defer::not_same_as_<adaptor_cursor<OtherIter, OtherAdapt>,
+                                         adaptor_cursor> &&
+                defer::convertible_to<OtherIter, BaseIter> &&
+                    defer::convertible_to<OtherAdapt, Adapt>)
+          : base_t{{std::move(that.data_.first()), std::move(that.data_.second())}}
+        {}
+    };
+
+    template<typename D>
+    using adaptor_cursor_t =
+        adaptor_cursor<detail::adapted_iterator_t<D>, detail::begin_adaptor_t<D>>;
+
+    template<typename D>
+    using adaptor_sentinel_t = meta::if_c<
+        same_as<detail::adapted_iterator_t<D>, detail::adapted_sentinel_t<D>> &&
+            same_as<detail::begin_adaptor_t<D>, detail::end_adaptor_t<D>>,
+        adaptor_cursor_t<D>,
+        adaptor_sentinel<detail::adapted_sentinel_t<D>, detail::end_adaptor_t<D>>>;
+
+    template<typename Derived, typename BaseRng,
+             cardinality Cardinality /*= range_cardinality<BaseRng>::value*/>
+    struct view_adaptor : view_facade<Derived, Cardinality>
+    {
+    private:
+        friend Derived;
+        friend range_access;
+        friend adaptor_base;
+        CPP_assert(viewable_range<BaseRng>);
+        using base_range_t = views::all_t<BaseRng>;
+        using view_facade<Derived, Cardinality>::derived;
+
+        base_range_t rng_;
+
+        constexpr adaptor_base begin_adaptor() const noexcept
+        {
+            return {};
+        }
+        constexpr adaptor_base end_adaptor() const noexcept
+        {
+            return {};
+        }
+
+        template<typename D>
+        static constexpr adaptor_cursor_t<D> begin_cursor_(D & d) noexcept(noexcept(
+            adaptor_cursor_t<D>{std::declval<detail::begin_adaptor_t<D> &>().begin(d),
+                                range_access::begin_adaptor(d)}))
+        {
+            auto adapt = range_access::begin_adaptor(d);
+            auto pos = adapt.begin(d);
+            return {std::move(pos), std::move(adapt)};
+        }
+        template<typename D = Derived>
+        constexpr auto begin_cursor() noexcept(
+            noexcept(view_adaptor::begin_cursor_(std::declval<D &>())))
+            -> CPP_ret(decltype(view_adaptor::begin_cursor_(std::declval<D &>())))( //
+                requires same_as<D, Derived>)
+        {
+            return view_adaptor::begin_cursor_(derived());
+        }
+        template<typename D = Derived>
+        constexpr auto begin_cursor() const
+            noexcept(noexcept(view_adaptor::begin_cursor_(std::declval<D const &>())))
+                -> CPP_ret(
+                    decltype(view_adaptor::begin_cursor_(std::declval<D const &>())))( //
+                    requires same_as<D, Derived> && range<base_range_t const>)
+        {
+            return view_adaptor::begin_cursor_(derived());
+        }
+
+        template<typename D>
+        static constexpr adaptor_sentinel_t<D> end_cursor_(D & d) noexcept(noexcept(
+            adaptor_sentinel_t<D>{std::declval<detail::end_adaptor_t<D> &>().end(d),
+                                  range_access::end_adaptor(d)}))
+        {
+            auto adapt = range_access::end_adaptor(d);
+            auto pos = adapt.end(d);
+            return {std::move(pos), std::move(adapt)};
+        }
+        template<typename D = Derived>
+        constexpr auto end_cursor() noexcept(
+            noexcept(view_adaptor::end_cursor_(std::declval<D &>())))
+            -> CPP_ret(decltype(view_adaptor::end_cursor_(std::declval<D &>())))( //
+                requires same_as<D, Derived>)
+        {
+            return view_adaptor::end_cursor_(derived());
+        }
+        template<typename D = Derived>
+        constexpr auto end_cursor() const noexcept(
+            noexcept(view_adaptor::end_cursor_(std::declval<D const &>())))
+            -> CPP_ret(decltype(view_adaptor::end_cursor_(std::declval<D const &>())))( //
+                requires same_as<D, Derived> && range<base_range_t const>)
+        {
+            return view_adaptor::end_cursor_(derived());
+        }
+
+    protected:
+        ~view_adaptor() = default;
+
+    public:
+        view_adaptor() = default;
+        view_adaptor(view_adaptor &&) = default;
+        view_adaptor(view_adaptor const &) = default;
+        view_adaptor & operator=(view_adaptor &&) = default;
+        view_adaptor & operator=(view_adaptor const &) = default;
+        explicit constexpr view_adaptor(BaseRng && rng)
+          : rng_(views::all(static_cast<BaseRng &&>(rng)))
+        {}
+        constexpr base_range_t & base() noexcept
+        {
+            return rng_;
+        }
+        /// \overload
+        constexpr base_range_t const & base() const noexcept
+        {
+            return rng_;
+        }
+    };
+
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/addressof.hpp b/inst/include/range/v3/view/addressof.hpp
new file mode 100644
index 0000000..a4b5ee9
--- /dev/null
+++ b/inst/include/range/v3/view/addressof.hpp
@@ -0,0 +1,59 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrey Diduh 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ADDRESSOF_HPP
+#define RANGES_V3_VIEW_ADDRESSOF_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/view/transform.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        struct addressof_fn
+        {
+        private:
+            struct take_address
+            {
+                template<typename V>
+                constexpr V * operator()(V & value) const noexcept
+                {
+                    return detail::addressof(value);
+                }
+            };
+
+        public:
+            CPP_template(typename Rng)(                                      //
+                requires viewable_range<Rng> && input_range<Rng> &&          //
+                    std::is_lvalue_reference<range_reference_t<Rng>>::value) //
+                constexpr auto CPP_auto_fun(operator())(Rng && rng)(const)(
+                    return transform(all(static_cast<Rng &&>(rng)), take_address{}))
+        };
+
+        /// \relates addressof_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<addressof_fn>, addressof)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_VIEW_ADDRESSOF_HPP
diff --git a/inst/include/range/v3/view/adjacent_filter.hpp b/inst/include/range/v3/view/adjacent_filter.hpp
new file mode 100644
index 0000000..96df0dc
--- /dev/null
+++ b/inst/include/range/v3/view/adjacent_filter.hpp
@@ -0,0 +1,176 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ADJACENT_FILTER_HPP
+#define RANGES_V3_VIEW_ADJACENT_FILTER_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/adjacent_find.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng, typename Pred)
+            concept adjacent_filter_constraints,
+                viewable_range<Rng> && forward_range<Rng> &&
+                indirect_binary_predicate_<Pred, iterator_t<Rng>, iterator_t<Rng>>
+        );
+        // clang-format on
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Pred>
+    struct RANGES_EMPTY_BASES adjacent_filter_view
+      : view_adaptor<adjacent_filter_view<Rng, Pred>, Rng,
+                     is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+      , private box<semiregular_box_t<Pred>, adjacent_filter_view<Rng, Pred>>
+    {
+    private:
+        friend range_access;
+
+        template<bool Const>
+        struct adaptor : adaptor_base
+        {
+        private:
+            friend struct adaptor<!Const>;
+            using CRng = meta::const_if_c<Const, Rng>;
+            using Parent = meta::const_if_c<Const, adjacent_filter_view>;
+            Parent * rng_;
+
+        public:
+            adaptor() = default;
+            constexpr adaptor(Parent * rng) noexcept
+              : rng_(rng)
+            {}
+            CPP_template(bool Other)(       //
+                requires Const && (!Other)) //
+                constexpr adaptor(adaptor<Other> that)
+              : rng_(that.rng_)
+            {}
+            constexpr void next(iterator_t<CRng> & it) const
+            {
+                auto const last = ranges::end(rng_->base());
+                auto & pred = rng_->adjacent_filter_view::box::get();
+                RANGES_EXPECT(it != last);
+                for(auto prev = it; ++it != last; prev = it)
+                    if(invoke(pred, *prev, *it))
+                        break;
+            }
+            CPP_member
+            constexpr auto prev(iterator_t<CRng> & it) const -> CPP_ret(void)( //
+                requires bidirectional_range<CRng>)
+            {
+                auto const first = ranges::begin(rng_->base());
+                auto & pred = rng_->adjacent_filter_view::box::get();
+                RANGES_EXPECT(it != first);
+                --it;
+                while(it != first)
+                {
+                    auto prev = it;
+                    if(invoke(pred, *--prev, *it))
+                        break;
+                    it = prev;
+                }
+            }
+            void distance_to() = delete;
+        };
+        constexpr auto begin_adaptor() noexcept -> adaptor<false>
+        {
+            return {this};
+        }
+        CPP_member
+        constexpr auto begin_adaptor() const noexcept -> CPP_ret(adaptor<true>)( //
+            requires detail::adjacent_filter_constraints<Rng const, Pred const>)
+        {
+            return {this};
+        }
+        constexpr auto end_adaptor() noexcept -> adaptor<false>
+        {
+            return {this};
+        }
+        CPP_member
+        constexpr auto end_adaptor() const noexcept -> CPP_ret(adaptor<true>)( //
+            requires detail::adjacent_filter_constraints<Rng const, Pred const>)
+        {
+            return {this};
+        }
+
+    public:
+        adjacent_filter_view() = default;
+        constexpr adjacent_filter_view(Rng rng, Pred pred)
+          : adjacent_filter_view::view_adaptor{detail::move(rng)}
+          , adjacent_filter_view::box(detail::move(pred))
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Rng>)
+        adjacent_filter_view(Rng &&, Fun)
+            ->adjacent_filter_view<views::all_t<Rng>, Fun>;
+#endif
+
+    namespace views
+    {
+        struct adjacent_filter_base_fn
+        {
+            template<typename Rng, typename Pred>
+            constexpr auto operator()(Rng && rng, Pred pred) const
+                -> CPP_ret(adjacent_filter_view<all_t<Rng>, Pred>)( //
+                    requires detail::adjacent_filter_constraints<Rng, Pred>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(pred)};
+            }
+        };
+
+        struct adjacent_filter_fn : adjacent_filter_base_fn
+        {
+            using adjacent_filter_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(
+                    bind_back(adjacent_filter_base_fn{}, std::move(pred)));
+            }
+        };
+
+        /// \relates adjacent_filter_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(adjacent_filter_fn, adjacent_filter)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::adjacent_filter_view)
+
+#endif
diff --git a/inst/include/range/v3/view/adjacent_remove_if.hpp b/inst/include/range/v3/view/adjacent_remove_if.hpp
new file mode 100644
index 0000000..56d179c
--- /dev/null
+++ b/inst/include/range/v3/view/adjacent_remove_if.hpp
@@ -0,0 +1,179 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ADJACENT_REMOVE_IF_HPP
+#define RANGES_V3_VIEW_ADJACENT_REMOVE_IF_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Pred>
+    struct RANGES_EMPTY_BASES adjacent_remove_if_view
+      : view_adaptor<adjacent_remove_if_view<Rng, Pred>, Rng,
+                     is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+      , private box<semiregular_box_t<Pred>, adjacent_remove_if_view<Rng, Pred>>
+    {
+        adjacent_remove_if_view() = default;
+        constexpr adjacent_remove_if_view(Rng rng, Pred pred)
+          : adjacent_remove_if_view::view_adaptor{detail::move(rng)}
+          , adjacent_remove_if_view::box(detail::move(pred))
+        {}
+
+    private:
+        friend range_access;
+
+        struct adaptor : adaptor_base
+        {
+        private:
+            adjacent_remove_if_view * rng_;
+
+        public:
+            adaptor() = default;
+            constexpr adaptor(adjacent_remove_if_view * rng) noexcept
+              : rng_(rng)
+            {}
+            static constexpr iterator_t<Rng> begin(adjacent_remove_if_view & rng)
+            {
+                return *rng.begin_;
+            }
+            constexpr void next(iterator_t<Rng> & it) const
+            {
+                RANGES_ASSERT(it != ranges::end(rng_->base()));
+                rng_->satisfy_forward(++it);
+            }
+            CPP_member
+            constexpr auto prev(iterator_t<Rng> & it) const -> CPP_ret(void)( //
+                requires bidirectional_range<Rng>)
+            {
+                rng_->satisfy_reverse(it);
+            }
+            void advance() = delete;
+            void distance_to() = delete;
+        };
+        constexpr adaptor begin_adaptor()
+        {
+            cache_begin();
+            return {this};
+        }
+        CPP_member
+        constexpr auto end_adaptor() -> CPP_ret(adaptor)( //
+            requires common_range<Rng>)
+        {
+            if(bidirectional_range<Rng>)
+                cache_begin();
+            return {this};
+        }
+        CPP_member
+        constexpr auto end_adaptor() noexcept -> CPP_ret(adaptor_base)( //
+            requires(!common_range<Rng>))
+        {
+            return {};
+        }
+
+        constexpr void satisfy_forward(iterator_t<Rng> & it)
+        {
+            auto const last = ranges::end(this->base());
+            if(it == last)
+                return;
+            auto & pred = this->adjacent_remove_if_view::box::get();
+            for(auto nxt = it; ++nxt != last && invoke(pred, *it, *nxt); it = nxt)
+                ;
+        }
+        constexpr void satisfy_reverse(iterator_t<Rng> & it)
+        {
+            auto const & first = *begin_;
+            RANGES_ASSERT(it != first);
+            (void)first;
+            auto prv = it;
+            --it;
+            if(prv == ranges::end(this->base()))
+            {
+                return;
+            }
+            auto & pred = this->adjacent_remove_if_view::box::get();
+            for(; invoke(pred, *it, *prv); prv = it, --it)
+                RANGES_ASSERT(it != first);
+        }
+
+        void cache_begin()
+        {
+            if(begin_)
+                return;
+            auto it = ranges::begin(this->base());
+            satisfy_forward(it);
+            begin_.emplace(std::move(it));
+        }
+
+        detail::non_propagating_cache<iterator_t<Rng>> begin_;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Rng>)
+        adjacent_remove_if_view(Rng &&, Fun)
+            ->adjacent_remove_if_view<views::all_t<Rng>, Fun>;
+#endif
+
+    namespace views
+    {
+        struct adjacent_remove_if_base_fn
+        {
+            template<typename Rng, typename Pred>
+            constexpr auto operator()(Rng && rng, Pred pred) const -> CPP_ret(
+                adjacent_remove_if_view<all_t<Rng>, Pred>)( //
+                requires viewable_range<Rng> && forward_range<Rng> &&
+                    indirect_binary_predicate_<Pred, iterator_t<Rng>, iterator_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(pred)};
+            }
+        };
+
+        struct adjacent_remove_if_fn : adjacent_remove_if_base_fn
+        {
+            using adjacent_remove_if_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(
+                    bind_back(adjacent_remove_if_base_fn{}, std::move(pred)));
+            }
+        };
+
+        /// \relates adjacent_remove_if_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(adjacent_remove_if_fn, adjacent_remove_if)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::adjacent_remove_if_view)
+
+#endif
diff --git a/inst/include/range/v3/view/all.hpp b/inst/include/range/v3/view/all.hpp
new file mode 100644
index 0000000..c19cf36
--- /dev/null
+++ b/inst/include/range/v3/view/all.hpp
@@ -0,0 +1,120 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_ALL_HPP
+#define RANGES_V3_VIEW_ALL_HPP
+
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/ref.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        struct all_fn
+        {
+        private:
+            /// If it's a view already, pass it though.
+            template<typename T>
+            static constexpr auto from_range_(T && t, std::true_type, detail::ignore_t,
+                                              detail::ignore_t)
+            {
+                return static_cast<T &&>(t);
+            }
+
+            /// If it is container-like, turn it into a view, being careful
+            /// to preserve the Sized-ness of the range.
+            template<typename T>
+            static constexpr auto from_range_(T && t, std::false_type, std::true_type,
+                                              detail::ignore_t)
+            {
+                return ranges::views::ref(t);
+            }
+
+            /// Not a view and not an lvalue? If it's a forwarding_range_, then
+            /// return a subrange holding the range's begin/end.
+            template<typename T>
+            static constexpr auto from_range_(T && t, std::false_type, std::false_type,
+                                              std::true_type)
+            {
+                return make_subrange(static_cast<T &&>(t));
+            }
+
+        public:
+            template<typename T>
+            constexpr auto CPP_fun(operator())(T && t)(const requires viewable_range<T>)
+            {
+                return all_fn::from_range_(static_cast<T &&>(t),
+                                           meta::bool_<view_<uncvref_t<T>>>{},
+                                           std::is_lvalue_reference<T>{},
+                                           meta::bool_<forwarding_range_<T>>{});
+            }
+
+            template<typename T>
+            RANGES_DEPRECATED("Passing a reference_wrapper to views::all is deprecated.")
+            constexpr auto operator()(std::reference_wrapper<T> r) const
+                -> CPP_ret(ref_view<T>)( //
+                    requires range<T &>)
+            {
+                return ranges::views::ref(r.get());
+            }
+        };
+
+        /// \relates all_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<all_fn>, all)
+
+        template<typename Rng>
+        using all_t = decltype(all(std::declval<Rng>()));
+    } // namespace views
+
+    template<typename Rng>
+    struct identity_adaptor : Rng
+    {
+        CPP_assert(view_<Rng>);
+
+        identity_adaptor() = default;
+        constexpr explicit identity_adaptor(Rng const & rng)
+          : Rng(rng)
+        {}
+        constexpr explicit identity_adaptor(Rng && rng)
+          : Rng(detail::move(rng))
+        {}
+    };
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::all;
+        }
+        CPP_template(typename Rng)(       //
+            requires viewable_range<Rng>) //
+            using all_view = ranges::views::all_t<Rng>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/any_view.hpp b/inst/include/range/v3/view/any_view.hpp
new file mode 100644
index 0000000..e787a7a
--- /dev/null
+++ b/inst/include/range/v3/view/any_view.hpp
@@ -0,0 +1,673 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//  Copyright Casey Carter 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ANY_VIEW_HPP
+#define RANGES_V3_VIEW_ANY_VIEW_HPP
+
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/utility/memory.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE
+
+namespace ranges
+{
+    /// \brief An enum that denotes the supported subset of range concepts supported by a
+    /// range.
+    enum class category
+    {
+        none = 0,             ///<\brief No concepts met.
+        input = 1,            ///<\brief satisfies ranges::concepts::input_range
+        forward = 3,          ///<\brief satisfies ranges::concepts::forward_range
+        bidirectional = 7,    ///<\brief satisfies ranges::concepts::bidirectional_range
+        random_access = 15,   ///<\brief satisfies ranges::concepts::random_access_range
+        mask = random_access, ///<\brief Mask away any properties other than iterator
+                              ///< category
+        sized = 16,           ///<\brief satisfies ranges::concepts::sized_range
+    };
+
+    /** \name Binary operators for ranges::category
+     *  \relates ranges::category
+     *  \{
+     */
+    constexpr category operator&(category lhs, category rhs) noexcept
+    {
+        return static_cast<category>(
+            static_cast<meta::_t<std::underlying_type<category>>>(lhs) &
+            static_cast<meta::_t<std::underlying_type<category>>>(rhs));
+    }
+
+    constexpr category operator|(category lhs, category rhs) noexcept
+    {
+        return static_cast<category>(
+            static_cast<meta::_t<std::underlying_type<category>>>(lhs) |
+            static_cast<meta::_t<std::underlying_type<category>>>(rhs));
+    }
+
+    constexpr category operator^(category lhs, category rhs) noexcept
+    {
+        return static_cast<category>(
+            static_cast<meta::_t<std::underlying_type<category>>>(lhs) ^
+            static_cast<meta::_t<std::underlying_type<category>>>(rhs));
+    }
+
+    constexpr category operator~(category lhs) noexcept
+    {
+        return static_cast<category>(
+            ~static_cast<meta::_t<std::underlying_type<category>>>(lhs));
+    }
+
+    constexpr category & operator&=(category & lhs, category rhs) noexcept
+    {
+        return (lhs = lhs & rhs);
+    }
+
+    constexpr category & operator|=(category & lhs, category rhs) noexcept
+    {
+        return (lhs = lhs | rhs);
+    }
+
+    constexpr category & operator^=(category & lhs, category rhs) noexcept
+    {
+        return (lhs = lhs ^ rhs);
+    }
+    //!\}
+
+    /// \brief For a given range, return a ranges::category enum with the satisfied
+    /// concepts.
+    template<typename Rng>
+    constexpr category get_categories() noexcept
+    {
+        return (input_range<Rng> ? category::input : category::none) |
+               (forward_range<Rng> ? category::forward : category::none) |
+               (bidirectional_range<Rng> ? category::bidirectional : category::none) |
+               (random_access_range<Rng> ? category::random_access : category::none) |
+               (sized_range<Rng> ? category::sized : category::none);
+    }
+
+    /// \cond
+    namespace detail
+    {
+        // workaround the fact that typeid ignores cv-qualifiers
+        template<typename>
+        struct rtti_tag
+        {};
+
+        struct any_ref
+        {
+            any_ref() = default;
+            template<typename T>
+            constexpr any_ref(T & obj) noexcept
+              : obj_(detail::addressof(obj))
+#ifndef NDEBUG
+              , info_(&typeid(rtti_tag<T>))
+#endif
+            {}
+            template<typename T>
+            T & get() const noexcept
+            {
+                RANGES_ASSERT(obj_ && info_ && *info_ == typeid(rtti_tag<T>));
+                return *const_cast<T *>(static_cast<T const volatile *>(obj_));
+            }
+
+        private:
+            void const volatile * obj_ = nullptr;
+#ifndef NDEBUG
+            std::type_info const * info_ = nullptr;
+#endif
+        };
+
+        template<typename Base>
+        struct cloneable : Base
+        {
+            using Base::Base;
+            virtual ~cloneable() = default;
+            cloneable() = default;
+            cloneable(cloneable const &) = delete;
+            cloneable & operator=(cloneable const &) = delete;
+            virtual std::unique_ptr<cloneable> clone() const = 0;
+        };
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng, typename Ref)
+            concept any_compatible_range,
+                convertible_to<range_reference_t<Rng>, Ref>
+        );
+        // clang-format on
+
+        template<typename Rng, typename = void>
+        struct any_view_sentinel_impl
+          : private box<sentinel_t<Rng>, any_view_sentinel_impl<Rng>>
+        {
+        private:
+            using box_t = typename any_view_sentinel_impl::box;
+
+        public:
+            any_view_sentinel_impl() = default;
+            any_view_sentinel_impl(Rng & rng)
+              : box_t(ranges::end(rng))
+            {}
+            void init(Rng & rng) noexcept
+            {
+                box_t::get() = ranges::end(rng);
+            }
+            sentinel_t<Rng> const & get(Rng &) const noexcept
+            {
+                return box_t::get();
+            }
+        };
+
+        template<typename Rng>
+        struct any_view_sentinel_impl<
+            Rng, meta::void_<decltype(ranges::end(std::declval<Rng const &>()))>>
+        {
+            any_view_sentinel_impl() = default;
+            any_view_sentinel_impl(Rng &) noexcept
+            {}
+            void init(Rng &) noexcept
+            {}
+            sentinel_t<Rng> get(Rng & rng) const noexcept
+            {
+                return ranges::end(rng);
+            }
+        };
+
+        template<typename Ref, bool Sized = false>
+        struct any_input_view_interface
+        {
+            virtual ~any_input_view_interface() = default;
+            virtual void init() = 0;
+            virtual bool done() = 0;
+            virtual Ref read() const = 0;
+            virtual void next() = 0;
+        };
+        template<typename Ref>
+        struct any_input_view_interface<Ref, true> : any_input_view_interface<Ref, false>
+        {
+            virtual std::size_t size() = 0;
+        };
+
+        template<typename Ref>
+        struct any_input_cursor
+        {
+            using single_pass = std::true_type;
+
+            any_input_cursor() = default;
+            constexpr any_input_cursor(any_input_view_interface<Ref> & view) noexcept
+              : view_{detail::addressof(view)}
+            {}
+            Ref read() const
+            {
+                return view_->read();
+            }
+            void next()
+            {
+                view_->next();
+            }
+            bool equal(any_input_cursor const &) const noexcept
+            {
+                return true;
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return !view_ || view_->done();
+            }
+
+        private:
+            any_input_view_interface<Ref> * view_ = nullptr;
+        };
+
+        template<typename Rng, typename Ref, bool Sized = false>
+        struct RANGES_EMPTY_BASES any_input_view_impl
+          : any_input_view_interface<Ref, Sized>
+          , private any_view_sentinel_impl<Rng>
+        {
+            CPP_assert(any_compatible_range<Rng, Ref>);
+            CPP_assert(!Sized || (bool)sized_range<Rng>);
+
+            explicit any_input_view_impl(Rng rng)
+              : rng_{std::move(rng)}
+            {}
+            any_input_view_impl(any_input_view_impl const &) = delete;
+            any_input_view_impl & operator=(any_input_view_impl const &) = delete;
+
+        private:
+            using sentinel_box_t = any_view_sentinel_impl<Rng>;
+
+            virtual void init() override
+            {
+                sentinel_box_t::init(rng_);
+                current_ = ranges::begin(rng_);
+            }
+            virtual bool done() override
+            {
+                return current_ == sentinel_box_t::get(rng_);
+            }
+            virtual Ref read() const override
+            {
+                return *current_;
+            }
+            virtual void next() override
+            {
+                ++current_;
+            }
+            std::size_t size() // override-ish
+            {
+                return static_cast<std::size_t>(ranges::size(rng_));
+            }
+
+            RANGES_NO_UNIQUE_ADDRESS Rng rng_;
+            RANGES_NO_UNIQUE_ADDRESS iterator_t<Rng> current_{};
+        };
+
+        template<typename Ref, category Cat = category::forward, typename enable = void>
+        struct any_cursor_interface;
+
+        template<typename Ref, category Cat>
+        struct any_cursor_interface<
+            Ref, Cat, meta::if_c<(Cat & category::mask) == category::forward>>
+        {
+            virtual ~any_cursor_interface() = default;
+            virtual any_ref iter()
+                const = 0; // returns a const ref to the cursor's wrapped iterator
+            virtual Ref read() const = 0;
+            virtual bool equal(any_cursor_interface const &) const = 0;
+            virtual void next() = 0;
+        };
+
+        template<typename Ref, category Cat>
+        struct any_cursor_interface<
+            Ref, Cat, meta::if_c<(Cat & category::mask) == category::bidirectional>>
+          : any_cursor_interface<Ref, (Cat & ~category::mask) | category::forward>
+        {
+            virtual void prev() = 0;
+        };
+
+        template<typename Ref, category Cat>
+        struct any_cursor_interface<
+            Ref, Cat, meta::if_c<(Cat & category::mask) == category::random_access>>
+          : any_cursor_interface<Ref, (Cat & ~category::mask) | category::bidirectional>
+        {
+            virtual void advance(std::ptrdiff_t) = 0;
+            virtual std::ptrdiff_t distance_to(any_cursor_interface const &) const = 0;
+        };
+
+        template<typename Ref, category Cat>
+        using any_cloneable_cursor_interface = cloneable<any_cursor_interface<Ref, Cat>>;
+
+        template<typename I, typename Ref, category Cat>
+        struct any_cursor_impl : any_cloneable_cursor_interface<Ref, Cat>
+        {
+            CPP_assert(convertible_to<iter_reference_t<I>, Ref>);
+            CPP_assert((Cat & category::forward) == category::forward);
+
+            any_cursor_impl() = default;
+            any_cursor_impl(I it)
+              : it_{std::move(it)}
+            {}
+
+        private:
+            using Forward =
+                any_cursor_interface<Ref, (Cat & ~category::mask) | category::forward>;
+
+            I it_;
+
+            any_ref iter() const override
+            {
+                return it_;
+            }
+            Ref read() const override
+            {
+                return *it_;
+            }
+            bool equal(Forward const & that_) const override
+            {
+                auto & that = polymorphic_downcast<any_cursor_impl const &>(that_);
+                return that.it_ == it_;
+            }
+            void next() override
+            {
+                ++it_;
+            }
+            std::unique_ptr<any_cloneable_cursor_interface<Ref, Cat>> clone()
+                const override
+            {
+                return detail::make_unique<any_cursor_impl>(it_);
+            }
+            void prev() // override (sometimes; it's complicated)
+            {
+                --it_;
+            }
+            void advance(std::ptrdiff_t n) // override-ish
+            {
+                it_ += n;
+            }
+            std::ptrdiff_t distance_to(
+                any_cursor_interface<Ref, Cat> const & that_) const // override-ish
+            {
+                auto & that = polymorphic_downcast<any_cursor_impl const &>(that_);
+                return static_cast<std::ptrdiff_t>(that.it_ - it_);
+            }
+        };
+
+        struct fully_erased_view
+        {
+            virtual bool at_end(
+                any_ref) = 0; // any_ref is a const ref to a wrapped iterator
+                              // to be compared to the erased view's last sentinel
+        protected:
+            ~fully_erased_view() = default;
+        };
+
+        struct any_sentinel
+        {
+            any_sentinel() = default;
+            constexpr explicit any_sentinel(fully_erased_view & view) noexcept
+              : view_{&view}
+            {}
+
+        private:
+            template<typename, category>
+            friend struct any_cursor;
+
+            fully_erased_view * view_ = nullptr;
+        };
+
+        template<typename Ref, category Cat>
+        struct any_cursor
+        {
+        private:
+            CPP_assert((Cat & category::forward) == category::forward);
+
+            std::unique_ptr<any_cloneable_cursor_interface<Ref, Cat>> ptr_;
+
+            template<typename Rng>
+            using impl_t = any_cursor_impl<iterator_t<Rng>, Ref, Cat>;
+
+        public:
+            any_cursor() = default;
+            template<typename Rng>
+            explicit CPP_ctor(any_cursor)(Rng && rng)( //
+                requires(!ranges::defer::same_as<detail::decay_t<Rng>, any_cursor>) &&
+                ranges::defer::forward_range<Rng> &&
+                defer::any_compatible_range<Rng, Ref>)
+              : ptr_{detail::make_unique<impl_t<Rng>>(begin(rng))}
+            {}
+            any_cursor(any_cursor &&) = default;
+            any_cursor(any_cursor const & that)
+              : ptr_{that.ptr_ ? that.ptr_->clone() : nullptr}
+            {}
+            any_cursor & operator=(any_cursor &&) = default;
+            any_cursor & operator=(any_cursor const & that)
+            {
+                ptr_ = (that.ptr_ ? that.ptr_->clone() : nullptr);
+                return *this;
+            }
+            Ref read() const
+            {
+                RANGES_EXPECT(ptr_);
+                return ptr_->read();
+            }
+            bool equal(any_cursor const & that) const
+            {
+                RANGES_EXPECT(!ptr_ == !that.ptr_);
+                return !ptr_ || ptr_->equal(*that.ptr_);
+            }
+            bool equal(any_sentinel const & that) const
+            {
+                RANGES_EXPECT(!ptr_ == !that.view_);
+                return !ptr_ || that.view_->at_end(ptr_->iter());
+            }
+            void next()
+            {
+                RANGES_EXPECT(ptr_);
+                ptr_->next();
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires(category::bidirectional == (Cat & category::bidirectional)))
+            {
+                RANGES_EXPECT(ptr_);
+                ptr_->prev();
+            }
+            CPP_member
+            auto advance(std::ptrdiff_t n) -> CPP_ret(void)( //
+                requires(category::random_access == (Cat & category::random_access)))
+            {
+                RANGES_EXPECT(ptr_);
+                ptr_->advance(n);
+            }
+            CPP_member
+            auto distance_to(any_cursor const & that) const -> CPP_ret(std::ptrdiff_t)( //
+                requires(category::random_access == (Cat & category::random_access)))
+            {
+                RANGES_EXPECT(!ptr_ == !that.ptr_);
+                return !ptr_ ? 0 : ptr_->distance_to(*that.ptr_);
+            }
+        };
+
+        template<typename Ref, category Cat,
+                 bool = (Cat & category::sized) == category::sized>
+        struct any_view_interface : fully_erased_view
+        {
+            CPP_assert((Cat & category::forward) == category::forward);
+
+            virtual ~any_view_interface() = default;
+            virtual any_cursor<Ref, Cat> begin_cursor() = 0;
+        };
+        template<typename Ref, category Cat>
+        struct any_view_interface<Ref, Cat, true> : any_view_interface<Ref, Cat, false>
+        {
+            virtual std::size_t size() = 0;
+        };
+
+        template<typename Ref, category Cat>
+        using any_cloneable_view_interface = cloneable<any_view_interface<Ref, Cat>>;
+
+        template<typename Rng, typename Ref, category Cat>
+        struct RANGES_EMPTY_BASES any_view_impl
+          : any_cloneable_view_interface<Ref, Cat>
+          , private box<Rng, any_view_impl<Rng, Ref, Cat>>
+          , private any_view_sentinel_impl<Rng>
+        {
+            CPP_assert((Cat & category::forward) == category::forward);
+            CPP_assert(any_compatible_range<Rng, Ref>);
+            CPP_assert((Cat & category::sized) == category::none ||
+                       (bool)sized_range<Rng>);
+
+            any_view_impl() = default;
+            any_view_impl(Rng rng)
+              : range_box_t{std::move(rng)}
+              , sentinel_box_t{range_box_t::get()}
+            // NB: initialization order dependence
+            {}
+
+        private:
+            using range_box_t = box<Rng, any_view_impl>;
+            using sentinel_box_t = any_view_sentinel_impl<Rng>;
+
+            any_cursor<Ref, Cat> begin_cursor() override
+            {
+                return any_cursor<Ref, Cat>{range_box_t::get()};
+            }
+            bool at_end(any_ref it_) override
+            {
+                auto & it = it_.get<iterator_t<Rng> const>();
+                return it == sentinel_box_t::get(range_box_t::get());
+            }
+            std::unique_ptr<any_cloneable_view_interface<Ref, Cat>> clone() const override
+            {
+                return detail::make_unique<any_view_impl>(range_box_t::get());
+            }
+            std::size_t size() // override-ish
+            {
+                return static_cast<std::size_t>(ranges::size(range_box_t::get()));
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \brief A type-erased view
+    /// \ingroup group-views
+    template<typename Ref, category Cat = category::input, typename enable = void>
+    struct any_view
+      : view_facade<any_view<Ref, Cat>,
+                    (Cat & category::sized) == category::sized ? finite : unknown>
+    {
+        friend range_access;
+        CPP_assert((Cat & category::forward) == category::forward);
+
+        any_view() = default;
+        template<typename Rng>
+        CPP_ctor(any_view)(Rng && rng)( //
+            requires(!defer::same_as<detail::decay_t<Rng>, any_view>) &&
+            defer::input_range<Rng> && detail::defer::any_compatible_range<Rng, Ref>)
+          : any_view(static_cast<Rng &&>(rng),
+                     meta::bool_<(get_categories<Rng>() & Cat) == Cat>{})
+        {}
+        any_view(any_view &&) = default;
+        any_view(any_view const & that)
+          : ptr_{that.ptr_ ? that.ptr_->clone() : nullptr}
+        {}
+        any_view & operator=(any_view &&) = default;
+        any_view & operator=(any_view const & that)
+        {
+            ptr_ = (that.ptr_ ? that.ptr_->clone() : nullptr);
+            return *this;
+        }
+
+        CPP_member
+        auto size() -> CPP_ret(std::size_t)( //
+            requires(category::sized == (Cat & category::sized)))
+        {
+            return ptr_ ? ptr_->size() : 0;
+        }
+
+    private:
+        template<typename Rng>
+        using impl_t = detail::any_view_impl<views::all_t<Rng>, Ref, Cat>;
+        template<typename Rng>
+        any_view(Rng && rng, std::true_type)
+          : ptr_{detail::make_unique<impl_t<Rng>>(views::all(static_cast<Rng &&>(rng)))}
+        {}
+        template<typename Rng>
+        any_view(Rng &&, std::false_type)
+        {
+            static_assert(
+                (get_categories<Rng>() & Cat) == Cat,
+                "The range passed to any_view() does not model the requested category");
+        }
+
+        detail::any_cursor<Ref, Cat> begin_cursor()
+        {
+            return ptr_ ? ptr_->begin_cursor() : detail::value_init{};
+        }
+        detail::any_sentinel end_cursor() noexcept
+        {
+            return detail::any_sentinel{*ptr_};
+        }
+
+        std::unique_ptr<detail::any_cloneable_view_interface<Ref, Cat>> ptr_;
+    };
+
+    // input and not forward
+    template<typename Ref, category Cat>
+    struct any_view<Ref, Cat, meta::if_c<(Cat & category::forward) == category::input>>
+      : view_facade<any_view<Ref, Cat, void>,
+                    (Cat & category::sized) == category::sized ? finite : unknown>
+    {
+        friend range_access;
+
+        any_view() = default;
+        template<typename Rng>
+        CPP_ctor(any_view)(Rng && rng)( //
+            requires(!defer::same_as<detail::decay_t<Rng>, any_view>) &&
+            defer::input_range<Rng> && detail::defer::any_compatible_range<Rng, Ref>)
+          : ptr_{std::make_shared<impl_t<Rng>>(views::all(static_cast<Rng &&>(rng)))}
+        {}
+
+        CPP_member
+        auto size() -> CPP_ret(std::size_t)( //
+            requires(category::sized == (Cat & category::sized)))
+        {
+            return ptr_ ? ptr_->size() : 0;
+        }
+
+    private:
+        template<typename Rng>
+        using impl_t =
+            detail::any_input_view_impl<views::all_t<Rng>, Ref,
+                                        (Cat & category::sized) == category::sized>;
+
+        detail::any_input_cursor<Ref> begin_cursor()
+        {
+            if(!ptr_)
+                return {};
+
+            ptr_->init();
+            return detail::any_input_cursor<Ref>{*ptr_};
+        }
+
+        std::shared_ptr<detail::any_input_view_interface<Ref, (Cat & category::sized) ==
+                                                                  category::sized>>
+            ptr_;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng)( //
+        requires view_<Rng>)    //
+        any_view(Rng &&)
+            ->any_view<range_reference_t<Rng>, get_categories<Rng>()>;
+#endif
+
+    template<typename Ref>
+    using any_input_view RANGES_DEPRECATED(
+        "Use any_view<Ref, category::input> instead.") = any_view<Ref, category::input>;
+
+    template<typename Ref>
+    using any_forward_view RANGES_DEPRECATED(
+        "Use any_view<Ref, category::forward> instead.") =
+        any_view<Ref, category::forward>;
+
+    template<typename Ref>
+    using any_bidirectional_view RANGES_DEPRECATED(
+        "Use any_view<Ref, category::bidirectional> instead.") =
+        any_view<Ref, category::bidirectional>;
+
+    template<typename Ref>
+    using any_random_access_view RANGES_DEPRECATED(
+        "Use any_view<Ref, category::random_access> instead.") =
+        any_view<Ref, category::random_access>;
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::any_view)
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/view/bounded.hpp b/inst/include/range/v3/view/bounded.hpp
new file mode 100644
index 0000000..7593232
--- /dev/null
+++ b/inst/include/range/v3/view/bounded.hpp
@@ -0,0 +1,22 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_BOUNDED_HPP
+#define RANGES_V3_VIEW_BOUNDED_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/view/common.hpp> instead.")
+
+#include <range/v3/view/common.hpp>
+
+#endif
diff --git a/inst/include/range/v3/view/c_str.hpp b/inst/include/range/v3/view/c_str.hpp
new file mode 100644
index 0000000..16223ee
--- /dev/null
+++ b/inst/include/range/v3/view/c_str.hpp
@@ -0,0 +1,90 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_C_STR_HPP
+#define RANGES_V3_VIEW_C_STR_HPP
+
+#include <type_traits>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/delimit.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        struct is_char_type_ : std::false_type
+        {};
+
+        template<>
+        struct is_char_type_<char> : std::true_type
+        {};
+
+        template<>
+        struct is_char_type_<wchar_t> : std::true_type
+        {};
+
+        template<>
+        struct is_char_type_<char16_t> : std::true_type
+        {};
+
+        template<>
+        struct is_char_type_<char32_t> : std::true_type
+        {};
+
+        template<typename T>
+        using is_char_type = is_char_type_<meta::_t<std::remove_cv<T>>>;
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        /// View a `\0`-terminated C string (e.g. from a const char*) as a
+        /// range.
+        struct c_str_fn
+        {
+            // Fixed-length
+            template<typename Char, std::size_t N>
+            auto operator()(Char (&sz)[N]) const -> CPP_ret(ranges::subrange<Char *>)( //
+                requires detail::is_char_type<Char>::value)
+            {
+                return {&sz[0], &sz[N - 1]};
+            }
+
+            // Null-terminated
+            template<typename Char>
+            auto operator()(Char * sz) const volatile
+                -> CPP_ret(ranges::delimit_view<
+                           ranges::subrange<Char *, ranges::unreachable_sentinel_t>,
+                           meta::_t<std::remove_cv<Char>>>)( //
+                    requires detail::is_char_type<Char>::value)
+            {
+                using ch_t = meta::_t<std::remove_cv<Char>>;
+                return ranges::views::delimit(sz, ch_t(0));
+            }
+        };
+
+        /// \relates c_str_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(c_str_fn, c_str)
+    } // namespace views
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/cache1.hpp b/inst/include/range/v3/view/cache1.hpp
new file mode 100644
index 0000000..31fab13
--- /dev/null
+++ b/inst/include/range/v3/view/cache1.hpp
@@ -0,0 +1,194 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_CACHE1_HPP
+#define RANGES_V3_VIEW_CACHE1_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/detail/range_access.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct cache1_view : view_facade<cache1_view<Rng>, range_cardinality<Rng>::value>
+    {
+    private:
+        CPP_assert(view_<Rng>);
+        CPP_assert(input_range<Rng>);
+        CPP_assert(constructible_from<range_value_t<Rng>, range_reference_t<Rng>>);
+        friend range_access;
+        Rng rng_;
+        bool dirty_;
+        detail::non_propagating_cache<range_value_t<Rng>> cache_;
+
+        CPP_member
+        auto update_(range_reference_t<Rng> && val) -> CPP_ret(void)(
+            requires assignable_from<range_value_t<Rng> &, range_reference_t<Rng>>)
+        {
+            if(!cache_)
+                cache_.emplace(static_cast<range_reference_t<Rng> &&>(val));
+            else
+                *cache_ = static_cast<range_reference_t<Rng> &&>(val);
+        }
+        CPP_member
+        auto update_(range_reference_t<Rng> && val) -> CPP_ret(void)(
+            requires(!assignable_from<range_value_t<Rng> &, range_reference_t<Rng>>))
+        {
+            cache_.emplace(static_cast<range_reference_t<Rng> &&>(val));
+        }
+
+        struct cursor;
+
+        struct sentinel
+        {
+        private:
+            friend cursor;
+            sentinel_t<Rng> last_;
+
+        public:
+            sentinel() = default;
+            constexpr explicit sentinel(sentinel_t<Rng> last)
+              : last_(std::move(last))
+            {}
+        };
+
+        struct cursor
+        {
+        private:
+            cache1_view * parent_;
+            iterator_t<Rng> current_;
+
+        public:
+            using value_type = range_value_t<Rng>;
+            using single_pass = std::true_type;
+            using difference_type = range_difference_t<Rng>;
+
+            cursor() = default;
+
+            constexpr explicit cursor(cache1_view * parent, iterator_t<Rng> current)
+              : parent_(parent)
+              , current_(std::move(current))
+            {}
+            range_value_t<Rng> && read() const
+            {
+                if(parent_->dirty_)
+                {
+                    parent_->update_(*current_);
+                    parent_->dirty_ = false;
+                }
+                return std::move(*parent_->cache_);
+            }
+            void next()
+            {
+                ++current_;
+                parent_->dirty_ = true;
+            }
+            bool equal(cursor const & that) const
+            {
+                return current_ == that.current_;
+            }
+            bool equal(sentinel const & that) const
+            {
+                return current_ == that.last_;
+            }
+            CPP_member
+            auto distance_to(cursor const & that) const -> CPP_ret(difference_type)( //
+                requires sized_sentinel_for<iterator_t<Rng>, iterator_t<Rng>>)
+            {
+                return that.current_ - current_;
+            }
+            CPP_member
+            auto distance_to(sentinel const & that) const -> CPP_ret(difference_type)( //
+                requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
+            {
+                return that.last_ - current_;
+            }
+        };
+
+        cursor begin_cursor()
+        {
+            dirty_ = true;
+            return cursor{this, ranges::begin(rng_)};
+        }
+
+        cursor end_cursor_impl(std::true_type)
+        {
+            return cursor{this, ranges::end(rng_)};
+        }
+        sentinel end_cursor_impl(std::false_type)
+        {
+            return sentinel{ranges::end(rng_)};
+        }
+        auto end_cursor()
+        {
+            return end_cursor_impl(meta::bool_<(bool)common_range<Rng>>{});
+        }
+
+    public:
+        cache1_view() = default;
+        constexpr explicit cache1_view(Rng rng)
+          : rng_{std::move(rng)}
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(rng_);
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    cache1_view(Rng &&)->cache1_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct cache1_fn
+        {
+            /// \brief Caches the most recent element within the view so that
+            /// dereferencing the view's iterator multiple times doesn't incur any
+            /// recomputation. This can be useful in adaptor pipelines that include
+            /// combinations of \c view::filter and \c view::transform, for instance.
+            /// \note \c views::cache1 is always single-pass.
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng) const //
+                -> CPP_ret(cache1_view<all_t<Rng>>)(    //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        constructible_from<range_value_t<Rng>, range_reference_t<Rng>>)
+            {
+                return cache1_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        /// \relates cache1_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<cache1_fn>, cache1)
+    } // namespace views
+
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::cache1_view)
+
+#endif
diff --git a/inst/include/range/v3/view/cartesian_product.hpp b/inst/include/range/v3/view/cartesian_product.hpp
new file mode 100644
index 0000000..8f7ea7f
--- /dev/null
+++ b/inst/include/range/v3/view/cartesian_product.hpp
@@ -0,0 +1,446 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-2014.
+//  Copyright Casey Carter 2017.
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_CARTESIAN_PRODUCT_HPP
+#define RANGES_V3_VIEW_CARTESIAN_PRODUCT_HPP
+
+#include <cstdint>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/tuple_algorithm.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/empty.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/view.hpp> // for dereference_fn
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename State, typename Value>
+        using product_cardinality = std::integral_constant<
+            cardinality,
+            State::value == 0 || Value::value == 0
+                ? static_cast<cardinality>(0)
+                : State::value == unknown || Value::value == unknown
+                      ? unknown
+                      : State::value == infinite || Value::value == infinite
+                            ? infinite
+                            : State::value == finite || Value::value == finite
+                                  ? finite
+                                  : static_cast<cardinality>(
+                                        State::value * Value::value)>;
+
+        struct cartesian_size_fn
+        {
+            template<typename Size, typename Rng>
+            auto operator()(Size s, Rng && rng) const
+                -> CPP_ret(common_type_t<Size, range_size_t<Rng>>)( //
+                    requires integer_like_<Size> && sized_range<Rng> &&
+                        common_with<Size, range_size_t<Rng>>)
+            {
+                using S = common_type_t<Size, range_size_t<Rng>>;
+                return static_cast<S>(s) * static_cast<S>(ranges::size(rng));
+            }
+        };
+
+        template<typename... Views>
+        using cartesian_product_cardinality =
+            meta::fold<meta::list<range_cardinality<Views>...>,
+                       std::integral_constant<cardinality, static_cast<cardinality>(
+                                                               (sizeof...(Views) > 0))>,
+                       meta::quote<detail::product_cardinality>>;
+    } // namespace detail
+      /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename...Views)
+        (concept cartesian_produce_view_can_const)(Views...),
+            and_v<range<Views const>...>
+    );
+    CPP_def
+    (
+        template(typename IsConst, typename...Views)
+        (concept cartesian_produce_view_can_size)(IsConst, Views...),
+            and_v<sized_range<meta::const_if<IsConst, Views>>...> &&
+                ranges::type<common_type_t<std::uintmax_t, range_size_t<meta::const_if<IsConst, Views>>...>>
+    );
+    CPP_def
+    (
+        template(typename IsConst, typename...Views)
+        (concept cartesian_produce_view_can_distance)(IsConst, Views...),
+            cartesian_produce_view_can_size<IsConst, Views...> &&
+            and_v<sized_sentinel_for<
+                iterator_t<meta::const_if<IsConst, Views>>,
+                iterator_t<meta::const_if<IsConst, Views>>>...>
+    );
+    CPP_def
+    (
+        template(typename IsConst, typename...Views)
+        (concept cartesian_produce_view_can_random)(IsConst, Views...),
+            cartesian_produce_view_can_distance<IsConst, Views...> &&
+            and_v<random_access_iterator<iterator_t<
+                meta::const_if<IsConst, Views>>>...>
+    );
+    CPP_def
+    (
+        template(typename IsConst, typename...Views)
+        (concept cartesian_produce_view_can_bidi)(IsConst, Views...),
+            cartesian_produce_view_can_random<IsConst, Views...> ||
+            and_v<common_range<meta::const_if<IsConst, Views>>...,
+                bidirectional_iterator<iterator_t<
+                    meta::const_if<IsConst, Views>>>...>
+    );
+    // clang-format on
+
+    template<typename... Views>
+    struct cartesian_product_view
+      : view_facade<cartesian_product_view<Views...>,
+                    detail::cartesian_product_cardinality<Views...>::value>
+    {
+    private:
+        friend range_access;
+        CPP_assert(and_v<(forward_range<Views> && view_<Views>)...>);
+        CPP_assert(sizeof...(Views) != 0);
+
+        static constexpr auto my_cardinality =
+            detail::cartesian_product_cardinality<Views...>::value;
+
+        std::tuple<Views...> views_;
+
+        template<bool IsConst_>
+        struct cursor
+        {
+        private:
+            using IsConst = meta::bool_<IsConst_>;
+            friend cursor<true>;
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst_, T>;
+            using difference_type =
+                common_type_t<std::intmax_t, range_difference_t<Views>...>;
+
+            constify_if<cartesian_product_view> * view_;
+            std::tuple<iterator_t<constify_if<Views>>...> its_;
+
+            void next_(meta::size_t<1>)
+            {
+                auto & v = std::get<0>(view_->views_);
+                auto & i = std::get<0>(its_);
+                auto const last = ranges::end(v);
+                RANGES_EXPECT(i != last);
+                ++i;
+            }
+            template<std::size_t N>
+            void next_(meta::size_t<N>)
+            {
+                auto & v = std::get<N - 1>(view_->views_);
+                auto & i = std::get<N - 1>(its_);
+                auto const last = ranges::end(v);
+                RANGES_EXPECT(i != last);
+                if(++i == last)
+                {
+                    i = ranges::begin(v);
+                    next_(meta::size_t<N - 1>{});
+                }
+            }
+            void prev_(meta::size_t<0>)
+            {
+                RANGES_EXPECT(false);
+            }
+            template<std::size_t N>
+            void prev_(meta::size_t<N>)
+            {
+                auto & v = std::get<N - 1>(view_->views_);
+                auto & i = std::get<N - 1>(its_);
+                if(i == ranges::begin(v))
+                {
+                    CPP_assert(cartesian_produce_view_can_bidi<IsConst, Views...>);
+                    // cartesian_produce_view_can_bidi<IsConst, Views...> implies this
+                    // advance call is O(1)
+                    ranges::advance(i, ranges::end(v));
+                    prev_(meta::size_t<N - 1>{});
+                }
+                --i;
+            }
+            bool equal_(cursor const &, meta::size_t<0>) const
+            {
+                return true;
+            }
+            template<std::size_t N>
+            bool equal_(cursor const & that, meta::size_t<N>) const
+            {
+                return std::get<N - 1>(its_) == std::get<N - 1>(that.its_) &&
+                       equal_(that, meta::size_t<N - 1>{});
+            }
+            difference_type distance_(cursor const & that, meta::size_t<1>) const
+            {
+                return difference_type{std::get<0>(that.its_) - std::get<0>(its_)};
+            }
+            template<std::size_t N>
+            difference_type distance_(cursor const & that, meta::size_t<N>) const
+            {
+                difference_type const d = distance_(that, meta::size_t<N - 1>{});
+                auto const scale = ranges::distance(std::get<N - 1>(view_->views_));
+                auto const increment = std::get<N - 1>(that.its_) - std::get<N - 1>(its_);
+                return difference_type{d * scale + increment};
+            }
+            void advance_(meta::size_t<0>, difference_type)
+            {
+                RANGES_EXPECT(false);
+            }
+            RANGES_DIAGNOSTIC_PUSH
+            RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO
+            template<std::size_t N>
+            void advance_(meta::size_t<N>, difference_type n)
+            {
+                if(n == 0)
+                    return;
+
+                auto & i = std::get<N - 1>(its_);
+                auto const my_size = static_cast<difference_type>(
+                    ranges::size(std::get<N - 1>(view_->views_)));
+                auto const first = ranges::begin(std::get<N - 1>(view_->views_));
+
+                auto const idx = static_cast<difference_type>(i - first);
+                RANGES_EXPECT(0 <= idx);
+                RANGES_EXPECT(idx < my_size || (N == 1 && idx == my_size && n < 0));
+                RANGES_EXPECT(n < INTMAX_MAX - idx);
+                n += idx;
+
+                auto n_div = n / my_size;
+                auto n_mod = n % my_size;
+
+                if(RANGES_CONSTEXPR_IF(N != 1))
+                {
+                    if(n_mod < 0)
+                    {
+                        n_mod += my_size;
+                        --n_div;
+                    }
+                    advance_(meta::size_t<N - 1>{}, n_div);
+                }
+                RANGES_EXPECT(0 <= n_mod && n_mod < my_size);
+
+                if(RANGES_CONSTEXPR_IF(N == 1))
+                {
+                    if(n_div > 0)
+                    {
+                        RANGES_EXPECT(n_div == 1);
+                        RANGES_EXPECT(n_mod == 0);
+                        n_mod = my_size;
+                    }
+                    else if(n_div < 0)
+                    {
+                        RANGES_EXPECT(n_div == -1);
+                        RANGES_EXPECT(n_mod == 0);
+                    }
+                }
+
+                using D = iter_difference_t<decltype(first)>;
+                i = first + static_cast<D>(n_mod);
+            }
+            RANGES_DIAGNOSTIC_POP
+            void check_at_end_(meta::size_t<1>, bool at_end = false)
+            {
+                if(at_end)
+                    ranges::advance(std::get<0>(its_),
+                                    ranges::end(std::get<0>(view_->views_)));
+            }
+            template<std::size_t N>
+            void check_at_end_(meta::size_t<N>, bool at_end = false)
+            {
+                return check_at_end_(
+                    meta::size_t<N - 1>{},
+                    at_end || bool(std::get<N - 1>(its_) ==
+                                   ranges::end(std::get<N - 1>(view_->views_))));
+            }
+            cursor(end_tag, constify_if<cartesian_product_view> * view,
+                   std::true_type) // common_with
+              : cursor(begin_tag{}, view)
+            {
+                CPP_assert(
+                    common_range<meta::at_c<meta::list<constify_if<Views>...>, 0>>);
+                std::get<0>(its_) = ranges::end(std::get<0>(view->views_));
+            }
+            cursor(end_tag, constify_if<cartesian_product_view> * view,
+                   std::false_type) // !common_with
+              : cursor(begin_tag{}, view)
+            {
+                using View0 = meta::at_c<meta::list<constify_if<Views>...>, 0>;
+                CPP_assert(!common_range<View0> && random_access_range<View0> &&
+                           sized_range<View0>);
+                std::get<0>(its_) += ranges::distance(std::get<0>(view->views_));
+            }
+
+        public:
+            using value_type = std::tuple<range_value_t<Views>...>;
+
+            cursor() = default;
+            explicit cursor(begin_tag, constify_if<cartesian_product_view> * view)
+              : view_(view)
+              , its_(tuple_transform(view->views_, ranges::begin))
+            {
+                // If any of the constituent views is empty, the cartesian_product is
+                // empty and this "begin" iterator needs to become an "end" iterator.
+                check_at_end_(meta::size_t<sizeof...(Views)>{});
+            }
+            explicit cursor(end_tag, constify_if<cartesian_product_view> * view)
+              : cursor(
+                    end_tag{}, view,
+                    meta::bool_<
+                        common_range<meta::at_c<meta::list<constify_if<Views>...>, 0>>>{})
+            {}
+            CPP_template(bool Other)( //
+                requires IsConst_ && (!Other)) cursor(cursor<Other> that)
+              : view_(that.view_)
+              , its_(std::move(that.its_))
+            {}
+            common_tuple<range_reference_t<constify_if<Views>>...> read() const
+            {
+                return tuple_transform(its_, detail::dereference_fn{});
+            }
+            void next()
+            {
+                next_(meta::size_t<sizeof...(Views)>{});
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return std::get<0>(its_) == ranges::end(std::get<0>(view_->views_));
+            }
+            bool equal(cursor const & that) const
+            {
+                return equal_(that, meta::size_t<sizeof...(Views)>{});
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires cartesian_produce_view_can_bidi<IsConst, Views...>)
+            {
+                prev_(meta::size_t<sizeof...(Views)>{});
+            }
+            CPP_member
+            auto CPP_fun(distance_to)(cursor const & that)(
+                const requires cartesian_produce_view_can_distance<IsConst, Views...>)
+            {
+                return distance_(that, meta::size_t<sizeof...(Views)>{});
+            }
+            CPP_member
+            auto advance(difference_type n) -> CPP_ret(void)( //
+                requires cartesian_produce_view_can_random<IsConst, Views...>)
+            {
+                advance_(meta::size_t<sizeof...(Views)>{}, n);
+            }
+        };
+        cursor<false> begin_cursor()
+        {
+            return cursor<false>{begin_tag{}, this};
+        }
+        CPP_member
+        auto begin_cursor() const -> CPP_ret(cursor<true>)( //
+            requires cartesian_produce_view_can_const<Views...>)
+        {
+            return cursor<true>{begin_tag{}, this};
+        }
+        CPP_member
+        auto end_cursor() -> CPP_ret(cursor<false>)( //
+            requires cartesian_produce_view_can_bidi<std::false_type, Views...>)
+        {
+            return cursor<false>{end_tag{}, this};
+        }
+        CPP_member
+        auto end_cursor() const -> CPP_ret(cursor<true>)( //
+            requires cartesian_produce_view_can_bidi<std::true_type, Views...>)
+        {
+            return cursor<true>{end_tag{}, this};
+        }
+        CPP_member
+        auto end_cursor() const -> CPP_ret(default_sentinel_t)( //
+            requires(!cartesian_produce_view_can_bidi<std::true_type, Views...>))
+        {
+            return {};
+        }
+
+    public:
+        cartesian_product_view() = default;
+        explicit constexpr cartesian_product_view(Views... views)
+          : views_{detail::move(views)...}
+        {}
+        CPP_template(int = 42)(            //
+            requires(my_cardinality >= 0)) //
+            static constexpr std::size_t size() noexcept
+        {
+            return std::size_t{my_cardinality};
+        }
+        CPP_member
+        auto CPP_fun(size)()(const //
+                             requires(my_cardinality < 0) &&
+                             cartesian_produce_view_can_size<std::true_type, Views...>)
+        {
+            return tuple_foldl(views_, std::uintmax_t{1}, detail::cartesian_size_fn{});
+        }
+        CPP_member
+        auto CPP_fun(size)()(requires(my_cardinality < 0) &&
+                             cartesian_produce_view_can_size<std::false_type, Views...>)
+        {
+            return tuple_foldl(views_, std::uintmax_t{1}, detail::cartesian_size_fn{});
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename... Rng>
+    cartesian_product_view(Rng &&...)->cartesian_product_view<views::all_t<Rng>...>;
+#endif
+
+    namespace views
+    {
+        struct cartesian_product_fn
+        {
+            template<typename... Rngs>
+            constexpr auto operator()(Rngs &&... rngs) const
+                -> CPP_ret(cartesian_product_view<all_t<Rngs>...>)( //
+                    requires(sizeof...(Rngs) != 0) &&
+                    concepts::and_v<(forward_range<Rngs> && viewable_range<Rngs>)...>)
+            {
+                return cartesian_product_view<all_t<Rngs>...>{
+                    all(static_cast<Rngs &&>(rngs))...};
+            }
+
+            constexpr empty_view<std::tuple<>> operator()() const noexcept
+            {
+                return {};
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(cartesian_product_fn, cartesian_product)
+    } // namespace views
+
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/chunk.hpp b/inst/include/range/v3/view/chunk.hpp
new file mode 100644
index 0000000..b397d95
--- /dev/null
+++ b/inst/include/range/v3/view/chunk.hpp
@@ -0,0 +1,444 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_CHUNK_HPP
+#define RANGES_V3_VIEW_CHUNK_HPP
+
+#include <limits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/optional.hpp> // for non_propagating_cache
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/take.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng, bool Const>
+        constexpr bool can_sized_sentinel_() noexcept
+        {
+            using I = iterator_t<meta::const_if_c<Const, Rng>>;
+            return (bool)sized_sentinel_for<I, I>;
+        }
+
+        template<typename T>
+        struct zero
+        {
+            zero() = default;
+            constexpr explicit zero(T const &) noexcept
+            {}
+            constexpr zero & operator=(T const &) noexcept
+            {
+                return *this;
+            }
+            constexpr zero const & operator=(T const &) const noexcept
+            {
+                return *this;
+            }
+            constexpr operator T() const
+            {
+                return T(0);
+            }
+            constexpr T exchange(T const &) const
+            {
+                return T(0);
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, bool IsForwardRange>
+    struct chunk_view_
+      : view_adaptor<chunk_view_<Rng, IsForwardRange>, Rng,
+                     is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+    {
+    private:
+        friend range_access;
+        CPP_assert(forward_range<Rng>);
+
+        template<bool Const>
+        using offset_t =
+            meta::if_c<bidirectional_range<meta::const_if_c<Const, Rng>> ||
+                           detail::can_sized_sentinel_<Rng, Const>(),
+                       range_difference_t<Rng>, detail::zero<range_difference_t<Rng>>>;
+
+        range_difference_t<Rng> n_ = 0;
+
+        template<bool Const>
+        struct RANGES_EMPTY_BASES adaptor
+          : adaptor_base
+          , private box<offset_t<Const>>
+        {
+        private:
+            friend adaptor<!Const>;
+            using CRng = meta::const_if_c<Const, Rng>;
+
+            range_difference_t<CRng> n_;
+            sentinel_t<CRng> end_;
+
+            constexpr offset_t<Const> const & offset() const
+            {
+                offset_t<Const> const & result = this->box<offset_t<Const>>::get();
+                RANGES_EXPECT(0 <= result && result < n_);
+                return result;
+            }
+            constexpr offset_t<Const> & offset()
+            {
+                return const_cast<offset_t<Const> &>(
+                    const_cast<adaptor const &>(*this).offset());
+            }
+
+        public:
+            adaptor() = default;
+            constexpr adaptor(meta::const_if_c<Const, chunk_view_> * cv)
+              : box<offset_t<Const>>{0}
+              , n_((RANGES_EXPECT(0 < cv->n_), cv->n_))
+              , end_(ranges::end(cv->base()))
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) constexpr adaptor(adaptor<Other> that)
+              : box<offset_t<Const>>(that.offset())
+              , n_(that.n_)
+              , end_(that.end_)
+            {}
+            constexpr auto read(iterator_t<CRng> const & it) const
+                -> decltype(views::take(make_subrange(it, end_), n_))
+            {
+                RANGES_EXPECT(it != end_);
+                RANGES_EXPECT(0 == offset());
+                return views::take(make_subrange(it, end_), n_);
+            }
+            constexpr void next(iterator_t<CRng> & it)
+            {
+                RANGES_EXPECT(it != end_);
+                RANGES_EXPECT(0 == offset());
+                offset() = ranges::advance(it, n_, end_);
+            }
+            CPP_member
+            constexpr auto prev(iterator_t<CRng> & it) -> CPP_ret(void)( //
+                requires bidirectional_range<CRng>)
+            {
+                ranges::advance(it, -n_ + offset());
+                offset() = 0;
+            }
+            CPP_member
+            constexpr auto distance_to(iterator_t<CRng> const & here,
+                                       iterator_t<CRng> const & there,
+                                       adaptor const & that) const
+                -> CPP_ret(range_difference_t<Rng>)( //
+                    requires(detail::can_sized_sentinel_<Rng, Const>()))
+            {
+                auto const delta = (there - here) + (that.offset() - offset());
+                // This can fail for cyclic base ranges when the chunk size does not
+                // divide the cycle length. Such iterator pairs are NOT in the domain of
+                // -.
+                RANGES_ENSURE(0 == delta % n_);
+                return delta / n_;
+            }
+            CPP_member
+            constexpr auto advance(iterator_t<CRng> & it,
+                                   range_difference_t<Rng> n) -> CPP_ret(void)( //
+                requires random_access_range<CRng>)
+            {
+                using Limits = std::numeric_limits<range_difference_t<CRng>>;
+                if(0 < n)
+                {
+                    RANGES_EXPECT(0 == offset());
+                    RANGES_EXPECT(n <= Limits::max() / n_);
+                    auto const remainder = ranges::advance(it, n * n_, end_) % n_;
+                    RANGES_EXPECT(0 <= remainder && remainder < n_);
+                    offset() = remainder;
+                }
+                else if(0 > n)
+                {
+                    RANGES_EXPECT(n >= Limits::min() / n_);
+                    ranges::advance(it, n * n_ + offset());
+                    offset() = 0;
+                }
+            }
+        };
+
+        constexpr adaptor<simple_view<Rng>()> begin_adaptor()
+        {
+            return adaptor<simple_view<Rng>()>{this};
+        }
+        CPP_member
+        constexpr auto begin_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires forward_range<Rng const>)
+        {
+            return adaptor<true>{this};
+        }
+        template<typename Size>
+        constexpr Size size_(Size base_size) const
+        {
+            auto const n = static_cast<Size>(n_);
+            return base_size / n + (0 != (base_size % n));
+        }
+
+    public:
+        chunk_view_() = default;
+        constexpr chunk_view_(Rng rng, range_difference_t<Rng> n)
+          : chunk_view_::view_adaptor(detail::move(rng))
+          , n_((RANGES_EXPECT(0 < n), n))
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return size_(ranges::size(this->base()));
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return size_(ranges::size(this->base()));
+        }
+    };
+
+    template<typename Rng>
+    struct chunk_view_<Rng, false>
+      : view_facade<chunk_view_<Rng, false>,
+                    is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+    {
+    private:
+        friend range_access;
+        CPP_assert(input_range<Rng> && !forward_range<Rng>);
+
+        using iter_cache_t = detail::non_propagating_cache<iterator_t<Rng>>;
+
+        Rng base_;
+        range_difference_t<Rng> n_;
+        range_difference_t<Rng> remainder_;
+        mutable iter_cache_t it_cache_;
+
+        constexpr iterator_t<Rng> & it() noexcept
+        {
+            return *it_cache_;
+        }
+        constexpr iterator_t<Rng> const & it() const noexcept
+        {
+            return *it_cache_;
+        }
+
+        struct outer_cursor
+        {
+        private:
+            struct inner_view : view_facade<inner_view, finite>
+            {
+            private:
+                friend range_access;
+
+                using value_type = range_value_t<Rng>;
+
+                chunk_view_ * rng_ = nullptr;
+
+                constexpr bool done() const noexcept
+                {
+                    RANGES_EXPECT(rng_);
+                    return rng_->remainder_ == 0;
+                }
+                constexpr bool equal(default_sentinel_t) const noexcept
+                {
+                    return done();
+                }
+                constexpr iter_reference_t<iterator_t<Rng>> read() const
+                {
+                    RANGES_EXPECT(!done());
+                    return *rng_->it();
+                }
+                constexpr iter_rvalue_reference_t<iterator_t<Rng>> move() const
+                {
+                    RANGES_EXPECT(!done());
+                    return ranges::iter_move(rng_->it());
+                }
+                constexpr void next()
+                {
+                    RANGES_EXPECT(!done());
+                    ++rng_->it();
+                    --rng_->remainder_;
+                    if(rng_->remainder_ != 0 && rng_->it() == ranges::end(rng_->base_))
+                        rng_->remainder_ = 0;
+                }
+                CPP_member
+                constexpr auto distance_to(default_sentinel_t) const
+                    -> CPP_ret(range_difference_t<Rng>)( //
+                        requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
+                {
+                    RANGES_EXPECT(rng_);
+                    auto const d = ranges::end(rng_->base_) - rng_->it();
+                    return ranges::min(d, rng_->remainder_);
+                }
+
+            public:
+                inner_view() = default;
+                constexpr explicit inner_view(chunk_view_ & view) noexcept
+                  : rng_{&view}
+                {}
+                CPP_member
+                constexpr auto CPP_fun(size)()(
+                    requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
+                {
+                    using size_type = detail::iter_size_t<iterator_t<Rng>>;
+                    return static_cast<size_type>(distance_to(default_sentinel_t{}));
+                }
+            };
+
+            chunk_view_ * rng_ = nullptr;
+
+        public:
+            using value_type = inner_view;
+
+            outer_cursor() = default;
+            constexpr explicit outer_cursor(chunk_view_ * view) noexcept
+              : rng_{view}
+            {}
+            constexpr inner_view read() const
+            {
+                RANGES_EXPECT(!done());
+                return inner_view{*rng_};
+            }
+            constexpr bool done() const
+            {
+                RANGES_EXPECT(rng_);
+                return rng_->it() == ranges::end(rng_->base_) && rng_->remainder_ != 0;
+            }
+            constexpr bool equal(default_sentinel_t) const
+            {
+                return done();
+            }
+            constexpr void next()
+            {
+                RANGES_EXPECT(!done());
+                ranges::advance(rng_->it(), rng_->remainder_, ranges::end(rng_->base_));
+                rng_->remainder_ = rng_->n_;
+            }
+            CPP_member
+            constexpr auto distance_to(default_sentinel_t) const
+                -> CPP_ret(range_difference_t<Rng>)( //
+                    requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
+            {
+                RANGES_EXPECT(rng_);
+                auto d = ranges::end(rng_->base_) - rng_->it();
+                if(d < rng_->remainder_)
+                    return 1;
+
+                d -= rng_->remainder_;
+                d = (d + rng_->n_ - 1) / rng_->n_;
+                d += (rng_->remainder_ != 0);
+                return d;
+            }
+        };
+
+        constexpr outer_cursor begin_cursor() noexcept
+        {
+            it_cache_ = ranges::begin(base_);
+            return outer_cursor{this};
+        }
+        template<typename Size>
+        constexpr Size size_(Size base_size) const
+        {
+            auto const n = static_cast<Size>(this->n_);
+            return base_size / n + (0 != base_size % n);
+        }
+
+    public:
+        chunk_view_() = default;
+        constexpr chunk_view_(Rng rng, range_difference_t<Rng> n)
+          : base_(detail::move(rng))
+          , n_((RANGES_EXPECT(0 < n), n))
+          , remainder_(n)
+          , it_cache_{nullopt}
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return size_(ranges::size(base_));
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return size_(ranges::size(base_));
+        }
+        Rng base() const
+        {
+            return base_;
+        }
+    };
+
+    template<typename Rng>
+    struct chunk_view : chunk_view_<Rng, (bool)forward_range<Rng>>
+    {
+        using chunk_view::chunk_view_::chunk_view_;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    chunk_view(Rng &&, range_difference_t<Rng>)->chunk_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        // In:  range<T>
+        // Out: range<range<T>>, where each inner range has $n$ elements.
+        //                       The last range may have fewer.
+        struct chunk_base_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng, range_difference_t<Rng> n) const
+                -> CPP_ret(chunk_view<all_t<Rng>>)( //
+                    requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return {all(static_cast<Rng &&>(rng)), n};
+            }
+        };
+
+        struct chunk_fn : chunk_base_fn
+        {
+            using chunk_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(chunk_base_fn{}, n));
+            }
+        };
+
+        /// \relates chunk_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(chunk_fn, chunk)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::chunk_view)
+
+#endif
diff --git a/inst/include/range/v3/view/common.hpp b/inst/include/range/v3/view/common.hpp
new file mode 100644
index 0000000..5bc64c9
--- /dev/null
+++ b/inst/include/range/v3/view/common.hpp
@@ -0,0 +1,228 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_COMMON_HPP
+#define RANGES_V3_VIEW_COMMON_HPP
+
+#include <type_traits>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/common_iterator.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        // clang-format off
+        CPP_def
+        (
+            template(typename R)
+            concept random_access_and_sized_range,
+                random_access_range<R> && sized_range<R>
+        );
+        // clang-format on
+
+        template<typename R>
+        using common_view_iterator_t =
+            meta::if_c<random_access_and_sized_range<R>, iterator_t<R>,
+                       common_iterator_t<iterator_t<R>, sentinel_t<R>>>;
+
+        template<typename Rng>
+        struct is_common_range : meta::bool_<common_range<Rng>>
+        {};
+    } // namespace detail
+    /// \endcond
+
+    template<typename Rng, bool = detail::is_common_range<Rng>::value>
+    struct common_view : view_interface<common_view<Rng>, range_cardinality<Rng>::value>
+    {
+    private:
+        CPP_assert(view_<Rng>);
+        CPP_assert(!(common_range<Rng> && view_<Rng>));
+        Rng rng_;
+
+        sentinel_t<Rng> end_(std::false_type)
+        {
+            return ranges::end(rng_);
+        }
+        iterator_t<Rng> end_(std::true_type)
+        {
+            return ranges::begin(rng_) + ranges::distance(rng_);
+        }
+        template<bool Const = true>
+        auto end_(std::false_type) const
+            -> CPP_ret(sentinel_t<meta::const_if_c<Const, Rng>>)( //
+                requires Const && range<meta::const_if_c<Const, Rng>>)
+        {
+            return ranges::end(rng_);
+        }
+        template<bool Const = true>
+        auto end_(std::true_type) const
+            -> CPP_ret(iterator_t<meta::const_if_c<Const, Rng>>)( //
+                requires Const && range<meta::const_if_c<Const, Rng>>)
+        {
+            return ranges::begin(rng_) + ranges::distance(rng_);
+        }
+
+    public:
+        common_view() = default;
+        explicit common_view(Rng rng)
+          : rng_(detail::move(rng))
+        {}
+        Rng base() const
+        {
+            return rng_;
+        }
+
+        detail::common_view_iterator_t<Rng> begin()
+        {
+            return detail::common_view_iterator_t<Rng>{ranges::begin(rng_)};
+        }
+        detail::common_view_iterator_t<Rng> end()
+        {
+            return detail::common_view_iterator_t<Rng>{
+                end_(meta::bool_<detail::random_access_and_sized_range<Rng>>{})};
+        }
+        CPP_member
+        auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(rng_);
+        }
+
+        template<bool Const = true>
+        auto begin() const
+            -> CPP_ret(detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>)( //
+                requires range<meta::const_if_c<Const, Rng>>)
+        {
+            return detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>{
+                ranges::begin(rng_)};
+        }
+        template<bool Const = true>
+        auto end() const
+            -> CPP_ret(detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>)( //
+                requires range<meta::const_if_c<Const, Rng>>)
+        {
+            return detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>{
+                end_(meta::bool_<detail::random_access_and_sized_range<
+                         meta::const_if_c<Const, Rng>>>{})};
+        }
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(rng_);
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng)(       //
+        requires(!common_range<Rng>)) //
+        common_view(Rng &&)
+            ->common_view<views::all_t<Rng>>;
+#endif
+
+    template<typename Rng>
+    struct common_view<Rng, true> : identity_adaptor<Rng>
+    {
+        CPP_assert(common_range<Rng>);
+        using identity_adaptor<Rng>::identity_adaptor;
+    };
+
+    namespace views
+    {
+        struct cpp20_common_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(all_t<Rng>)( //
+                requires viewable_range<Rng> && common_range<Rng>)
+            {
+                return all(static_cast<Rng &&>(rng));
+            }
+
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(common_view<all_t<Rng>>)( //
+                requires viewable_range<Rng> && (!common_range<Rng>))
+            {
+                return common_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        struct common_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(common_view<all_t<Rng>>)( //
+                requires viewable_range<Rng>)
+            {
+                return common_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        /// \relates common_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<common_fn>, common)
+    } // namespace views
+    /// @}
+
+    /// \cond
+    template<typename Rng>
+    using bounded_view RANGES_DEPRECATED(
+        "The name bounded_view is deprecated. "
+        "Please use common_view instead.") = common_view<Rng>;
+    /// \endcond
+
+    namespace views
+    {
+        /// \cond
+        namespace
+        {
+            RANGES_DEPRECATED(
+                "The name views::bounded is deprecated. "
+                "Please use views::common instead.")
+            RANGES_INLINE_VAR constexpr auto & bounded = common;
+        } // namespace
+
+        template<typename Rng>
+        using bounded_t RANGES_DEPRECATED("The name views::bounded_t is deprecated.") =
+            decltype(common(std::declval<Rng>()));
+        /// \endcond
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            RANGES_INLINE_VARIABLE(
+                ranges::views::view_closure<ranges::views::cpp20_common_fn>, common)
+        }
+        CPP_template(typename Rng)(                      //
+            requires view_<Rng> && (!common_range<Rng>)) //
+            using common_view = ranges::common_view<Rng>;
+    } // namespace cpp20
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::common_view)
+
+#endif
diff --git a/inst/include/range/v3/view/concat.hpp b/inst/include/range/v3/view/concat.hpp
new file mode 100644
index 0000000..e5d4560
--- /dev/null
+++ b/inst/include/range/v3/view/concat.hpp
@@ -0,0 +1,415 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-2014.
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_CONCAT_HPP
+#define RANGES_V3_VIEW_CONCAT_HPP
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/tuple_algorithm.hpp>
+#include <range/v3/utility/variant.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename State, typename Value>
+        using concat_cardinality_ = std::integral_constant<
+            cardinality,
+            State::value == infinite || Value::value == infinite
+                ? infinite
+                : State::value == unknown || Value::value == unknown
+                      ? unknown
+                      : State::value == finite || Value::value == finite
+                            ? finite
+                            : static_cast<cardinality>(State::value + Value::value)>;
+
+        template<typename... Rngs>
+        using concat_cardinality =
+            meta::fold<meta::list<range_cardinality<Rngs>...>,
+                       std::integral_constant<cardinality, static_cast<cardinality>(0)>,
+                       meta::quote<concat_cardinality_>>;
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename... Rngs>
+    struct concat_view
+      : view_facade<concat_view<Rngs...>, detail::concat_cardinality<Rngs...>::value>
+    {
+    private:
+        friend range_access;
+        using difference_type_ = common_type_t<range_difference_t<Rngs>...>;
+        static constexpr std::size_t cranges{sizeof...(Rngs)};
+        std::tuple<Rngs...> rngs_;
+
+        template<bool IsConst>
+        struct cursor;
+
+        template<bool IsConst>
+        struct sentinel
+        {
+        private:
+            friend struct sentinel<!IsConst>;
+            friend struct cursor<IsConst>;
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst, T>;
+            using concat_view_t = constify_if<concat_view>;
+            sentinel_t<constify_if<meta::back<meta::list<Rngs...>>>> end_;
+
+        public:
+            sentinel() = default;
+            sentinel(concat_view_t * rng, end_tag)
+              : end_(end(std::get<cranges - 1>(rng->rngs_)))
+            {}
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other)) sentinel(sentinel<Other> that)
+              : end_(std::move(that.end_))
+            {}
+        };
+
+        template<bool IsConst>
+        struct cursor
+        {
+            using difference_type = common_type_t<range_difference_t<Rngs>...>;
+
+        private:
+            friend struct cursor<!IsConst>;
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst, T>;
+            using concat_view_t = constify_if<concat_view>;
+            concat_view_t * rng_;
+            variant<iterator_t<constify_if<Rngs>>...> its_;
+
+            template<std::size_t N>
+            void satisfy(meta::size_t<N>)
+            {
+                RANGES_EXPECT(its_.index() == N);
+                if(ranges::get<N>(its_) == end(std::get<N>(rng_->rngs_)))
+                {
+                    ranges::emplace<N + 1>(its_, begin(std::get<N + 1>(rng_->rngs_)));
+                    this->satisfy(meta::size_t<N + 1>{});
+                }
+            }
+            void satisfy(meta::size_t<cranges - 1>)
+            {
+                RANGES_EXPECT(its_.index() == cranges - 1);
+            }
+            struct next_fun
+            {
+                cursor * pos;
+                template<typename I, std::size_t N>
+                auto operator()(indexed_element<I, N> it) const -> CPP_ret(void)( //
+                    requires input_iterator<I>)
+                {
+                    RANGES_ASSERT(it.get() != end(std::get<N>(pos->rng_->rngs_)));
+                    ++it.get();
+                    pos->satisfy(meta::size_t<N>{});
+                }
+            };
+            struct prev_fun
+            {
+                cursor * pos;
+                template<typename I>
+                auto operator()(indexed_element<I, 0> it) const -> CPP_ret(void)( //
+                    requires bidirectional_iterator<I>)
+                {
+                    RANGES_ASSERT(it.get() != begin(std::get<0>(pos->rng_->rngs_)));
+                    --it.get();
+                }
+                template<typename I, std::size_t N>
+                auto operator()(indexed_element<I, N> it) const -> CPP_ret(void)( //
+                    requires(N != 0) && bidirectional_iterator<I>)
+                {
+                    if(it.get() == begin(std::get<N>(pos->rng_->rngs_)))
+                    {
+                        auto && rng = std::get<N - 1>(pos->rng_->rngs_);
+                        ranges::emplace<N - 1>(
+                            pos->its_,
+                            ranges::next(ranges::begin(rng), ranges::end(rng)));
+                        pos->its_.visit_i(*this);
+                    }
+                    else
+                        --it.get();
+                }
+            };
+            struct advance_fwd_fun
+            {
+                cursor * pos;
+                difference_type n;
+                template<typename I>
+                auto operator()(indexed_element<I, cranges - 1> it) const
+                    -> CPP_ret(void)( //
+                        requires random_access_iterator<I>)
+                {
+                    ranges::advance(it.get(), n);
+                }
+                template<typename I, std::size_t N>
+                auto operator()(indexed_element<I, N> it) const -> CPP_ret(void)( //
+                    requires random_access_iterator<I>)
+                {
+                    auto last = ranges::end(std::get<N>(pos->rng_->rngs_));
+                    // BUGBUG If distance(it, last) > n, then using bounded advance
+                    // is O(n) when it need not be since the last iterator position
+                    // is actually not interesting. Only the "rest" is needed, which
+                    // can sometimes be O(1).
+                    auto rest = ranges::advance(it.get(), n, std::move(last));
+                    pos->satisfy(meta::size_t<N>{});
+                    if(rest != 0)
+                        pos->its_.visit_i(advance_fwd_fun{pos, rest});
+                }
+            };
+            struct advance_rev_fun
+            {
+                cursor * pos;
+                difference_type n;
+                template<typename I>
+                auto operator()(indexed_element<I, 0> it) const -> CPP_ret(void)( //
+                    requires random_access_iterator<I>)
+                {
+                    ranges::advance(it.get(), n);
+                }
+                template<typename I, std::size_t N>
+                auto operator()(indexed_element<I, N> it) const -> CPP_ret(void)( //
+                    requires random_access_iterator<I>)
+                {
+                    auto first = ranges::begin(std::get<N>(pos->rng_->rngs_));
+                    if(it.get() == first)
+                    {
+                        auto && rng = std::get<N - 1>(pos->rng_->rngs_);
+                        ranges::emplace<N - 1>(
+                            pos->its_,
+                            ranges::next(ranges::begin(rng), ranges::end(rng)));
+                        pos->its_.visit_i(*this);
+                    }
+                    else
+                    {
+                        auto rest = ranges::advance(it.get(), n, std::move(first));
+                        if(rest != 0)
+                            pos->its_.visit_i(advance_rev_fun{pos, rest});
+                    }
+                }
+            };
+            [[noreturn]] static difference_type distance_to_(meta::size_t<cranges>,
+                                                             cursor const &,
+                                                             cursor const &)
+            {
+                RANGES_EXPECT(false);
+            }
+            template<std::size_t N>
+            static difference_type distance_to_(meta::size_t<N>, cursor const & from,
+                                                cursor const & to)
+            {
+                if(from.its_.index() > N)
+                    return cursor::distance_to_(meta::size_t<N + 1>{}, from, to);
+                if(from.its_.index() == N)
+                {
+                    if(to.its_.index() == N)
+                        return distance(ranges::get<N>(from.its_),
+                                        ranges::get<N>(to.its_));
+                    return distance(ranges::get<N>(from.its_),
+                                    end(std::get<N>(from.rng_->rngs_))) +
+                           cursor::distance_to_(meta::size_t<N + 1>{}, from, to);
+                }
+                if(from.its_.index() < N && to.its_.index() > N)
+                    return distance(std::get<N>(from.rng_->rngs_)) +
+                           cursor::distance_to_(meta::size_t<N + 1>{}, from, to);
+                RANGES_EXPECT(to.its_.index() == N);
+                return distance(begin(std::get<N>(from.rng_->rngs_)),
+                                ranges::get<N>(to.its_));
+            }
+
+        public:
+            // BUGBUG what about rvalue_reference and common_reference?
+            using reference = common_reference_t<range_reference_t<constify_if<Rngs>>...>;
+            using single_pass = meta::or_c<single_pass_iterator_<iterator_t<Rngs>>...>;
+            cursor() = default;
+            cursor(concat_view_t * rng, begin_tag)
+              : rng_(rng)
+              , its_{emplaced_index<0>, begin(std::get<0>(rng->rngs_))}
+            {
+                this->satisfy(meta::size_t<0>{});
+            }
+            cursor(concat_view_t * rng, end_tag)
+              : rng_(rng)
+              , its_{emplaced_index<cranges - 1>, end(std::get<cranges - 1>(rng->rngs_))}
+            {}
+            CPP_template(bool Other)(         //
+                requires IsConst && (!Other)) //
+                cursor(cursor<Other> that)
+              : rng_(that.rng_)
+              , its_(std::move(that.its_))
+            {}
+            reference read() const
+            {
+                // Kind of a dumb implementation. Surely there's a better way.
+                return ranges::get<0>(unique_variant(its_.visit(
+                    compose(convert_to<reference>{}, detail::dereference_fn{}))));
+            }
+            void next()
+            {
+                its_.visit_i(next_fun{this});
+            }
+            CPP_member
+            auto equal(cursor const & pos) const -> CPP_ret(bool)( //
+                requires equality_comparable<variant<iterator_t<constify_if<Rngs>>...>>)
+            {
+                return its_ == pos.its_;
+            }
+            bool equal(sentinel<IsConst> const & pos) const
+            {
+                return its_.index() == cranges - 1 &&
+                       ranges::get<cranges - 1>(its_) == pos.end_;
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires and_v<bidirectional_range<Rngs>...>)
+            {
+                its_.visit_i(prev_fun{this});
+            }
+            CPP_member
+            auto advance(difference_type n) -> CPP_ret(void)( //
+                requires and_v<random_access_range<Rngs>...>)
+            {
+                if(n > 0)
+                    its_.visit_i(advance_fwd_fun{this, n});
+                else if(n < 0)
+                    its_.visit_i(advance_rev_fun{this, n});
+            }
+            CPP_member
+            auto distance_to(cursor const & that) const -> CPP_ret(difference_type)( //
+                requires and_v<sized_sentinel_for<iterator_t<Rngs>, iterator_t<Rngs>>...>)
+            {
+                if(its_.index() <= that.its_.index())
+                    return cursor::distance_to_(meta::size_t<0>{}, *this, that);
+                return -cursor::distance_to_(meta::size_t<0>{}, that, *this);
+            }
+        };
+        cursor<meta::and_c<simple_view<Rngs>()...>::value> begin_cursor()
+        {
+            return {this, begin_tag{}};
+        }
+        meta::if_<meta::and_c<(bool)common_range<Rngs>...>,
+                  cursor<meta::and_c<simple_view<Rngs>()...>::value>,
+                  sentinel<meta::and_c<simple_view<Rngs>()...>::value>>
+        end_cursor()
+        {
+            return {this, end_tag{}};
+        }
+        CPP_member
+        auto begin_cursor() const -> CPP_ret(cursor<true>)( //
+            requires and_v<range<Rngs const>...>)
+        {
+            return {this, begin_tag{}};
+        }
+        CPP_member
+        auto end_cursor() const -> CPP_ret(
+            meta::if_<meta::and_c<(bool)common_range<Rngs const>...>, cursor<true>,
+                      sentinel<true>>)( //
+            requires and_v<range<Rngs const>...>)
+        {
+            return {this, end_tag{}};
+        }
+
+    public:
+        concat_view() = default;
+        explicit concat_view(Rngs... rngs)
+          : rngs_{std::move(rngs)...}
+        {}
+        CPP_member
+        constexpr auto size() const -> CPP_ret(std::size_t)( //
+            requires(detail::concat_cardinality<Rngs...>::value >= 0))
+        {
+            return static_cast<std::size_t>(detail::concat_cardinality<Rngs...>::value);
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(
+            const requires(detail::concat_cardinality<Rngs...>::value < 0) &&
+            and_v<sized_range<Rngs const>...>)
+        {
+            using size_type = common_type_t<range_size_t<Rngs const>...>;
+            return tuple_foldl(
+                tuple_transform(rngs_,
+                                [](auto && r) -> size_type { return ranges::size(r); }),
+                size_type{0},
+                plus{});
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(
+            requires(detail::concat_cardinality<Rngs...>::value < 0) &&
+            and_v<sized_range<Rngs>...>)
+        {
+            using size_type = common_type_t<range_size_t<Rngs>...>;
+            return tuple_foldl(
+                tuple_transform(rngs_,
+                                [](auto && r) -> size_type { return ranges::size(r); }),
+                size_type{0},
+                plus{});
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename... Rng>
+    concat_view(Rng &&...)->concat_view<views::all_t<Rng>...>;
+#endif
+
+    namespace views
+    {
+        struct concat_fn
+        {
+            template<typename... Rngs>
+            auto operator()(Rngs &&... rngs) const
+                -> CPP_ret(concat_view<all_t<Rngs>...>)( //
+                    requires and_v<(viewable_range<Rngs> && input_range<Rngs>)...>)
+            {
+                return concat_view<all_t<Rngs>...>{all(static_cast<Rngs &&>(rngs))...};
+            }
+            template<typename Rng>
+            auto operator()(Rng && rng) const //
+                -> CPP_ret(all_t<Rng>)(       //
+                    requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return all(static_cast<Rng &&>(rng));
+            }
+        };
+
+        /// \relates concat_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(concat_fn, concat)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::concat_view)
+
+#endif
diff --git a/inst/include/range/v3/view/const.hpp b/inst/include/range/v3/view/const.hpp
new file mode 100644
index 0000000..0e7671c
--- /dev/null
+++ b/inst/include/range/v3/view/const.hpp
@@ -0,0 +1,130 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_CONST_HPP
+#define RANGES_V3_VIEW_CONST_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/utility/common_type.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct const_view : view_adaptor<const_view<Rng>, Rng>
+    {
+    private:
+        friend range_access;
+        template<bool Const>
+        struct adaptor : adaptor_base
+        {
+            using CRng = meta::const_if_c<Const, Rng>;
+            using value_ = range_value_t<CRng>;
+            using reference_ =
+                common_reference_t<value_ const &&, range_reference_t<CRng>>;
+            using rvalue_reference_ =
+                common_reference_t<value_ const &&, range_rvalue_reference_t<CRng>>;
+            adaptor() = default;
+            CPP_template(bool Other)(       //
+                requires Const && (!Other)) //
+                constexpr adaptor(adaptor<Other>)
+            {}
+            reference_ read(iterator_t<CRng> const & it) const
+            {
+                return *it;
+            }
+            rvalue_reference_ iter_move(iterator_t<CRng> const & it) const
+                noexcept(noexcept(rvalue_reference_(ranges::iter_move(it))))
+            {
+                return ranges::iter_move(it);
+            }
+        };
+        adaptor<simple_view<Rng>()> begin_adaptor()
+        {
+            return {};
+        }
+        CPP_member
+        auto begin_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires range<Rng const>)
+        {
+            return {};
+        }
+        adaptor<simple_view<Rng>()> end_adaptor()
+        {
+            return {};
+        }
+        CPP_member
+        auto end_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires range<Rng const>)
+        {
+            return {};
+        }
+
+    public:
+        const_view() = default;
+        explicit const_view(Rng rng)
+          : const_view::view_adaptor{std::move(rng)}
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(this->base());
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(this->base());
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    const_view(Rng &&)->const_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct const_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(const_view<all_t<Rng>>)( //
+                requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return const_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        /// \relates const_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<const_fn>, const_)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::const_view)
+
+#endif
diff --git a/inst/include/range/v3/view/counted.hpp b/inst/include/range/v3/view/counted.hpp
new file mode 100644
index 0000000..ea2275a
--- /dev/null
+++ b/inst/include/range/v3/view/counted.hpp
@@ -0,0 +1,123 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_COUNTED_HPP
+#define RANGES_V3_VIEW_COUNTED_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/counted_iterator.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/subrange.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename I>
+    struct counted_view : view_interface<counted_view<I>, finite>
+    {
+    private:
+        friend range_access;
+        I it_;
+        iter_difference_t<I> n_;
+
+    public:
+        counted_view() = default;
+        counted_view(I it, iter_difference_t<I> n)
+          : it_(it)
+          , n_(n)
+        {
+            RANGES_EXPECT(0 <= n_);
+        }
+        counted_iterator<I> begin() const
+        {
+            return make_counted_iterator(it_, n_);
+        }
+        default_sentinel_t end() const
+        {
+            return {};
+        }
+        auto size() const
+        {
+            return static_cast<detail::iter_size_t<I>>(n_);
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename I>
+    counted_view(I, iter_difference_t<I>)->counted_view<I>;
+#endif
+
+    namespace views
+    {
+        struct cpp20_counted_fn
+        {
+            template<typename I>
+            auto operator()(I it, iter_difference_t<I> n) const
+                -> CPP_ret(subrange<counted_iterator<I>, default_sentinel_t>)( //
+                    requires input_or_output_iterator<I> && (!random_access_iterator<I>))
+            {
+                return {make_counted_iterator(std::move(it), n), default_sentinel};
+            }
+            template<typename I>
+            auto operator()(I it, iter_difference_t<I> n) const
+                -> CPP_ret(subrange<I>)( //
+                    requires random_access_iterator<I>)
+            {
+                return {it, it + n};
+            }
+        };
+
+        struct counted_fn
+        {
+            template<typename I>
+            auto operator()(I it, iter_difference_t<I> n) const
+                -> CPP_ret(counted_view<I>)( //
+                    requires input_or_output_iterator<I> && (!random_access_iterator<I>))
+            {
+                return {std::move(it), n};
+            }
+            template<typename I>
+            auto operator()(I it, iter_difference_t<I> n) const
+                -> CPP_ret(subrange<I>)( //
+                    requires random_access_iterator<I>)
+            {
+                return {it, it + n};
+            }
+        };
+
+        /// \relates counted_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(counted_fn, counted)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            RANGES_INLINE_VARIABLE(ranges::views::cpp20_counted_fn, counted)
+        }
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::counted_view)
+
+#endif
diff --git a/inst/include/range/v3/view/cycle.hpp b/inst/include/range/v3/view/cycle.hpp
new file mode 100644
index 0000000..7dcfe3f
--- /dev/null
+++ b/inst/include/range/v3/view/cycle.hpp
@@ -0,0 +1,234 @@
+/// \file cycle.hpp
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi 2015
+//  Copyright Casey Carter 2015
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_CYCLE_HPP
+#define RANGES_V3_VIEW_CYCLE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/get.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, bool /* = (bool) is_infinite<Rng>() */>
+    struct RANGES_EMPTY_BASES cycled_view
+      : view_facade<cycled_view<Rng>, infinite>
+      , private detail::non_propagating_cache<iterator_t<Rng>, cycled_view<Rng>,
+                                              !common_range<Rng>>
+    {
+    private:
+        CPP_assert(forward_range<Rng> && !is_infinite<Rng>::value);
+        friend range_access;
+        Rng rng_;
+
+        using cache_t = detail::non_propagating_cache<iterator_t<Rng>, cycled_view<Rng>,
+                                                      !common_range<Rng>>;
+
+        template<bool IsConst>
+        struct cursor
+        {
+        private:
+            friend struct cursor<!IsConst>;
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst, T>;
+            using cycled_view_t = constify_if<cycled_view>;
+            using CRng = constify_if<Rng>;
+            using iterator = iterator_t<CRng>;
+
+            cycled_view_t * rng_{};
+            iterator it_{};
+            std::intmax_t n_ = 0;
+
+            iterator get_end_(std::true_type, bool = false) const
+            {
+                return ranges::end(rng_->rng_);
+            }
+            template<bool CanBeEmpty = false>
+            iterator get_end_(std::false_type, meta::bool_<CanBeEmpty> = {}) const
+            {
+                auto & end_ = static_cast<cache_t &>(*rng_);
+                RANGES_EXPECT(CanBeEmpty || end_);
+                if(CanBeEmpty && !end_)
+                    end_ = ranges::next(it_, ranges::end(rng_->rng_));
+                return *end_;
+            }
+            void set_end_(std::true_type) const
+            {}
+            void set_end_(std::false_type) const
+            {
+                auto & end_ = static_cast<cache_t &>(*rng_);
+                if(!end_)
+                    end_ = it_;
+            }
+
+        public:
+            cursor() = default;
+            cursor(cycled_view_t * rng)
+              : rng_(rng)
+              , it_(ranges::begin(rng->rng_))
+            {}
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other)) cursor(cursor<Other> that)
+              : rng_(that.rng_)
+              , it_(std::move(that.it_))
+            {}
+            // clang-format off
+            auto CPP_auto_fun(read)()(const)
+            (
+                return *it_
+            )
+                // clang-format on
+                CPP_member
+            auto equal(cursor const & pos) const -> CPP_ret(bool)( //
+                requires equality_comparable<iterator>)
+            {
+                RANGES_EXPECT(rng_ == pos.rng_);
+                return n_ == pos.n_ && it_ == pos.it_;
+            }
+            void next()
+            {
+                auto const last = ranges::end(rng_->rng_);
+                RANGES_EXPECT(it_ != last);
+                if(++it_ == last)
+                {
+                    ++n_;
+                    this->set_end_(meta::bool_<(bool)common_range<CRng>>{});
+                    it_ = ranges::begin(rng_->rng_);
+                }
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires bidirectional_range<CRng>)
+            {
+                if(it_ == ranges::begin(rng_->rng_))
+                {
+                    RANGES_EXPECT(n_ > 0); // decrementing the begin iterator?!
+                    --n_;
+                    it_ = this->get_end_(meta::bool_<(bool)common_range<CRng>>{});
+                }
+                --it_;
+            }
+            CPP_template(typename Diff)( //
+                requires random_access_range<CRng> &&
+                    detail::integer_like_<Diff>) void advance(Diff n)
+            {
+                auto const first = ranges::begin(rng_->rng_);
+                auto const last = this->get_end_(meta::bool_<(bool)common_range<CRng>>{},
+                                                 meta::bool_<true>());
+                auto const dist = last - first;
+                auto const d = it_ - first;
+                auto const off = (d + n) % dist;
+                n_ += (d + n) / dist;
+                RANGES_EXPECT(n_ >= 0);
+                using D = range_difference_t<Rng>;
+                it_ = first + static_cast<D>(off < 0 ? off + dist : off);
+            }
+            CPP_member
+            auto CPP_fun(distance_to)(cursor const & that)(
+                const requires sized_sentinel_for<iterator, iterator>)
+            {
+                RANGES_EXPECT(that.rng_ == rng_);
+                auto const first = ranges::begin(rng_->rng_);
+                auto const last = this->get_end_(meta::bool_<(bool)common_range<Rng>>{},
+                                                 meta::bool_<true>());
+                auto const dist = last - first;
+                return (that.n_ - n_) * dist + (that.it_ - it_);
+            }
+        };
+
+        CPP_member
+        auto begin_cursor() -> CPP_ret(cursor<false>)( //
+            requires(!simple_view<Rng>() || !common_range<Rng const>))
+        {
+            return {this};
+        }
+        CPP_member
+        auto begin_cursor() const -> CPP_ret(cursor<true>)( //
+            requires common_range<Rng const>)
+        {
+            return {this};
+        }
+        unreachable_sentinel_t end_cursor() const
+        {
+            return unreachable;
+        }
+
+    public:
+        cycled_view() = default;
+        /// \pre <tt>!empty(rng)</tt>
+        explicit cycled_view(Rng rng)
+          : rng_(std::move(rng))
+        {
+            RANGES_EXPECT(!ranges::empty(rng_));
+        }
+    };
+
+    template<typename Rng>
+    struct cycled_view<Rng, true> : identity_adaptor<Rng>
+    {
+        CPP_assert(is_infinite<Rng>::value);
+        using identity_adaptor<Rng>::identity_adaptor;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    cycled_view(Rng &&)->cycled_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        /// Returns an infinite range that endlessly repeats the source
+        /// range.
+        struct cycle_fn
+        {
+            /// \pre <tt>!empty(rng)</tt>
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(cycled_view<all_t<Rng>>)( //
+                requires viewable_range<Rng> && forward_range<Rng>)
+            {
+                return cycled_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        /// \relates cycle_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<cycle_fn>, cycle)
+    } // namespace views
+      /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::cycled_view)
+
+#endif
diff --git a/inst/include/range/v3/view/delimit.hpp b/inst/include/range/v3/view/delimit.hpp
new file mode 100644
index 0000000..7fc7e9b
--- /dev/null
+++ b/inst/include/range/v3/view/delimit.hpp
@@ -0,0 +1,122 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_DELIMIT_HPP
+#define RANGES_V3_VIEW_DELIMIT_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Val>
+    struct delimit_view
+      : view_adaptor<delimit_view<Rng, Val>, Rng,
+                     is_finite<Rng>::value ? finite : unknown>
+    {
+    private:
+        friend range_access;
+        Val value_;
+
+        struct sentinel_adaptor : adaptor_base
+        {
+            sentinel_adaptor() = default;
+            sentinel_adaptor(Val value)
+              : value_(std::move(value))
+            {}
+            template<class I, class S>
+            bool empty(I const & it, S const & last) const
+            {
+                return it == last || *it == value_;
+            }
+            Val value_;
+        };
+
+        sentinel_adaptor end_adaptor() const
+        {
+            return {value_};
+        }
+
+    public:
+        delimit_view() = default;
+        constexpr delimit_view(Rng rng, Val value)
+          : delimit_view::view_adaptor{std::move(rng)}
+          , value_(std::move(value))
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Val)(requires copy_constructible<Val>)
+        delimit_view(Rng &&, Val)
+            ->delimit_view<views::all_t<Rng>, Val>;
+#endif
+
+    namespace views
+    {
+        struct delimit_base_fn
+        {
+            template<typename I_, typename Val, typename I = detail::decay_t<I_>>
+            constexpr auto operator()(I_ && begin_, Val value) const
+                -> CPP_ret(delimit_view<subrange<I, unreachable_sentinel_t>, Val>)( //
+                    requires(!range<I_> && convertible_to<I_, I> && input_iterator<I> &&
+                             semiregular<Val> &&
+                             equality_comparable_with<Val, iter_reference_t<I>>))
+            {
+                return {{static_cast<I_ &&>(begin_), {}}, std::move(value)};
+            }
+
+            template<typename Rng, typename Val>
+            constexpr auto operator()(Rng && rng, Val value) const //
+                -> CPP_ret(delimit_view<all_t<Rng>, Val>)(         //
+                    requires viewable_range<Rng> && input_range<Rng> && semiregular<
+                        Val> && equality_comparable_with<Val, range_reference_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(value)};
+            }
+        };
+
+        struct delimit_fn : delimit_base_fn
+        {
+            using delimit_base_fn::operator();
+
+            template<typename Val>
+            constexpr auto operator()(Val value) const
+            {
+                return make_view_closure(bind_back(delimit_base_fn{}, std::move(value)));
+            }
+        };
+
+        /// \relates delimit_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(delimit_fn, delimit)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::delimit_view)
+
+#endif
diff --git a/inst/include/range/v3/view/drop.hpp b/inst/include/range/v3/view/drop.hpp
new file mode 100644
index 0000000..90f5710
--- /dev/null
+++ b/inst/include/range/v3/view/drop.hpp
@@ -0,0 +1,195 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_DROP_HPP
+#define RANGES_V3_VIEW_DROP_HPP
+
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/min.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct RANGES_EMPTY_BASES drop_view
+      : view_interface<drop_view<Rng>,
+                       is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+      , private detail::non_propagating_cache<iterator_t<Rng>, drop_view<Rng>,
+                                              !random_access_range<Rng>>
+    {
+    private:
+        using difference_type_ = range_difference_t<Rng>;
+        Rng rng_;
+        difference_type_ n_;
+
+        template<bool Const = true>
+        auto get_begin_(std::true_type, std::true_type) const
+            -> CPP_ret(iterator_t<meta::const_if_c<Const, Rng>>)( //
+                requires Const && range<meta::const_if_c<Const, Rng>>)
+        {
+            CPP_assert(random_access_range<meta::const_if_c<Const, Rng>>);
+            return next(ranges::begin(rng_), n_, ranges::end(rng_));
+        }
+        iterator_t<Rng> get_begin_(std::true_type, std::false_type)
+        {
+            CPP_assert(random_access_range<Rng>);
+            return next(ranges::begin(rng_), n_, ranges::end(rng_));
+        }
+        iterator_t<Rng> get_begin_(std::false_type, detail::ignore_t)
+        {
+            CPP_assert(!random_access_range<Rng>);
+            using cache_t =
+                detail::non_propagating_cache<iterator_t<Rng>, drop_view<Rng>>;
+            auto & begin_ = static_cast<cache_t &>(*this);
+            if(!begin_)
+                begin_ = next(ranges::begin(rng_), n_, ranges::end(rng_));
+            return *begin_;
+        }
+
+    public:
+        drop_view() = default;
+        drop_view(Rng rng, difference_type_ n)
+          : rng_(std::move(rng))
+          , n_(n)
+        {
+            RANGES_EXPECT(n >= 0);
+        }
+        iterator_t<Rng> begin()
+        {
+            return this->get_begin_(meta::bool_<random_access_range<Rng>>{},
+                                    std::false_type{});
+        }
+        sentinel_t<Rng> end()
+        {
+            return ranges::end(rng_);
+        }
+        template<bool Const = true>
+        auto begin() const -> CPP_ret(iterator_t<meta::const_if_c<Const, Rng>>)( //
+            requires Const && random_access_range<meta::const_if_c<Const, Rng>>)
+        {
+            return this->get_begin_(std::true_type{}, std::true_type{});
+        }
+        template<bool Const = true>
+        auto end() const -> CPP_ret(sentinel_t<meta::const_if_c<Const, Rng>>)( //
+            requires Const && random_access_range<meta::const_if_c<Const, Rng>>)
+        {
+            return ranges::end(rng_);
+        }
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            auto const s = ranges::size(rng_);
+            auto const n = static_cast<range_size_t<Rng const>>(n_);
+            return s < n ? 0 : s - n;
+        }
+        CPP_member
+        auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            auto const s = ranges::size(rng_);
+            auto const n = static_cast<range_size_t<Rng>>(n_);
+            return s < n ? 0 : s - n;
+        }
+        Rng base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    drop_view(Rng &&, range_difference_t<Rng>)->drop_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct drop_base_fn
+        {
+        private:
+            template<typename Rng>
+            static auto impl_(Rng && rng, range_difference_t<Rng> n, input_range_tag)
+                -> drop_view<all_t<Rng>>
+            {
+                return {all(static_cast<Rng &&>(rng)), n};
+            }
+            template<typename Rng>
+            static auto impl_(Rng && rng, range_difference_t<Rng> n,
+                              random_access_range_tag)
+                -> CPP_ret(subrange<iterator_t<Rng>, sentinel_t<Rng>>)( //
+                    requires forwarding_range_<Rng> && sized_range<Rng>)
+            {
+                return {begin(rng) + ranges::min(n, distance(rng)), end(rng)};
+            }
+
+        public:
+            template<typename Rng>
+            auto CPP_fun(operator())(Rng && rng, range_difference_t<Rng> n)(
+                const //
+                requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return drop_base_fn::impl_(
+                    static_cast<Rng &&>(rng), n, range_tag_of<Rng>{});
+            }
+        };
+
+        struct drop_fn : drop_base_fn
+        {
+            using drop_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(drop_base_fn{}, n));
+            }
+        };
+
+        /// \relates drop_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(drop_fn, drop)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::drop;
+        }
+        CPP_template(typename Rng)( //
+            requires view_<Rng>)    //
+            using drop_view = ranges::drop_view<Rng>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::drop_view)
+
+#endif
diff --git a/inst/include/range/v3/view/drop_exactly.hpp b/inst/include/range/v3/view/drop_exactly.hpp
new file mode 100644
index 0000000..a85afee
--- /dev/null
+++ b/inst/include/range/v3/view/drop_exactly.hpp
@@ -0,0 +1,178 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_DROP_EXACTLY_HPP
+#define RANGES_V3_VIEW_DROP_EXACTLY_HPP
+
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct RANGES_EMPTY_BASES drop_exactly_view
+      : view_interface<drop_exactly_view<Rng>,
+                       is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+      , private detail::non_propagating_cache<iterator_t<Rng>, drop_exactly_view<Rng>,
+                                              !random_access_range<Rng>>
+    {
+    private:
+        using difference_type_ = range_difference_t<Rng>;
+        Rng rng_;
+        difference_type_ n_;
+
+        // random_access_range == true
+        template<bool Const = true>
+        auto get_begin_(std::true_type) const
+            -> CPP_ret(iterator_t<meta::const_if_c<Const, Rng>>)( //
+                requires Const && random_access_range<meta::const_if_c<Const, Rng>>)
+        {
+            return next(ranges::begin(rng_), n_);
+        }
+        iterator_t<Rng> get_begin_(std::true_type)
+        {
+            return next(ranges::begin(rng_), n_);
+        }
+        // random_access_range == false
+        iterator_t<Rng> get_begin_(std::false_type)
+        {
+            using cache_t =
+                detail::non_propagating_cache<iterator_t<Rng>, drop_exactly_view<Rng>>;
+            auto & begin_ = static_cast<cache_t &>(*this);
+            if(!begin_)
+                begin_ = next(ranges::begin(rng_), n_);
+            return *begin_;
+        }
+
+    public:
+        drop_exactly_view() = default;
+        drop_exactly_view(Rng rng, difference_type_ n)
+          : rng_(std::move(rng))
+          , n_(n)
+        {
+            RANGES_EXPECT(n >= 0);
+        }
+        iterator_t<Rng> begin()
+        {
+            return this->get_begin_(meta::bool_<random_access_range<Rng>>{});
+        }
+        sentinel_t<Rng> end()
+        {
+            return ranges::end(rng_);
+        }
+        template<bool Const = true>
+        auto begin() const -> CPP_ret(iterator_t<meta::const_if_c<Const, Rng>>)( //
+            requires Const && random_access_range<meta::const_if_c<Const, Rng>>)
+        {
+            return this->get_begin_(std::true_type{});
+        }
+        template<bool Const = true>
+        auto end() const -> CPP_ret(sentinel_t<meta::const_if_c<Const, Rng>>)( //
+            requires Const && random_access_range<meta::const_if_c<Const, Rng>>)
+        {
+            return ranges::end(rng_);
+        }
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(rng_) - static_cast<range_size_t<Rng const>>(n_);
+        }
+        CPP_member
+        auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(rng_) - static_cast<range_size_t<Rng>>(n_);
+        }
+        Rng base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    drop_exactly_view(Rng &&, range_difference_t<Rng>)
+        ->drop_exactly_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct drop_exactly_base_fn
+        {
+        private:
+            template<typename Rng>
+            static auto impl_(Rng && rng, range_difference_t<Rng> n, input_range_tag)
+                -> drop_exactly_view<all_t<Rng>>
+            {
+                return {all(static_cast<Rng &&>(rng)), n};
+            }
+            template<typename Rng>
+            static auto impl_(Rng && rng, range_difference_t<Rng> n,
+                              random_access_range_tag)
+                -> CPP_ret(subrange<iterator_t<Rng>, sentinel_t<Rng>>)( //
+                    requires forwarding_range_<Rng>)
+            {
+                return {begin(rng) + n, end(rng)};
+            }
+
+        public:
+            template<typename Rng>
+            auto CPP_fun(operator())(Rng && rng, range_difference_t<Rng> n)(
+                const //
+                requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return drop_exactly_base_fn::impl_(
+                    static_cast<Rng &&>(rng), n, range_tag_of<Rng>{});
+            }
+        };
+
+        struct drop_exactly_fn : drop_exactly_base_fn
+        {
+            using drop_exactly_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(drop_exactly_base_fn{}, n));
+            }
+        };
+
+        /// \relates drop_exactly_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(drop_exactly_fn, drop_exactly)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::drop_exactly_view)
+
+#endif
diff --git a/inst/include/range/v3/view/drop_last.hpp b/inst/include/range/v3/view/drop_last.hpp
new file mode 100644
index 0000000..2fcba37
--- /dev/null
+++ b/inst/include/range/v3/view/drop_last.hpp
@@ -0,0 +1,365 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrey Diduh 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_DROP_LAST_HPP
+#define RANGES_V3_VIEW_DROP_LAST_HPP
+
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/counted_iterator.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        namespace drop_last_view
+        {
+            template<typename Rng>
+            range_size_t<Rng> get_size(Rng & rng, range_difference_t<Rng> n_)
+            {
+                RANGES_EXPECT(n_ >= 0);
+                range_size_t<Rng> const initial_size = ranges::size(rng);
+                range_size_t<Rng> const n = static_cast<range_size_t<Rng>>(n_);
+                RANGES_EXPECT(initial_size >= n);
+                return initial_size > n ? initial_size - n : 0;
+            }
+
+            template<typename Rng>
+            auto get_end(Rng & rng, range_difference_t<Rng> n, int)
+                -> CPP_ret(iterator_t<Rng>)( //
+                    requires random_access_range<Rng> && sized_range<Rng>)
+            {
+                return begin(rng) + static_cast<range_difference_t<Rng>>(
+                                        drop_last_view::get_size(rng, n));
+            }
+            template<typename Rng>
+            auto get_end(Rng & rng, range_difference_t<Rng> n, long)
+                -> CPP_ret(iterator_t<Rng>)( //
+                    requires bidirectional_range<Rng> && common_range<Rng>)
+            {
+                return prev(end(rng), n, begin(rng));
+            }
+
+            enum class mode_enum
+            {
+                bidi,
+                forward,
+                sized,
+                invalid
+            };
+
+            template<mode_enum Mode>
+            using mode_t = std::integral_constant<mode_enum, Mode>;
+
+            using mode_bidi = mode_t<mode_enum::bidi>;
+            using mode_forward = mode_t<mode_enum::forward>;
+            using mode_sized = mode_t<mode_enum::sized>;
+            using mode_invalid = mode_t<mode_enum::invalid>;
+
+            template<typename Rng>
+            constexpr mode_enum get_mode() noexcept
+            {
+                // keep range bound
+                // Sized Bidi O(N)
+                return (random_access_range<Rng> && view_<Rng> && sized_range<Rng> &&
+                        view_<Rng>) ||
+                               (bidirectional_range<Rng> && view_<Rng> &&
+                                common_range<Rng> && view_<Rng>)    //
+                           ? mode_enum::bidi                        //
+                           : sized_range<Rng> && view_<Rng>         //
+                                 ? mode_enum::sized                 //
+                                 : forward_range<Rng> && view_<Rng> //
+                                       ? mode_enum::forward         //
+                                       : mode_enum::invalid;        //
+
+                // max performance
+                // Sized Bidi O(1)
+                // Sized Bidi use mode::sized instead of mode::bidi - thus become unbound.
+                /*return (random_access_range<Rng> && view_<Rng> && sized_range<Rng> &&
+                   view_<Rng>) || (bidirectional_range<Rng> && view_<Rng> &&
+                   common_range<Rng> && view_<Rng>) ? mode::bidi : sized_range<Rng> &&
+                   view_<Rng> ? mode::sized : bidirectional_range<Rng> && view_<Rng> &&
+                   common_range<Rng> && view_<Rng> ? mode::bidi : forward_range<Rng> &&
+                   view_<Rng> ? mode::forward : mode::invalid;*/
+            }
+
+            template<typename Rng>
+            using mode_of = mode_t<drop_last_view::get_mode<Rng>()>;
+        } // namespace drop_last_view
+    }     // namespace detail
+    /// \endcond
+
+    template<typename Rng, typename = detail::drop_last_view::mode_of<Rng>>
+    struct drop_last_view
+    {};
+
+    template<typename Rng>
+    struct drop_last_view<Rng, detail::drop_last_view::mode_bidi>
+      : view_interface<drop_last_view<Rng, detail::drop_last_view::mode_bidi>,
+                       is_finite<Rng>::value
+                           ? finite
+                           : range_cardinality<Rng>::value> // finite at best
+    {
+        CPP_assert(
+            (random_access_range<Rng> && view_<Rng> && sized_range<Rng> && view_<Rng>) ||
+            (bidirectional_range<Rng> && view_<Rng> && common_range<Rng> && view_<Rng>));
+
+    private:
+        friend range_access;
+        using difference_t = range_difference_t<Rng>;
+
+        Rng rng_;
+        difference_t n_;
+        detail::non_propagating_cache<iterator_t<Rng>> end_;
+
+    public:
+        drop_last_view() = default;
+        constexpr drop_last_view(Rng rng, difference_t n)
+          : rng_(std::move(rng))
+          , n_(n)
+        {
+            RANGES_EXPECT(n >= 0);
+        }
+
+        iterator_t<Rng> begin()
+        {
+            return ranges::begin(rng_);
+        }
+        sentinel_t<Rng> end()
+        {
+            if(!end_)
+                end_ = detail::drop_last_view::get_end(rng_, n_, 0);
+            return *end_;
+        }
+        template<typename CRng = Rng const>
+        auto begin() const -> CPP_ret(iterator_t<CRng>)( //
+            requires random_access_range<CRng> && sized_range<CRng>)
+        {
+            return ranges::begin(rng_);
+        }
+        template<typename CRng = Rng const>
+        auto end() const -> CPP_ret(iterator_t<CRng>)( //
+            requires random_access_range<CRng> && sized_range<CRng>)
+        {
+            return detail::drop_last_view::get_end(rng_, n_, 0);
+        }
+
+        auto CPP_fun(size)()( //
+            requires sized_range<Rng>)
+        {
+            return detail::drop_last_view::get_size(rng_, n_);
+        }
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return detail::drop_last_view::get_size(rng_, n_);
+        }
+
+        Rng & base()
+        {
+            return rng_;
+        }
+        Rng const & base() const
+        {
+            return rng_;
+        }
+    };
+
+    template<typename Rng>
+    struct drop_last_view<Rng, detail::drop_last_view::mode_forward>
+      : view_adaptor<drop_last_view<Rng, detail::drop_last_view::mode_forward>, Rng,
+                     is_finite<Rng>::value
+                         ? finite
+                         : range_cardinality<Rng>::value> // finite at best (but
+                                                          // unknown is expected)
+    {
+        CPP_assert(forward_range<Rng> && view_<Rng>);
+
+    private:
+        friend range_access;
+
+        using difference_t = range_difference_t<Rng>;
+        difference_t n_;
+        detail::non_propagating_cache<iterator_t<Rng>> probe_begin;
+
+        struct adaptor : adaptor_base
+        {
+            iterator_t<Rng> probe_;
+
+            adaptor() = default;
+            adaptor(iterator_t<Rng> probe_first)
+              : probe_(std::move(probe_first))
+            {}
+            void next(iterator_t<Rng> & it)
+            {
+                ++it;
+                ++probe_;
+            }
+        };
+
+        struct sentinel_adaptor : adaptor_base
+        {
+            template<typename I, typename S>
+            bool empty(I const &, adaptor const & ia, S const & s) const
+            {
+                return ia.probe_ == s;
+            }
+        };
+
+        adaptor begin_adaptor()
+        {
+            if(!probe_begin)
+                probe_begin = next(begin(this->base()), n_, end(this->base()));
+            return {*probe_begin};
+        }
+        sentinel_adaptor end_adaptor()
+        {
+            return {};
+        }
+
+    public:
+        drop_last_view() = default;
+        constexpr drop_last_view(Rng rng, difference_t n)
+          : drop_last_view::view_adaptor(std::move(rng))
+          , n_(n)
+        {
+            RANGES_EXPECT(n >= 0);
+        }
+
+        CPP_member
+        auto CPP_fun(size)()( //
+            requires sized_range<Rng>)
+        {
+            return detail::drop_last_view::get_size(this->base(), n_);
+        }
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return detail::drop_last_view::get_size(this->base(), n_);
+        }
+    };
+
+    template<typename Rng>
+    struct drop_last_view<Rng, detail::drop_last_view::mode_sized>
+      : view_interface<drop_last_view<Rng, detail::drop_last_view::mode_sized>, finite>
+    {
+        CPP_assert(sized_range<Rng> && view_<Rng>);
+
+    private:
+        friend range_access;
+
+        using difference_t = range_difference_t<Rng>;
+        Rng rng_;
+        difference_t n_;
+
+    public:
+        drop_last_view() = default;
+        constexpr drop_last_view(Rng rng, difference_t n)
+          : rng_(std::move(rng))
+          , n_(n)
+        {
+            RANGES_EXPECT(n >= 0);
+        }
+
+        counted_iterator<iterator_t<Rng>> begin()
+        {
+            return {ranges::begin(rng_), static_cast<difference_t>(size())};
+        }
+        template<typename CRng = Rng const>
+        auto begin() const -> CPP_ret(counted_iterator<iterator_t<CRng>>)( //
+            requires sized_range<CRng>)
+        {
+            return {ranges::begin(rng_), static_cast<difference_t>(size())};
+        }
+        default_sentinel_t end() const
+        {
+            return {};
+        }
+        range_size_t<Rng> size()
+        {
+            return detail::drop_last_view::get_size(this->base(), n_);
+        }
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return detail::drop_last_view::get_size(this->base(), n_);
+        }
+
+        Rng & base()
+        {
+            return rng_;
+        }
+        Rng const & base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    drop_last_view(Rng &&, range_difference_t<Rng>)->drop_last_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct drop_last_base_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng, range_difference_t<Rng> n) const
+                -> CPP_ret(drop_last_view<all_t<Rng>>)( //
+                    requires sized_range<Rng> || forward_range<Rng>)
+            {
+                return {all(static_cast<Rng &&>(rng)), n};
+            }
+        };
+
+        struct drop_last_fn : drop_last_base_fn
+        {
+            using drop_last_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(drop_last_base_fn{}, n));
+            }
+        };
+
+        RANGES_INLINE_VARIABLE(drop_last_fn, drop_last)
+    } // namespace views
+
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::drop_last_view)
+
+#endif
diff --git a/inst/include/range/v3/view/drop_while.hpp b/inst/include/range/v3/view/drop_while.hpp
new file mode 100644
index 0000000..900e923
--- /dev/null
+++ b/inst/include/range/v3/view/drop_while.hpp
@@ -0,0 +1,147 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_DROP_WHILE_HPP
+#define RANGES_V3_VIEW_DROP_WHILE_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Pred>
+    struct drop_while_view
+      : view_interface<drop_while_view<Rng, Pred>,
+                       is_finite<Rng>::value ? finite : unknown>
+    {
+    private:
+        Rng rng_;
+        RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Pred> pred_;
+        detail::non_propagating_cache<iterator_t<Rng>> begin_;
+
+        iterator_t<Rng> get_begin_()
+        {
+            if(!begin_)
+                begin_ = find_if_not(rng_, std::ref(pred_));
+            return *begin_;
+        }
+
+    public:
+        drop_while_view() = default;
+        drop_while_view(Rng rng, Pred pred)
+          : rng_(std::move(rng))
+          , pred_(std::move(pred))
+        {}
+        iterator_t<Rng> begin()
+        {
+            return get_begin_();
+        }
+        sentinel_t<Rng> end()
+        {
+            return ranges::end(rng_);
+        }
+        Rng base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Fun>)
+        drop_while_view(Rng &&, Fun)
+            ->drop_while_view<views::all_t<Rng>, Fun>;
+#endif
+
+    namespace views
+    {
+        struct drop_while_base_fn
+        {
+            template<typename Rng, typename Pred>
+            auto operator()(Rng && rng, Pred pred) const
+                -> CPP_ret(drop_while_view<all_t<Rng>, Pred>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<Pred, iterator_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(pred)};
+            }
+            template<typename Rng, typename Pred, typename Proj>
+            auto operator()(Rng && rng, Pred pred, Proj proj) const
+                -> CPP_ret(drop_while_view<all_t<Rng>, composed<Pred, Proj>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<composed<Pred, Proj>, iterator_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        compose(std::move(pred), std::move(proj))};
+            }
+        };
+
+        struct drop_while_fn : drop_while_base_fn
+        {
+            using drop_while_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(
+                    bind_back(drop_while_base_fn{}, std::move(pred)));
+            }
+            template<typename Pred, typename Proj>
+            constexpr auto CPP_fun(operator())(Pred && pred,
+                                               Proj proj)(const //
+                                                          requires(!range<Pred>))
+            {
+                return make_view_closure(bind_back(
+                    drop_while_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
+            }
+        };
+
+        /// \relates drop_while_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(drop_while_fn, drop_while)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::drop_while;
+        }
+        CPP_template(typename Rng, typename Pred)( //
+            requires viewable_range<Rng> && input_range<Rng> &&
+                indirect_unary_predicate<Pred, iterator_t<Rng>>) //
+            using drop_while_view = ranges::drop_while_view<Rng, Pred>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::drop_while_view)
+
+#endif
diff --git a/inst/include/range/v3/view/empty.hpp b/inst/include/range/v3/view/empty.hpp
new file mode 100644
index 0000000..d378f09
--- /dev/null
+++ b/inst/include/range/v3/view/empty.hpp
@@ -0,0 +1,101 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_EMPTY_HPP
+#define RANGES_V3_VIEW_EMPTY_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/view/interface.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        struct empty_view_base
+        {
+            template<typename T>
+            friend constexpr T * begin(empty_view<T>) noexcept
+            {
+                return nullptr;
+            }
+            template<typename T>
+            friend constexpr T * end(empty_view<T>) noexcept
+            {
+                return nullptr;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    template<typename T>
+    struct empty_view
+      : view_interface<empty_view<T>, (cardinality)0>
+      , private detail::empty_view_base
+    {
+        static_assert(std::is_object<T>::value,
+                      "The template parameter to empty_view must be an object type.");
+        empty_view() = default;
+        static constexpr T * begin() noexcept
+        {
+            return nullptr;
+        }
+        static constexpr T * end() noexcept
+        {
+            return nullptr;
+        }
+        static constexpr std::size_t size() noexcept
+        {
+            return 0u;
+        }
+        static constexpr T * data() noexcept
+        {
+            return nullptr;
+        }
+        RANGES_DEPRECATED(
+            "Replace views::empty<T>() with views::empty<>. "
+            "It is now a variable template.")
+        empty_view operator()() const
+        {
+            return *this;
+        }
+    };
+
+    namespace views
+    {
+        template<typename T>
+        RANGES_INLINE_VAR constexpr empty_view<T> empty{};
+    }
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::empty;
+        }
+        CPP_template(typename T)(              //
+            requires std::is_object<T>::value) //
+            using empty_view = ranges::empty_view<T>;
+    } // namespace cpp20
+
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::empty_view)
+
+#endif
diff --git a/inst/include/range/v3/view/enumerate.hpp b/inst/include/range/v3/view/enumerate.hpp
new file mode 100644
index 0000000..f4409d2
--- /dev/null
+++ b/inst/include/range/v3/view/enumerate.hpp
@@ -0,0 +1,112 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Casey Carter 2018-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ENUMERATE_HPP
+#define RANGES_V3_VIEW_ENUMERATE_HPP
+
+#include <range/v3/core.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/zip.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // Counts from zero up.
+        // See https://github.com/ericniebler/range-v3/issues/1141
+        // for why we don't just use iota_view.
+        template<typename Size, typename Diff>
+        struct index_view : view_facade<index_view<Size, Diff>, infinite>
+        {
+        private:
+            friend range_access;
+
+            struct cursor
+            {
+                using difference_type = Diff;
+
+            private:
+                friend range_access;
+                Size index_{0};
+
+                Size read() const
+                {
+                    return index_;
+                }
+                void next()
+                {
+                    ++index_;
+                }
+                bool equal(cursor const & that) const
+                {
+                    return that.index_ == index_;
+                }
+                void prev()
+                {
+                    --index_;
+                }
+                void advance(Diff n)
+                {
+                    index_ += static_cast<Size>(n);
+                }
+                Diff distance_to(cursor const & that) const
+                {
+                    return static_cast<Diff>(static_cast<Diff>(that.index_) -
+                                             static_cast<Diff>(index_));
+                }
+
+            public:
+                cursor() = default;
+            };
+            cursor begin_cursor() const
+            {
+                return cursor{};
+            }
+            unreachable_sentinel_t end_cursor() const
+            {
+                return unreachable;
+            }
+
+        public:
+            index_view() = default;
+        };
+    } // namespace detail
+    /// \endcond
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        /// Lazily pairs each element in a source range with
+        /// its corresponding index.
+        struct enumerate_fn
+        {
+            template<typename Rng>
+            auto CPP_fun(operator())(Rng && rng)(const requires viewable_range<Rng>)
+            {
+                using D = range_difference_t<Rng>;
+                using S = detail::iter_size_t<iterator_t<Rng>>;
+                return zip(detail::index_view<S, D>(), all(static_cast<Rng &&>(rng)));
+            }
+        };
+
+        /// \relates enumerate_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<enumerate_fn>, enumerate)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/exclusive_scan.hpp b/inst/include/range/v3/view/exclusive_scan.hpp
new file mode 100644
index 0000000..442e9ab
--- /dev/null
+++ b/inst/include/range/v3/view/exclusive_scan.hpp
@@ -0,0 +1,183 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Mitsutaka Takeda 2018-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGE_V3_VIEW_EXCLUSIVE_SCAN_HPP
+#define RANGE_V3_VIEW_EXCLUSIVE_SCAN_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    // clang-format off
+    CPP_def
+    (
+        template(typename Rng, typename T, typename Fun)
+        concept exclusive_scan_constraints,
+            viewable_range<Rng> && input_range<Rng> &&
+            copy_constructible<T> &&
+            invocable<Fun &, T, range_reference_t<Rng>> &&
+            assignable_from<T &, invoke_result_t<Fun &, T, range_reference_t<Rng>>>
+    );
+    // clang-format on
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename T, typename Fun>
+    struct exclusive_scan_view : view_adaptor<exclusive_scan_view<Rng, T, Fun>, Rng>
+    {
+    private:
+        friend range_access;
+        CPP_assert(exclusive_scan_constraints<Rng, T, Fun>);
+
+        semiregular_box_t<T> init_;
+        semiregular_box_t<Fun> fun_;
+        using single_pass = meta::bool_<single_pass_iterator_<iterator_t<Rng>>>;
+        using use_sentinel_t = meta::bool_<!common_range<Rng> || single_pass{}>;
+
+        template<bool IsConst>
+        struct adaptor : adaptor_base
+        {
+        private:
+            friend struct adaptor<!IsConst>;
+            using exclusive_scan_view_t = meta::const_if_c<IsConst, exclusive_scan_view>;
+            using CRng = meta::const_if_c<IsConst, Rng>;
+            semiregular_box_t<T> sum_;
+            exclusive_scan_view_t * rng_;
+
+            // clang-format off
+            auto CPP_auto_fun(move_or_copy_init)(std::false_type)
+            (
+                return (rng_->init_)
+            )
+
+            // If the base range is single-pass, we can move the init value.
+            auto CPP_auto_fun(move_or_copy_init)(std::true_type)
+            (
+                return std::move(rng_->init_)
+            )
+                // clang-format on
+                public : using single_pass = exclusive_scan_view::single_pass;
+            adaptor() = default;
+            adaptor(exclusive_scan_view_t * rng)
+              : rng_(rng)
+            {}
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other)) adaptor(adaptor<Other> that)
+              : rng_(that.rng_)
+            {}
+            iterator_t<CRng> begin(exclusive_scan_view_t &)
+            {
+                sum_ = move_or_copy_init(single_pass{});
+                return ranges::begin(rng_->base());
+            }
+            T read(iterator_t<CRng> const &) const
+            {
+                return sum_;
+            }
+            void next(iterator_t<CRng> & it)
+            {
+                RANGES_EXPECT(it != ranges::end(rng_->base()));
+                sum_ = invoke(rng_->fun_, static_cast<T &&>(std::move(sum_)), *it);
+                ++it;
+            }
+            void prev() = delete;
+        };
+
+        adaptor<false> begin_adaptor()
+        {
+            return {this};
+        }
+        meta::if_<use_sentinel_t, adaptor_base, adaptor<false>> end_adaptor()
+        {
+            return {this};
+        }
+        CPP_member
+        auto begin_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires exclusive_scan_constraints<Rng const, T, Fun const>)
+        {
+            return {this};
+        }
+        CPP_member
+        auto end_adaptor() const
+            -> CPP_ret(meta::if_<use_sentinel_t, adaptor_base, adaptor<true>>)( //
+                requires exclusive_scan_constraints<Rng const, T, Fun const>)
+        {
+            return {this};
+        }
+
+    public:
+        exclusive_scan_view() = default;
+        constexpr exclusive_scan_view(Rng rng, T init, Fun fun)
+          : exclusive_scan_view::view_adaptor{std::move(rng)}
+          , init_(std::move(init))
+          , fun_(std::move(fun))
+        {}
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(this->base());
+        }
+        CPP_member
+        auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(this->base());
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename T,
+                 typename Fun)(requires copy_constructible<T> && copy_constructible<Fun>)
+        exclusive_scan_view(Rng &&, T, Fun)
+            ->exclusive_scan_view<views::all_t<Rng>, T, Fun>;
+#endif
+
+    namespace views
+    {
+        struct exclusive_scan_base_fn
+        {
+            template<typename Rng, typename T, typename Fun = plus>
+            constexpr auto operator()(Rng && rng, T init, Fun fun = Fun{}) const
+                -> CPP_ret(exclusive_scan_view<all_t<Rng>, T, Fun>)( //
+                    requires exclusive_scan_constraints<Rng, T, Fun>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(init), std::move(fun)};
+            }
+        };
+
+        struct exclusive_scan_fn : exclusive_scan_base_fn
+        {
+            using exclusive_scan_base_fn::operator();
+
+            template<typename T, typename Fun = plus>
+            constexpr auto operator()(T init, Fun fun = {}) const
+            {
+                return make_view_closure(
+                    bind_back(exclusive_scan_base_fn{}, std::move(init), std::move(fun)));
+            }
+        };
+
+        /// \relates exclusive_scan_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(exclusive_scan_fn, exclusive_scan)
+    } // namespace views
+    /// @}
+} // namespace ranges
+#endif // RANGE_V3_VIEW_EXCLUSIVE_SCAN_HPP
diff --git a/inst/include/range/v3/view/facade.hpp b/inst/include/range/v3/view/facade.hpp
new file mode 100644
index 0000000..52df23e
--- /dev/null
+++ b/inst/include/range/v3/view/facade.hpp
@@ -0,0 +1,133 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_FACADE_HPP
+#define RANGES_V3_VIEW_FACADE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/basic_iterator.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/view/interface.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Derived>
+        using begin_cursor_t = detail::decay_t<decltype(
+            range_access::begin_cursor(std::declval<Derived &>()))>;
+
+        template<typename Derived>
+        using end_cursor_t = detail::decay_t<decltype(
+            range_access::end_cursor(std::declval<Derived &>()))>;
+
+        template<typename Derived>
+        using facade_iterator_t = basic_iterator<begin_cursor_t<Derived>>;
+
+        template<typename Derived>
+        using facade_sentinel_t =
+            meta::if_c<same_as<begin_cursor_t<Derived>, end_cursor_t<Derived>>,
+                       facade_iterator_t<Derived>, end_cursor_t<Derived>>;
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+
+    /// \brief A utility for constructing a view from a (derived) type that
+    /// implements begin and end cursors.
+    /// \tparam Derived A type that derives from `view_facade` and implements
+    /// begin and end cursors. This type is permitted to be incomplete.
+    /// \tparam Cardinality The cardinality of this view: `finite`, `infinite`,
+    /// or `unknown`. See `ranges::cardinality`.
+    template<typename Derived, cardinality Cardinality>
+    struct view_facade : view_interface<Derived, Cardinality>
+    {
+    protected:
+        friend range_access;
+        using view_interface<Derived, Cardinality>::derived;
+        struct view_as_cursor : Derived
+        {
+            view_as_cursor() = default;
+            explicit view_as_cursor(Derived const * derived)
+              : Derived(*derived)
+            {}
+            explicit operator bool() = delete;
+            explicit operator bool() const = delete;
+        };
+        // Default implementations
+        constexpr view_as_cursor begin_cursor() const
+        {
+            return view_as_cursor{&derived()};
+        }
+        constexpr default_sentinel_t end_cursor() const
+        {
+            return {};
+        }
+
+    public:
+        /// Let `d` be `static_cast<Derived &>(*this)`. Let `b` be
+        /// `std::as_const(d).begin_cursor()` if that expression is well-formed;
+        /// otherwise, let `b` be `d.begin_cursor()`. Let `B` be the type of
+        /// `b`.
+        /// \return `ranges::basic_iterator<B>(b)`
+        template<typename D = Derived>
+        constexpr auto begin() -> CPP_ret(detail::facade_iterator_t<D>)( //
+            requires same_as<D, Derived>)
+        {
+            return detail::facade_iterator_t<D>{range_access::begin_cursor(derived())};
+        }
+        /// \overload
+        template<typename D = Derived>
+        constexpr auto begin() const -> CPP_ret(detail::facade_iterator_t<D const>)( //
+            requires same_as<D, Derived>)
+        {
+            return detail::facade_iterator_t<D const>{
+                range_access::begin_cursor(derived())};
+        }
+        /// Let `d` be `static_cast<Derived &>(*this)`. Let `e` be
+        /// `std::as_const(d).end_cursor()` if that expression is well-formed;
+        /// otherwise, let `e` be `d.end_cursor()`. Let `E` be the type of
+        /// `e`.
+        /// \return `ranges::basic_iterator<E>(e)` if `E` is the same
+        /// as `B` computed above for `begin()`; otherwise, return `e`.
+        template<typename D = Derived>
+        constexpr auto end() -> CPP_ret(detail::facade_sentinel_t<D>)( //
+            requires same_as<D, Derived>)
+        {
+            return static_cast<detail::facade_sentinel_t<D>>(
+                range_access::end_cursor(derived()));
+        }
+        /// \overload
+        template<typename D = Derived>
+        constexpr auto end() const -> CPP_ret(detail::facade_sentinel_t<D const>)( //
+            requires same_as<D, Derived>)
+        {
+            return static_cast<detail::facade_sentinel_t<D const>>(
+                range_access::end_cursor(derived()));
+        }
+    };
+
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/filter.hpp b/inst/include/range/v3/view/filter.hpp
new file mode 100644
index 0000000..625cd33
--- /dev/null
+++ b/inst/include/range/v3/view/filter.hpp
@@ -0,0 +1,135 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_FILTER_HPP
+#define RANGES_V3_VIEW_FILTER_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/not_fn.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/remove_if.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Pred>
+    struct filter_view : remove_if_view<Rng, logical_negate<Pred>>
+    {
+        filter_view() = default;
+        constexpr filter_view(Rng rng, Pred pred)
+          : filter_view::remove_if_view{std::move(rng), not_fn(std::move(pred))}
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Pred)( //
+        requires input_range<Rng> && indirect_unary_predicate<Pred, iterator_t<Rng>> &&
+            view_<Rng> && std::is_object<Pred>::value) //
+        filter_view(Rng &&, Pred)
+            ->filter_view<views::all_t<Rng>, Pred>;
+#endif
+
+    namespace views
+    {
+        struct filter_fn;
+
+        /// Given a source range and a unary predicate,
+        /// present a view of the elements that satisfy the predicate.
+        struct cpp20_filter_base_fn
+        {
+            template<typename Rng, typename Pred>
+            constexpr auto operator()(Rng && rng, Pred pred) const
+                -> CPP_ret(filter_view<all_t<Rng>, Pred>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<Pred, iterator_t<Rng>>)
+            {
+                return filter_view<all_t<Rng>, Pred>{all(static_cast<Rng &&>(rng)),
+                                                     std::move(pred)};
+            }
+        };
+
+        struct cpp20_filter_fn : cpp20_filter_base_fn
+        {
+            using cpp20_filter_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(
+                    bind_back(cpp20_filter_base_fn{}, std::move(pred)));
+            }
+        };
+
+        /// Given a source range, unary predicate, and optional projection,
+        /// present a view of the elements that satisfy the predicate.
+        struct filter_base_fn : cpp20_filter_base_fn
+        {
+            using cpp20_filter_base_fn::operator();
+
+            template<typename Rng, typename Pred, typename Proj>
+            constexpr auto operator()(Rng && rng, Pred pred, Proj proj) const
+                -> CPP_ret(filter_view<all_t<Rng>, composed<Pred, Proj>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<Pred, projected<iterator_t<Rng>, Proj>>)
+            {
+                return filter_view<all_t<Rng>, composed<Pred, Proj>>{
+                    all(static_cast<Rng &&>(rng)),
+                    compose(std::move(pred), std::move(proj))};
+            }
+        };
+
+        struct filter_fn : filter_base_fn
+        {
+            using filter_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(bind_back(filter_base_fn{}, std::move(pred)));
+            }
+
+            template<typename Pred, typename Proj>
+            constexpr auto operator()(Pred pred, Proj proj) const
+            {
+                return make_view_closure(
+                    bind_back(filter_base_fn{}, std::move(pred), std::move(proj)));
+            }
+        };
+
+        /// \relates filter_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(filter_fn, filter)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            RANGES_INLINE_VARIABLE(ranges::views::cpp20_filter_fn, filter)
+        }
+        CPP_template(typename V, typename Pred)( //
+            requires input_range<V> && indirect_unary_predicate<Pred, iterator_t<V>> &&
+                view_<V> && std::is_object<Pred>::value) //
+            using filter_view = ranges::filter_view<V, Pred>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::filter_view)
+
+#endif
diff --git a/inst/include/range/v3/view/for_each.hpp b/inst/include/range/v3/view/for_each.hpp
new file mode 100644
index 0000000..b666029
--- /dev/null
+++ b/inst/include/range/v3/view/for_each.hpp
@@ -0,0 +1,136 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_FOR_EACH_HPP
+#define RANGES_V3_VIEW_FOR_EACH_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/generate_n.hpp>
+#include <range/v3/view/join.hpp>
+#include <range/v3/view/repeat_n.hpp>
+#include <range/v3/view/single.hpp>
+#include <range/v3/view/transform.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    namespace views
+    {
+        /// Lazily applies an unary function to each element in the source
+        /// range that returns another range (possibly empty), flattening
+        /// the result.
+        struct for_each_base_fn
+        {
+            template<typename Rng, typename Fun>
+            constexpr auto CPP_fun(operator())(Rng && rng, Fun fun)(
+                const requires viewable_range<Rng> && transformable_range<Rng, Fun> &&
+                    joinable_range<transform_view<all_t<Rng>, Fun>>)
+            {
+                return join(transform(static_cast<Rng &&>(rng), std::move(fun)));
+            }
+        };
+
+        struct for_each_fn : for_each_base_fn
+        {
+            using for_each_base_fn::operator();
+
+            template<typename Fun>
+            constexpr auto operator()(Fun fun) const
+            {
+                return make_view_closure(bind_back(for_each_base_fn{}, std::move(fun)));
+            }
+        };
+
+        /// \relates for_each_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(for_each_fn, for_each)
+    } // namespace views
+
+    struct yield_fn
+    {
+        template<typename V>
+        auto operator()(V v) const -> CPP_ret(single_view<V>)( //
+            requires copy_constructible<V>)
+        {
+            return views::single(std::move(v));
+        }
+    };
+
+    /// \relates yield_fn
+    /// \ingroup group-views
+    RANGES_INLINE_VARIABLE(yield_fn, yield)
+
+    struct yield_from_fn
+    {
+        template<typename Rng>
+        auto operator()(Rng rng) const -> CPP_ret(Rng)( //
+            requires view_<Rng>)
+        {
+            return rng;
+        }
+    };
+
+    /// \relates yield_from_fn
+    /// \ingroup group-views
+    RANGES_INLINE_VARIABLE(yield_from_fn, yield_from)
+
+    struct yield_if_fn
+    {
+        template<typename V>
+        repeat_n_view<V> operator()(bool b, V v) const
+        {
+            return views::repeat_n(std::move(v), b ? 1 : 0);
+        }
+    };
+
+    /// \relates yield_if_fn
+    /// \ingroup group-views
+    RANGES_INLINE_VARIABLE(yield_if_fn, yield_if)
+
+    struct lazy_yield_if_fn
+    {
+        template<typename F>
+        auto operator()(bool b, F f) const -> CPP_ret(generate_n_view<F>)( //
+            requires invocable<F &>)
+        {
+            return views::generate_n(std::move(f), b ? 1 : 0);
+        }
+    };
+
+    /// \relates lazy_yield_if_fn
+    /// \ingroup group-views
+    RANGES_INLINE_VARIABLE(lazy_yield_if_fn, lazy_yield_if)
+    /// @}
+
+    /// \cond
+    CPP_template(typename Rng, typename Fun)( //
+        requires viewable_range<Rng> && views::transformable_range<Rng, Fun> &&
+            input_range<invoke_result_t<Fun &, range_reference_t<Rng>>>) //
+        auto
+        operator>>=(Rng && rng, Fun fun)
+    {
+        return views::for_each(static_cast<Rng &&>(rng), std::move(fun));
+    }
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/generate.hpp b/inst/include/range/v3/view/generate.hpp
new file mode 100644
index 0000000..6c4944e
--- /dev/null
+++ b/inst/include/range/v3/view/generate.hpp
@@ -0,0 +1,117 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_GENERATE_HPP
+#define RANGES_V3_VIEW_GENERATE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename G>
+    struct generate_view : view_facade<generate_view<G>, infinite>
+    {
+    private:
+        friend range_access;
+        using result_t = invoke_result_t<G &>;
+        semiregular_box_t<G> gen_;
+        detail::non_propagating_cache<result_t> val_;
+        struct cursor
+        {
+        private:
+            generate_view * view_;
+
+        public:
+            cursor() = default;
+            explicit cursor(generate_view * view)
+              : view_(view)
+            {}
+            result_t && read() const
+            {
+                if(!view_->val_)
+                    view_->val_.emplace(view_->gen_());
+                return static_cast<result_t &&>(static_cast<result_t &>(*view_->val_));
+            }
+            void next()
+            {
+                if(view_->val_)
+                    view_->val_.reset();
+                else
+                    view_->gen_();
+            }
+        };
+        cursor begin_cursor()
+        {
+            return cursor{this};
+        }
+        unreachable_sentinel_t end_cursor() const
+        {
+            return {};
+        }
+
+    public:
+        generate_view() = default;
+        explicit generate_view(G g)
+          : gen_(std::move(g))
+        {}
+        result_t & cached()
+        {
+            return *val_;
+        }
+    };
+
+    namespace views
+    {
+        struct generate_fn
+        {
+            template<typename G>
+            auto operator()(G g) const -> CPP_ret(generate_view<G>)( //
+                requires invocable<G &> && copy_constructible<G> &&
+                    std::is_object<detail::decay_t<invoke_result_t<G &>>>::value &&
+                        constructible_from<detail::decay_t<invoke_result_t<G &>>,
+                                           invoke_result_t<G &>> &&
+                            assignable_from<detail::decay_t<invoke_result_t<G &>> &,
+                                            invoke_result_t<G &>>)
+            {
+                return generate_view<G>{std::move(g)};
+            }
+        };
+
+        /// \relates generate_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(generate_fn, generate)
+    } // namespace views
+    /// \@}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::generate_view)
+
+#endif
diff --git a/inst/include/range/v3/view/generate_n.hpp b/inst/include/range/v3/view/generate_n.hpp
new file mode 100644
index 0000000..365f893
--- /dev/null
+++ b/inst/include/range/v3/view/generate_n.hpp
@@ -0,0 +1,124 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_GENERATE_N_HPP
+#define RANGES_V3_VIEW_GENERATE_N_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/generate.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename G>
+    struct generate_n_view : view_facade<generate_n_view<G>, finite>
+    {
+    private:
+        friend range_access;
+        using result_t = invoke_result_t<G &>;
+        semiregular_box_t<G> gen_;
+        detail::non_propagating_cache<result_t> val_;
+        std::size_t n_;
+        struct cursor
+        {
+        private:
+            generate_n_view * rng_;
+
+        public:
+            cursor() = default;
+            explicit cursor(generate_n_view * rng)
+              : rng_(rng)
+            {}
+            bool equal(default_sentinel_t) const
+            {
+                return 0 == rng_->n_;
+            }
+            result_t && read() const
+            {
+                if(!rng_->val_)
+                    rng_->val_.emplace(rng_->gen_());
+                return static_cast<result_t &&>(static_cast<result_t &>(*rng_->val_));
+            }
+            void next()
+            {
+                RANGES_EXPECT(0 != rng_->n_);
+                if(rng_->val_)
+                    rng_->val_.reset();
+                else
+                    rng_->gen_();
+                --rng_->n_;
+            }
+        };
+        cursor begin_cursor()
+        {
+            return cursor{this};
+        }
+
+    public:
+        generate_n_view() = default;
+        explicit generate_n_view(G g, std::size_t n)
+          : gen_(std::move(g))
+          , n_(n)
+        {}
+        result_t & cached()
+        {
+            return *val_;
+        }
+        std::size_t size() const
+        {
+            return n_;
+        }
+    };
+
+    namespace views
+    {
+        struct generate_n_fn
+        {
+            template<typename G>
+            auto operator()(G g, std::size_t n) const -> CPP_ret(generate_n_view<G>)( //
+                requires invocable<G &> && copy_constructible<G> &&
+                    std::is_object<detail::decay_t<invoke_result_t<G &>>>::value &&
+                        constructible_from<detail::decay_t<invoke_result_t<G &>>,
+                                           invoke_result_t<G &>> &&
+                            assignable_from<detail::decay_t<invoke_result_t<G &>> &,
+                                            invoke_result_t<G &>>)
+            {
+                return generate_n_view<G>{std::move(g), n};
+            }
+        };
+
+        /// \relates generate_n_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(generate_n_fn, generate_n)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::generate_n_view)
+
+#endif
diff --git a/inst/include/range/v3/view/getlines.hpp b/inst/include/range/v3/view/getlines.hpp
new file mode 100644
index 0000000..26e228f
--- /dev/null
+++ b/inst/include/range/v3/view/getlines.hpp
@@ -0,0 +1,108 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_GETLINES_HPP
+#define RANGES_V3_VIEW_GETLINES_HPP
+
+#include <istream>
+#include <string>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    struct getlines_view : view_facade<getlines_view, unknown>
+    {
+    private:
+        friend range_access;
+        std::istream * sin_;
+        std::string str_;
+        char delim_;
+        struct cursor
+        {
+        private:
+            friend range_access;
+            using single_pass = std::true_type;
+            getlines_view * rng_ = nullptr;
+
+        public:
+            cursor() = default;
+            explicit cursor(getlines_view * rng)
+              : rng_(rng)
+            {}
+            void next()
+            {
+                rng_->next();
+            }
+            std::string & read() const noexcept
+            {
+                return rng_->str_;
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return !rng_->sin_;
+            }
+            bool equal(cursor that) const
+            {
+                return !rng_->sin_ == !that.rng_->sin_;
+            }
+        };
+        void next()
+        {
+            if(!std::getline(*sin_, str_, delim_))
+                sin_ = nullptr;
+        }
+        cursor begin_cursor()
+        {
+            return cursor{this};
+        }
+
+    public:
+        getlines_view() = default;
+        getlines_view(std::istream & sin, char delim = '\n')
+          : sin_(&sin)
+          , str_{}
+          , delim_(delim)
+        {
+            this->next(); // prime the pump
+        }
+        std::string & cached() noexcept
+        {
+            return str_;
+        }
+    };
+
+    /// \cond
+    using getlines_range RANGES_DEPRECATED(
+        "getlines_range has been renamed getlines_view") = getlines_view;
+    /// \endcond
+
+    struct getlines_fn
+    {
+        getlines_view operator()(std::istream & sin, char delim = '\n') const
+        {
+            return getlines_view{sin, delim};
+        }
+    };
+
+    RANGES_INLINE_VARIABLE(getlines_fn, getlines)
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/group_by.hpp b/inst/include/range/v3/view/group_by.hpp
new file mode 100644
index 0000000..305c253
--- /dev/null
+++ b/inst/include/range/v3/view/group_by.hpp
@@ -0,0 +1,180 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_GROUP_BY_HPP
+#define RANGES_V3_VIEW_GROUP_BY_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/take_while.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    // TODO group_by could support Input ranges by keeping mutable state in
+    // the range itself. The group_by view would then be mutable-only and
+    // Input.
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Fun>
+    struct group_by_view
+      : view_facade<group_by_view<Rng, Fun>,
+                    is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+    {
+    private:
+        friend range_access;
+        Rng rng_;
+        semiregular_box_t<Fun> fun_;
+
+        template<bool IsConst>
+        struct cursor
+        {
+        private:
+            friend struct cursor<!IsConst>;
+            friend range_access;
+            friend group_by_view;
+            using CRng = meta::const_if_c<IsConst, Rng>;
+            iterator_t<CRng> cur_;
+            sentinel_t<CRng> last_;
+            semiregular_box_ref_or_val_t<Fun, IsConst> fun_;
+
+            struct pred
+            {
+                iterator_t<CRng> first_;
+                semiregular_box_ref_or_val_t<Fun, IsConst> fun_;
+                bool operator()(range_reference_t<CRng> r) const
+                {
+                    return invoke(fun_, *first_, r);
+                }
+            };
+#ifdef RANGES_WORKAROUND_MSVC_787074
+            template<bool Const = IsConst>
+            auto read() const
+                -> take_while_view<subrange<iterator_t<meta::const_if_c<Const, Rng>>,
+                                            sentinel_t<meta::const_if_c<Const, Rng>>>,
+                                   pred>
+#else  // ^^^ workaround / no workaround vvv
+            auto read() const
+                -> take_while_view<subrange<iterator_t<CRng>, sentinel_t<CRng>>, pred>
+#endif // RANGES_WORKAROUND_MSVC_787074
+            {
+                return {{cur_, last_}, {cur_, fun_}};
+            }
+            void next()
+            {
+                cur_ = find_if_not(cur_, last_, pred{cur_, fun_});
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return cur_ == last_;
+            }
+            bool equal(cursor const & that) const
+            {
+                return cur_ == that.cur_;
+            }
+            cursor(semiregular_box_ref_or_val_t<Fun, IsConst> fun, iterator_t<CRng> first,
+                   sentinel_t<CRng> last)
+              : cur_(first)
+              , last_(last)
+              , fun_(fun)
+            {}
+
+        public:
+            cursor() = default;
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other)) cursor(cursor<Other> that)
+              : cur_(std::move(that.cur_))
+              , last_(std::move(last_))
+              , fun_(std::move(that.fun_))
+            {}
+        };
+        cursor<false> begin_cursor()
+        {
+            return {fun_, ranges::begin(rng_), ranges::end(rng_)};
+        }
+        template<bool Const = true>
+        auto begin_cursor() const -> CPP_ret(cursor<Const>)( //
+            requires Const && range<meta::const_if_c<Const, Rng>> && invocable<
+                Fun const &, range_common_reference_t<meta::const_if_c<Const, Rng>>,
+                range_common_reference_t<meta::const_if_c<Const, Rng>>>)
+        {
+            return {fun_, ranges::begin(rng_), ranges::end(rng_)};
+        }
+
+    public:
+        group_by_view() = default;
+        constexpr group_by_view(Rng rng, Fun fun)
+          : rng_(std::move(rng))
+          , fun_(std::move(fun))
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Fun>)
+        group_by_view(Rng &&, Fun)
+            ->group_by_view<views::all_t<Rng>, Fun>;
+#endif
+
+    namespace views
+    {
+        struct group_by_base_fn
+        {
+            template<typename Rng, typename Fun>
+            constexpr auto operator()(Rng && rng, Fun fun) const
+                -> CPP_ret(group_by_view<all_t<Rng>, Fun>)( //
+                    requires viewable_range<Rng> && forward_range<Rng> &&
+                        indirect_relation<Fun, iterator_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(fun)};
+            }
+        };
+
+        struct group_by_fn : group_by_base_fn
+        {
+            using group_by_base_fn::operator();
+
+            template<typename Fun>
+            constexpr auto operator()(Fun fun) const
+            {
+                return make_view_closure(bind_back(group_by_base_fn{}, std::move(fun)));
+            }
+        };
+
+        /// \relates group_by_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(group_by_fn, group_by)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::group_by_view)
+
+#endif
diff --git a/inst/include/range/v3/view/indices.hpp b/inst/include/range/v3/view/indices.hpp
new file mode 100644
index 0000000..52cd960
--- /dev/null
+++ b/inst/include/range/v3/view/indices.hpp
@@ -0,0 +1,77 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Gonzalo Brito Gadeschi
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_INDICES_HPP
+#define RANGES_V3_VIEW_INDICES_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/iota.hpp>
+#include <range/v3/view/take_exactly.hpp>
+
+namespace ranges
+{
+    namespace views
+    {
+        /// Half-open range of indices: [from, to).
+        struct indices_fn : iota_view<std::size_t>
+        {
+            indices_fn() = default;
+
+            template<typename Val>
+            auto operator()(Val to) const -> CPP_ret(iota_view<Val, Val>)( //
+                requires integral<Val>)
+            {
+                return {Val(), to};
+            }
+            template<typename Val>
+            auto operator()(Val from, Val to) const -> CPP_ret(iota_view<Val, Val>)( //
+                requires integral<Val>)
+            {
+                return {from, to};
+            }
+        };
+
+        /// Inclusive range of indices: [from, to].
+        struct closed_indices_fn
+        {
+            template<typename Val>
+            auto operator()(Val to) const -> CPP_ret(closed_iota_view<Val>)( //
+                requires integral<Val>)
+            {
+                return {Val(), to};
+            }
+            template<typename Val>
+            auto operator()(Val from, Val to) const -> CPP_ret(closed_iota_view<Val>)( //
+                requires integral<Val>)
+            {
+                return {from, to};
+            }
+        };
+
+        /// \relates indices_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(indices_fn, indices)
+
+        /// \relates closed_indices_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(closed_indices_fn, closed_indices)
+    } // namespace views
+} // namespace ranges
+
+#endif // RANGES_V3_VIEW_INDICES_HPP
diff --git a/inst/include/range/v3/view/indirect.hpp b/inst/include/range/v3/view/indirect.hpp
new file mode 100644
index 0000000..669dbdf
--- /dev/null
+++ b/inst/include/range/v3/view/indirect.hpp
@@ -0,0 +1,140 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_INDIRECT_HPP
+#define RANGES_V3_VIEW_INDIRECT_HPP
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct indirect_view : view_adaptor<indirect_view<Rng>, Rng>
+    {
+    private:
+        friend range_access;
+
+        template<bool IsConst>
+        struct adaptor : adaptor_base
+        {
+            friend adaptor<!IsConst>;
+            using CRng = meta::const_if_c<IsConst, Rng>;
+
+            adaptor() = default;
+            CPP_template(bool Other)(         //
+                requires IsConst && (!Other)) //
+                constexpr adaptor(adaptor<Other>) noexcept
+            {}
+
+            // clang-format off
+            constexpr auto CPP_auto_fun(read)(iterator_t<CRng> const &it)(const)
+            (
+                return **it
+            )
+            constexpr auto CPP_auto_fun(iter_move)(iterator_t<CRng> const &it)(const)
+            (
+                return ranges::iter_move(*it)
+            )
+            // clang-format on
+        };
+
+        CPP_member
+        constexpr auto begin_adaptor() noexcept -> CPP_ret(adaptor<false>)( //
+            requires(!simple_view<Rng>()))
+        {
+            return {};
+        }
+        CPP_member
+        constexpr auto begin_adaptor() const noexcept -> CPP_ret(adaptor<true>)( //
+            requires range<Rng const>)
+        {
+            return {};
+        }
+
+        CPP_member
+        constexpr auto end_adaptor() noexcept -> CPP_ret(adaptor<false>)( //
+            requires(!simple_view<Rng>()))
+        {
+            return {};
+        }
+        CPP_member
+        constexpr auto end_adaptor() const noexcept -> CPP_ret(adaptor<true>)( //
+            requires range<Rng const>)
+        {
+            return {};
+        }
+
+    public:
+        indirect_view() = default;
+        explicit constexpr indirect_view(Rng rng)
+          : indirect_view::view_adaptor{detail::move(rng)}
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(this->base());
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(this->base());
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    indirect_view(Rng &&)->indirect_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct indirect_fn
+        {
+            template<typename Rng>
+            constexpr auto CPP_fun(operator())(Rng && rng)(
+                const requires viewable_range<Rng> && input_range<Rng> &&
+                // We shouldn't need to strip references to test if something
+                // is readable. https://github.com/ericniebler/stl2/issues/594
+                // readable<range_reference_t<Rng>>)
+                ((bool)readable<range_value_t<Rng>>)) // Cast to bool needed for GCC (???)
+            {
+                return indirect_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        /// \relates indirect_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<indirect_fn>, indirect)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::indirect_view)
+
+#endif
diff --git a/inst/include/range/v3/view/interface.hpp b/inst/include/range/v3/view/interface.hpp
new file mode 100644
index 0000000..b0255d7
--- /dev/null
+++ b/inst/include/range/v3/view/interface.hpp
@@ -0,0 +1,529 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_VIEW_INTERFACE_HPP
+#define RANGES_V3_VIEW_INTERFACE_HPP
+
+#include <iosfwd>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/common_iterator.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+
+#if defined(RANGES_WORKAROUND_GCC_91525)
+#define CPP_template_gcc_workaround CPP_template_sfinae
+#else
+#define CPP_template_gcc_workaround CPP_template
+#endif
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename From, typename To = From>
+        struct slice_bounds
+        {
+            From from;
+            To to;
+            template<typename F, typename T>
+            constexpr CPP_ctor(slice_bounds)(F f, T t)( //
+                requires convertible_to<F, From> && convertible_to<T, To>)
+              : from(static_cast<From>(f))
+              , to(static_cast<To>(t))
+            {}
+        };
+
+        template<typename Int>
+        struct from_end_
+        {
+            Int dist_;
+
+            constexpr explicit from_end_(Int dist)
+              : dist_(dist)
+            {}
+
+            CPP_template(typename Other)(                                               //
+                requires integer_like_<Other> && explicitly_convertible_to<Other, Int>) //
+                constexpr
+                operator from_end_<Other>() const
+            {
+                return from_end_<Other>{static_cast<Other>(dist_)};
+            }
+        };
+
+        template<typename Rng>
+        using from_end_of_t = from_end_<range_difference_t<Rng>>;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng)
+            concept can_empty_,
+                requires (Rng &rng)
+                (
+                    ranges::empty(rng)
+                )
+        );
+        // clang-format on
+
+        constexpr bool has_fixed_size_(cardinality c) noexcept
+        {
+            return c >= 0 || c == infinite;
+        }
+
+        template<bool>
+        struct dependent_
+        {
+            template<typename T>
+            using invoke = T;
+        };
+
+        template<typename Stream, typename Rng>
+        Stream & print_rng_(Stream & sout, Rng & rng)
+        {
+            sout << '[';
+            auto it = ranges::begin(rng);
+            auto const e = ranges::end(rng);
+            if(it != e)
+            {
+                for(;;)
+                {
+                    sout << *it;
+                    if(++it == e)
+                        break;
+                    sout << ',';
+                }
+            }
+            sout << ']';
+            return sout;
+        }
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Derived, cardinality Cardinality /* = finite*/>
+    struct view_interface : basic_view<Cardinality>
+    {
+    protected:
+        template<bool B>
+        using D = meta::invoke<detail::dependent_<B>, Derived>;
+
+        constexpr Derived & derived() noexcept
+        {
+            CPP_assert(derived_from<Derived, view_interface>);
+            return static_cast<Derived &>(*this);
+        }
+        /// \overload
+        constexpr Derived const & derived() const noexcept
+        {
+            CPP_assert(derived_from<Derived, view_interface>);
+            return static_cast<Derived const &>(*this);
+        }
+        ~view_interface() = default;
+
+    public:
+        view_interface() = default;
+        view_interface(view_interface &&) = default;
+        view_interface(view_interface const &) = default;
+        view_interface & operator=(view_interface &&) = default;
+        view_interface & operator=(view_interface const &) = default;
+        // A few ways of testing whether a range can be empty:
+        CPP_member
+        constexpr auto empty() const noexcept -> CPP_ret(bool)( //
+            requires(detail::has_fixed_size_(Cardinality)))
+        {
+            return Cardinality == 0;
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto empty() noexcept(noexcept(
+            bool(ranges::size(std::declval<D<True> &>()) == 0))) -> CPP_ret(bool)( //
+            requires True && (Cardinality < 0) && (Cardinality != infinite) &&
+            (!forward_range<D<True>>)&&sized_range<D<True>>)
+        {
+            return ranges::size(derived()) == 0;
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto empty() const
+            noexcept(noexcept(bool(ranges::size(std::declval<D<True> const &>()) == 0)))
+                -> CPP_ret(bool)( //
+                    requires True && (Cardinality < 0) && (Cardinality != infinite) &&
+                    (!forward_range<D<True> const>)&&sized_range<D<True> const>)
+        {
+            return ranges::size(derived()) == 0;
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto empty() noexcept(
+            noexcept(bool(ranges::begin(std::declval<D<True> &>()) ==
+                          ranges::end(std::declval<D<True> &>())))) -> CPP_ret(bool)( //
+            requires True && (!detail::has_fixed_size_(Cardinality)) &&
+            forward_range<D<True>>)
+        {
+            return bool(ranges::begin(derived()) == ranges::end(derived()));
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto empty() const
+            noexcept(noexcept(bool(ranges::begin(std::declval<D<True> const &>()) ==
+                                   ranges::end(std::declval<D<True> const &>()))))
+                -> CPP_ret(bool)( //
+                    requires True && (!detail::has_fixed_size_(Cardinality)) &&
+                    forward_range<D<True> const>)
+        {
+            return bool(ranges::begin(derived()) == ranges::end(derived()));
+        }
+        CPP_template_gcc_workaround(bool True = true)(    //
+            requires True && detail::can_empty_<D<True>>) // clang-format off
+        constexpr explicit operator bool()
+            noexcept(noexcept(ranges::empty(std::declval<D<True> &>())))
+        {
+            return !ranges::empty(derived());
+        }
+        // clang-format on
+        /// \overload
+        CPP_template_gcc_workaround(bool True = true)(          //
+            requires True && detail::can_empty_<D<True> const>) // clang-format off
+        constexpr explicit operator bool() const
+            noexcept(noexcept(ranges::empty(std::declval<D<True> const &>())))
+        {
+            return !ranges::empty(derived());
+        }
+        // clang-format on
+        /// If the size of the range is known at compile-time and finite,
+        /// return it.
+        template<bool True = true, int = 42>
+        static constexpr auto size() noexcept -> CPP_ret(std::size_t)( //
+            requires True && (Cardinality >= 0))
+        {
+            return static_cast<std::size_t>(Cardinality);
+        }
+        /// If `sized_sentinel_for<sentinel_t<Derived>, iterator_t<Derived>>` is
+        /// satisfied, and if `Derived` is a `forward_range`, then return
+        /// `end - begin` cast to an unsigned integer.
+        template<bool True = true>
+        constexpr auto size() -> CPP_ret(detail::iter_size_t<iterator_t<D<True>>>)( //
+            requires True && (Cardinality < 0) &&
+            sized_sentinel_for<sentinel_t<D<True>>, iterator_t<D<True>>> &&
+            forward_range<D<True>>)
+        {
+            using size_type = detail::iter_size_t<iterator_t<D<True>>>;
+            return static_cast<size_type>(derived().end() - derived().begin());
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto size() const                               //
+            -> CPP_ret(detail::iter_size_t<iterator_t<D<True>>>)( //
+                requires True && (Cardinality < 0) &&
+                sized_sentinel_for<sentinel_t<D<True> const>,
+                                   iterator_t<D<True> const>> &&
+                forward_range<D<True> const>)
+        {
+            using size_type = detail::iter_size_t<iterator_t<D<True>>>;
+            return static_cast<size_type>(derived().end() - derived().begin());
+        }
+        /// Access the first element in a range:
+        template<bool True = true>
+        constexpr auto front() -> CPP_ret(range_reference_t<D<True>>)( //
+            requires True && forward_range<D<True>>)
+        {
+            return *derived().begin();
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto front() const -> CPP_ret(range_reference_t<D<True> const>)( //
+            requires True && forward_range<D<True> const>)
+        {
+            return *derived().begin();
+        }
+        /// Access the last element in a range:
+        template<bool True = true>
+        constexpr auto back() -> CPP_ret(range_reference_t<D<True>>)( //
+            requires True && common_range<D<True>> && bidirectional_range<D<True>>)
+        {
+            return *prev(derived().end());
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto back() const -> CPP_ret(range_reference_t<D<True> const>)( //
+            requires True && common_range<D<True> const> &&
+                bidirectional_range<D<True> const>)
+        {
+            return *prev(derived().end());
+        }
+        /// Simple indexing:
+        template<bool True = true>
+        constexpr auto operator[](range_difference_t<D<True>> n)
+            -> CPP_ret(range_reference_t<D<True>>)( //
+                requires True && random_access_range<D<True>>)
+        {
+            return derived().begin()[n];
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto operator[](range_difference_t<D<True>> n) const
+            -> CPP_ret(range_reference_t<D<True> const>)( //
+                requires True && random_access_range<D<True> const>)
+        {
+            return derived().begin()[n];
+        }
+        /// Returns a reference to the element at specified location pos, with bounds
+        /// checking.
+        template<bool True = true>
+        constexpr auto at(range_difference_t<D<True>> n)
+            -> CPP_ret(range_reference_t<D<True>>)( //
+                requires True && random_access_range<D<True>> && sized_range<D<True>>)
+        {
+            using size_type = range_size_t<Derived>;
+            if(n < 0 || size_type(n) >= ranges::size(derived()))
+            {
+                throw std::out_of_range("view_interface::at");
+            }
+            return derived().begin()[n];
+        }
+        /// \overload
+        template<bool True = true>
+        constexpr auto at(range_difference_t<D<True>> n) const
+            -> CPP_ret(range_reference_t<D<True> const>)( //
+                requires True && random_access_range<D<True> const> &&
+                    sized_range<D<True> const>)
+        {
+            using size_type = range_size_t<Derived const>;
+            if(n < 0 || size_type(n) >= ranges::size(derived()))
+            {
+                throw std::out_of_range("view_interface::at");
+            }
+            return derived().begin()[n];
+        }
+        /// Python-ic slicing:
+        //      rng[{4,6}]
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && input_range<D<True> &>)                      //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && input_range<D<True> const &>)                //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) const &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && input_range<D<True>>)                        //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) &&
+        {
+            return Slice{}(detail::move(derived()), offs.from, offs.to);
+        }
+        //      rng[{4,end-2}]
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)(      //
+            requires True && input_range<D<True> &> && sized_range<D<True> &>) //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>,
+                                            detail::from_end_of_t<D<True>>>
+                           offs) &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && input_range<D<True> const &> &&
+                sized_range<D<True> const &>) //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>,
+                                            detail::from_end_of_t<D<True>>>
+                           offs) const &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)(  //
+            requires True && input_range<D<True>> && sized_range<D<True>>) //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>,
+                                            detail::from_end_of_t<D<True>>>
+                           offs) &&
+        {
+            return Slice{}(detail::move(derived()), offs.from, offs.to);
+        }
+        //      rng[{end-4,end-2}]
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && (forward_range<D<True> &> ||
+                              (input_range<D<True> &> && sized_range<D<True> &>))) //
+            constexpr auto
+            operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
+                                            detail::from_end_of_t<D<True>>>
+                           offs) &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True &&
+            (forward_range<D<True> const &> ||
+             (input_range<D<True> const &> && sized_range<D<True> const &>))) //
+            constexpr auto
+            operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
+                                            detail::from_end_of_t<D<True>>>
+                           offs) const &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True &&
+            (forward_range<D<True>> || (input_range<D<True>> && sized_range<D<True>>))) //
+            constexpr auto
+            operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
+                                            detail::from_end_of_t<D<True>>>
+                           offs) &&
+        {
+            return Slice{}(detail::move(derived()), offs.from, offs.to);
+        }
+        //      rng[{4,end}]
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && input_range<D<True> &>)                      //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && input_range<D<True> const &>)                //
+            constexpr auto
+            operator[](
+                detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) const &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && input_range<D<True>>)                        //
+            constexpr auto
+            operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) &&
+        {
+            return Slice{}(detail::move(derived()), offs.from, offs.to);
+        }
+        //      rng[{end-4,end}]
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True && (forward_range<D<True> &> ||
+                              (input_range<D<True> &> && sized_range<D<True> &>))) //
+            constexpr auto
+            operator[](
+                detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True &&
+            (forward_range<D<True> const &> ||
+             (input_range<D<True> const &> && sized_range<D<True> const &>))) //
+            constexpr auto
+            operator[](
+                detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) const &
+        {
+            return Slice{}(derived(), offs.from, offs.to);
+        }
+        /// \overload
+        CPP_template(bool True = true, typename Slice = views::slice_fn)( //
+            requires True &&
+            (forward_range<D<True>> || (input_range<D<True>> && sized_range<D<True>>))) //
+            constexpr auto
+            operator[](
+                detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) &&
+        {
+            return Slice{}(detail::move(derived()), offs.from, offs.to);
+        }
+        /// \cond
+        /// Implicit conversion to something that looks like a container.
+        CPP_template(typename Container, bool True = true)( // clang-format off
+            requires detail::convertible_to_cont<D<True>, Container>)
+        RANGES_DEPRECATED(
+            "Implicit conversion from a view to a container is deprecated. "
+            "Please use ranges::to in <range/v3/range/conversion.hpp> instead.")
+        constexpr operator Container() // clang-format on
+        {
+            return ranges::to<Container>(derived());
+        }
+        /// \overload
+        CPP_template(typename Container, bool True = true)( // clang-format off
+            requires detail::convertible_to_cont<D<True> const, Container>)
+        RANGES_DEPRECATED(
+            "Implicit conversion from a view to a container is deprecated. "
+            "Please use ranges::to in <range/v3/range/conversion.hpp> instead.")
+        constexpr operator Container() const // clang-format on
+        {
+            return ranges::to<Container>(derived());
+        }
+        /// \endcond
+    private:
+        /// \brief Print a range to an ostream
+        template<bool True = true>
+        friend auto operator<<(std::ostream & sout, Derived const & rng)
+            -> CPP_broken_friend_ret(std::ostream &)( //
+                requires True && input_range<D<True> const>)
+        {
+            return detail::print_rng_(sout, rng);
+        }
+        /// \overload
+        template<bool True = true>
+        friend auto operator<<(std::ostream & sout, Derived & rng)
+            -> CPP_broken_friend_ret(std::ostream &)( //
+                requires True && (!range<D<True> const>)&&input_range<D<True>>)
+        {
+            return detail::print_rng_(sout, rng);
+        }
+        /// \overload
+        template<bool True = true>
+        friend auto operator<<(std::ostream & sout, Derived && rng)
+            -> CPP_broken_friend_ret(std::ostream &)( //
+                requires True && (!range<D<True> const>)&&input_range<D<True>>)
+        {
+            return detail::print_rng_(sout, rng);
+        }
+    };
+
+    namespace cpp20
+    {
+        CPP_template(typename Derived)( //
+            requires std::is_class<Derived>::value &&
+                same_as<Derived, meta::_t<std::remove_cv<Derived>>>) //
+            using view_interface = ranges::view_interface<Derived, ranges::unknown>;
+    }
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/intersperse.hpp b/inst/include/range/v3/view/intersperse.hpp
new file mode 100644
index 0000000..de3adb9
--- /dev/null
+++ b/inst/include/range/v3/view/intersperse.hpp
@@ -0,0 +1,238 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_INTERSPERSE_HPP
+#define RANGES_V3_VIEW_INTERSPERSE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct intersperse_view
+      : view_adaptor<intersperse_view<Rng>, Rng,
+                     (range_cardinality<Rng>::value > 0)
+                         ? static_cast<cardinality>(range_cardinality<Rng>::value * 2 - 1)
+                         : range_cardinality<Rng>::value>
+    {
+        intersperse_view() = default;
+        constexpr intersperse_view(Rng rng, range_value_t<Rng> val)
+          : intersperse_view::view_adaptor{detail::move(rng)}
+          , val_(detail::move(val))
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            auto const n = ranges::size(this->base());
+            return n ? n * 2 - 1 : 0;
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            auto const n = ranges::size(this->base());
+            return n ? n * 2 - 1 : 0;
+        }
+
+    private:
+        friend range_access;
+        template<bool Const>
+        struct cursor_adaptor : adaptor_base
+        {
+        private:
+            friend struct cursor_adaptor<!Const>;
+            using CRng = meta::const_if_c<Const, Rng>;
+            bool toggle_ = false;
+            range_value_t<Rng> val_;
+
+        public:
+            cursor_adaptor() = default;
+            explicit constexpr cursor_adaptor(range_value_t<Rng> const & val)
+              : val_{val}
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) cursor_adaptor(cursor_adaptor<Other> that)
+              : toggle_(that.toggle_)
+              , val_(std::move(that.val_))
+            {}
+            template<typename View>
+            constexpr iterator_t<CRng> begin(View & view)
+            {
+                auto first = ranges::begin(view.base());
+                toggle_ = first != ranges::end(view.base());
+                return first;
+            }
+            constexpr range_value_t<Rng> read(iterator_t<CRng> const & it) const
+            {
+                return toggle_ ? *it : val_;
+            }
+            CPP_member
+            constexpr auto equal(iterator_t<CRng> const & it0,
+                                 iterator_t<CRng> const & it1,
+                                 cursor_adaptor const & other) const -> CPP_ret(bool)( //
+                requires sentinel_for<iterator_t<CRng>, iterator_t<CRng>>)
+            {
+                return it0 == it1 && toggle_ == other.toggle_;
+            }
+            constexpr void next(iterator_t<CRng> & it)
+            {
+                if(toggle_)
+                    ++it;
+                toggle_ = !toggle_;
+            }
+            CPP_member
+            constexpr auto prev(iterator_t<CRng> & it) -> CPP_ret(void)( //
+                requires bidirectional_range<CRng>)
+            {
+                toggle_ = !toggle_;
+                if(toggle_)
+                    --it;
+            }
+            CPP_member
+            constexpr auto distance_to(iterator_t<CRng> const & it,
+                                       iterator_t<CRng> const & other_it,
+                                       cursor_adaptor const & other) const
+                -> CPP_ret(range_difference_t<Rng>)( //
+                    requires sized_sentinel_for<iterator_t<CRng>, iterator_t<CRng>>)
+            {
+                return (other_it - it) * 2 + (other.toggle_ - toggle_);
+            }
+            CPP_member
+            constexpr auto advance(iterator_t<CRng> & it,
+                                   range_difference_t<CRng> n) -> CPP_ret(void)( //
+                requires random_access_range<CRng>)
+            {
+                ranges::advance(it, n >= 0 ? (n + toggle_) / 2 : (n - !toggle_) / 2);
+                if(n % 2 != 0)
+                    toggle_ = !toggle_;
+            }
+        };
+        template<bool Const>
+        struct sentinel_adaptor : adaptor_base
+        {
+        private:
+            using CRng = meta::const_if_c<Const, Rng>;
+
+        public:
+            sentinel_adaptor() = default;
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) sentinel_adaptor(sentinel_adaptor<Other>)
+            {}
+            static constexpr bool empty(iterator_t<CRng> const & it,
+                                        cursor_adaptor<Const> const &,
+                                        sentinel_t<CRng> const & sent)
+            {
+                return it == sent;
+            }
+        };
+        constexpr auto begin_adaptor() -> cursor_adaptor<false>
+        {
+            return cursor_adaptor<false>{val_};
+        }
+        CPP_member
+        constexpr auto begin_adaptor() const -> CPP_ret(cursor_adaptor<true>)( //
+            requires range<Rng const>)
+        {
+            return cursor_adaptor<true>{val_};
+        }
+        CPP_member
+        constexpr auto end_adaptor() -> CPP_ret(cursor_adaptor<false>)( //
+            requires common_range<Rng> && (!single_pass_iterator_<iterator_t<Rng>>))
+        {
+            return cursor_adaptor<false>{val_};
+        }
+        CPP_member
+        constexpr auto end_adaptor() noexcept -> CPP_ret(sentinel_adaptor<false>)( //
+            requires(!common_range<Rng>) || single_pass_iterator_<iterator_t<Rng>>)
+        {
+            return {};
+        }
+        template<bool Const = true>
+        constexpr auto end_adaptor() const -> CPP_ret(cursor_adaptor<Const>)( //
+            requires Const && range<meta::const_if_c<Const, Rng>> &&
+                common_range<meta::const_if_c<Const, Rng>> &&
+            (!single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng>>>))
+        {
+            return cursor_adaptor<true>{val_};
+        }
+        template<bool Const = true>
+        constexpr auto end_adaptor() const noexcept
+            -> CPP_ret(sentinel_adaptor<Const>)( //
+                requires Const && range<meta::const_if_c<Const, Rng>> &&
+                (!common_range<meta::const_if_c<Const, Rng>> ||
+                 single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng>>>))
+        {
+            return {};
+        }
+
+        range_value_t<Rng> val_;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    intersperse_view(Rng &&, range_value_t<Rng>)->intersperse_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct intersperse_base_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng, range_value_t<Rng> val) const
+                -> CPP_ret(intersperse_view<all_t<Rng>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        convertible_to<range_reference_t<Rng>, range_value_t<Rng>> &&
+                            semiregular<range_value_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(val)};
+            }
+        };
+
+        struct intersperse_fn : intersperse_base_fn
+        {
+            using intersperse_base_fn::operator();
+
+            template<typename T>
+            constexpr auto CPP_fun(operator())(T t)(const //
+                                                    requires copyable<T>)
+            {
+                return make_view_closure(bind_back(intersperse_base_fn{}, std::move(t)));
+            }
+        };
+
+        /// \relates intersperse_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(intersperse_fn, intersperse)
+    } // namespace views
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::intersperse_view)
+
+#endif
diff --git a/inst/include/range/v3/view/iota.hpp b/inst/include/range/v3/view/iota.hpp
new file mode 100644
index 0000000..3722613
--- /dev/null
+++ b/inst/include/range/v3/view/iota.hpp
@@ -0,0 +1,569 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_IOTA_HPP
+#define RANGES_V3_VIEW_IOTA_HPP
+
+#include <climits>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/diffmax_t.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/delimit.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/take_exactly.hpp>
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
+RANGES_DIAGNOSTIC_IGNORE_TRUNCATION
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<std::size_t N, typename = void>
+        struct promote_as_signed_
+        {
+            // This shouldn't cause us to LOSE precision, but maybe it doesn't
+            // net us any either.
+            static_assert(sizeof(std::intmax_t) * CHAR_BIT >= N,
+                          "Possible extended integral type?");
+            using difference_type = diffmax_t;
+        };
+
+        template<std::size_t N>
+        struct promote_as_signed_<N, enable_if_t<(N < 16)>>
+        {
+            using difference_type = std::int_fast16_t;
+        };
+
+        template<std::size_t N>
+        struct promote_as_signed_<N, enable_if_t<(N >= 16 && N < 32)>>
+        {
+            using difference_type = std::int_fast32_t;
+        };
+
+        template<std::size_t N>
+        struct promote_as_signed_<N, enable_if_t<(N >= 32 && N < 64)>>
+        {
+            using difference_type = std::int_fast64_t;
+        };
+
+        template<typename I>
+        using iota_difference_t = typename if_then_t<
+            std::is_integral<I>::value && sizeof(I) == sizeof(iter_difference_t<I>),
+            promote_as_signed_<sizeof(iter_difference_t<I>) * CHAR_BIT>,
+            with_difference_type_<iter_difference_t<I>>>::difference_type;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename I)
+            concept decrementable_,
+                requires (I i)
+                (
+                    --i,
+                    i--,
+                    concepts::requires_<same_as<I&, decltype(--i)>>,
+                    concepts::requires_<same_as<I, decltype(i--)>>
+                ) &&
+                incrementable<I>
+        );
+
+        CPP_def
+        (
+            template(typename I)
+            concept advanceable_,
+                requires (I i, I const j, iota_difference_t<I> const n)
+                (
+                    j - j,
+                    i += n,
+                    i -= n,
+                    static_cast<I>(j - n),
+                    static_cast<I>(j + n),
+                    static_cast<I>(n + j),
+                    // NOT TO SPEC:
+                    // Unsigned integers are advanceable, but subtracting them results in
+                    // an unsigned integral, which is not the same as the difference type,
+                    // which is signed.
+                    concepts::requires_<convertible_to<decltype(j - j), iota_difference_t<I>>>,
+                    concepts::requires_<same_as<I&, decltype(i += n)>>,
+                    concepts::requires_<same_as<I&, decltype(i -= n)>> //,
+                    // concepts::requires_<convertible_to<decltype(i - n), I>>,
+                    // concepts::requires_<convertible_to<decltype(i + n), I>>,
+                    // concepts::requires_<convertible_to<decltype(n + i), I>>
+                ) &&
+                decrementable_<I> && totally_ordered<I>
+        );
+        // clang-format on
+
+        template<typename I>
+        auto iota_advance_(I & i, iota_difference_t<I> n) -> CPP_ret(void)( //
+            requires(!unsigned_integral<I>))
+        {
+            // TODO: bounds-check this
+            i += n;
+        }
+
+        template<typename Int>
+        auto iota_advance_(Int & i, iota_difference_t<Int> n) -> CPP_ret(void)( //
+            requires unsigned_integral<Int>)
+        {
+            // TODO: bounds-check this
+            if(n >= 0)
+                i += static_cast<Int>(n);
+            else
+                i -= static_cast<Int>(-n);
+        }
+
+        template<typename I>
+        auto iota_distance_(I const & i, I const & s) -> CPP_ret(iota_difference_t<I>)( //
+            requires advanceable_<I> && (!integral<I>))
+        {
+            return static_cast<iota_difference_t<I>>(s - i);
+        }
+
+        template<typename Int>
+        auto iota_distance_(Int i0, Int i1) -> CPP_ret(iota_difference_t<Int>)( //
+            requires signed_integral<Int>)
+        {
+            // TODO: bounds-check this
+            return static_cast<iota_difference_t<Int>>(
+                static_cast<iota_difference_t<Int>>(i1) -
+                static_cast<iota_difference_t<Int>>(i0));
+        }
+
+        template<typename Int>
+        auto iota_distance_(Int i0, Int i1) -> CPP_ret(iota_difference_t<Int>)( //
+            requires unsigned_integral<Int>)
+        {
+            // TODO: bounds-check this
+            return (i0 > i1) ? static_cast<iota_difference_t<Int>>(
+                                   -static_cast<iota_difference_t<Int>>(i0 - i1))
+                             : static_cast<iota_difference_t<Int>>(i1 - i0);
+        }
+    } // namespace detail
+    /// \endcond
+
+    /// \cond
+    namespace iota_view_detail
+    {
+        struct adl_hook
+        {};
+
+        // Extension: iota_view models forwarding-range, as suggested by
+        // https://github.com/ericniebler/stl2/issues/575
+        template<class From, class To>
+        constexpr auto begin(iota_view<From, To> r)
+        {
+            return r.begin();
+        }
+        template<class From, class To>
+        constexpr auto end(iota_view<From, To> r)
+        {
+            return r.end();
+        }
+
+        template<class From, class To>
+        constexpr auto begin(closed_iota_view<From, To> r)
+        {
+            return r.begin();
+        }
+        template<class From, class To>
+        constexpr auto end(closed_iota_view<From, To> r)
+        {
+            return r.end();
+        }
+    } // namespace iota_view_detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+
+    /// An iota view in a closed range
+    template<typename From, typename To /* = From */>
+    struct RANGES_EMPTY_BASES closed_iota_view
+      : view_facade<closed_iota_view<From, To>, finite>
+      , private iota_view_detail::adl_hook
+    {
+    private:
+        friend range_access;
+
+        From from_ = From();
+        RANGES_NO_UNIQUE_ADDRESS To to_ = To();
+
+        struct cursor
+        {
+            using difference_type = detail::iota_difference_t<From>;
+
+        private:
+            friend range_access;
+            From from_ = From();
+            RANGES_NO_UNIQUE_ADDRESS To to_ = To();
+            bool done_ = false;
+
+            From read() const
+            {
+                RANGES_EXPECT(!done_);
+                return from_;
+            }
+            void next()
+            {
+                RANGES_EXPECT(!done_);
+                if(from_ == to_)
+                    done_ = true;
+                else
+                    ++from_;
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return done_;
+            }
+            CPP_member
+            auto equal(cursor const & that) const -> CPP_ret(bool)( //
+                requires equality_comparable<From>)
+            {
+                return that.from_ == from_ && that.done_ == done_;
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires detail::decrementable_<From>)
+            {
+                if(done_)
+                    done_ = false;
+                else
+                    --from_;
+            }
+            CPP_member
+            auto advance(difference_type n) -> CPP_ret(void)( //
+                requires detail::advanceable_<From>)
+            {
+                if(n > 0)
+                {
+                    RANGES_ENSURE(detail::iota_distance_(from_, to_) >= n - !done_);
+                    detail::iota_advance_(
+                        from_,
+                        n - (done_ = (detail::iota_distance_(from_, to_) <= n - !done_)));
+                }
+                else if(n < 0)
+                    detail::iota_advance_(from_, n + std::exchange(done_, false));
+            }
+            CPP_member
+            auto distance_to(cursor const & that) const -> CPP_ret(difference_type)( //
+                requires detail::advanceable_<From>)
+            {
+                using D = difference_type;
+                return static_cast<D>(detail::iota_distance_(from_, that.from_)) +
+                       ((D)that.done_ - (D)done_);
+            }
+            CPP_member
+            auto distance_to(default_sentinel_t) const -> CPP_ret(difference_type)( //
+                requires sized_sentinel_for<To, From>)
+            {
+                return difference_type(to_ - from_) + !done_;
+            }
+
+        public:
+            cursor() = default;
+            constexpr cursor(From from, To to, bool done = false)
+              : from_(std::move(from))
+              , to_(std::move(to))
+              , done_(done)
+            {}
+        };
+
+        cursor begin_cursor() const
+        {
+            return {from_, to_};
+        }
+        CPP_member
+        auto end_cursor() const -> CPP_ret(cursor)( //
+            requires same_as<From, To>)
+        {
+            return {to_, to_, true};
+        }
+        CPP_member
+        auto end_cursor() const -> CPP_ret(default_sentinel_t)( //
+            requires(!same_as<From, To>))
+        {
+            return {};
+        }
+
+        constexpr void check_bounds_(std::true_type)
+        {
+            RANGES_EXPECT(from_ <= to_);
+        }
+        constexpr void check_bounds_(std::false_type)
+        {}
+
+    public:
+        closed_iota_view() = default;
+        constexpr closed_iota_view(meta::id_t<From> from, meta::id_t<To> to)
+          : from_(std::move(from))
+          , to_(std::move(to))
+        {
+            check_bounds_(meta::bool_<totally_ordered_with<From, To>>{});
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename From, typename To)( //
+        requires weakly_incrementable<From> && semiregular<To> &&
+        (!integral<From> || !integral<To> ||
+         std::is_signed<From>::value == std::is_signed<To>::value)) //
+        closed_iota_view(From, To)
+            ->closed_iota_view<From, To>;
+#endif
+
+    template<typename From, typename To /* = unreachable_sentinel_t*/>
+    struct RANGES_EMPTY_BASES iota_view
+      : view_facade<iota_view<From, To>,
+                    same_as<To, unreachable_sentinel_t>
+                        ? infinite
+                        : std::is_integral<From>::value && std::is_integral<To>::value
+                              ? finite
+                              : unknown>
+      , private iota_view_detail::adl_hook
+    {
+    private:
+        friend range_access;
+        From from_ = From();
+        RANGES_NO_UNIQUE_ADDRESS To to_ = To();
+
+        struct cursor;
+        struct sentinel
+        {
+        private:
+            friend struct cursor;
+            RANGES_NO_UNIQUE_ADDRESS To to_;
+
+        public:
+            sentinel() = default;
+            constexpr explicit sentinel(To to)
+              : to_(std::move(to))
+            {}
+        };
+
+        struct cursor
+        {
+            using difference_type = detail::iota_difference_t<From>;
+
+        private:
+            friend range_access;
+            From from_;
+
+            From read() const
+            {
+                return from_;
+            }
+            void next()
+            {
+                ++from_;
+            }
+            bool equal(sentinel const & that) const
+            {
+                return from_ == that.to_;
+            }
+            CPP_member
+            auto equal(cursor const & that) const -> CPP_ret(bool)( //
+                requires equality_comparable<From>)
+            {
+                return that.from_ == from_;
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires detail::decrementable_<From>)
+            {
+                --from_;
+            }
+            CPP_member
+            auto advance(difference_type n) -> CPP_ret(void)( //
+                requires detail::advanceable_<From>)
+            {
+                detail::iota_advance_(from_, n);
+            }
+            // Not to spec: TODO the relational operators will effectively be constrained
+            // with Advanceable, but they should be constrained with totally_ordered.
+            // Reimplement iota_view without view_facade or basic_iterator.
+            CPP_member
+            auto distance_to(cursor const & that) const -> CPP_ret(difference_type)( //
+                requires detail::advanceable_<From>)
+            {
+                return detail::iota_distance_(from_, that.from_);
+            }
+            // Extension: see https://github.com/ericniebler/stl2/issues/613
+            CPP_member
+            auto distance_to(sentinel const & that) const -> CPP_ret(difference_type)( //
+                requires sized_sentinel_for<To, From>)
+            {
+                return that.to_ - from_;
+            }
+
+        public:
+            cursor() = default;
+            constexpr explicit cursor(From from)
+              : from_(std::move(from))
+            {}
+        };
+        cursor begin_cursor() const
+        {
+            return cursor{from_};
+        }
+        CPP_member
+        auto CPP_fun(end_cursor)()(const requires(same_as<To, unreachable_sentinel_t>))
+        {
+            return unreachable;
+        }
+        CPP_member
+        auto CPP_fun(end_cursor)()(const requires(!same_as<To, unreachable_sentinel_t>))
+        {
+            return detail::if_then_t<same_as<From, To>, cursor, sentinel>{to_};
+        }
+        constexpr void check_bounds_(std::true_type)
+        {
+            RANGES_EXPECT(from_ <= to_);
+        }
+        constexpr void check_bounds_(std::false_type)
+        {}
+
+    public:
+#ifdef RANGES_WORKAROUND_MSVC_934264
+        constexpr
+#endif // RANGES_WORKAROUND_MSVC_934264
+            iota_view() = default;
+        constexpr explicit iota_view(From from)
+          : from_(std::move(from))
+        {}
+        constexpr iota_view(meta::id_t<From> from, meta::id_t<To> to)
+          : from_(std::move(from))
+          , to_(std::move(to))
+        {
+            check_bounds_(meta::bool_<totally_ordered_with<From, To>>{});
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename From, typename To)( //
+        requires weakly_incrementable<From> && semiregular<To> &&
+        (!integral<From> || !integral<To> ||
+         std::is_signed<From>::value == std::is_signed<To>::value)) //
+        iota_view(From, To)
+            ->iota_view<From, To>;
+#endif
+
+    namespace views
+    {
+        struct iota_fn
+        {
+            template<typename From>
+            auto operator()(From value) const -> CPP_ret(iota_view<From>)( //
+                requires weakly_incrementable<From>)
+            {
+                return iota_view<From>{std::move(value)};
+            }
+            template<typename From, typename To>
+            auto operator()(From from, To to) const -> CPP_ret(iota_view<From, To>)( //
+                requires weakly_incrementable<From> && semiregular<To> &&
+                    detail::weakly_equality_comparable_with_<From, To> &&
+                (!integral<From> || !integral<To> ||
+                 std::is_signed<From>::value == std::is_signed<To>::value))
+            {
+                return {std::move(from), std::move(to)};
+            }
+        };
+
+        struct closed_iota_fn
+        {
+            template<typename From, typename To>
+            auto operator()(From from, To to) const
+                -> CPP_ret(closed_iota_view<From, To>)( //
+                    requires weakly_incrementable<From> && semiregular<To> &&
+                        detail::weakly_equality_comparable_with_<From, To> &&
+                    (!integral<From> || !integral<To> ||
+                     std::is_signed<From>::value == std::is_signed<To>::value))
+            {
+                return {std::move(from), std::move(to)};
+            }
+        };
+
+        /// \relates iota_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(iota_fn, iota)
+
+        /// \relates closed_iota_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(closed_iota_fn, closed_iota)
+
+        struct ints_fn : iota_view<int>
+        {
+            ints_fn() = default;
+
+            template<typename Val>
+            RANGES_DEPRECATED(
+                "This potentially confusing API is deprecated. Prefer to "
+                "explicitly specify the upper bound as with ranges::unreachable, as in "
+                "views::ints( n, unreachable )")
+            constexpr auto
+            operator()(Val value) const -> CPP_ret(iota_view<Val>)( //
+                requires integral<Val>)
+            {
+                return iota_view<Val>{value};
+            }
+            template<typename Val>
+            constexpr auto operator()(Val value, unreachable_sentinel_t) const
+                -> CPP_ret(iota_view<Val>)( //
+                    requires integral<Val>)
+            {
+                return iota_view<Val>{value};
+            }
+            template<typename Val>
+            constexpr auto operator()(Val from, Val to) const
+                -> CPP_ret(iota_view<Val, Val>)( //
+                    requires integral<Val>)
+            {
+                return {from, to};
+            }
+        };
+
+        /// \relates ints_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(ints_fn, ints)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::iota;
+        }
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::closed_iota_view)
+RANGES_SATISFY_BOOST_RANGE(::ranges::iota_view)
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/view/istream.hpp b/inst/include/range/v3/view/istream.hpp
new file mode 100644
index 0000000..b95713f
--- /dev/null
+++ b/inst/include/range/v3/view/istream.hpp
@@ -0,0 +1,119 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ISTREAM_HPP
+#define RANGES_V3_VIEW_ISTREAM_HPP
+
+#include <istream>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Val>
+    struct istream_view : view_facade<istream_view<Val>, unknown>
+    {
+    private:
+        friend range_access;
+        std::istream * sin_;
+        semiregular_box_t<Val> obj_;
+        struct cursor
+        {
+        private:
+            friend range_access;
+            using single_pass = std::true_type;
+            istream_view * rng_ = nullptr;
+
+        public:
+            cursor() = default;
+            explicit cursor(istream_view * rng)
+              : rng_(rng)
+            {}
+            void next()
+            {
+                rng_->next();
+            }
+            Val & read() const noexcept
+            {
+                return rng_->cached();
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return !rng_->sin_;
+            }
+            bool equal(cursor that) const
+            {
+                return !rng_->sin_ == !that.rng_->sin_;
+            }
+        };
+        void next()
+        {
+            if(!(*sin_ >> cached()))
+                sin_ = nullptr;
+        }
+        cursor begin_cursor()
+        {
+            return cursor{this};
+        }
+
+    public:
+        istream_view() = default;
+        explicit istream_view(std::istream & sin)
+          : sin_(&sin)
+          , obj_{}
+        {
+            next(); // prime the pump
+        }
+        Val & cached() noexcept
+        {
+            return obj_;
+        }
+    };
+
+    /// \cond
+    template<typename Val>
+    using istream_range RANGES_DEPRECATED(
+        "istream_range<T> has been renamed to istream_view<T>") = istream_view<Val>;
+    /// \endcond
+
+    /// \cond
+    namespace _istream_
+    {
+        /// \endcond
+        template<typename Val>
+        inline auto istream(std::istream & sin) -> CPP_ret(istream_view<Val>)( //
+            requires copy_constructible<Val> && default_constructible<Val>)
+        {
+            return istream_view<Val>{sin};
+        }
+        /// \cond
+    } // namespace _istream_
+    using namespace _istream_;
+    /// \endcond
+
+    namespace cpp20
+    {
+        template<typename Val>
+        using basic_istream_view = ::ranges::istream_view<Val>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/join.hpp b/inst/include/range/v3/view/join.hpp
new file mode 100644
index 0000000..f96f84f
--- /dev/null
+++ b/inst/include/range/v3/view/join.hpp
@@ -0,0 +1,633 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_JOIN_HPP
+#define RANGES_V3_VIEW_JOIN_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/range_for.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/variant.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/single.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // Compute the cardinality of a joined range
+        constexpr cardinality join_cardinality_(
+            cardinality Outer, cardinality Inner,
+            cardinality Joiner = static_cast<cardinality>(0)) noexcept
+        {
+            return Outer == infinite || Inner == infinite ||
+                           (Joiner == infinite && Outer != 0 && Outer != 1)
+                       ? infinite
+                       : Outer == unknown || Inner == unknown ||
+                                 (Joiner == unknown && Outer != 0 && Outer != 1)
+                             ? unknown
+                             : Outer == finite || Inner == finite ||
+                                       (Joiner == finite && Outer != 0 && Outer != 1)
+                                   ? finite
+                                   : static_cast<cardinality>(
+                                         Outer * Inner +
+                                         (Outer == 0 ? 0 : (Outer - 1) * Joiner));
+        }
+
+        template<typename Range>
+        constexpr cardinality join_cardinality() noexcept
+        {
+            return detail::join_cardinality_(
+                range_cardinality<Range>::value,
+                range_cardinality<range_reference_t<Range>>::value);
+        }
+
+        template<typename Range, typename JoinRange>
+        constexpr cardinality join_cardinality() noexcept
+        {
+            return detail::join_cardinality_(
+                range_cardinality<Range>::value,
+                range_cardinality<range_reference_t<Range>>::value,
+                range_cardinality<JoinRange>::value);
+        }
+
+        template<typename Inner>
+        struct store_inner_
+        {
+            views::all_t<Inner> inner_ = views::all_t<Inner>();
+
+            constexpr views::all_t<Inner> & update_inner_(Inner && inner)
+            {
+                return (inner_ = views::all(static_cast<Inner &&>(inner)));
+            }
+            constexpr views::all_t<Inner> & get_inner_(ignore_t) noexcept
+            {
+                return inner_;
+            }
+        };
+
+        struct pass_thru_inner_
+        {
+            // Intentionally promote xvalues to lvalues here:
+            template<typename Inner>
+            static constexpr Inner & update_inner_(Inner && inner) noexcept
+            {
+                return inner;
+            }
+            template<typename OuterIt>
+            static constexpr decltype(auto) get_inner_(OuterIt && outer_it)
+            {
+                return *outer_it;
+            }
+        };
+
+        template<typename Rng>
+        using join_view_inner =
+            if_then_t<!std::is_reference<range_reference_t<Rng>>::value,
+                      store_inner_<range_reference_t<Rng>>, pass_thru_inner_>;
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename I)
+            concept has_member_arrow_,
+                requires (I i)
+                (
+                    i.operator->()
+                )
+        );
+
+        CPP_def
+        (
+            template(typename I)
+            concept has_arrow_,
+                input_iterator<I> && (std::is_pointer<I>::value || has_member_arrow_<I>)
+        );
+        // clang-format on
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+
+    // Join a range of ranges
+    template<typename Rng>
+    struct RANGES_EMPTY_BASES join_view
+      : view_facade<join_view<Rng>, detail::join_cardinality<Rng>()>
+      , private detail::join_view_inner<Rng>
+    {
+        CPP_assert(input_range<Rng> && view_<Rng>);
+        CPP_assert(input_range<range_reference_t<Rng>>);
+        CPP_assert(viewable_range<range_reference_t<Rng>>);
+
+        join_view() = default;
+        explicit join_view(Rng rng)
+          : outer_(views::all(std::move(rng)))
+        {}
+        // Not to spec
+        CPP_member
+        static constexpr auto size() -> CPP_ret(std::size_t)( //
+            requires(detail::join_cardinality<Rng>() >= 0))
+        {
+            return static_cast<std::size_t>(detail::join_cardinality<Rng>());
+        }
+        // Not to spec
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires(detail::join_cardinality<Rng>() < 0) &&
+                                       (range_cardinality<Rng>::value >= 0) &&
+                                       forward_range<Rng> &&
+                                       sized_range<range_reference_t<Rng>>)
+        {
+            range_size_t<range_reference_t<Rng>> n = 0;
+            RANGES_FOR(auto && inner, outer_)
+                n += ranges::size(inner);
+            return n;
+        }
+        // // ericniebler/stl2#605
+        constexpr Rng base() const
+        {
+            return outer_;
+        }
+
+    private:
+        friend range_access;
+        Rng outer_{};
+
+        template<bool Const>
+        struct cursor
+        {
+        private:
+            using Parent = detail::if_then_t<Const, join_view const, join_view>;
+            using COuter = detail::if_then_t<Const, Rng const, Rng>;
+            using CInner = range_reference_t<COuter>;
+            using ref_is_glvalue = std::is_reference<CInner>;
+
+            Parent * rng_ = nullptr;
+            iterator_t<COuter> outer_it_{};
+            iterator_t<CInner> inner_it_{};
+
+            void satisfy()
+            {
+                for(; outer_it_ != ranges::end(rng_->outer_); ++outer_it_)
+                {
+                    auto & inner = rng_->update_inner_(*outer_it_);
+                    inner_it_ = ranges::begin(inner);
+                    if(inner_it_ != ranges::end(inner))
+                        return;
+                }
+                if(RANGES_CONSTEXPR_IF(ref_is_glvalue::value))
+                    inner_it_ = iterator_t<CInner>();
+            }
+
+        public:
+            using single_pass = meta::bool_<single_pass_iterator_<iterator_t<COuter>> ||
+                                            single_pass_iterator_<iterator_t<CInner>> ||
+                                            !ref_is_glvalue::value>;
+            cursor() = default;
+            template<typename BeginOrEnd>
+            constexpr cursor(Parent * rng, BeginOrEnd begin_or_end)
+              : rng_{rng}
+              , outer_it_(begin_or_end(rng->outer_))
+            {
+                satisfy();
+            }
+            CPP_template(bool Other)( //
+                requires Const && (!Other) &&
+                convertible_to<iterator_t<Rng>, iterator_t<COuter>> &&
+                convertible_to<iterator_t<range_reference_t<Rng>>,
+                               iterator_t<CInner>>) //
+                constexpr cursor(cursor<Other> that)
+              : rng_(that.rng_)
+              , outer_it_(std::move(that.outer_it_))
+              , inner_it_(std::move(that.inner_it_))
+            {}
+            CPP_member
+            constexpr auto arrow() -> CPP_ret(iterator_t<CInner>)( //
+                requires detail::has_arrow_<iterator_t<CInner>>)
+            {
+                return inner_it_;
+            }
+            constexpr bool equal(default_sentinel_t) const
+            {
+                return outer_it_ == ranges::end(rng_->outer_);
+            }
+            CPP_member
+            constexpr auto equal(cursor const & that) const -> CPP_ret(bool)( //
+                requires ref_is_glvalue::value && equality_comparable<
+                    iterator_t<COuter>> && equality_comparable<iterator_t<CInner>>)
+            {
+                return outer_it_ == that.outer_it_ && inner_it_ == that.inner_it_;
+            }
+            constexpr void next()
+            {
+                auto && inner_rng = rng_->get_inner_(outer_it_);
+                if(++inner_it_ == ranges::end(inner_rng))
+                {
+                    ++outer_it_;
+                    satisfy();
+                }
+            }
+            CPP_member
+            constexpr auto prev() -> CPP_ret(void)( //
+                requires ref_is_glvalue::value && bidirectional_range<COuter> &&
+                    bidirectional_range<CInner> &&
+                        common_range<CInner>) // ericniebler/stl2#606
+            {
+                if(outer_it_ == ranges::end(rng_->outer_))
+                    inner_it_ = ranges::end(*--outer_it_);
+                while(inner_it_ == ranges::begin(*outer_it_))
+                    inner_it_ = ranges::end(*--outer_it_);
+                --inner_it_;
+            }
+            // clang-format off
+            constexpr auto CPP_auto_fun(read)()(const)
+            (
+                return *inner_it_
+            )
+            constexpr auto CPP_auto_fun(move)()(const)
+            (
+                return iter_move(inner_it_)
+            )
+            // clang-format on
+        };
+        static constexpr bool use_const_always() noexcept
+        {
+            return simple_view<Rng>() && std::is_reference<range_reference_t<Rng>>::value;
+        }
+        struct end_cursor_fn
+        {
+            constexpr auto operator()(join_view * this_, std::true_type) const
+            {
+                return cursor<use_const_always()>{this_, ranges::end};
+            }
+            constexpr auto operator()(join_view *, std::false_type) const
+            {
+                return default_sentinel_t{};
+            }
+        };
+        struct cend_cursor_fn
+        {
+            constexpr auto operator()(join_view const * this_, std::true_type) const
+            {
+                return cursor<true>{this_, ranges::end};
+            }
+            constexpr auto operator()(join_view const *, std::false_type) const
+            {
+                return default_sentinel_t{};
+            }
+        };
+
+        constexpr cursor<use_const_always()> begin_cursor()
+        {
+            return {this, ranges::begin};
+        }
+
+        template<bool Const = true>
+        constexpr auto begin_cursor() const -> CPP_ret(cursor<Const>)( //
+            requires Const && input_range<meta::const_if_c<Const, Rng>> &&
+                std::is_reference<range_reference_t<meta::const_if_c<Const, Rng>>>::value)
+        {
+            return {this, ranges::begin};
+        }
+
+        constexpr auto end_cursor()
+        {
+            using cond =
+                meta::bool_<std::is_reference<range_reference_t<Rng>>::value &&
+                            forward_range<Rng> && forward_range<range_reference_t<Rng>> &&
+                            common_range<Rng> && common_range<range_reference_t<Rng>>>;
+            return end_cursor_fn{}(this, cond{});
+        }
+
+        template<bool Const = true>
+        constexpr auto CPP_fun(end_cursor)()(
+            const requires Const && input_range<meta::const_if_c<Const, Rng>> &&
+                std::is_reference<range_reference_t<meta::const_if_c<Const, Rng>>>::value)
+        {
+            using CRng = meta::const_if_c<Const, Rng>;
+            using cond =
+                meta::bool_<std::is_reference<range_reference_t<CRng>>::value &&
+                            forward_range<CRng> &&
+                            forward_range<range_reference_t<CRng>> &&
+                            common_range<CRng> && common_range<range_reference_t<CRng>>>;
+            return cend_cursor_fn{}(this, cond{});
+        }
+    };
+
+    // Join a range of ranges, inserting a range of values between them.
+    // TODO: Support const iteration when range_reference_t<Rng> is a true reference.
+    template<typename Rng, typename ValRng>
+    struct join_with_view
+      : view_facade<join_with_view<Rng, ValRng>, detail::join_cardinality<Rng, ValRng>()>
+    {
+        CPP_assert(input_range<Rng>);
+        CPP_assert(input_range<range_reference_t<Rng>>);
+        CPP_assert(forward_range<ValRng>);
+        CPP_assert(
+            common_with<range_value_t<range_reference_t<Rng>>, range_value_t<ValRng>>);
+        CPP_assert(semiregular<common_type_t<range_value_t<range_reference_t<Rng>>,
+                                             range_value_t<ValRng>>>);
+
+        join_with_view() = default;
+        join_with_view(Rng rng, ValRng val)
+          : outer_(views::all(std::move(rng)))
+          , val_(views::all(std::move(val)))
+        {}
+        CPP_member
+        static constexpr auto size() -> CPP_ret(std::size_t)( //
+            requires(detail::join_cardinality<Rng, ValRng>() >= 0))
+        {
+            return static_cast<std::size_t>(detail::join_cardinality<Rng, ValRng>());
+        }
+        CPP_member
+        auto CPP_fun(size)()(const requires(detail::join_cardinality<Rng, ValRng>() <
+                                            0) &&
+                             (range_cardinality<Rng>::value >= 0) && forward_range<Rng> &&
+                             sized_range<range_reference_t<Rng>> && sized_range<ValRng>)
+        {
+            range_size_t<range_reference_t<Rng>> n = 0;
+            RANGES_FOR(auto && inner, outer_)
+                n += ranges::size(inner);
+            return n + (range_cardinality<Rng>::value == 0
+                            ? 0
+                            : ranges::size(val_) * (range_cardinality<Rng>::value - 1));
+        }
+
+    private:
+        friend range_access;
+        using Outer = views::all_t<Rng>;
+        using Inner = views::all_t<range_reference_t<Outer>>;
+
+        Outer outer_{};
+        Inner inner_{};
+        views::all_t<ValRng> val_{};
+
+        class cursor
+        {
+            join_with_view * rng_ = nullptr;
+            iterator_t<Outer> outer_it_{};
+            variant<iterator_t<ValRng>, iterator_t<Inner>> cur_{};
+
+            void satisfy()
+            {
+                while(true)
+                {
+                    if(cur_.index() == 0)
+                    {
+                        if(ranges::get<0>(cur_) != ranges::end(rng_->val_))
+                            break;
+                        rng_->inner_ = views::all(*outer_it_);
+                        ranges::emplace<1>(cur_, ranges::begin(rng_->inner_));
+                    }
+                    else
+                    {
+                        if(ranges::get<1>(cur_) != ranges::end(rng_->inner_))
+                            break;
+                        if(++outer_it_ == ranges::end(rng_->outer_))
+                            break;
+                        ranges::emplace<0>(cur_, ranges::begin(rng_->val_));
+                    }
+                }
+            }
+
+        public:
+            using value_type = common_type_t<range_value_t<Inner>, range_value_t<ValRng>>;
+            using reference =
+                common_reference_t<range_reference_t<Inner>, range_reference_t<ValRng>>;
+            using rvalue_reference = common_reference_t<range_rvalue_reference_t<Inner>,
+                                                        range_rvalue_reference_t<ValRng>>;
+            using single_pass = std::true_type;
+            cursor() = default;
+            cursor(join_with_view * rng)
+              : rng_{rng}
+              , outer_it_(ranges::begin(rng->outer_))
+            {
+                if(outer_it_ != ranges::end(rng->outer_))
+                {
+                    rng->inner_ = views::all(*outer_it_);
+                    ranges::emplace<1>(cur_, ranges::begin(rng->inner_));
+                    satisfy();
+                }
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return outer_it_ == ranges::end(rng_->outer_);
+            }
+            void next()
+            {
+                // visit(cur_, [](auto& it){ ++it; });
+                if(cur_.index() == 0)
+                {
+                    auto & it = ranges::get<0>(cur_);
+                    RANGES_ASSERT(it != ranges::end(rng_->val_));
+                    ++it;
+                }
+                else
+                {
+                    auto & it = ranges::get<1>(cur_);
+                    RANGES_ASSERT(it != ranges::end(rng_->inner_));
+                    ++it;
+                }
+                satisfy();
+            }
+            reference read() const
+            {
+                // return visit(cur_, [](auto& it) -> reference { return *it; });
+                if(cur_.index() == 0)
+                    return *ranges::get<0>(cur_);
+                else
+                    return *ranges::get<1>(cur_);
+            }
+            rvalue_reference move() const
+            {
+                // return visit(cur_, [](auto& it) -> rvalue_reference { return
+                // iter_move(it); });
+                if(cur_.index() == 0)
+                    return iter_move(ranges::get<0>(cur_));
+                else
+                    return iter_move(ranges::get<1>(cur_));
+            }
+        };
+        cursor begin_cursor()
+        {
+            return {this};
+        }
+    };
+
+    namespace views
+    {
+        /// \cond
+        // Don't forget to update views::for_each whenever this set
+        // of concepts changes
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng)
+            concept joinable_range,
+                viewable_range<Rng> && input_range<Rng> &&
+                input_range<range_reference_t<Rng>> &&
+                viewable_range<range_reference_t<Rng>>
+        );
+
+        CPP_def
+        (
+            template(typename Rng, typename ValRng)
+            concept joinable_with_range,
+                joinable_range<Rng> &&
+                viewable_range<ValRng> && forward_range<ValRng> &&
+                common_with<range_value_t<ValRng>, range_value_t<range_reference_t<Rng>>> &&
+                semiregular<
+                    common_type_t<
+                        range_value_t<ValRng>,
+                        range_value_t<range_reference_t<Rng>>>> &&
+                common_reference_with<
+                    range_reference_t<ValRng>,
+                    range_reference_t<range_reference_t<Rng>>> &&
+                common_reference_with<
+                    range_rvalue_reference_t<ValRng>,
+                    range_rvalue_reference_t<range_reference_t<Rng>>>
+        );
+        // clang-format on
+        /// \endcond
+
+        struct cpp20_join_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(join_view<all_t<Rng>>)( //
+                requires joinable_range<Rng>)
+            {
+                return join_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        struct join_base_fn : cpp20_join_fn
+        {
+            /// implementation detail
+            template<typename Rng>
+            using inner_value_t = range_value_t<range_reference_t<Rng>>;
+
+            using cpp20_join_fn::operator();
+
+            template<typename Rng>
+            auto operator()(Rng && rng, inner_value_t<Rng> v) const
+                -> CPP_ret(join_with_view<all_t<Rng>,
+                                          single_view<inner_value_t<Rng>>>)( //
+                    requires joinable_with_range<Rng, single_view<inner_value_t<Rng>>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), single(std::move(v))};
+            }
+
+            template<typename Rng, typename ValRng>
+            auto operator()(Rng && rng, ValRng && val) const
+                -> CPP_ret(join_with_view<all_t<Rng>, all_t<ValRng>>)( //
+                    requires joinable_with_range<Rng, ValRng>)
+            {
+                return {all(static_cast<Rng &&>(rng)), all(static_cast<ValRng &&>(val))};
+            }
+        };
+
+        struct join_fn : join_base_fn
+        {
+            using join_base_fn::operator();
+
+            template<typename T>
+            constexpr auto CPP_fun(operator())(T && t)(const //
+                                                       requires(!joinable_range<T>))
+            {
+                return make_view_closure(bind_back(join_base_fn{}, static_cast<T &&>(t)));
+            }
+#ifdef RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+            template<typename T, std::size_t N>
+            struct lamduh
+            {
+                T (&val_)[N];
+
+                template<typename Rng>
+                auto operator()(Rng && rng) const
+                    -> invoke_result_t<join_fn, Rng, T (&)[N]>
+                {
+                    return join_fn{}(static_cast<Rng &&>(rng), val_);
+                }
+            };
+
+            template<typename T, std::size_t N>
+            constexpr view_closure<lamduh<T, N>> operator()(T (&val)[N]) const
+            {
+                return view_closure<lamduh<T, N>>{lamduh<T, N> { val }};
+            }
+#else  // ^^^ workaround / no workaround vvv
+            template<typename T, std::size_t N>
+            constexpr auto operator()(T (&val)[N]) const
+            {
+                return make_view_closure(
+                    [&val](
+                        auto && rng) -> invoke_result_t<join_fn, decltype(rng), T(&)[N]> {
+                        return join_fn{}(static_cast<decltype(rng)>(rng), val);
+                    });
+            }
+#endif // RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+        };
+
+        /// \relates join_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<join_fn>, join)
+    } // namespace views
+    /// @}
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng)(              //
+        requires views::joinable_range<Rng>) //
+        explicit join_view(Rng &&)
+            ->join_view<views::all_t<Rng>>;
+
+    CPP_template(typename Rng, typename ValRng)(          //
+        requires views::joinable_with_range<Rng, ValRng>) //
+        explicit join_with_view(Rng &&, ValRng &&)
+            ->join_with_view<views::all_t<Rng>, views::all_t<ValRng>>;
+#endif
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            RANGES_INLINE_VARIABLE(
+                ranges::views::view_closure<ranges::views::cpp20_join_fn>, join)
+        }
+        CPP_template(typename Rng)( //
+            requires input_range<Rng> && view_<Rng> &&
+                input_range<iter_reference_t<iterator_t<Rng>>> &&
+            (std::is_reference<iter_reference_t<iterator_t<Rng>>>::value ||
+             view_<iter_value_t<iterator_t<Rng>>>)) //
+            using join_view = ranges::join_view<Rng>;
+    } // namespace cpp20
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::join_view)
+RANGES_SATISFY_BOOST_RANGE(::ranges::join_with_view)
+
+#endif
diff --git a/inst/include/range/v3/view/linear_distribute.hpp b/inst/include/range/v3/view/linear_distribute.hpp
new file mode 100644
index 0000000..4609832
--- /dev/null
+++ b/inst/include/range/v3/view/linear_distribute.hpp
@@ -0,0 +1,114 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Casey Carter 2017
+//  Copyright Gonzalo Brito Gadeschi 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_LINEAR_DISTRIBUTE_HPP
+#define RANGES_V3_VIEW_LINEAR_DISTRIBUTE_HPP
+
+#include <type_traits>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    namespace views
+    {
+        /// \addtogroup group-views
+        /// @{
+
+        template<typename T>
+        struct linear_distribute_view : view_facade<linear_distribute_view<T>, finite>
+        {
+            CPP_assert(std::is_arithmetic<T>());
+
+        private:
+            friend range_access;
+
+            T from_, to_;
+            std::ptrdiff_t n_;
+
+            constexpr T read() const noexcept
+            {
+                return from_;
+            }
+            constexpr bool equal(default_sentinel_t) const noexcept
+            {
+                return n_ == 0;
+            }
+            constexpr bool equal(linear_distribute_view const & other) const noexcept
+            {
+                bool const eq = n_ == other.n_;
+                RANGES_DIAGNOSTIC_PUSH
+                RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL
+                RANGES_EXPECT(to_ == other.to_);
+                RANGES_EXPECT(!eq || from_ == other.from_);
+                RANGES_DIAGNOSTIC_POP
+                return eq;
+            }
+            constexpr void next() noexcept
+            {
+                RANGES_EXPECT(n_ > 0);
+                --n_;
+                if(n_ == 0)
+                {
+                    from_ = to_;
+                }
+                else
+                {
+                    from_ += (to_ - from_) / T(n_);
+                }
+            }
+
+        public:
+            constexpr linear_distribute_view() = default;
+            constexpr linear_distribute_view(T from, T to__, std::ptrdiff_t n) noexcept
+              : from_(from)
+              , to_(to__)
+              , n_(n)
+            {
+                RANGES_EXPECT(n_ > 0);
+                RANGES_EXPECT(to_ >= from_);
+            }
+            constexpr std::size_t size() const noexcept
+            {
+                return static_cast<std::size_t>(n_);
+            }
+        };
+
+        /// Distributes `n` values linearly in the closed interval [`from`, `to`].
+        ///
+        /// \pre `from <= to && n > 0`
+        ///
+        /// If `from == to`, returns n-times `to`.
+        /// If `n == 1` returns `to`.
+        struct linear_distribute_fn
+        {
+            template<typename T>
+            constexpr auto CPP_fun(operator())(T from, T to, std::ptrdiff_t n)(
+                const requires std::is_arithmetic<T>::value)
+            {
+                return linear_distribute_view<T>{from, to, n};
+            }
+        };
+
+        /// \relates linear_distribute_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(linear_distribute_fn, linear_distribute)
+    } // namespace views
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/map.hpp b/inst/include/range/v3/view/map.hpp
new file mode 100644
index 0000000..a5ec6cc
--- /dev/null
+++ b/inst/include/range/v3/view/map.hpp
@@ -0,0 +1,140 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_MAP_HPP
+#define RANGES_V3_VIEW_MAP_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/transform.hpp>
+#include <range/v3/view/view.hpp>
+
+// TODO: Reuse subrange's pair_like concept here and have get_first and get_second
+// dispatch through get<>()
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename T>
+        constexpr T & get_first_second_helper(T & t, std::true_type) noexcept
+        {
+            return t;
+        }
+
+        template<typename T>
+        constexpr auto get_first_second_helper(T & t, std::false_type) noexcept(
+            std::is_nothrow_move_constructible<T>::value) -> CPP_ret(T)( //
+            requires move_constructible<T>)
+        {
+            return std::move(t);
+        }
+
+        template<typename P, typename E>
+        using get_first_second_tag = meta::bool_<std::is_lvalue_reference<P>::value ||
+                                                 std::is_lvalue_reference<E>::value>;
+
+        struct get_first
+        {
+            // clang-format off
+            template<typename Pair>
+            constexpr auto CPP_auto_fun(operator())(Pair &&p)(const)
+            (
+                return get_first_second_helper(
+                    p.first,
+                    get_first_second_tag<Pair, decltype(p.first)>{})
+            )
+            // clang-format on
+        };
+
+        struct get_second
+        {
+            // clang-format off
+            template<typename Pair>
+            constexpr auto CPP_auto_fun(operator())(Pair &&p)(const)
+            (
+                return get_first_second_helper(
+                    p.second,
+                    get_first_second_tag<Pair, decltype(p.second)>{})
+            )
+            // clang-format on
+        };
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename T)
+            concept kv_pair_like_,
+                invocable<get_first const &, T> &&
+                invocable<get_second const &, T>
+        );
+        // clang-format on
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        struct keys_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(keys_range_view<all_t<Rng>>)( //
+                requires viewable_range<Rng> && input_range<Rng> &&
+                    detail::kv_pair_like_<range_reference_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), detail::get_first{}};
+            }
+        };
+
+        struct values_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(values_view<all_t<Rng>>)( //
+                requires viewable_range<Rng> && input_range<Rng> &&
+                    detail::kv_pair_like_<range_reference_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), detail::get_second{}};
+            }
+        };
+
+        /// \relates keys_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<keys_fn>, keys)
+
+        /// \relates values_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<values_fn>, values)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::keys;
+            using ranges::views::values;
+        } // namespace views
+        // TODO(@cjdb): provide implementation for elements_view
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/move.hpp b/inst/include/range/v3/view/move.hpp
new file mode 100644
index 0000000..ed2759d
--- /dev/null
+++ b/inst/include/range/v3/view/move.hpp
@@ -0,0 +1,123 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_MOVE_HPP
+#define RANGES_V3_VIEW_MOVE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct move_view : view_adaptor<move_view<Rng>, Rng>
+    {
+    private:
+        friend range_access;
+        template<bool Const>
+        struct adaptor : adaptor_base
+        {
+            adaptor() = default;
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) constexpr adaptor(adaptor<Other>)
+            {}
+            using CRng = meta::const_if_c<Const, Rng>;
+            using value_type = range_value_t<Rng>;
+            range_rvalue_reference_t<CRng> read(iterator_t<CRng> const & it) const
+            {
+                return ranges::iter_move(it);
+            }
+            range_rvalue_reference_t<CRng> iter_move(iterator_t<CRng> const & it) const
+            {
+                return ranges::iter_move(it);
+            }
+        };
+        adaptor<simple_view<Rng>()> begin_adaptor()
+        {
+            return {};
+        }
+        adaptor<simple_view<Rng>()> end_adaptor()
+        {
+            return {};
+        }
+        CPP_member
+        auto begin_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires input_range<Rng const>)
+        {
+            return {};
+        }
+        CPP_member
+        auto end_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires input_range<Rng const>)
+        {
+            return {};
+        }
+
+    public:
+        move_view() = default;
+        explicit move_view(Rng rng)
+          : move_view::view_adaptor{std::move(rng)}
+        {}
+        CPP_member
+        auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(this->base());
+        }
+        CPP_member
+        auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(this->base());
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    move_view(Rng &&)->move_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct move_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const -> CPP_ret(move_view<all_t<Rng>>)( //
+                requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return move_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        /// \relates move_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<move_fn>, move)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::move_view)
+
+#endif
diff --git a/inst/include/range/v3/view/partial_sum.hpp b/inst/include/range/v3/view/partial_sum.hpp
new file mode 100644
index 0000000..7550288
--- /dev/null
+++ b/inst/include/range/v3/view/partial_sum.hpp
@@ -0,0 +1,221 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_PARTIAL_SUM_HPP
+#define RANGES_V3_VIEW_PARTIAL_SUM_HPP
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/arithmetic.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng, typename Fun)
+            concept partial_sum_view_constraints,
+                input_range<Rng> &&
+                copy_constructible<Fun> &&
+                copy_constructible<range_value_t<Rng>> &&
+                constructible_from<range_value_t<Rng>, range_reference_t<Rng>> &&
+                assignable_from<range_value_t<Rng> &, range_reference_t<Rng>> &&
+                indirectly_binary_invocable_<Fun &, iterator_t<Rng>, iterator_t<Rng>> &&
+                assignable_from<
+                    range_value_t<Rng> &,
+                    indirect_result_t<Fun &, iterator_t<Rng>, iterator_t<Rng>>>
+        );
+        // clang-format on
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Fun>
+    struct partial_sum_view
+      : view_facade<partial_sum_view<Rng, Fun>, range_cardinality<Rng>::value>
+    {
+    private:
+        friend range_access;
+        CPP_assert(view_<Rng>);
+        CPP_assert(detail::partial_sum_view_constraints<Rng, Fun>);
+
+        RANGES_NO_UNIQUE_ADDRESS Rng base_{};
+        RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Fun> fun_;
+
+        template<bool IsConst>
+        struct cursor
+        {
+        private:
+            friend cursor<true>;
+
+            using Parent = meta::const_if_c<IsConst, partial_sum_view>;
+            using Base = meta::const_if_c<IsConst, Rng>;
+
+            Parent * parent_ = nullptr;
+            RANGES_NO_UNIQUE_ADDRESS iterator_t<Base> current_{};
+            RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<range_value_t<Rng>> sum_;
+
+        public:
+            using single_pass = meta::bool_<single_pass_iterator_<iterator_t<Base>>>;
+
+            cursor() = default;
+            constexpr explicit cursor(Parent * rng)
+              : parent_{rng}
+              , current_(ranges::begin(rng->base_))
+            {
+                if(current_ != ranges::end(rng->base_))
+                    sum_ = *current_;
+            }
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other) &&
+                convertible_to<iterator_t<Rng> const &,
+                               iterator_t<Base>>) //
+                constexpr cursor(cursor<Other> const & that)
+              : parent_{that.parent_}
+              , current_(that.current_)
+              , sum_(that.sum_)
+            {}
+            constexpr range_value_t<Rng> read() const
+            {
+                RANGES_EXPECT(current_ != ranges::end(parent_->base_));
+                return sum_;
+            }
+            constexpr void next()
+            {
+                auto last = ranges::end(parent_->base_);
+                RANGES_EXPECT(current_ != last);
+                if(++current_ != last)
+                {
+                    auto & sum = static_cast<range_value_t<Rng> &>(sum_);
+                    using F = meta::const_if_c<IsConst, Fun>;
+                    auto & f = static_cast<F &>(parent_->fun_);
+                    sum = invoke(f, sum, *current_);
+                }
+            }
+            constexpr bool equal(default_sentinel_t) const
+            {
+                return current_ == ranges::end(parent_->base_);
+            }
+            CPP_member
+            constexpr bool CPP_fun(equal)(cursor const & that)(
+                const requires equality_comparable<iterator_t<Base>>)
+            {
+                RANGES_EXPECT(parent_ == that.parent_);
+                return current_ == that.current_;
+            }
+        };
+
+        constexpr cursor<false> begin_cursor()
+        {
+            return cursor<false>{this};
+        }
+        template<typename CRng = Rng const>
+        constexpr auto begin_cursor() const -> CPP_ret(cursor<true>)( //
+            requires detail::partial_sum_view_constraints<CRng, Fun const>)
+        {
+            return cursor<true>{this};
+        }
+
+    public:
+        partial_sum_view() = default;
+        constexpr partial_sum_view(Rng rng, Fun fun) noexcept(
+            std::is_nothrow_move_constructible<Rng>::value &&
+                std::is_nothrow_move_constructible<Fun>::value)
+          : base_(std::move(rng))
+          , fun_(std::move(fun))
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(base_);
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(base_);
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Fun>)
+        partial_sum_view(Rng &&, Fun)
+            ->partial_sum_view<views::all_t<Rng>, Fun>;
+#endif
+
+    namespace views
+    {
+        struct partial_sum_base_fn
+        {
+            template<typename Rng, typename Fun = plus>
+            constexpr auto operator()(Rng && rng, Fun fun = {}) const
+                -> CPP_ret(partial_sum_view<all_t<Rng>, Fun>)( //
+                    requires detail::partial_sum_view_constraints<all_t<Rng>, Fun>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(fun)};
+            }
+        };
+
+        struct partial_sum_fn : partial_sum_base_fn
+        {
+            using partial_sum_base_fn::operator();
+
+            template<typename Fun>
+            constexpr auto CPP_fun(operator())(Fun && fun)(const //
+                                                           requires(!range<Fun>))
+            {
+                return make_view_closure(
+                    bind_back(partial_sum_base_fn{}, static_cast<Fun &&>(fun)));
+            }
+            template<typename Fun = plus>
+            RANGES_DEPRECATED(
+                "Use \"ranges::views::partial_sum\" instead of "
+                "\"ranges::views::partial_sum()\".")
+            constexpr auto
+            operator()() const
+            {
+                return make_view_closure(bind_back(partial_sum_base_fn{}, Fun{}));
+            }
+        };
+
+        /// \relates partial_sum_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<partial_sum_fn>, partial_sum)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::partial_sum_view)
+
+#endif
diff --git a/inst/include/range/v3/view/ref.hpp b/inst/include/range/v3/view/ref.hpp
new file mode 100644
index 0000000..a1ccc69
--- /dev/null
+++ b/inst/include/range/v3/view/ref.hpp
@@ -0,0 +1,153 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REF_HPP
+#define RANGES_V3_VIEW_REF_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/view.hpp>
+
+RANGES_DISABLE_WARNINGS
+
+namespace ranges
+{
+    template<typename Rng>
+    struct ref_view;
+
+    /// \cond
+    namespace _ref_view_
+    {
+        struct adl_hook
+        {};
+
+        template<typename Rng>
+        constexpr iterator_t<Rng> begin(ref_view<Rng> && rng) noexcept(
+            noexcept(rng.begin()))
+        {
+            return rng.begin();
+        }
+        template<typename Rng>
+        constexpr iterator_t<Rng> begin(ref_view<Rng> const && rng) noexcept(
+            noexcept(rng.begin()))
+        {
+            return rng.begin();
+        }
+        template<typename Rng>
+        constexpr sentinel_t<Rng> end(ref_view<Rng> && rng) noexcept(noexcept(rng.end()))
+        {
+            return rng.end();
+        }
+        template<typename Rng>
+        constexpr sentinel_t<Rng> end(ref_view<Rng> const && rng) noexcept(
+            noexcept(rng.end()))
+        {
+            return rng.end();
+        }
+    } // namespace _ref_view_
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct ref_view
+      : view_interface<ref_view<Rng>, range_cardinality<Rng>::value>
+      , private _ref_view_::adl_hook
+    {
+    private:
+        CPP_assert(range<Rng>);
+        static_assert(std::is_object<Rng>::value, "");
+        Rng * rng_ = nullptr; // exposition only
+    public:
+        constexpr ref_view() noexcept = default;
+        constexpr ref_view(Rng & rng) noexcept
+          : rng_(detail::addressof(rng))
+        {}
+        constexpr Rng & base() const noexcept
+        {
+            return *rng_;
+        }
+        constexpr iterator_t<Rng> begin() const noexcept(noexcept(ranges::begin(*rng_)))
+        {
+            return ranges::begin(*rng_);
+        }
+        constexpr sentinel_t<Rng> end() const noexcept(noexcept(ranges::end(*rng_)))
+        {
+            return ranges::end(*rng_);
+        }
+        CPP_member
+        constexpr auto empty() const noexcept(noexcept(ranges::empty(*rng_)))
+            -> CPP_ret(bool)( //
+                requires detail::can_empty_<Rng>)
+        {
+            return ranges::empty(*rng_);
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const noexcept(noexcept(ranges::size(*rng_))) //
+                                       requires sized_range<Rng>)
+        {
+            return ranges::size(*rng_);
+        }
+        CPP_member
+        constexpr auto CPP_fun(data)()(const noexcept(noexcept(ranges::data(*rng_))) //
+                                       requires contiguous_range<Rng>)
+        {
+            return ranges::data(*rng_);
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename R)(requires range<R>) ref_view(R &)->ref_view<R>;
+#endif
+
+    namespace views
+    {
+        struct ref_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng & rng) const noexcept
+                -> CPP_ret(ref_view<Rng>)( //
+                    requires range<Rng>)
+            {
+                return ref_view<Rng>(rng);
+            }
+            template<typename Rng>
+            void operator()(Rng const && rng) const = delete;
+        };
+
+        /// \relates const_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(ref_fn, ref)
+    } // namespace views
+
+    namespace cpp20
+    {
+        CPP_template(typename Rng)(              //
+            requires std::is_object<Rng>::value) //
+            using ref_view = ranges::ref_view<Rng>;
+    }
+} // namespace ranges
+
+RANGES_RE_ENABLE_WARNINGS
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::ref_view)
+
+#endif
diff --git a/inst/include/range/v3/view/remove.hpp b/inst/include/range/v3/view/remove.hpp
new file mode 100644
index 0000000..f32f84d
--- /dev/null
+++ b/inst/include/range/v3/view/remove.hpp
@@ -0,0 +1,101 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Andrey Diduh 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REMOVE_HPP
+#define RANGES_V3_VIEW_REMOVE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/view/remove_if.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        struct remove_base_fn
+        {
+        private:
+            template<typename Value>
+            struct pred_
+            {
+                Value value_;
+                template<typename T>
+                auto operator()(T && other) const -> CPP_ret(bool)( //
+                    requires equality_comparable_with<T, Value const &>)
+                {
+                    return static_cast<T &&>(other) == value_;
+                }
+            };
+
+        public:
+            template<typename Rng, typename Value>
+            constexpr auto CPP_fun(operator())(Rng && rng, Value value)(
+                const requires move_constructible<Value> && viewable_range<Rng> &&
+                    input_range<Rng> &&
+                        indirectly_comparable<iterator_t<Rng>, Value const *, equal_to>)
+            {
+                return remove_if(static_cast<Rng &&>(rng),
+                                 pred_<Value>{std::move(value)});
+            }
+
+            template<typename Rng, typename Value, typename Proj>
+            constexpr auto CPP_fun(operator())(Rng && rng, Value value, Proj proj)(
+                const requires move_constructible<Value> && viewable_range<Rng> &&
+                    input_range<Rng> && indirectly_comparable<
+                        iterator_t<Rng>, Value const *, equal_to, Proj>)
+            {
+                return remove_if(static_cast<Rng &&>(rng),
+                                 pred_<Value>{std::move(value)},
+                                 std::move(proj));
+            }
+        };
+
+        struct remove_fn : remove_base_fn
+        {
+            using remove_base_fn::operator();
+
+            template<typename Value>
+            constexpr auto operator()(Value value) const
+            {
+                return make_view_closure(bind_back(remove_base_fn{}, std::move(value)));
+            }
+            template<typename Value, typename Proj>
+            constexpr auto CPP_fun(operator())(Value && value,
+                                               Proj proj)(const //
+                                                          requires(!range<Value>))
+            {
+                return make_view_closure(bind_back(
+                    remove_base_fn{}, static_cast<Value &&>(value), std::move(proj)));
+            }
+        };
+
+        /// \relates remove_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(remove_fn, remove)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_VIEW_REMOVE_HPP
diff --git a/inst/include/range/v3/view/remove_if.hpp b/inst/include/range/v3/view/remove_if.hpp
new file mode 100644
index 0000000..d80326d
--- /dev/null
+++ b/inst/include/range/v3/view/remove_if.hpp
@@ -0,0 +1,201 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REMOVE_IF_HPP
+#define RANGES_V3_VIEW_REMOVE_IF_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/view.hpp>
+
+RANGES_DISABLE_WARNINGS
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Pred>
+    struct RANGES_EMPTY_BASES remove_if_view
+      : view_adaptor<remove_if_view<Rng, Pred>, Rng,
+                     is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+      , private box<semiregular_box_t<Pred>>
+    {
+        remove_if_view() = default;
+        constexpr remove_if_view(Rng rng, Pred pred)
+          : remove_if_view::view_adaptor{detail::move(rng)}
+          , remove_if_view::box(detail::move(pred))
+        {}
+
+    private:
+        friend range_access;
+
+        struct adaptor : adaptor_base
+        {
+            adaptor() = default;
+            constexpr adaptor(remove_if_view * rng) noexcept
+              : rng_(rng)
+            {}
+            static constexpr iterator_t<Rng> begin(remove_if_view & rng)
+            {
+                return *rng.begin_;
+            }
+            constexpr void next(iterator_t<Rng> & it) const
+            {
+                RANGES_ASSERT(it != ranges::end(rng_->base()));
+                rng_->satisfy_forward(++it);
+            }
+            CPP_member
+            constexpr auto prev(iterator_t<Rng> & it) const -> CPP_ret(void)( //
+                requires bidirectional_range<Rng>)
+            {
+                rng_->satisfy_reverse(it);
+            }
+            void advance() = delete;
+            void distance_to() = delete;
+
+        private:
+            remove_if_view * rng_;
+        };
+        constexpr adaptor begin_adaptor()
+        {
+            cache_begin();
+            return {this};
+        }
+        CPP_member
+        constexpr auto end_adaptor() const noexcept -> CPP_ret(adaptor_base)( //
+            requires(!common_range<Rng>))
+        {
+            return {};
+        }
+        CPP_member
+        constexpr auto end_adaptor() -> CPP_ret(adaptor)( //
+            requires common_range<Rng>)
+        {
+            if(bidirectional_range<Rng>)
+                cache_begin();
+            return {this};
+        }
+
+        constexpr void satisfy_forward(iterator_t<Rng> & it)
+        {
+            auto const last = ranges::end(this->base());
+            auto & pred = this->remove_if_view::box::get();
+            while(it != last && invoke(pred, *it))
+                ++it;
+        }
+        constexpr void satisfy_reverse(iterator_t<Rng> & it)
+        {
+            RANGES_ASSERT(begin_);
+            auto const & first = *begin_;
+            auto & pred = this->remove_if_view::box::get();
+            do
+            {
+                RANGES_ASSERT(it != first);
+                (void)first;
+                --it;
+            } while(invoke(pred, *it));
+        }
+
+        constexpr void cache_begin()
+        {
+            if(begin_)
+                return;
+            auto it = ranges::begin(this->base());
+            satisfy_forward(it);
+            begin_.emplace(std::move(it));
+        }
+
+        detail::non_propagating_cache<iterator_t<Rng>> begin_;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Pred)(requires copy_constructible<Pred>)
+        remove_if_view(Rng &&, Pred)
+            ->remove_if_view<views::all_t<Rng>, Pred>;
+#endif
+
+    namespace views
+    {
+        /// Given a source range, unary predicate, and optional projection,
+        /// present a view of the elements that do not satisfy the predicate.
+        struct remove_if_base_fn
+        {
+            template<typename Rng, typename Pred>
+            constexpr auto operator()(Rng && rng, Pred pred) const
+                -> CPP_ret(remove_if_view<all_t<Rng>, Pred>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<Pred, iterator_t<Rng>>)
+            {
+                return remove_if_view<all_t<Rng>, Pred>{all(static_cast<Rng &&>(rng)),
+                                                        std::move(pred)};
+            }
+            template<typename Rng, typename Pred, typename Proj>
+            constexpr auto operator()(Rng && rng, Pred pred, Proj proj) const
+                -> CPP_ret(remove_if_view<all_t<Rng>, composed<Pred, Proj>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<Pred, projected<iterator_t<Rng>, Proj>>)
+            {
+                return remove_if_view<all_t<Rng>, composed<Pred, Proj>>{
+                    all(static_cast<Rng &&>(rng)),
+                    compose(std::move(pred), std::move(proj))};
+            }
+        };
+
+        struct remove_if_fn : remove_if_base_fn
+        {
+            using remove_if_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(bind_back(remove_if_base_fn{}, std::move(pred)));
+            }
+            template<typename Pred, typename Proj>
+            constexpr auto CPP_fun(operator())(Pred && pred,
+                                               Proj proj)(const //
+                                                          requires(!range<Pred>))
+            {
+                return make_view_closure(bind_back(
+                    remove_if_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
+            }
+        };
+
+        /// \relates remove_if_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(remove_if_fn, remove_if)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+RANGES_RE_ENABLE_WARNINGS
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::remove_if_view)
+
+#endif
diff --git a/inst/include/range/v3/view/repeat.hpp b/inst/include/range/v3/view/repeat.hpp
new file mode 100644
index 0000000..b3ad5d8
--- /dev/null
+++ b/inst/include/range/v3/view/repeat.hpp
@@ -0,0 +1,120 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REPEAT_HPP
+#define RANGES_V3_VIEW_REPEAT_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    // Ordinarily, a view shouldn't contain its elements. This is so that copying
+    // and assigning ranges is O(1), and also so that in the event of element
+    // mutation, all the copies of the range see the mutation the same way. The
+    // repeat_view *does* own its lone element, though. This is OK because:
+    //  - O(N) copying is fine when N==1 as it is in this case, and
+    //  - The element is immutable, so there is no potential for incorrect
+    //    semantics.
+    template<typename Val>
+    struct repeat_view : view_facade<repeat_view<Val>, infinite>
+    {
+    private:
+        semiregular_box_t<Val> value_;
+        friend range_access;
+
+        struct cursor
+        {
+        private:
+            Val const * value_;
+            std::ptrdiff_t n_ = 0;
+
+        public:
+            cursor() = default;
+            explicit cursor(Val const & value)
+              : value_(std::addressof(value))
+            {}
+            Val const & read() const noexcept
+            {
+                return *value_;
+            }
+            bool equal(cursor const & that) const
+            {
+                return n_ == that.n_;
+            }
+            void next()
+            {
+                ++n_;
+            }
+            void prev()
+            {
+                --n_;
+            }
+            void advance(std::ptrdiff_t d)
+            {
+                n_ += d;
+            }
+            std::ptrdiff_t distance_to(cursor const & that) const
+            {
+                return that.n_ - n_;
+            }
+        };
+        cursor begin_cursor() const
+        {
+            return cursor{value_};
+        }
+        unreachable_sentinel_t end_cursor() const
+        {
+            return unreachable;
+        }
+
+    public:
+        repeat_view() = default;
+        constexpr explicit repeat_view(Val value)
+          : value_(detail::move(value))
+        {}
+    };
+
+    namespace views
+    {
+        struct repeat_fn
+        {
+            template<typename Val>
+            auto operator()(Val value) const -> CPP_ret(repeat_view<Val>)( //
+                requires copy_constructible<Val>)
+            {
+                return repeat_view<Val>{std::move(value)};
+            }
+        };
+
+        /// \relates repeat_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(repeat_fn, repeat)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::repeat_view)
+
+#endif
diff --git a/inst/include/range/v3/view/repeat_n.hpp b/inst/include/range/v3/view/repeat_n.hpp
new file mode 100644
index 0000000..573a2de
--- /dev/null
+++ b/inst/include/range/v3/view/repeat_n.hpp
@@ -0,0 +1,129 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REPEAT_N_HPP
+#define RANGES_V3_VIEW_REPEAT_N_HPP
+
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    // Ordinarily, a view shouldn't contain its elements. This is so that copying
+    // and assigning ranges is O(1), and also so that in the event of element
+    // mutation, all the copies of the range see the mutation the same way. The
+    // repeat_n_view *does* own its lone element, though. This is OK because:
+    //  - O(N) copying is fine when N==1 as it is in this case, and
+    //  - The element is immutable, so there is no potential for incorrect
+    //    semantics.
+    template<typename Val>
+    struct repeat_n_view : view_facade<repeat_n_view<Val>, finite>
+    {
+    private:
+        friend range_access;
+        semiregular_box_t<Val> value_;
+        std::ptrdiff_t n_;
+
+        struct cursor
+        {
+        private:
+            Val const * value_;
+            std::ptrdiff_t n_;
+
+        public:
+            cursor() = default;
+            cursor(Val const & value, std::ptrdiff_t n)
+              : value_(std::addressof(value))
+              , n_(n)
+            {}
+            Val const & read() const
+            {
+                return *value_;
+            }
+            constexpr bool equal(default_sentinel_t) const
+            {
+                return 0 == n_;
+            }
+            bool equal(cursor const & that) const
+            {
+                return n_ == that.n_;
+            }
+            void next()
+            {
+                RANGES_EXPECT(0 != n_);
+                --n_;
+            }
+            void prev()
+            {
+                ++n_;
+            }
+            void advance(std::ptrdiff_t n)
+            {
+                n_ -= n;
+            }
+            std::ptrdiff_t distance_to(cursor const & that) const
+            {
+                return n_ - that.n_;
+            }
+        };
+        cursor begin_cursor() const
+        {
+            return {value_, n_};
+        }
+
+    public:
+        repeat_n_view() = default;
+        constexpr repeat_n_view(Val value, std::ptrdiff_t n)
+          : value_(detail::move(value))
+          , n_((RANGES_EXPECT(0 <= n), n))
+        {}
+        constexpr std::size_t size() const
+        {
+            return static_cast<std::size_t>(n_);
+        }
+    };
+
+    namespace views
+    {
+        struct repeat_n_fn
+        {
+            template<typename Val>
+            auto operator()(Val value, std::ptrdiff_t n) const
+                -> CPP_ret(repeat_n_view<Val>)( //
+                    requires copy_constructible<Val>)
+            {
+                return repeat_n_view<Val>{std::move(value), n};
+            }
+        };
+
+        /// \relates repeat_n_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(repeat_n_fn, repeat_n)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::repeat_n_view)
+
+#endif
diff --git a/inst/include/range/v3/view/replace.hpp b/inst/include/range/v3/view/replace.hpp
new file mode 100644
index 0000000..c37235b
--- /dev/null
+++ b/inst/include/range/v3/view/replace.hpp
@@ -0,0 +1,140 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REPLACE_HPP
+#define RANGES_V3_VIEW_REPLACE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/transform.hpp>
+#include <range/v3/view/view.hpp>
+
+RANGES_DISABLE_WARNINGS
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Val1, typename Val2>
+        struct replacer_fn
+        {
+        private:
+            Val1 old_value_;
+            Val2 new_value_;
+
+        public:
+            replacer_fn() = default;
+            constexpr replacer_fn(Val1 old_value, Val2 new_value)
+              : old_value_(std::move(old_value))
+              , new_value_(std::move(new_value))
+            {}
+
+            template<typename I>
+            [[noreturn]] common_type_t<decay_t<unwrap_reference_t<Val2 const &>>,
+                                       iter_value_t<I>> &
+            operator()(copy_tag, I const &) const
+            {
+                RANGES_EXPECT(false);
+            }
+
+            template<typename I>
+            common_reference_t<unwrap_reference_t<Val2 const &>, iter_reference_t<I>>
+            operator()(I const & i) const
+            {
+                auto && x = *i;
+                if(x == unwrap_reference(old_value_))
+                    return unwrap_reference(new_value_);
+                return ((decltype(x) &&)x);
+            }
+
+            template<typename I>
+            common_reference_t<unwrap_reference_t<Val2 const &>,
+                               iter_rvalue_reference_t<I>>
+            operator()(move_tag, I const & i) const
+            {
+                auto && x = iter_move(i);
+                if(x == unwrap_reference(old_value_))
+                    return unwrap_reference(new_value_);
+                return ((decltype(x) &&)x);
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        struct replace_base_fn
+        {
+            template<typename Rng, typename Val1, typename Val2>
+            constexpr auto operator()(Rng && rng, Val1 && old_value,
+                                      Val2 && new_value) const //
+                -> CPP_ret(replace_view<all_t<Rng>, detail::decay_t<Val1>,
+                                        detail::decay_t<Val2>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> && same_as<
+                        detail::decay_t<unwrap_reference_t<Val1>>,
+                        detail::decay_t<unwrap_reference_t<Val2>>> &&
+                        equality_comparable_with<
+                            detail::decay_t<unwrap_reference_t<Val1>>,
+                            range_value_t<Rng>> &&
+                            common_with<detail::decay_t<unwrap_reference_t<Val2 const &>>,
+                                        range_value_t<Rng>> &&
+                                common_reference_with<unwrap_reference_t<Val2 const &>,
+                                                      range_reference_t<Rng>> &&
+                                    common_reference_with<
+                                        unwrap_reference_t<Val2 const &>,
+                                        range_rvalue_reference_t<Rng>>)
+            {
+                return {
+                    all(static_cast<Rng &&>(rng)),
+                    {static_cast<Val1 &&>(old_value), static_cast<Val2 &&>(new_value)}};
+            }
+        };
+
+        struct replace_fn : replace_base_fn
+        {
+            using replace_base_fn::operator();
+
+            template<typename Val1, typename Val2>
+            constexpr auto CPP_fun(operator())(Val1 old_value, Val2 new_value)(
+                const //
+                requires same_as<detail::decay_t<unwrap_reference_t<Val1>>,
+                                 detail::decay_t<unwrap_reference_t<Val2>>>)
+            {
+                return make_view_closure(bind_back(
+                    replace_base_fn{}, std::move(old_value), std::move(new_value)));
+            }
+        };
+
+        /// \relates replace_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(replace_fn, replace)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/view/replace_if.hpp b/inst/include/range/v3/view/replace_if.hpp
new file mode 100644
index 0000000..fd3ecd8
--- /dev/null
+++ b/inst/include/range/v3/view/replace_if.hpp
@@ -0,0 +1,157 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REPLACE_IF_HPP
+#define RANGES_V3_VIEW_REPLACE_IF_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/utility/compressed_pair.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/transform.hpp>
+#include <range/v3/view/view.hpp>
+
+RANGES_DISABLE_WARNINGS
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Pred, typename Val>
+        struct replacer_if_fn : compressed_pair<semiregular_box_t<Pred>, Val>
+        {
+        private:
+            using base_t = compressed_pair<semiregular_box_t<Pred>, Val>;
+            using base_t::first;
+            using base_t::second;
+
+        public:
+            replacer_if_fn() = default;
+            constexpr replacer_if_fn(Pred pred, Val new_value)
+              : base_t{std::move(pred), std::move(new_value)}
+            {}
+
+            template<typename I>
+            [[noreturn]] common_type_t<decay_t<unwrap_reference_t<Val const &>>,
+                                       iter_value_t<I>> &
+            operator()(copy_tag, I const &) const
+            {
+                RANGES_EXPECT(false);
+            }
+
+            template<typename I>
+            auto operator()(I const & i)
+                -> CPP_ret(common_reference_t<unwrap_reference_t<Val const &>,
+                                              iter_reference_t<I>>)( //
+                    requires(!invocable<Pred const &, iter_reference_t<I>>))
+            {
+                auto && x = *i;
+                if(invoke(first(), (decltype(x) &&)x))
+                    return unwrap_reference(second());
+                return (decltype(x) &&)x;
+            }
+            template<typename I>
+            auto operator()(I const & i) const
+                -> CPP_ret(common_reference_t<unwrap_reference_t<Val const &>,
+                                              iter_reference_t<I>>)( //
+                    requires invocable<Pred const &, iter_reference_t<I>>)
+            {
+                auto && x = *i;
+                if(invoke(first(), (decltype(x) &&)x))
+                    return unwrap_reference(second());
+                return (decltype(x) &&)x;
+            }
+
+            template<typename I>
+            auto operator()(move_tag, I const & i)
+                -> CPP_ret(common_reference_t<unwrap_reference_t<Val const &>,
+                                              iter_rvalue_reference_t<I>>)( //
+                    requires(!invocable<Pred const &, iter_rvalue_reference_t<I>>))
+            {
+                auto && x = iter_move(i);
+                if(invoke(first(), (decltype(x) &&)x))
+                    return unwrap_reference(second());
+                return (decltype(x) &&)x;
+            }
+            template<typename I>
+            auto operator()(move_tag, I const & i) const
+                -> CPP_ret(common_reference_t<unwrap_reference_t<Val const &>,
+                                              iter_rvalue_reference_t<I>>)( //
+                    requires invocable<Pred const &, iter_rvalue_reference_t<I>>)
+            {
+                auto && x = iter_move(i);
+                if(invoke(first(), (decltype(x) &&)x))
+                    return unwrap_reference(second());
+                return (decltype(x) &&)x;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        struct replace_if_base_fn
+        {
+            template<typename Rng, typename Pred, typename Val>
+            constexpr auto operator()(Rng && rng, Pred pred, Val new_value) const
+                -> CPP_ret(replace_if_view<all_t<Rng>, Pred, Val>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<Pred, iterator_t<Rng>> &&
+                            common_with<detail::decay_t<unwrap_reference_t<Val const &>>,
+                                        range_value_t<Rng>> &&
+                                common_reference_with<unwrap_reference_t<Val const &>,
+                                                      range_reference_t<Rng>> &&
+                                    common_reference_with<unwrap_reference_t<Val const &>,
+                                                          range_rvalue_reference_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        {std::move(pred), std::move(new_value)}};
+            }
+        };
+
+        struct replace_if_fn : replace_if_base_fn
+        {
+            using replace_if_base_fn::operator();
+
+            template<typename Pred, typename Val>
+            constexpr auto operator()(Pred pred, Val new_value) const
+            {
+                return make_view_closure(bind_back(
+                    replace_if_base_fn{}, std::move(pred), std::move(new_value)));
+            }
+        };
+
+        /// \relates replace_if_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(replace_if_fn, replace_if)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+RANGES_RE_ENABLE_WARNINGS
+
+#endif
diff --git a/inst/include/range/v3/view/reverse.hpp b/inst/include/range/v3/view/reverse.hpp
new file mode 100644
index 0000000..7746e80
--- /dev/null
+++ b/inst/include/range/v3/view/reverse.hpp
@@ -0,0 +1,168 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_REVERSE_HPP
+#define RANGES_V3_VIEW_REVERSE_HPP
+
+#include <iterator>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/reverse_iterator.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/box.hpp>
+#include <range/v3/utility/get.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct RANGES_EMPTY_BASES reverse_view
+      : view_interface<reverse_view<Rng>, range_cardinality<Rng>::value>
+      , private detail::non_propagating_cache<iterator_t<Rng>, reverse_view<Rng>,
+                                              !common_range<Rng>>
+    {
+    private:
+        CPP_assert(bidirectional_range<Rng>);
+        Rng rng_;
+        constexpr reverse_iterator<iterator_t<Rng>> begin_(std::true_type)
+        {
+            return make_reverse_iterator(ranges::end(rng_));
+        }
+        constexpr reverse_iterator<iterator_t<Rng>> begin_(std::false_type)
+        {
+            using cache_t =
+                detail::non_propagating_cache<iterator_t<Rng>, reverse_view<Rng>>;
+            auto & end_ = static_cast<cache_t &>(*this);
+            if(!end_)
+                end_ = ranges::next(ranges::begin(rng_), ranges::end(rng_));
+            return make_reverse_iterator(*end_);
+        }
+
+    public:
+        reverse_view() = default;
+        explicit constexpr reverse_view(Rng rng)
+          : rng_(detail::move(rng))
+        {}
+        Rng base() const
+        {
+            return rng_;
+        }
+        constexpr reverse_iterator<iterator_t<Rng>> begin()
+        {
+            return begin_(meta::bool_<(bool)common_range<Rng>>{});
+        }
+        template<bool Const = true>
+        constexpr auto begin() const
+            -> CPP_ret(reverse_iterator<iterator_t<meta::const_if_c<Const, Rng>>>)( //
+                requires Const && common_range<meta::const_if_c<Const, Rng>>)
+        {
+            return make_reverse_iterator(ranges::end(rng_));
+        }
+        constexpr reverse_iterator<iterator_t<Rng>> end()
+        {
+            return make_reverse_iterator(ranges::begin(rng_));
+        }
+        template<bool Const = true>
+        constexpr auto end() const
+            -> CPP_ret(reverse_iterator<iterator_t<meta::const_if_c<Const, Rng>>>)( //
+                requires Const && common_range<meta::const_if_c<Const, Rng>>)
+        {
+            return make_reverse_iterator(ranges::begin(rng_));
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(rng_);
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(rng_);
+        }
+    };
+
+    template<typename Rng>
+    struct reverse_view<reverse_view<Rng>> : Rng
+    {
+        CPP_assert(bidirectional_range<Rng>);
+        CPP_assert(
+            same_as<detail::decay_t<decltype(std::declval<reverse_view<Rng>>().base())>,
+                    Rng>);
+
+        reverse_view() = default;
+        explicit constexpr reverse_view(reverse_view<Rng> rng)
+          : Rng(rng.base())
+        {}
+
+        constexpr reverse_view<Rng> base() const
+        {
+            return reverse_view<Rng>{*this};
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    reverse_view(Rng &&)->reverse_view<views::all_t<Rng>>;
+
+    template<typename Rng>
+    reverse_view(reverse_view<Rng>)->reverse_view<reverse_view<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct reverse_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng) const
+                -> CPP_ret(reverse_view<all_t<Rng>>)( //
+                    requires viewable_range<Rng> && bidirectional_range<Rng>)
+            {
+                return reverse_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
+            }
+        };
+
+        /// \relates reverse_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<reverse_fn>, reverse)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::reverse;
+        }
+        CPP_template(typename Rng)(                          //
+            requires view_<Rng> && bidirectional_range<Rng>) //
+            using reverse_view = ranges::reverse_view<Rng>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::reverse_view)
+
+#endif
diff --git a/inst/include/range/v3/view/sample.hpp b/inst/include/range/v3/view/sample.hpp
new file mode 100644
index 0000000..9ed302c
--- /dev/null
+++ b/inst/include/range/v3/view/sample.hpp
@@ -0,0 +1,287 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SAMPLE_HPP
+#define RANGES_V3_VIEW_SAMPLE_HPP
+
+#include <meta/meta.hpp>
+
+#include <range/v3/algorithm/shuffle.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng,
+                 bool = (bool)sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>>
+        class size_tracker
+        {
+            range_difference_t<Rng> size_;
+
+        public:
+            CPP_assert(forward_range<Rng> || sized_range<Rng>);
+            size_tracker() = default;
+            size_tracker(Rng & rng)
+              : size_(ranges::distance(rng))
+            {}
+            void decrement()
+            {
+                --size_;
+            }
+            range_difference_t<Rng> get(Rng &, iterator_t<Rng> &) const
+            {
+                return size_;
+            }
+        };
+
+        // Impl for sized_sentinel_for (no need to store anything)
+        template<typename Rng>
+        class size_tracker<Rng, true>
+        {
+        public:
+            size_tracker() = default;
+            size_tracker(Rng &)
+            {}
+            void decrement()
+            {}
+            range_difference_t<Rng> get(Rng & rng, iterator_t<Rng> const & it) const
+            {
+                return ranges::end(rng) - it;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+
+    // Take a random sampling from another view
+    template<typename Rng, typename URNG>
+    class sample_view : public view_facade<sample_view<Rng, URNG>, finite>
+    {
+        friend range_access;
+        using D = range_difference_t<Rng>;
+        Rng rng_;
+        // Mutable is OK here because sample_view is an Input view.
+        mutable range_difference_t<Rng> size_;
+        URNG * engine_;
+
+        template<bool IsConst>
+        class cursor
+        {
+            friend cursor<!IsConst>;
+
+            using Base = meta::const_if_c<IsConst, Rng>;
+            meta::const_if_c<IsConst, sample_view> * parent_;
+            iterator_t<Base> current_;
+            RANGES_NO_UNIQUE_ADDRESS detail::size_tracker<Base> size_;
+
+            D pop_size()
+            {
+                return size_.get(parent_->rng_, current_);
+            }
+            void advance()
+            {
+                if(parent_->size_ > 0)
+                {
+                    using Dist = std::uniform_int_distribution<D>;
+                    Dist dist{};
+                    URNG & engine = *parent_->engine_;
+
+                    for(;; ++current_, size_.decrement())
+                    {
+                        RANGES_ASSERT(current_ != ranges::end(parent_->rng_));
+                        auto n = pop_size();
+                        RANGES_EXPECT(n > 0);
+                        typename Dist::param_type const interval{0, n - 1};
+                        if(dist(engine, interval) < parent_->size_)
+                            break;
+                    }
+                }
+            }
+
+        public:
+            using value_type = range_value_t<Rng>;
+            using difference_type = D;
+
+            cursor() = default;
+            explicit cursor(meta::const_if_c<IsConst, sample_view> * rng)
+              : parent_(rng)
+              , current_(ranges::begin(rng->rng_))
+              , size_{rng->rng_}
+            {
+                auto n = pop_size();
+                if(rng->size_ > n)
+                    rng->size_ = n;
+                advance();
+            }
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other)) cursor(cursor<Other> that)
+              : parent_(that.parent_)
+              , current_(std::move(that.current_))
+              , size_(that.size_)
+            {}
+            range_reference_t<Rng> read() const
+            {
+                return *current_;
+            }
+            bool equal(default_sentinel_t) const
+            {
+                RANGES_EXPECT(parent_);
+                return parent_->size_ <= 0;
+            }
+            void next()
+            {
+                RANGES_EXPECT(parent_);
+                RANGES_EXPECT(parent_->size_ > 0);
+                --parent_->size_;
+                RANGES_ASSERT(current_ != ranges::end(parent_->rng_));
+                ++current_;
+                size_.decrement();
+                advance();
+            }
+        };
+
+        cursor<false> begin_cursor()
+        {
+            return cursor<false>{this};
+        }
+        template<bool Const = true>
+        auto begin_cursor() const -> CPP_ret(cursor<Const>)( //
+            requires Const &&
+            (sized_range<meta::const_if_c<Const, Rng>> ||
+             sized_sentinel_for<sentinel_t<meta::const_if_c<Const, Rng>>,
+                                iterator_t<meta::const_if_c<Const, Rng>>> ||
+             forward_range<meta::const_if_c<Const, Rng>>))
+        {
+            return cursor<true>{this};
+        }
+
+    public:
+        sample_view() = default;
+
+        explicit sample_view(Rng rng, D sample_size, URNG & generator)
+          : rng_(std::move(rng))
+          , size_(sample_size)
+          , engine_(std::addressof(generator))
+        {
+            RANGES_EXPECT(sample_size >= 0);
+        }
+
+        Rng base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng, typename URNG>
+    sample_view(Rng &&, range_difference_t<Rng>, URNG &)
+        ->sample_view<views::all_t<Rng>, URNG>;
+#endif
+
+    namespace views
+    {
+        /// Returns a random sample of a range of length `size(range)`.
+        struct sample_base_fn
+        {
+            template<typename Rng, typename URNG = detail::default_random_engine>
+            auto operator()(Rng && rng, range_difference_t<Rng> sample_size,
+                            URNG & generator = detail::get_random_engine()) const
+                -> CPP_ret(sample_view<all_t<Rng>, URNG>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        uniform_random_bit_generator<URNG> && convertible_to<
+                            invoke_result_t<URNG &>, range_difference_t<Rng>> &&
+                    (sized_range<Rng> ||
+                     sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>> ||
+                     forward_range<Rng>))
+            {
+                return sample_view<all_t<Rng>, URNG>{
+                    all(static_cast<Rng &&>(rng)), sample_size, generator};
+            }
+        };
+
+        struct sample_fn : sample_base_fn
+        {
+            using sample_base_fn::operator();
+
+#ifdef RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+            template<typename Size, typename URNG>
+            struct lamduh
+            {
+                Size n;
+                URNG & urng;
+
+                template<typename Rng>
+                auto operator()(Rng && rng) const
+                    -> invoke_result_t<sample_base_fn, Rng, range_difference_t<Rng>,
+                                       URNG &>
+                {
+                    return sample_base_fn{}(static_cast<Rng &&>(rng),
+                                            static_cast<range_difference_t<Rng>>(n),
+                                            urng);
+                }
+            };
+
+            template<typename Size, typename URNG = detail::default_random_engine>
+            constexpr auto CPP_fun(operator())(Size n,
+                                               URNG & urng = detail::get_random_engine())(
+                const //
+                requires integral<Size> && uniform_random_bit_generator<URNG>)
+            {
+                return make_view_closure(lamduh<Size, URNG>{std::move(n), urng});
+            }
+#else  // ^^^ workaround / no workaround vvv
+            template<typename Size, typename URNG = detail::default_random_engine>
+            constexpr auto CPP_fun(operator())(Size n,
+                                               URNG & urng = detail::get_random_engine())(
+                const //
+                requires integral<Size> && uniform_random_bit_generator<URNG>)
+            {
+                return make_view_closure(
+                    [n, &urng](
+                        auto && rng) -> invoke_result_t<sample_base_fn,
+                                                        decltype(rng),
+                                                        range_difference_t<decltype(rng)>,
+                                                        URNG &> {
+                        return sample_base_fn{}(
+                            static_cast<decltype(rng)>(rng),
+                            static_cast<range_difference_t<decltype(rng)>>(n),
+                            urng);
+                    });
+            }
+#endif // RANGES_WORKAROUND_MSVC_OLD_LAMBDA
+        };
+
+        /// \relates sample_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(sample_fn, sample)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::sample_view)
+
+#endif
diff --git a/inst/include/range/v3/view/set_algorithm.hpp b/inst/include/range/v3/view/set_algorithm.hpp
new file mode 100644
index 0000000..8f81076
--- /dev/null
+++ b/inst/include/range/v3/view/set_algorithm.hpp
@@ -0,0 +1,868 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Tomislav Ivek 2015-2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SET_ALGORITHM_HPP
+#define RANGES_V3_VIEW_SET_ALGORITHM_HPP
+
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/comparisons.hpp>
+#include <range/v3/functional/identity.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng1, typename Rng2, typename C, typename P1, typename P2,
+                 template<bool, typename...> class Cursor, cardinality Cardinality>
+        struct set_algorithm_view
+          : view_facade<set_algorithm_view<Rng1, Rng2, C, P1, P2, Cursor, Cardinality>,
+                        Cardinality>
+        {
+        private:
+            friend range_access;
+            semiregular_box_t<C> pred_;
+            semiregular_box_t<P1> proj1_;
+            semiregular_box_t<P2> proj2_;
+            Rng1 rng1_;
+            Rng2 rng2_;
+
+            template<bool IsConst>
+            using cursor = Cursor<IsConst, Rng1, Rng2, C, P1, P2>;
+
+            cursor<simple_view<Rng1>() && simple_view<Rng2>()> begin_cursor()
+            {
+                return {pred_,
+                        proj1_,
+                        proj2_,
+                        ranges::begin(rng1_),
+                        ranges::end(rng1_),
+                        ranges::begin(rng2_),
+                        ranges::end(rng2_)};
+            }
+            CPP_member
+            auto begin_cursor() const -> CPP_ret(cursor<true>)( //
+                requires range<Rng1 const> && range<Rng2 const>)
+            {
+                return {pred_,
+                        proj1_,
+                        proj2_,
+                        ranges::begin(rng1_),
+                        ranges::end(rng1_),
+                        ranges::begin(rng2_),
+                        ranges::end(rng2_)};
+            }
+
+        public:
+            set_algorithm_view() = default;
+            set_algorithm_view(Rng1 rng1, Rng2 rng2, C pred, P1 proj1, P2 proj2)
+              : pred_(std::move(pred))
+              , proj1_(std::move(proj1))
+              , proj2_(std::move(proj2))
+              , rng1_(std::move(rng1))
+              , rng2_(std::move(rng2))
+            {}
+        };
+
+        template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
+                 typename P2>
+        struct set_difference_cursor
+        {
+        private:
+            friend struct set_difference_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;
+            using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
+            using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
+            using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
+            pred_ref_ pred_;
+            proj1_ref_ proj1_;
+            proj2_ref_ proj2_;
+
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst, T>;
+
+            using R1 = constify_if<Rng1>;
+            using R2 = constify_if<Rng2>;
+
+            iterator_t<R1> it1_;
+            sentinel_t<R1> end1_;
+
+            iterator_t<R2> it2_;
+            sentinel_t<R2> end2_;
+
+            void satisfy()
+            {
+                while(it1_ != end1_)
+                {
+                    if(it2_ == end2_)
+                        return;
+
+                    if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
+                        return;
+
+                    if(!invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
+                        ++it1_;
+
+                    ++it2_;
+                }
+            }
+
+        public:
+            using value_type = range_value_t<constify_if<Rng1>>;
+            using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
+                                           single_pass_iterator_<iterator_t<R2>>>;
+
+            set_difference_cursor() = default;
+            set_difference_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,
+                                  iterator_t<R1> it1, sentinel_t<R1> end1,
+                                  iterator_t<R2> it2, sentinel_t<R2> end2)
+              : pred_(std::move(pred))
+              , proj1_(std::move(proj1))
+              , proj2_(std::move(proj2))
+              , it1_(std::move(it1))
+              , end1_(std::move(end1))
+              , it2_(std::move(it2))
+              , end2_(std::move(end2))
+            {
+                satisfy();
+            }
+            CPP_template(bool Other)(         //
+                requires IsConst && (!Other)) //
+                set_difference_cursor(
+                    set_difference_cursor<Other, Rng1, Rng2, C, P1, P2> that)
+              : pred_(std::move(that.pred_))
+              , proj1_(std::move(that.proj1_))
+              , proj2_(std::move(that.proj2_))
+              , it1_(std::move(that.it1_))
+              , end1_(std::move(that.end1_))
+              , it2_(std::move(that.it2_))
+              , end2_(std::move(that.end2_))
+            {}
+            // clang-format off
+            auto CPP_auto_fun(read)()(const)
+            (
+                return *it1_
+            )
+                // clang-format on
+                void next()
+            {
+                ++it1_;
+                satisfy();
+            }
+            CPP_member
+            auto equal(set_difference_cursor const & that) const -> CPP_ret(bool)( //
+                requires forward_range<Rng1>)
+            {
+                // does not support comparing iterators from different ranges
+                return it1_ == that.it1_;
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return it1_ == end1_;
+            }
+            // clang-format off
+            auto CPP_auto_fun(move)()(const)
+            (
+                return iter_move(it1_)
+            )
+            // clang-format on
+        };
+
+        constexpr cardinality set_difference_cardinality(cardinality c1, cardinality c2)
+        {
+            return (c1 == unknown)
+                       ? unknown
+                       : (c1 >= 0) || (c1 == finite) ? finite : // else, c1 == infinite
+                             (c2 >= 0) || (c2 == finite) ? infinite : unknown;
+        }
+    } // namespace detail
+    /// \endcond
+
+    template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
+    using set_difference_view =
+        detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_difference_cursor,
+                                   detail::set_difference_cardinality(
+                                       range_cardinality<Rng1>::value,
+                                       range_cardinality<Rng2>::value)>;
+
+    namespace views
+    {
+        struct set_difference_base_fn
+        {
+            template<typename Rng1, typename Rng2, typename C = less,
+                     typename P1 = identity, typename P2 = identity>
+            auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},
+                            P2 proj2 = P2{}) const
+                -> CPP_ret(set_difference_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>)( //
+                    requires viewable_range<Rng1> && input_range<Rng1> &&
+                        viewable_range<Rng2> && input_range<Rng2> &&
+                            indirect_relation<C, projected<iterator_t<Rng1>, P1>,
+                                              projected<iterator_t<Rng2>, P2>>)
+            {
+                return {all(static_cast<Rng1 &&>(rng1)),
+                        all(static_cast<Rng2 &&>(rng2)),
+                        std::move(pred),
+                        std::move(proj1),
+                        std::move(proj2)};
+            }
+        };
+
+        struct set_difference_fn : set_difference_base_fn
+        {
+            using set_difference_base_fn::operator();
+
+            template<typename Rng2, typename C = less, typename P1 = identity,
+                     typename P2 = identity>
+            constexpr auto CPP_fun(operator())(Rng2 && rng2, C && pred = C{},
+                                               P1 proj1 = P1{}, P2 proj2 = P2{})(
+                const //
+                requires viewable_range<Rng2> && input_range<Rng2> &&
+                (!range<C>))
+            {
+                return make_view_closure(bind_back(set_difference_base_fn{},
+                                                   all(rng2),
+                                                   static_cast<C &&>(pred),
+                                                   std::move(proj1),
+                                                   std::move(proj2)));
+            }
+        };
+
+        /// \relates set_difference_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(set_difference_fn, set_difference)
+    } // namespace views
+    /// @}
+
+    /// \cond
+    namespace detail
+    {
+        template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
+                 typename P2>
+        struct set_intersection_cursor
+        {
+        private:
+            friend struct set_intersection_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;
+            using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
+            using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
+            using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
+            pred_ref_ pred_;
+            proj1_ref_ proj1_;
+            proj2_ref_ proj2_;
+
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst, T>;
+
+            using R1 = constify_if<Rng1>;
+            using R2 = constify_if<Rng2>;
+
+            iterator_t<R1> it1_;
+            sentinel_t<R1> end1_;
+
+            iterator_t<R2> it2_;
+            sentinel_t<R2> end2_;
+
+            void satisfy()
+            {
+                while(it1_ != end1_ && it2_ != end2_)
+                {
+                    if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
+                        ++it1_;
+                    else
+                    {
+                        if(!invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
+                            return;
+                        ++it2_;
+                    }
+                }
+            }
+
+        public:
+            using value_type = range_value_t<R1>;
+            using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
+                                           single_pass_iterator_<iterator_t<R2>>>;
+
+            set_intersection_cursor() = default;
+            set_intersection_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,
+                                    iterator_t<R1> it1, sentinel_t<R1> end1,
+                                    iterator_t<R2> it2, sentinel_t<R2> end2)
+              : pred_(std::move(pred))
+              , proj1_(std::move(proj1))
+              , proj2_(std::move(proj2))
+              , it1_(std::move(it1))
+              , end1_(std::move(end1))
+              , it2_(std::move(it2))
+              , end2_(std::move(end2))
+            {
+                satisfy();
+            }
+            CPP_template(bool Other)(         //
+                requires IsConst && (!Other)) //
+                set_intersection_cursor(
+                    set_intersection_cursor<Other, Rng1, Rng2, C, P1, P2> that)
+              : pred_(std::move(that.pred_))
+              , proj1_(std::move(that.proj1_))
+              , proj2_(std::move(that.proj2_))
+              , it1_(std::move(that.it1_))
+              , end1_(std::move(that.end1_))
+              , it2_(std::move(that.it2_))
+              , end2_(std::move(that.end2_))
+            {}
+            // clang-format off
+            auto CPP_auto_fun(read)()(const)
+            (
+                return *it1_
+            )
+                // clang-format on
+                void next()
+            {
+                ++it1_;
+                ++it2_;
+                satisfy();
+            }
+            CPP_member
+            auto equal(set_intersection_cursor const & that) const -> CPP_ret(bool)( //
+                requires forward_range<Rng1>)
+            {
+                // does not support comparing iterators from different ranges
+                return it1_ == that.it1_;
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return (it1_ == end1_) || (it2_ == end2_);
+            }
+            // clang-format off
+            auto CPP_auto_fun(move)()(const)
+            (
+                return iter_move(it1_)
+            )
+            // clang-format on
+        };
+
+        constexpr cardinality set_intersection_cardinality(cardinality c1, cardinality c2)
+        {
+            return (c1 == unknown) || (c2 == unknown)
+                       ? unknown
+                       : (c1 >= 0 || c1 == finite) || (c2 >= 0 || c2 == finite) ? finite
+                                                                                : unknown;
+        }
+    } // namespace detail
+    /// \endcond
+
+    template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
+    using set_intersection_view =
+        detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_intersection_cursor,
+                                   detail::set_intersection_cardinality(
+                                       range_cardinality<Rng1>::value,
+                                       range_cardinality<Rng2>::value)>;
+
+    namespace views
+    {
+        struct set_intersection_base_fn
+        {
+            template<typename Rng1, typename Rng2, typename C = less,
+                     typename P1 = identity, typename P2 = identity>
+            auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},
+                            P2 proj2 = P2{}) const
+                -> CPP_ret(set_intersection_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>)( //
+                    requires viewable_range<Rng1> && input_range<Rng1> &&
+                        viewable_range<Rng2> && input_range<Rng2> &&
+                            indirect_relation<C, projected<iterator_t<Rng1>, P1>,
+                                              projected<iterator_t<Rng2>, P2>>)
+            {
+                return {all(static_cast<Rng1 &&>(rng1)),
+                        all(static_cast<Rng2 &&>(rng2)),
+                        std::move(pred),
+                        std::move(proj1),
+                        std::move(proj2)};
+            }
+        };
+
+        struct set_intersection_fn : set_intersection_base_fn
+        {
+            using set_intersection_base_fn::operator();
+
+            template<typename Rng2, typename C = less, typename P1 = identity,
+                     typename P2 = identity>
+            constexpr auto CPP_fun(operator())(Rng2 && rng2, C && pred = C{},
+                                               P1 proj1 = P1{}, P2 proj2 = P2{})(
+                const //
+                requires viewable_range<Rng2> && input_range<Rng2> &&
+                (!range<C>))
+            {
+                return make_view_closure(bind_back(set_intersection_base_fn{},
+                                                   all(rng2),
+                                                   static_cast<C &&>(pred),
+                                                   std::move(proj1),
+                                                   std::move(proj2)));
+            }
+        };
+
+        /// \relates set_intersection_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(set_intersection_fn, set_intersection)
+    } // namespace views
+    /// @}
+
+    /// \cond
+    namespace detail
+    {
+        template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
+                 typename P2>
+        struct set_union_cursor
+        {
+        private:
+            friend struct set_union_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;
+            using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
+            using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
+            using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
+            pred_ref_ pred_;
+            proj1_ref_ proj1_;
+            proj2_ref_ proj2_;
+
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst, T>;
+
+            using R1 = constify_if<Rng1>;
+            using R2 = constify_if<Rng2>;
+
+            iterator_t<R1> it1_;
+            sentinel_t<R1> end1_;
+
+            iterator_t<R2> it2_;
+            sentinel_t<R2> end2_;
+
+            enum class state_t
+            {
+                FIRST,
+                SECOND
+            } state;
+
+            void satisfy()
+            {
+                if(it1_ == end1_)
+                {
+                    state = state_t::SECOND;
+                    return;
+                }
+
+                if(it2_ == end2_)
+                {
+                    state = state_t::FIRST;
+                    return;
+                }
+
+                if(invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
+                {
+                    state = state_t::SECOND;
+                    return;
+                }
+
+                if(!invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
+                    ++it2_;
+
+                state = state_t::FIRST;
+            }
+
+        public:
+            using value_type = common_type_t<range_value_t<R1>, range_value_t<R2>>;
+            using reference_type =
+                common_reference_t<range_reference_t<R1>, range_reference_t<R2>>;
+            using rvalue_reference_type =
+                common_reference_t<range_rvalue_reference_t<R1>,
+                                   range_rvalue_reference_t<R2>>;
+            using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
+                                           single_pass_iterator_<iterator_t<R2>>>;
+
+            set_union_cursor() = default;
+            set_union_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,
+                             iterator_t<R1> it1, sentinel_t<R1> end1, iterator_t<R2> it2,
+                             sentinel_t<R2> end2)
+              : pred_(std::move(pred))
+              , proj1_(std::move(proj1))
+              , proj2_(std::move(proj2))
+              , it1_(std::move(it1))
+              , end1_(std::move(end1))
+              , it2_(std::move(it2))
+              , end2_(std::move(end2))
+            {
+                satisfy();
+            }
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other))
+                set_union_cursor(set_union_cursor<Other, Rng1, Rng2, C, P1, P2> that)
+              : pred_(std::move(that.pred_))
+              , proj1_(std::move(that.proj1_))
+              , proj2_(std::move(that.proj2_))
+              , it1_(std::move(that.it1_))
+              , end1_(std::move(that.end1_))
+              , it2_(std::move(that.it2_))
+              , end2_(std::move(that.end2_))
+            {}
+            reference_type read() const noexcept(noexcept(*it1_) && noexcept(*it2_))
+            {
+                if(state == state_t::SECOND)
+                    return *it2_;
+                else
+                    return *it1_;
+            }
+            void next()
+            {
+                if(state == state_t::FIRST)
+                    ++it1_;
+                else
+                    ++it2_;
+                satisfy();
+            }
+            CPP_member
+            auto equal(set_union_cursor const & that) const -> CPP_ret(bool)( //
+                requires forward_range<Rng1> && forward_range<Rng2>)
+            {
+                // does not support comparing iterators from different ranges
+                return (it1_ == that.it1_) && (it2_ == that.it2_);
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return (it1_ == end1_) && (it2_ == end2_);
+            }
+            rvalue_reference_type move() const
+                noexcept(noexcept(iter_move(it1_)) && noexcept(iter_move(it2_)))
+            {
+                if(state == state_t::SECOND)
+                    return iter_move(it2_);
+                else
+                    return iter_move(it1_);
+            }
+        };
+
+        constexpr cardinality set_union_cardinality(cardinality c1, cardinality c2)
+        {
+            return (c1 == infinite) || (c2 == infinite)
+                       ? infinite
+                       : (c1 == unknown) || (c2 == unknown) ? unknown : finite;
+        }
+
+    } // namespace detail
+    /// \endcond
+
+    template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
+    using set_union_view =
+        detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_union_cursor,
+                                   detail::set_union_cardinality(
+                                       range_cardinality<Rng1>::value,
+                                       range_cardinality<Rng2>::value)>;
+
+    namespace views
+    {
+        struct set_union_base_fn
+        {
+        public:
+            template<typename Rng1, typename Rng2, typename C = less,
+                     typename P1 = identity, typename P2 = identity>
+            auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},
+                            P2 proj2 = P2{}) const
+                -> CPP_ret(set_union_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>)( //
+                    requires viewable_range<Rng1> && input_range<Rng1> &&
+                        viewable_range<Rng2> && input_range<Rng2> && common_with<
+                            range_value_t<Rng1>, range_value_t<Rng2>> &&
+                            common_reference_with<range_reference_t<Rng1>,
+                                                  range_reference_t<Rng2>> &&
+                                common_reference_with<range_rvalue_reference_t<Rng1>,
+                                                      range_rvalue_reference_t<Rng2>> &&
+                                    indirect_relation<C, projected<iterator_t<Rng1>, P1>,
+                                                      projected<iterator_t<Rng2>, P2>>)
+            {
+                return {all(static_cast<Rng1 &&>(rng1)),
+                        all(static_cast<Rng2 &&>(rng2)),
+                        std::move(pred),
+                        std::move(proj1),
+                        std::move(proj2)};
+            }
+        };
+
+        struct set_union_fn : set_union_base_fn
+        {
+            using set_union_base_fn::operator();
+
+            template<typename Rng2, typename C = less, typename P1 = identity,
+                     typename P2 = identity>
+            constexpr auto CPP_fun(operator())(Rng2 && rng2, C && pred = C{},
+                                               P1 proj1 = P1{}, P2 proj2 = P2{})(
+                const //
+                requires viewable_range<Rng2> && input_range<Rng2> &&
+                (!range<C>))
+            {
+                return make_view_closure(bind_back(set_union_base_fn{},
+                                                   all(rng2),
+                                                   static_cast<C &&>(pred),
+                                                   std::move(proj1),
+                                                   std::move(proj2)));
+            }
+        };
+
+        /// \relates set_union_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(set_union_fn, set_union)
+    } // namespace views
+    /// @}
+
+    /// \cond
+    namespace detail
+    {
+        template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
+                 typename P2>
+        struct set_symmetric_difference_cursor
+        {
+        private:
+            friend struct set_symmetric_difference_cursor<!IsConst, Rng1, Rng2, C, P1,
+                                                          P2>;
+            using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
+            using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
+            using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
+            pred_ref_ pred_;
+            proj1_ref_ proj1_;
+            proj2_ref_ proj2_;
+
+            template<typename T>
+            using constify_if = meta::const_if_c<IsConst, T>;
+
+            using R1 = constify_if<Rng1>;
+            using R2 = constify_if<Rng2>;
+
+            iterator_t<R1> it1_;
+            sentinel_t<R1> end1_;
+
+            iterator_t<R2> it2_;
+            sentinel_t<R2> end2_;
+
+            enum class state_t
+            {
+                FIRST,
+                SECOND,
+                ONLY_FIRST,
+                ONLY_SECOND
+            } state;
+
+            void satisfy()
+            {
+                while(it1_ != end1_)
+                {
+                    if(it2_ == end2_)
+                    {
+                        state = state_t::ONLY_FIRST;
+                        return;
+                    }
+
+                    if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
+                    {
+                        state = state_t::FIRST;
+                        return;
+                    }
+                    else
+                    {
+                        if(invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
+                        {
+                            state = state_t::SECOND;
+                            return;
+                        }
+                        else
+                        {
+                            ++it1_;
+                            ++it2_;
+                        }
+                    }
+                }
+                state = state_t::ONLY_SECOND;
+            }
+
+        public:
+            using value_type = common_type_t<range_value_t<R1>, range_value_t<R2>>;
+            using reference_type =
+                common_reference_t<range_reference_t<R1>, range_reference_t<R2>>;
+            using rvalue_reference_type =
+                common_reference_t<range_rvalue_reference_t<R1>,
+                                   range_rvalue_reference_t<R2>>;
+            using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
+                                           single_pass_iterator_<iterator_t<R2>>>;
+
+            set_symmetric_difference_cursor() = default;
+            set_symmetric_difference_cursor(pred_ref_ pred, proj1_ref_ proj1,
+                                            proj2_ref_ proj2, iterator_t<R1> it1,
+                                            sentinel_t<R1> end1, iterator_t<R2> it2,
+                                            sentinel_t<R2> end2)
+              : pred_(std::move(pred))
+              , proj1_(std::move(proj1))
+              , proj2_(std::move(proj2))
+              , it1_(std::move(it1))
+              , end1_(std::move(end1))
+              , it2_(std::move(it2))
+              , end2_(std::move(end2))
+              , state()
+            {
+                satisfy();
+            }
+            CPP_template(bool Other)(         //
+                requires IsConst && (!Other)) //
+                set_symmetric_difference_cursor(
+                    set_symmetric_difference_cursor<Other, Rng1, Rng2, C, P1, P2> that)
+              : pred_(std::move(that.pred_))
+              , proj1_(std::move(that.proj1_))
+              , proj2_(std::move(that.proj2_))
+              , it1_(std::move(that.it1_))
+              , end1_(std::move(that.end1_))
+              , it2_(std::move(that.it2_))
+              , end2_(std::move(that.end2_))
+              , state(that.state)
+            {}
+            reference_type read() const noexcept(noexcept(*it1_) && noexcept(*it2_))
+            {
+                if(state == state_t::SECOND || state == state_t::ONLY_SECOND)
+                    return *it2_;
+                else
+                    return *it1_;
+            }
+            void next()
+            {
+                switch(state)
+                {
+                case state_t::FIRST:
+                    ++it1_;
+                    satisfy();
+                    break;
+                case state_t::ONLY_FIRST:
+                    ++it1_;
+                    break;
+                case state_t::SECOND:
+                    ++it2_;
+                    satisfy();
+                    break;
+                case state_t::ONLY_SECOND:
+                    ++it2_;
+                    break;
+                }
+            }
+            CPP_member
+            auto equal(set_symmetric_difference_cursor const & that) const
+                -> CPP_ret(bool)( //
+                    requires forward_range<R1> && forward_range<R2>)
+            {
+                // does not support comparing iterators from different ranges:
+                return (it1_ == that.it1_) && (it2_ == that.it2_);
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return (it1_ == end1_) && (it2_ == end2_);
+            }
+            rvalue_reference_type move() const
+                noexcept(noexcept(iter_move(it1_)) && noexcept(iter_move(it2_)))
+            {
+                if(state == state_t::SECOND || state == state_t::ONLY_SECOND)
+                    return iter_move(it2_);
+                else
+                    return iter_move(it1_);
+            }
+        };
+
+        constexpr cardinality set_symmetric_difference_cardinality(cardinality c1,
+                                                                   cardinality c2)
+        {
+            return (c1 == unknown) || (c2 == unknown)
+                       ? unknown
+                       : (c1 == infinite) != (c2 == infinite)
+                             ? infinite
+                             : (c1 == infinite) && (c2 == infinite) ? unknown : finite;
+        }
+
+    } // namespace detail
+    /// \endcond
+
+    template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
+    using set_symmetric_difference_view = detail::set_algorithm_view<
+        Rng1, Rng2, C, P1, P2, detail::set_symmetric_difference_cursor,
+        detail::set_symmetric_difference_cardinality(range_cardinality<Rng1>::value,
+                                                     range_cardinality<Rng2>::value)>;
+
+    namespace views
+    {
+        struct set_symmetric_difference_base_fn
+        {
+            template<typename Rng1, typename Rng2, typename C = less,
+                     typename P1 = identity, typename P2 = identity>
+            auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},
+                            P2 proj2 = P2{}) const
+                -> CPP_ret(set_symmetric_difference_view<all_t<Rng1>, all_t<Rng2>, C, P1,
+                                                         P2>)( //
+                    requires viewable_range<Rng1> && input_range<Rng1> &&
+                        viewable_range<Rng2> && input_range<Rng2> && common_with<
+                            range_value_t<Rng1>, range_value_t<Rng2>> &&
+                            common_reference_with<range_reference_t<Rng1>,
+                                                  range_reference_t<Rng2>> &&
+                                common_reference_with<range_rvalue_reference_t<Rng1>,
+                                                      range_rvalue_reference_t<Rng2>> &&
+                                    indirect_relation<C, projected<iterator_t<Rng1>, P1>,
+                                                      projected<iterator_t<Rng2>, P2>>)
+            {
+                return {all(static_cast<Rng1 &&>(rng1)),
+                        all(static_cast<Rng2 &&>(rng2)),
+                        std::move(pred),
+                        std::move(proj1),
+                        std::move(proj2)};
+            }
+        };
+
+        struct set_symmetric_difference_fn : set_symmetric_difference_base_fn
+        {
+            using set_symmetric_difference_base_fn::operator();
+
+            template<typename Rng2, typename C = less, typename P1 = identity,
+                     typename P2 = identity>
+            constexpr auto CPP_fun(operator())(Rng2 && rng2, C && pred = C{},
+                                               P1 proj1 = P1{}, P2 proj2 = P2{})(
+                const //
+                requires viewable_range<Rng2> && input_range<Rng2> &&
+                (!range<C>))
+            {
+                return make_view_closure(bind_back(set_symmetric_difference_base_fn{},
+                                                   all(rng2),
+                                                   static_cast<C &&>(pred),
+                                                   std::move(proj1),
+                                                   std::move(proj2)));
+            }
+        };
+
+        /// \relates set_symmetric_difference_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(set_symmetric_difference_fn, set_symmetric_difference)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/single.hpp b/inst/include/range/v3/view/single.hpp
new file mode 100644
index 0000000..9f5608a
--- /dev/null
+++ b/inst/include/range/v3/view/single.hpp
@@ -0,0 +1,137 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SINGLE_HPP
+#define RANGES_V3_VIEW_SINGLE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/addressof.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename T>
+    struct single_view : view_interface<single_view<T>, (cardinality)1>
+    {
+    private:
+        CPP_assert(copy_constructible<T>);
+        static_assert(std::is_object<T>::value,
+                      "The template parameter of single_view must be an object type");
+        semiregular_box_t<T> value_;
+        template<typename... Args>
+        constexpr single_view(in_place_t, std::true_type, Args &&... args)
+          : value_{static_cast<Args &&>(args)...}
+        {}
+        template<typename... Args>
+        constexpr single_view(in_place_t, std::false_type, Args &&... args)
+          : value_{in_place, static_cast<Args &&>(args)...}
+        {}
+
+    public:
+        single_view() = default;
+        constexpr explicit single_view(T const & t)
+          : value_(t)
+        {}
+        constexpr explicit single_view(T && t)
+          : value_(std::move(t))
+        {}
+        CPP_template(class... Args)(                 //
+            requires constructible_from<T, Args...>) //
+            constexpr single_view(in_place_t, Args &&... args)
+          : single_view{in_place,
+                        meta::bool_<(bool)semiregular<T>>{},
+                        static_cast<Args &&>(args)...}
+        {}
+        constexpr T * begin() noexcept
+        {
+            return data();
+        }
+        constexpr T const * begin() const noexcept
+        {
+            return data();
+        }
+        constexpr T * end() noexcept
+        {
+            return data() + 1;
+        }
+        constexpr T const * end() const noexcept
+        {
+            return data() + 1;
+        }
+        static constexpr std::size_t size() noexcept
+        {
+            return 1u;
+        }
+        constexpr T * data() noexcept
+        {
+            return detail::addressof(static_cast<T &>(value_));
+        }
+        constexpr T const * data() const noexcept
+        {
+            return detail::addressof(static_cast<T const &>(value_));
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<class T>
+    explicit single_view(T &&)->single_view<detail::decay_t<T>>;
+#endif
+
+    namespace views
+    {
+        struct single_fn
+        {
+            template<typename Val>
+            auto operator()(Val value) const -> CPP_ret(single_view<Val>)( //
+                requires copy_constructible<Val>)
+            {
+                return single_view<Val>{std::move(value)};
+            }
+        };
+
+        /// \relates single_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(single_fn, single)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::single;
+        }
+        CPP_template(typename T)(              //
+            requires std::is_object<T>::value) //
+            using single_view = ranges::single_view<T>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::single_view)
+
+#endif
diff --git a/inst/include/range/v3/view/slice.hpp b/inst/include/range/v3/view/slice.hpp
new file mode 100644
index 0000000..ae83bab
--- /dev/null
+++ b/inst/include/range/v3/view/slice.hpp
@@ -0,0 +1,343 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SLICE_HPP
+#define RANGES_V3_VIEW_SLICE_HPP
+
+#include <type_traits>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/counted_iterator.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/drop_exactly.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng, typename Int>
+        iterator_t<Rng> pos_at_(Rng && rng, Int i, input_range_tag, std::true_type)
+        {
+            RANGES_EXPECT(0 <= i);
+            return next(ranges::begin(rng), i);
+        }
+
+        template<typename Rng, typename Int>
+        iterator_t<Rng> pos_at_(Rng && rng, Int i, bidirectional_range_tag,
+                                std::false_type)
+        {
+            if(0 > i)
+            {
+                // If it's not common and we know the size, faster to count from the front
+                if(RANGES_CONSTEXPR_IF(sized_range<Rng> && !common_range<Rng>))
+                    return next(ranges::begin(rng), distance(rng) + i);
+                // Otherwise, probably faster to count from the back.
+                return next(ranges::next(ranges::begin(rng), ranges::end(rng)), i);
+            }
+            return next(ranges::begin(rng), i);
+        }
+
+        template<typename Rng, typename Int>
+        iterator_t<Rng> pos_at_(Rng && rng, Int i, input_range_tag, std::false_type)
+        {
+            RANGES_EXPECT(i >= 0 || (bool)sized_range<Rng> || (bool)forward_range<Rng>);
+            if(0 > i)
+                return next(ranges::begin(rng), distance(rng) + i);
+            return next(ranges::begin(rng), i);
+        }
+
+        template<typename Rng, bool IsRandomAccess>
+        struct slice_view_ : view_facade<slice_view<Rng>, finite>
+        {
+        private:
+            friend range_access;
+            Rng rng_;
+            range_difference_t<Rng> from_, count_;
+            detail::non_propagating_cache<iterator_t<Rng>> begin_;
+
+            iterator_t<Rng> get_begin_()
+            {
+                if(!begin_)
+                    begin_ = detail::pos_at_(
+                        rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{});
+                return *begin_;
+            }
+
+        public:
+            slice_view_() = default;
+            constexpr slice_view_(Rng rng, range_difference_t<Rng> from,
+                                  range_difference_t<Rng> count)
+              : rng_(std::move(rng))
+              , from_(from)
+              , count_(count)
+            {}
+            counted_iterator<iterator_t<Rng>> begin()
+            {
+                return make_counted_iterator(get_begin_(), count_);
+            }
+            default_sentinel_t end()
+            {
+                return {};
+            }
+            auto size() const
+            {
+                return static_cast<detail::iter_size_t<iterator_t<Rng>>>(count_);
+            }
+            Rng base() const
+            {
+                return rng_;
+            }
+        };
+
+        template<typename Rng>
+        struct slice_view_<Rng, true> : view_interface<slice_view<Rng>, finite>
+        {
+        private:
+            Rng rng_;
+            range_difference_t<Rng> from_, count_;
+
+        public:
+            slice_view_() = default;
+            constexpr slice_view_(Rng rng, range_difference_t<Rng> from,
+                                  range_difference_t<Rng> count)
+              : rng_(std::move(rng))
+              , from_(from)
+              , count_(count)
+            {
+                RANGES_EXPECT(0 <= count_);
+            }
+            iterator_t<Rng> begin()
+            {
+                return detail::pos_at_(
+                    rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{});
+            }
+            iterator_t<Rng> end()
+            {
+                return detail::pos_at_(
+                           rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{}) +
+                       count_;
+            }
+            template<typename BaseRng = Rng>
+            auto begin() const -> CPP_ret(iterator_t<BaseRng const>)( //
+                requires range<BaseRng const>)
+            {
+                return detail::pos_at_(
+                    rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{});
+            }
+            template<typename BaseRng = Rng>
+            auto end() const -> CPP_ret(iterator_t<BaseRng const>)( //
+                requires range<BaseRng const>)
+            {
+                return detail::pos_at_(
+                           rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{}) +
+                       count_;
+            }
+            auto size() const
+            {
+                return static_cast<detail::iter_size_t<iterator_t<Rng>>>(count_);
+            }
+            Rng base() const
+            {
+                return rng_;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct slice_view : detail::slice_view_<Rng, (bool)random_access_range<Rng>>
+    {
+        using detail::slice_view_<Rng, (bool)random_access_range<Rng>>::slice_view_;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    slice_view(Rng &&, range_difference_t<Rng>, range_difference_t<Rng>)
+        ->slice_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct slice_base_fn
+        {
+        private:
+            template<typename Rng>
+            static constexpr slice_view<all_t<Rng>> impl_(Rng && rng,
+                                                          range_difference_t<Rng> from,
+                                                          range_difference_t<Rng> count,
+                                                          input_range_tag, range_tag = {})
+            {
+                return {all(static_cast<Rng &&>(rng)), from, count};
+            }
+            template<typename Rng>
+            static auto impl_(Rng && rng, range_difference_t<Rng> from,
+                              range_difference_t<Rng> count, random_access_range_tag,
+                              common_range_tag = {})
+                -> CPP_ret(subrange<iterator_t<Rng>>)( //
+                    requires forwarding_range_<Rng>)
+            {
+                auto it =
+                    detail::pos_at_(rng, from, range_tag_of<Rng>{}, is_infinite<Rng>{});
+                return {it, it + count};
+            }
+
+        public:
+            // slice(rng, 2, 4)
+            template<typename Rng>
+            constexpr auto CPP_fun(operator())( //
+                Rng && rng, range_difference_t<Rng> from, range_difference_t<Rng> to)(
+                const //
+                requires viewable_range<Rng> && input_range<Rng>)
+            {
+                RANGES_EXPECT(0 <= from && from <= to);
+                return slice_base_fn::impl_(
+                    static_cast<Rng &&>(rng), from, to - from, range_tag_of<Rng>{});
+            }
+            // slice(rng, 4, end-2)
+            //  TODO Support Forward, non-Sized ranges by returning a range that
+            //       doesn't know it's size?
+            template<typename Rng>
+            auto CPP_fun(operator())( //
+                Rng && rng, range_difference_t<Rng> from,
+                detail::from_end_of_t<Rng> to)(
+                const //
+                requires viewable_range<Rng> && input_range<Rng> && sized_range<Rng>)
+            {
+                static_assert(!is_infinite<Rng>::value,
+                              "Can't index from the end of an infinite range!");
+                RANGES_EXPECT(0 <= from);
+                RANGES_ASSERT(from <= distance(rng) + to.dist_);
+                return slice_base_fn::impl_(static_cast<Rng &&>(rng),
+                                            from,
+                                            distance(rng) + to.dist_ - from,
+                                            range_tag_of<Rng>{});
+            }
+            // slice(rng, end-4, end-2)
+            template<typename Rng>
+            auto CPP_fun(operator())( //
+                Rng && rng, detail::from_end_of_t<Rng> from,
+                detail::from_end_of_t<Rng> to)(const //
+                                               requires viewable_range<Rng> &&
+                                               (forward_range<Rng> ||
+                                                (input_range<Rng> && sized_range<Rng>)))
+            {
+                static_assert(!is_infinite<Rng>::value,
+                              "Can't index from the end of an infinite range!");
+                RANGES_EXPECT(from.dist_ <= to.dist_);
+                return slice_base_fn::impl_(static_cast<Rng &&>(rng),
+                                            from.dist_,
+                                            to.dist_ - from.dist_,
+                                            range_tag_of<Rng>{},
+                                            common_range_tag_of<Rng>{});
+            }
+            // slice(rng, 4, end)
+            template<typename Rng>
+            auto CPP_fun(operator())(Rng && rng, range_difference_t<Rng> from, end_fn)(
+                const //
+                requires viewable_range<Rng> && input_range<Rng>)
+            {
+                RANGES_EXPECT(0 <= from);
+                return ranges::views::drop_exactly(static_cast<Rng &&>(rng), from);
+            }
+            // slice(rng, end-4, end)
+            template<typename Rng>
+            auto CPP_fun(operator())(Rng && rng, detail::from_end_of_t<Rng> from,
+                                     end_fn)(const //
+                                             requires viewable_range<Rng> &&
+                                             (forward_range<Rng> ||
+                                              (input_range<Rng> && sized_range<Rng>)))
+            {
+                static_assert(!is_infinite<Rng>::value,
+                              "Can't index from the end of an infinite range!");
+                return slice_base_fn::impl_(static_cast<Rng &&>(rng),
+                                            from.dist_,
+                                            -from.dist_,
+                                            range_tag_of<Rng>{},
+                                            common_range_tag_of<Rng>{});
+            }
+        };
+
+        struct slice_fn : slice_base_fn
+        {
+            using slice_base_fn::operator();
+
+            // Overloads for the pipe syntax: rng | views::slice(from,to)
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int from, Int to)(
+                const //
+                requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(slice_base_fn{}, from, to));
+            }
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int from,
+                                               detail::from_end_<Int> to)(
+                const //
+                requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(slice_base_fn{}, from, to));
+            }
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(detail::from_end_<Int> from,
+                                               detail::from_end_<Int> to)(
+                const //
+                requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(slice_base_fn{}, from, to));
+            }
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int from, end_fn)(
+                const //
+                requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(
+                    bind_back(ranges::views::drop_exactly_base_fn{}, from));
+            }
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(detail::from_end_<Int> from,
+                                               end_fn to)(
+                const //
+                requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(slice_base_fn{}, from, to));
+            }
+        };
+
+        /// \relates _slice_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(slice_fn, slice)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::slice_view)
+
+#endif
diff --git a/inst/include/range/v3/view/sliding.hpp b/inst/include/range/v3/view/sliding.hpp
new file mode 100644
index 0000000..39f98f8
--- /dev/null
+++ b/inst/include/range/v3/view/sliding.hpp
@@ -0,0 +1,391 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Tobias Mayer 2016
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SLIDING_HPP
+#define RANGES_V3_VIEW_SLIDING_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/counted.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace sliding_view_detail
+    {
+        enum class cache
+        {
+            none,
+            first,
+            last
+        };
+
+        template<typename Rng>
+        using caching = std::integral_constant<
+            cache, random_access_range<Rng> && sized_range<Rng>
+                       ? cache::none
+                       : bidirectional_range<Rng> && common_range<Rng> ? cache::last
+                                                                       : cache::first>;
+    } // namespace sliding_view_detail
+    /// \endcond
+
+    template<typename Rng,
+             sliding_view_detail::cache = sliding_view_detail::caching<Rng>::value>
+    struct sliding_view;
+
+    /// \cond
+    namespace sliding_view_detail
+    {
+        template<typename Rng>
+        using uncounted_t =
+            decltype(ranges::uncounted(std::declval<iterator_t<Rng> &>()));
+
+        template<typename Rng, bool = (bool)random_access_range<Rng>>
+        struct trailing
+        {
+            trailing() = default;
+            constexpr trailing(Rng & rng)
+              : it_{uncounted(ranges::begin(rng))}
+            {}
+            constexpr uncounted_t<Rng> get(iterator_t<Rng> const &,
+                                           range_difference_t<Rng>) const
+            {
+                return it_;
+            }
+            void next()
+            {
+                ++it_;
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)(requires bidirectional_range<Rng>)
+            {
+                --it_;
+            }
+
+        private:
+            uncounted_t<Rng> it_;
+        };
+
+        template<typename Rng>
+        struct trailing<Rng, true>
+        {
+            trailing() = default;
+            constexpr trailing(Rng &) noexcept
+            {}
+            constexpr uncounted_t<Rng> get(iterator_t<Rng> const & it,
+                                           range_difference_t<Rng> n) const
+            {
+                return uncounted(it - (n - 1));
+            }
+            void next()
+            {}
+            void prev()
+            {}
+        };
+
+        template<typename Rng>
+        struct RANGES_EMPTY_BASES sv_base
+          : view_adaptor<sliding_view<Rng>, Rng,
+                         is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+          , private detail::non_propagating_cache<iterator_t<Rng>, sv_base<Rng>,
+                                                  caching<Rng>::value != cache::none>
+        {
+            CPP_assert(forward_range<Rng>);
+            sv_base() = default;
+            sv_base(Rng rng, range_difference_t<Rng> n)
+              : sv_base::view_adaptor(std::move(rng))
+              , n_(n)
+            {
+                RANGES_ASSERT(0 < n_);
+            }
+            CPP_member
+            auto CPP_fun(size)()(const requires sized_range<Rng const>)
+            {
+                auto const count = ranges::size(this->base());
+                auto const n = static_cast<range_size_t<Rng const>>(n_);
+                return count < n ? 0 : count - n + 1;
+            }
+            CPP_member
+            auto CPP_fun(size)()(requires sized_range<Rng>)
+            {
+                auto const count = ranges::size(this->base());
+                auto const n = static_cast<range_size_t<Rng>>(n_);
+                return count < n ? 0 : count - n + 1;
+            }
+
+        protected:
+            range_difference_t<Rng> n_;
+
+            optional<iterator_t<Rng>> & cache() &
+            {
+                return static_cast<cache_t &>(*this);
+            }
+            optional<iterator_t<Rng>> const & cache() const &
+            {
+                return static_cast<cache_t const &>(*this);
+            }
+
+        private:
+            using cache_t = detail::non_propagating_cache<iterator_t<Rng>, sv_base<Rng>>;
+        };
+    } // namespace sliding_view_detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct sliding_view<Rng, sliding_view_detail::cache::first>
+      : sliding_view_detail::sv_base<Rng>
+    {
+    private:
+        friend range_access;
+
+        iterator_t<Rng> get_first()
+        {
+            auto & first = this->cache();
+            if(!first)
+            {
+                first = ranges::next(
+                    ranges::begin(this->base()), this->n_ - 1, ranges::end(this->base()));
+            }
+            return *first;
+        }
+
+        struct RANGES_EMPTY_BASES adaptor
+          : adaptor_base
+          , sliding_view_detail::trailing<Rng>
+        {
+        private:
+            using base_t = sliding_view_detail::trailing<Rng>;
+            range_difference_t<Rng> n_ = {};
+
+        public:
+            adaptor() = default;
+            adaptor(sliding_view * v)
+              : base_t{v->base()}
+              , n_{v->n_}
+            {}
+            iterator_t<Rng> begin(sliding_view & v)
+            {
+                return v.get_first();
+            }
+            auto read(iterator_t<Rng> const & it) const
+                -> decltype(views::counted(uncounted(it), n_))
+            {
+                return views::counted(base_t::get(it, n_), n_);
+            }
+            void next(iterator_t<Rng> & it)
+            {
+                ++it;
+                base_t::next();
+            }
+            CPP_member
+            auto prev(iterator_t<Rng> & it) -> CPP_ret(void)( //
+                requires bidirectional_range<Rng>)
+            {
+                base_t::prev();
+                --it;
+            }
+            CPP_member
+            auto advance(iterator_t<Rng> & it, range_difference_t<Rng> n)
+                -> CPP_ret(void)( //
+                    requires random_access_range<Rng>)
+            {
+                it += n;
+            }
+        };
+
+        adaptor begin_adaptor()
+        {
+            return {this};
+        }
+        meta::if_c<common_range<Rng>, adaptor, adaptor_base> end_adaptor()
+        {
+            return {this};
+        }
+
+    public:
+        using sliding_view::sv_base::sv_base;
+    };
+
+    template<typename Rng>
+    struct sliding_view<Rng, sliding_view_detail::cache::last>
+      : sliding_view_detail::sv_base<Rng>
+    {
+    private:
+        friend range_access;
+
+        iterator_t<Rng> get_last()
+        {
+            auto & last = this->cache();
+            if(!last)
+            {
+                last = ranges::prev(
+                    ranges::end(this->base()), this->n_ - 1, ranges::begin(this->base()));
+            }
+            return *last;
+        }
+
+        struct adaptor : adaptor_base
+        {
+        private:
+            range_difference_t<Rng> n_ = {};
+
+        public:
+            adaptor() = default;
+            adaptor(sliding_view * v)
+              : n_{v->n_}
+            {}
+            iterator_t<Rng> end(sliding_view & v)
+            {
+                return v.get_last();
+            }
+            auto read(iterator_t<Rng> const & it) const
+                -> decltype(views::counted(uncounted(it), n_))
+            {
+                return views::counted(uncounted(it), n_);
+            }
+        };
+
+        adaptor begin_adaptor()
+        {
+            return {this};
+        }
+        adaptor end_adaptor()
+        {
+            return {this};
+        }
+
+    public:
+        using sliding_view::sv_base::sv_base;
+    };
+
+    template<typename Rng>
+    struct sliding_view<Rng, sliding_view_detail::cache::none>
+      : sliding_view_detail::sv_base<Rng>
+    {
+    private:
+        friend range_access;
+
+        template<bool Const>
+        struct adaptor : adaptor_base
+        {
+        private:
+            friend adaptor<!Const>;
+            using CRng = meta::const_if_c<Const, Rng>;
+            range_difference_t<Rng> n_ = 0;
+
+        public:
+            adaptor() = default;
+            adaptor(range_difference_t<Rng> n)
+              : n_(n)
+            {}
+            template<bool Other>
+            CPP_ctor(adaptor)(adaptor<Other> that)( //
+                requires Const && (!Other))
+              : n_(that.n_)
+            {}
+            iterator_t<CRng> end(meta::const_if_c<Const, sliding_view> & v) const
+            {
+                auto const sz = ranges::distance(v.base());
+                auto const offset = n_ - 1 < sz ? n_ - 1 : sz;
+                return ranges::begin(v.base()) + (sz - offset);
+            }
+            auto read(iterator_t<CRng> const & it) const
+                -> decltype(views::counted(uncounted(it), n_))
+            {
+                return views::counted(uncounted(it), n_);
+            }
+        };
+
+        adaptor<simple_view<Rng>()> begin_adaptor()
+        {
+            return {this->n_};
+        }
+        CPP_member
+        auto begin_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires range<Rng const>)
+        {
+            return {this->n_};
+        }
+        adaptor<simple_view<Rng>()> end_adaptor()
+        {
+            return {this->n_};
+        }
+        CPP_member
+        auto end_adaptor() const -> CPP_ret(adaptor<true>)( //
+            requires range<Rng const>)
+        {
+            return {this->n_};
+        }
+
+    public:
+        using sliding_view::sv_base::sv_base;
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    sliding_view(Rng &&, range_difference_t<Rng>)->sliding_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        // In:  range<T>
+        // Out: range<range<T>>, where each inner range has $n$ elements.
+        struct sliding_base_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng, range_difference_t<Rng> n) const
+                -> CPP_ret(sliding_view<all_t<Rng>>)( //
+                    requires viewable_range<Rng> && forward_range<Rng>)
+            {
+                return {all(static_cast<Rng &&>(rng)), n};
+            }
+        };
+
+        struct sliding_fn : sliding_base_fn
+        {
+            using sliding_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(sliding_base_fn{}, n));
+            }
+        };
+
+        /// \relates sliding_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(sliding_fn, sliding)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/span.hpp b/inst/include/range/v3/view/span.hpp
new file mode 100644
index 0000000..45eca5e
--- /dev/null
+++ b/inst/include/range/v3/view/span.hpp
@@ -0,0 +1,418 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Casey Carter 2016-2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SPAN_HPP
+#define RANGES_V3_VIEW_SPAN_HPP
+
+#include <cstddef>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/equal.hpp>
+#include <range/v3/algorithm/lexicographical_compare.hpp>
+#include <range/v3/iterator/reverse_iterator.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/view/interface.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        using span_index_t = std::ptrdiff_t;
+    } // namespace detail
+    /// \endcond
+
+    constexpr detail::span_index_t dynamic_extent = -1;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename To, typename From>
+        constexpr auto narrow_cast(From from) noexcept -> CPP_ret(To)( //
+            requires integral<To> && integral<From>)
+        {
+            using C = common_type_t<To, From>;
+            return RANGES_EXPECT((from > 0) == (static_cast<To>(from) > 0)),
+                   RANGES_EXPECT(static_cast<C>(from) ==
+                                 static_cast<C>(static_cast<To>(from))),
+                   static_cast<To>(from);
+        }
+
+        template<typename T>
+        constexpr span_index_t byte_size(span_index_t n) noexcept
+        {
+            return n == dynamic_extent ? dynamic_extent
+                                       : (RANGES_EXPECT(n >= 0),
+                                          RANGES_EXPECT(narrow_cast<std::size_t>(n) <=
+                                                        PTRDIFF_MAX / sizeof(T)),
+                                          n * narrow_cast<span_index_t>(sizeof(T)));
+        }
+
+        template<span_index_t N>
+        struct span_extent
+        {
+            CPP_assert(N >= 0);
+
+            constexpr span_extent() noexcept = default;
+            constexpr span_extent(span_index_t size) noexcept
+              // this constructor does nothing, the delegation exists only
+              // to provide a place for the contract check expression.
+              : span_extent{(RANGES_EXPECT(size == N), tag{})}
+            {}
+
+            constexpr span_index_t size() const noexcept
+            {
+                return N;
+            }
+
+        private:
+            struct tag
+            {};
+            constexpr span_extent(tag) noexcept
+            {}
+        };
+        template<>
+        struct span_extent<dynamic_extent>
+        {
+            span_extent() = default;
+            constexpr span_extent(span_index_t size) noexcept
+              : size_{((void)RANGES_EXPECT(size >= 0), size)}
+            {}
+            constexpr span_index_t size() const noexcept
+            {
+                return size_;
+            }
+
+        private:
+            span_index_t size_ = 0;
+        };
+
+        constexpr span_index_t subspan_extent(span_index_t Extent, span_index_t Offset,
+                                              span_index_t Count) noexcept
+        {
+            return Count == dynamic_extent && Extent != dynamic_extent ? Extent - Offset
+                                                                       : Count;
+        }
+    } // namespace detail
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename Rng, typename T)
+        concept span_compatible_range,
+            sized_range<Rng> && contiguous_range<Rng> &&
+            detail::is_convertible<
+                detail::element_t<Rng>(*)[],
+                T(*)[]>::value
+    );
+
+    CPP_def
+    (
+        template(typename Rng, detail::span_index_t N)
+        (concept span_dynamic_conversion)(Rng, N),
+            N == dynamic_extent ||
+                range_cardinality<Rng>::value < cardinality()
+    );
+
+    CPP_def
+    (
+        template(typename Rng, detail::span_index_t N)
+        (concept span_static_conversion)(Rng, N),
+            N != dynamic_extent && range_cardinality<Rng>::value == N
+    );
+    // clang-format on
+    /// \endcond
+
+    template<typename T, detail::span_index_t N = dynamic_extent>
+    struct RANGES_EMPTY_BASES span
+      : public view_interface<
+            span<T, N>, (N == dynamic_extent ? finite : static_cast<cardinality>(N))>
+      , public detail::span_extent<N>
+    {
+        CPP_assert(std::is_object<T>::value);
+
+        using element_type = T;
+        using value_type = meta::_t<std::remove_cv<T>>;
+        using index_type = detail::span_index_t;
+        using difference_type = index_type;
+        using pointer = T *;
+        using reference = T &;
+        using iterator = T *;
+        using reverse_iterator = ranges::reverse_iterator<iterator>;
+
+        static constexpr index_type extent = N;
+
+        constexpr span() noexcept = default;
+        constexpr span(pointer ptr, index_type cnt) noexcept
+          : detail::span_extent<N>{(RANGES_EXPECT(cnt >= 0), cnt)}
+          , data_{(RANGES_EXPECT(0 == cnt || ptr != nullptr), ptr)}
+        {}
+        template<typename = void> // Artificially templatize so that the other
+                                  // constructor is preferred for {ptr, 0}
+        constexpr span(pointer first, pointer last) noexcept
+          : span{first, last - first}
+        {}
+
+        CPP_template(typename Rng)( //
+            requires(!defer::same_as<span, uncvref_t<Rng>>) &&
+            defer::span_compatible_range<Rng, T> &&
+            defer::span_dynamic_conversion<Rng, N>) //
+            constexpr span(Rng && rng) noexcept(noexcept(ranges::data(rng),
+                                                         ranges::size(rng)))
+          : span{ranges::data(rng), detail::narrow_cast<index_type>(ranges::size(rng))}
+        {}
+
+        CPP_template(typename Rng)( //
+            requires(!defer::same_as<span, uncvref_t<Rng>>) &&
+            defer::span_compatible_range<Rng, T> &&
+            defer::span_static_conversion<Rng, N>) //
+            constexpr span(Rng && rng) noexcept(noexcept(ranges::data(rng)))
+          : span{ranges::data(rng), N}
+        {}
+
+        template<index_type Count>
+        constexpr span<T, Count> first() const noexcept
+        {
+            static_assert(Count >= 0, "Count of elements to extract cannot be negative.");
+            static_assert(
+                N == dynamic_extent || Count <= N,
+                "Count of elements to extract must be less than the static span extent.");
+            return RANGES_EXPECT(Count <= size()),
+                   RANGES_EXPECT(Count == 0 || data_ != nullptr),
+                   span<T, Count>{data_, Count};
+        }
+        constexpr span<T> first(index_type cnt) const noexcept
+        {
+            return RANGES_EXPECT(cnt >= 0 && cnt <= size()),
+                   RANGES_EXPECT(cnt == 0 || data_ != nullptr), span<T>{data_, cnt};
+        }
+
+        template<index_type Count>
+        constexpr span<T, Count> last() const noexcept
+        {
+            static_assert(Count >= 0, "Count of elements to extract cannot be negative.");
+            static_assert(
+                N == dynamic_extent || Count <= N,
+                "Count of elements to extract must be less than the static span extent.");
+            return RANGES_EXPECT(Count <= size()),
+                   RANGES_EXPECT((Count == 0 && size() == 0) || data_ != nullptr),
+                   span<T, Count>{data_ + size() - Count, Count};
+        }
+        constexpr span<T> last(index_type cnt) const noexcept
+        {
+            return RANGES_EXPECT(cnt >= 0 && cnt <= size()),
+                   RANGES_EXPECT((cnt == 0 && size() == 0) || data_ != nullptr),
+                   span<T>{data_ + size() - cnt, cnt};
+        }
+
+        template<index_type Offset, index_type Count>
+        constexpr span<T, detail::subspan_extent(N, Offset, Count)> subspan() const
+            noexcept
+        {
+            static_assert(Offset >= 0,
+                          "Offset of first element to extract cannot be negative.");
+            static_assert(Count >= dynamic_extent,
+                          "Count of elements to extract cannot be negative.");
+            static_assert(
+                N == dynamic_extent ||
+                    N >= Offset + (Count == dynamic_extent ? 0 : Count),
+                "Sequence of elements to extract must be within the static span extent.");
+            return RANGES_EXPECT(size() >=
+                                 Offset + (Count == dynamic_extent ? 0 : Count)),
+                   RANGES_EXPECT((Offset == 0 && Count <= 0) || data_ != nullptr),
+                   span<T, detail::subspan_extent(N, Offset, Count)>{
+                       data_ + Offset, Count == dynamic_extent ? size() - Offset : Count};
+        }
+        template<index_type Offset>
+        constexpr span<T, (N >= Offset ? N - Offset : dynamic_extent)> subspan() const
+            noexcept
+        {
+            static_assert(Offset >= 0,
+                          "Offset of first element to extract cannot be negative.");
+            static_assert(N == dynamic_extent || N >= Offset,
+                          "Offset of first element to extract must be within the static "
+                          "span extent.");
+            return RANGES_EXPECT(size() >= Offset),
+                   RANGES_EXPECT((Offset == 0 && size() == 0) || data_ != nullptr),
+                   span < T,
+                   N >= Offset ? N - Offset
+                               : dynamic_extent > {data_ + Offset, size() - Offset};
+        }
+        constexpr span<T, dynamic_extent> subspan(index_type offset) const noexcept
+        {
+            return RANGES_EXPECT(offset >= 0), RANGES_EXPECT(size() >= offset),
+                   RANGES_EXPECT((offset == 0 && size() == 0) || data_ != nullptr),
+                   span<T, dynamic_extent>{data_ + offset, size() - offset};
+        }
+        constexpr span<T, dynamic_extent> subspan(index_type offset, index_type cnt) const
+            noexcept
+        {
+            return RANGES_EXPECT(offset >= 0), RANGES_EXPECT(cnt >= 0),
+                   RANGES_EXPECT(size() >= offset + cnt),
+                   RANGES_EXPECT((offset == 0 && cnt == 0) || data_ != nullptr),
+                   span<T, dynamic_extent>{data_ + offset, cnt};
+        }
+
+        constexpr pointer data() const noexcept
+        {
+            return data_;
+        }
+        using detail::span_extent<N>::size;
+        constexpr index_type size_bytes() const noexcept
+        {
+            return detail::byte_size<T>(size());
+        }
+        constexpr bool empty() const noexcept
+        {
+            return size() == 0;
+        }
+
+        constexpr reference operator[](index_type idx) const noexcept
+        {
+            return RANGES_EXPECT(idx >= 0), RANGES_EXPECT(idx < size()),
+                   RANGES_EXPECT(data_), data_[idx];
+        }
+
+        constexpr iterator begin() const noexcept
+        {
+            return RANGES_EXPECT(!size() || data_), data_;
+        }
+        constexpr iterator end() const noexcept
+        {
+            return RANGES_EXPECT(!size() || data_), data_ + size();
+        }
+        constexpr reverse_iterator rbegin() const noexcept
+        {
+            return reverse_iterator{end()};
+        }
+        constexpr reverse_iterator rend() const noexcept
+        {
+            return reverse_iterator{begin()};
+        }
+
+        template<typename U, index_type M>
+        auto operator==(span<U, M> const & that) const -> CPP_ret(bool)( //
+            requires equality_comparable_with<T, U>)
+        {
+            RANGES_EXPECT(!size() || data());
+            RANGES_EXPECT(!that.size() || that.data());
+            return ranges::equal(*this, that);
+        }
+        template<typename U, index_type M>
+        auto operator!=(span<U, M> const & that) const -> CPP_ret(bool)( //
+            requires equality_comparable_with<T, U>)
+        {
+            return !(*this == that);
+        }
+
+        template<typename U, index_type M>
+        auto operator<(span<U, M> const & that) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            RANGES_EXPECT(!size() || data());
+            RANGES_EXPECT(!that.size() || that.data());
+            return ranges::lexicographical_compare(*this, that);
+        }
+        template<typename U, index_type M>
+        auto operator>(span<U, M> const & that) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            return that < *this;
+        }
+        template<typename U, index_type M>
+        auto operator<=(span<U, M> const & that) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            return !(that < *this);
+        }
+        template<typename U, index_type M>
+        auto operator>=(span<U, M> const & that) const -> CPP_ret(bool)( //
+            requires totally_ordered_with<T, U>)
+        {
+            return !(*this < that);
+        }
+
+    private:
+        T * data_ = nullptr;
+    };
+
+    template<typename T, detail::span_index_t N>
+    constexpr detail::span_index_t span<T, N>::extent;
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng)(         //
+        requires contiguous_range<Rng>) //
+        span(Rng && rng)
+            ->span<detail::element_t<Rng>, (range_cardinality<Rng>::value < cardinality()
+                                                ? dynamic_extent
+                                                : static_cast<detail::span_index_t>(
+                                                      range_cardinality<Rng>::value))>;
+#endif
+
+    template<typename T, detail::span_index_t N>
+    span<unsigned char const, detail::byte_size<T>(N)> as_bytes(span<T, N> s) noexcept
+    {
+        return {reinterpret_cast<unsigned char const *>(s.data()), s.size_bytes()};
+    }
+    template<typename T, detail::span_index_t N>
+    span<unsigned char, detail::byte_size<T>(N)> as_writeable_bytes(span<T, N> s) noexcept
+    {
+        return {reinterpret_cast<unsigned char *>(s.data()), s.size_bytes()};
+    }
+
+    template<typename ElementType>
+    constexpr span<ElementType> make_span(ElementType * ptr,
+                                          detail::span_index_t cnt) noexcept
+    {
+        return span<ElementType>{ptr, cnt};
+    }
+    template<typename ElementType>
+    constexpr span<ElementType> make_span(ElementType * first,
+                                          ElementType * last) noexcept
+    {
+        return span<ElementType>{first, last};
+    }
+    CPP_template(typename Rng)( //
+        requires contiguous_range<Rng> &&
+        (range_cardinality<Rng>::value < cardinality())) //
+        constexpr span<detail::element_t<Rng>> make_span(Rng && rng) noexcept(
+            noexcept(ranges::data(rng), ranges::size(rng)))
+    {
+        return {ranges::data(rng),
+                detail::narrow_cast<detail::span_index_t>(ranges::size(rng))};
+    }
+    CPP_template(typename Rng)( //
+        requires contiguous_range<Rng> &&
+        (range_cardinality<Rng>::value >= cardinality())) //
+        constexpr span<
+            detail::element_t<Rng>,
+            static_cast<detail::span_index_t>(
+                range_cardinality<Rng>::
+                    value)> make_span(Rng && rng) noexcept(noexcept(ranges::data(rng)))
+    {
+        return {ranges::data(rng), range_cardinality<Rng>::value};
+    }
+
+    /// @}
+} // namespace ranges
+
+#endif // RANGES_V3_VIEW_SPAN_HPP
diff --git a/inst/include/range/v3/view/split.hpp b/inst/include/range/v3/view/split.hpp
new file mode 100644
index 0000000..f7fa52d
--- /dev/null
+++ b/inst/include/range/v3/view/split.hpp
@@ -0,0 +1,669 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SPLIT_HPP
+#define RANGES_V3_VIEW_SPLIT_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/mismatch.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/single.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        // clang-format off
+        CPP_def
+        (
+            template(typename R)
+            concept tiny_range,
+                sized_range<R> &&
+                ranges::type<std::integral_constant<
+                    decltype(std::remove_reference_t<R>::size()),
+                    std::remove_reference_t<R>::size()>> &&
+                (std::remove_reference_t<R>::size() <= 1)
+        );
+        // clang-format on
+    } // namespace detail
+
+    template<typename V, typename Pattern>
+#if CPP_CXX_CONCEPTS
+        requires input_range<V> && forward_range<Pattern> && view_<V> && view_<
+            Pattern> && indirectly_comparable<iterator_t<V>, iterator_t<Pattern>,
+                                              ranges::equal_to> &&
+        (forward_range<V> || detail::tiny_range<Pattern>)
+#endif
+            struct split_view;
+
+    namespace detail
+    {
+        struct there
+        {
+            template<typename T>
+            static decltype(auto) current_(T & t) noexcept
+            {
+                return (t.curr_);
+            }
+        };
+
+        template<typename It>
+        struct here
+        {
+            It curr_ = It();
+            It & current_(ignore_t) noexcept
+            {
+                return curr_;
+            }
+            It const & current_(ignore_t) const noexcept
+            {
+                return curr_;
+            }
+        };
+
+        template<bool>
+        struct here_or_there_
+        {
+            template<typename>
+            using invoke = there;
+        };
+
+        template<>
+        struct here_or_there_<true>
+        {
+            template<typename It>
+            using invoke = here<It>;
+        };
+
+        template<typename It>
+        using split_view_base = meta::invoke<here_or_there_<!forward_iterator<It>>, It>;
+
+        template<typename JoinView, bool Const>
+        struct split_outer_iterator;
+
+        template<typename JoinView, bool Const>
+        struct split_inner_iterator;
+
+        template<typename V, typename Pattern, bool Const>
+        struct split_inner_iterator<split_view<V, Pattern>, Const>
+        {
+        private:
+            using Outer = split_outer_iterator<split_view<V, Pattern>, Const>;
+            using Base = meta::const_if_c<Const, V>;
+            using BaseIterCategory =
+                typename std::iterator_traits<iterator_t<Base>>::iterator_category;
+            Outer i_ = Outer();
+            bool incremented_ = false;
+            constexpr decltype(auto) current_() noexcept
+            {
+                return i_.current_();
+            }
+            constexpr decltype(auto) current_() const noexcept
+            {
+                return i_.current_();
+            }
+            constexpr bool done_() const
+            {
+                auto cur = current_();
+                auto last = ranges::end(i_.parent_->base_);
+                if(cur == last)
+                    return true;
+                auto pcur = ranges::begin(i_.parent_->pattern_);
+                auto pend = ranges::end(i_.parent_->pattern_);
+                if(pcur == pend)
+                    return incremented_;
+                do
+                {
+                    if(*cur != *pcur)
+                        return false;
+                    if(++pcur == pend)
+                        return true;
+                } while(++cur != last);
+                return false;
+            }
+#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
+            constexpr void pre_inc(std::true_type) // Forward
+            {
+                ++current_();
+            }
+            constexpr void pre_inc(std::false_type) // Input
+            {
+                if(Pattern::size() != 0)
+                    ++current_();
+            }
+            constexpr split_inner_iterator post_inc(std::true_type) // Forward
+            {
+                auto tmp = *this;
+                pre_inc(std::true_type{});
+                return tmp;
+            }
+            constexpr void post_inc(std::false_type) // Input
+            {
+                pre_inc(std::false_type{});
+            }
+#endif
+        public:
+            using iterator_concept = typename Outer::iterator_concept;
+            using iterator_category =
+                if_then_t<derived_from<BaseIterCategory, std::forward_iterator_tag>,
+                          std::forward_iterator_tag, std::input_iterator_tag>;
+            using value_type = range_value_t<Base>;
+            using difference_type = range_difference_t<Base>;
+            using reference = range_reference_t<Base>;        // Not to spec
+            using pointer = iter_pointer_t<iterator_t<Base>>; // Not to spec
+
+            split_inner_iterator() = default;
+
+            constexpr explicit split_inner_iterator(Outer i)
+              : i_(std::move(i))
+            {}
+
+            constexpr decltype(auto) operator*() const
+            {
+                return *current_();
+            }
+
+            constexpr split_inner_iterator & operator++()
+            {
+                incremented_ = true;
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+                if constexpr(!forward_range<Base>)
+                    if constexpr(Pattern::size() == 0)
+                        return *this;
+                ++current_();
+#else
+                pre_inc(meta::bool_<forward_range<Base>>{});
+#endif
+                return *this;
+            }
+
+            constexpr decltype(auto) operator++(int)
+            {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+                if constexpr(forward_range<V>)
+                {
+                    auto tmp = *this;
+                    ++*this;
+                    return tmp;
+                }
+                else
+                    ++*this;
+#else
+                return post_inc(meta::bool_<forward_range<V>>{});
+#endif
+            }
+
+            CPP_broken_friend_member
+            friend constexpr auto operator==(split_inner_iterator const & x,
+                                             split_inner_iterator const & y)
+                -> CPP_broken_friend_ret(bool)( //
+                    requires forward_range<Base>)
+            {
+                return x.i_.curr_ == y.i_.curr_;
+            }
+            CPP_broken_friend_member
+            friend constexpr auto operator!=(split_inner_iterator const & x,
+                                             split_inner_iterator const & y)
+                -> CPP_broken_friend_ret(bool)( //
+                    requires forward_range<Base>)
+            {
+                return x.i_.curr_ != y.i_.curr_;
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator==(split_inner_iterator const & x,
+                                             default_sentinel_t)
+            {
+                return x.done_();
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator==(default_sentinel_t,
+                                             split_inner_iterator const & x)
+            {
+                return x.done_();
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator!=(split_inner_iterator const & x,
+                                             default_sentinel_t)
+            {
+                return !x.done_();
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator!=(default_sentinel_t,
+                                             split_inner_iterator const & x)
+            {
+                return !x.done_();
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr decltype(auto) iter_move(
+                split_inner_iterator const &
+                    i) noexcept(noexcept(ranges::iter_move(i.current_())))
+            {
+                return ranges::iter_move(i.current_());
+            }
+            CPP_broken_friend_member
+            friend constexpr auto iter_swap(
+                split_inner_iterator const & x,
+                split_inner_iterator const &
+                    y) noexcept(noexcept(ranges::iter_swap(x.current_(), y.current_())))
+                -> CPP_broken_friend_ret(void)( //
+                    requires indirectly_swappable<iterator_t<Base>>)
+            {
+                ranges::iter_swap(x.current_(), y.current_());
+            }
+        };
+
+        template<typename It>
+        using split_outer_iterator_base =
+            meta::invoke<here_or_there_<forward_iterator<It>>, It>;
+
+        template<typename JoinView, bool Const>
+        struct split_outer_iterator;
+
+        template<typename V, typename Pattern, bool Const>
+        struct split_outer_iterator<split_view<V, Pattern>, Const>
+          : split_outer_iterator_base<iterator_t<meta::const_if_c<Const, V>>>
+        {
+        private:
+            friend struct split_inner_iterator<split_view<V, Pattern>, Const>;
+            using Parent = meta::const_if_c<Const, split_view<V, Pattern>>;
+            using Base = meta::const_if_c<Const, V>;
+            using Current = split_outer_iterator_base<iterator_t<Base>>;
+
+            Parent * parent_ = nullptr;
+            constexpr decltype(auto) current_() noexcept
+            {
+                return parent_->current_(*this);
+            }
+            constexpr decltype(auto) current_() const noexcept
+            {
+                return parent_->current_(*this);
+            }
+            constexpr decltype(auto) base_() const noexcept
+            {
+                return (parent_->base_);
+            }
+#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
+            constexpr split_outer_iterator post_inc(std::true_type) // Forward
+            {
+                auto tmp = *this;
+                ++*this;
+                return tmp;
+            }
+            constexpr void post_inc(std::false_type) // Input
+            {
+                ++*this;
+            }
+#endif
+
+        public:
+            using iterator_concept =
+                if_then_t<forward_range<Base>, std::forward_iterator_tag,
+                          std::input_iterator_tag>;
+            using iterator_category = std::input_iterator_tag;
+            struct value_type : view_interface<value_type>
+            {
+            private:
+                split_outer_iterator i_ = split_outer_iterator();
+
+            public:
+                value_type() = default;
+                constexpr explicit value_type(split_outer_iterator i)
+                  : i_(std::move(i))
+                {}
+                constexpr split_inner_iterator<split_view<V, Pattern>, Const> begin()
+                    const
+                {
+                    return split_inner_iterator<split_view<V, Pattern>, Const>(i_);
+                }
+                constexpr default_sentinel_t end() const
+                {
+                    return default_sentinel;
+                }
+            };
+            using difference_type = range_difference_t<Base>;
+            using reference = value_type; // Not to spec
+            using pointer = value_type *; // Not to spec
+
+            split_outer_iterator() = default;
+
+            CPP_member
+            constexpr explicit CPP_ctor(split_outer_iterator)(Parent & parent)( //
+                requires(!forward_range<Base>))
+              : parent_(&parent)
+            {}
+
+            CPP_member
+            constexpr CPP_ctor(split_outer_iterator)(Parent & parent,
+                                                     iterator_t<Base> current)( //
+                requires forward_range<Base>)
+              : Current{std::move(current)}
+              , parent_(&parent)
+            {}
+
+            CPP_template(bool Other)( //
+                requires Const && (!Other) &&
+                convertible_to<iterator_t<V>, iterator_t<Base>>) //
+                constexpr split_outer_iterator(
+                    split_outer_iterator<split_view<V, Pattern>, Other> i)
+              : Current{std::move(i.curr_)}
+              , parent_(i.parent_)
+            {}
+
+            constexpr value_type operator*() const
+            {
+                return value_type{*this};
+            }
+
+            constexpr split_outer_iterator & operator++()
+            {
+                auto & current = current_();
+                const auto last = ranges::end(base_());
+                if(current == last)
+                    return *this;
+                auto const pbegin = ranges::begin(parent_->pattern_);
+                auto const pend = ranges::end(parent_->pattern_);
+                if(pbegin == pend)
+                    ++current;
+                else
+                    do
+                    {
+                        const auto ret = ranges::mismatch(current, last, pbegin, pend);
+                        if(ret.in2 == pend)
+                        {
+                            current = ret.in1; // The pattern matched; skip it
+                            break;
+                        }
+                    } while(++current != last);
+                return *this;
+            }
+
+            constexpr decltype(auto) operator++(int)
+            {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+                if constexpr(forward_range<Base>)
+                {
+                    auto tmp = *this;
+                    ++*this;
+                    return tmp;
+                }
+                else
+                    ++*this;
+#else
+                return post_inc(meta::bool_<forward_range<Base>>{});
+#endif
+            }
+
+            CPP_broken_friend_member
+            friend constexpr auto operator==(split_outer_iterator const & x,
+                                             split_outer_iterator const & y)
+                -> CPP_broken_friend_ret(bool)( //
+                    requires forward_range<Base>)
+            {
+                return x.curr_ == y.curr_;
+            }
+            CPP_broken_friend_member
+            friend constexpr auto operator!=(split_outer_iterator const & x,
+                                             split_outer_iterator const & y)
+                -> CPP_broken_friend_ret(bool)( //
+                    requires forward_range<Base>)
+            {
+                return x.curr_ != y.curr_;
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator==(split_outer_iterator const & x,
+                                             default_sentinel_t)
+            {
+                return x.current_() == ranges::end(x.base_());
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator==(default_sentinel_t,
+                                             split_outer_iterator const & x)
+            {
+                return x.current_() == ranges::end(x.base_());
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator!=(split_outer_iterator const & x,
+                                             default_sentinel_t)
+            {
+                return x.current_() != ranges::end(x.base_());
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator!=(default_sentinel_t,
+                                             split_outer_iterator const & x)
+            {
+                return x.current_() != ranges::end(x.base_());
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    template<typename V, typename Pattern>
+#if CPP_CXX_CONCEPTS
+        requires input_range<V> && forward_range<Pattern> && view_<V> && view_<
+            Pattern> && indirectly_comparable<iterator_t<V>, iterator_t<Pattern>,
+                                              ranges::equal_to> &&
+        (forward_range<V> || detail::tiny_range<Pattern>)
+#endif
+            struct RANGES_EMPTY_BASES split_view
+      : view_interface<split_view<V, Pattern>, is_finite<V>::value ? finite : unknown>
+      , private detail::split_view_base<iterator_t<V>>
+    {
+    private:
+        template<typename, bool>
+        friend struct detail::split_outer_iterator;
+        template<typename, bool>
+        friend struct detail::split_inner_iterator;
+
+        V base_ = V();
+        Pattern pattern_ = Pattern();
+        template<bool Const>
+        using outer_iterator = detail::split_outer_iterator<split_view, Const>;
+
+#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
+        outer_iterator<simple_view<V>()> begin_(std::true_type)
+        {
+            return outer_iterator<simple_view<V>()>{*this, ranges::begin(base_)};
+        }
+        outer_iterator<false> begin_(std::false_type)
+        {
+            this->curr_ = ranges::begin(base_);
+            return outer_iterator<false>{*this};
+        }
+
+        outer_iterator<simple_view<V>()> end_(std::true_type) const
+        {
+            return outer_iterator<true>{*this, ranges::end(base_)};
+        }
+        default_sentinel_t end_(std::false_type) const
+        {
+            return default_sentinel;
+        }
+#endif
+
+    public:
+        split_view() = default;
+
+        constexpr split_view(V base, Pattern pattern)
+          : base_((V &&) base)
+          , pattern_((Pattern &&) pattern)
+        {}
+
+        CPP_member
+        constexpr CPP_ctor(split_view)(V base, range_value_t<V> e)(
+            requires constructible_from<Pattern, range_value_t<V>>)
+          : base_(std::move(base))
+          , pattern_(e)
+        {}
+
+        constexpr V base() const
+        {
+            return base_;
+        }
+
+        constexpr auto begin() -> outer_iterator<forward_range<V> && simple_view<V>()>
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(forward_range<V>)
+                return outer_iterator<simple_view<V>()>{*this, ranges::begin(base_)};
+            else
+            {
+                this->curr_ = ranges::begin(base_);
+                return outer_iterator<false>{*this};
+            }
+#else
+            return begin_(meta::bool_<forward_range<V>>{});
+#endif
+        }
+        CPP_member
+        constexpr auto begin() const -> CPP_ret(outer_iterator<true>)( //
+            requires forward_range<V> && forward_range<const V>)
+        {
+            return {*this, ranges::begin(base_)};
+        }
+        CPP_member
+        constexpr auto end() -> CPP_ret(outer_iterator<simple_view<V>()>)( //
+            requires forward_range<V> && common_range<V>)
+        {
+            return outer_iterator<simple_view<V>()>{*this, ranges::end(base_)};
+        }
+        constexpr auto end() const
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(forward_range<V> && forward_range<const V> &&
+                         common_range<const V>)
+                return outer_iterator<true>{*this, ranges::end(base_)};
+            else
+                return default_sentinel;
+#else
+            return end_(meta::bool_ < forward_range<V> && forward_range<const V> &&
+                        common_range<const V> > {});
+#endif
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename R, typename P)( //
+        requires input_range<R> && forward_range<P> && viewable_range<R> &&
+            viewable_range<P> &&
+                indirectly_comparable<iterator_t<R>, iterator_t<P>, ranges::equal_to> &&
+        (forward_range<R> || detail::tiny_range<P>)) //
+        split_view(R &&, P &&)
+            ->split_view<views::all_t<R>, views::all_t<P>>;
+
+    CPP_template(typename R)(    //
+        requires input_range<R>) //
+        split_view(R &&, range_value_t<R>)
+            ->split_view<views::all_t<R>, single_view<range_value_t<R>>>;
+#endif
+
+    namespace views
+    {
+        struct split_base_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng, range_value_t<Rng> val) const
+                -> CPP_ret(split_view<all_t<Rng>, single_view<range_value_t<Rng>>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirectly_comparable<iterator_t<Rng>, range_value_t<Rng> const *,
+                                              ranges::equal_to>)
+            {
+                return {all(static_cast<Rng &&>(rng)), single(std::move(val))};
+            }
+
+            template<typename Rng, typename Pattern>
+            constexpr auto operator()(Rng && rng, Pattern && pattern) const
+                -> CPP_ret(split_view<all_t<Rng>, all_t<Pattern>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        viewable_range<Pattern> && forward_range<Pattern> &&
+                            indirectly_comparable<iterator_t<Rng>, iterator_t<Pattern>,
+                                                  ranges::equal_to> &&
+                    (forward_range<Rng> || detail::tiny_range<Pattern>))
+            {
+                return {all((Rng &&) rng), all((Pattern &&) pattern)};
+            }
+        };
+
+        struct split_fn : split_base_fn
+        {
+            using split_base_fn::operator();
+
+            template<typename T>
+            constexpr auto operator()(T t) const
+            {
+                return make_view_closure(bind_back(split_base_fn{}, std::move(t)));
+            }
+        };
+
+        /// \relates split_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(split_fn, split)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::split;
+        }
+        CPP_template(typename Rng, typename Pattern)( //
+            requires input_range<Rng> && forward_range<Pattern> && view_<Rng> &&
+                view_<Pattern> && indirectly_comparable<
+                    iterator_t<Rng>, iterator_t<Pattern>, ranges::equal_to> &&
+            (forward_range<Rng> ||
+             ranges::detail::tiny_range<Pattern>)) using split_view =
+            ranges::split_view<Rng, Pattern>;
+    } // namespace cpp20
+
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::split_view)
+
+#endif
diff --git a/inst/include/range/v3/view/split_when.hpp b/inst/include/range/v3/view/split_when.hpp
new file mode 100644
index 0000000..b0aabfe
--- /dev/null
+++ b/inst/include/range/v3/view/split_when.hpp
@@ -0,0 +1,224 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SPLIT_WHEN_HPP
+#define RANGES_V3_VIEW_SPLIT_WHEN_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/facade.hpp>
+#include <range/v3/view/indirect.hpp>
+#include <range/v3/view/iota.hpp>
+#include <range/v3/view/take_while.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    template<typename Rng, typename Fun>
+    struct split_when_view
+      : view_facade<split_when_view<Rng, Fun>,
+                    is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+    {
+    private:
+        friend range_access;
+        Rng rng_;
+        semiregular_box_t<Fun> fun_;
+
+        template<bool IsConst>
+        struct cursor
+        {
+        private:
+            friend range_access;
+            friend split_when_view;
+            friend struct cursor<!IsConst>;
+            bool zero_;
+            using CRng = meta::const_if_c<IsConst, Rng>;
+            iterator_t<CRng> cur_;
+            sentinel_t<CRng> last_;
+            using fun_ref_t = semiregular_box_ref_or_val_t<Fun, IsConst>;
+            fun_ref_t fun_;
+
+            struct search_pred
+            {
+                bool zero_;
+                iterator_t<CRng> first_;
+                sentinel_t<CRng> last_;
+                fun_ref_t fun_;
+                bool operator()(iterator_t<CRng> cur) const
+                {
+                    return (zero_ && cur == first_) ||
+                           (cur != last_ && !invoke(fun_, cur, last_).first);
+                }
+            };
+            using reference_ =
+                indirect_view<take_while_view<iota_view<iterator_t<CRng>>, search_pred>>;
+            reference_ read() const
+            {
+                return reference_{{views::iota(cur_), {zero_, cur_, last_, fun_}}};
+            }
+            void next()
+            {
+                RANGES_EXPECT(cur_ != last_);
+                // If the last match consumed zero elements, bump the position.
+                if(zero_)
+                {
+                    zero_ = false;
+                    ++cur_;
+                }
+                for(; cur_ != last_; ++cur_)
+                {
+                    auto p = invoke(fun_, cur_, last_);
+                    if(p.first)
+                    {
+                        zero_ = (cur_ == p.second);
+                        cur_ = p.second;
+                        return;
+                    }
+                }
+            }
+            bool equal(default_sentinel_t) const
+            {
+                return cur_ == last_;
+            }
+            bool equal(cursor const & that) const
+            {
+                return cur_ == that.cur_;
+            }
+            cursor(fun_ref_t fun, iterator_t<CRng> first, sentinel_t<CRng> last)
+              : cur_(first)
+              , last_(last)
+              , fun_(fun)
+            {
+                // For skipping an initial zero-length match
+                auto p = invoke(fun, first, last);
+                zero_ = p.first && first == p.second;
+            }
+
+        public:
+            cursor() = default;
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other)) cursor(cursor<Other> that)
+              : cursor{std::move(that.cur_), std::move(that.last_), std::move(that.fun_)}
+            {}
+        };
+        cursor<false> begin_cursor()
+        {
+            return {fun_, ranges::begin(rng_), ranges::end(rng_)};
+        }
+        template<bool Const = true>
+        auto begin_cursor() const -> CPP_ret(cursor<Const>)( //
+            requires Const && range<meta::const_if_c<Const, Rng>> &&
+                invocable<Fun const &, iterator_t<meta::const_if_c<Const, Rng>>,
+                          sentinel_t<meta::const_if_c<Const, Rng>>>)
+        {
+            return {fun_, ranges::begin(rng_), ranges::end(rng_)};
+        }
+
+    public:
+        split_when_view() = default;
+        split_when_view(Rng rng, Fun fun)
+          : rng_(std::move(rng))
+          , fun_(std::move(fun))
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Fun>)
+        split_when_view(Rng &&, Fun)
+            ->split_when_view<views::all_t<Rng>, Fun>;
+#endif
+
+    namespace views
+    {
+        struct split_when_base_fn
+        {
+        private:
+            template<typename Pred>
+            struct predicate_pred_
+            {
+                semiregular_box_t<Pred> pred_;
+
+                template<typename I, typename S>
+                auto operator()(I cur, S last) const -> CPP_ret(std::pair<bool, I>)( //
+                    requires sentinel_for<S, I>)
+                {
+                    auto where = ranges::find_if_not(cur, last, std::ref(pred_));
+                    return {cur != where, where};
+                }
+            };
+
+        public:
+            template<typename Rng, typename Fun>
+            auto operator()(Rng && rng, Fun fun) const        //
+                -> CPP_ret(split_when_view<all_t<Rng>, Fun>)( //
+                    requires viewable_range<Rng> && forward_range<Rng> &&
+                        invocable<Fun &, iterator_t<Rng>, sentinel_t<Rng>> && invocable<
+                            Fun &, iterator_t<Rng>, iterator_t<Rng>> &&
+                            copy_constructible<Fun> && convertible_to<
+                                invoke_result_t<Fun &, iterator_t<Rng>, sentinel_t<Rng>>,
+                                std::pair<bool, iterator_t<Rng>>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(fun)};
+            }
+            template<typename Rng, typename Fun>
+            auto operator()(Rng && rng, Fun fun) const
+                -> CPP_ret(split_when_view<all_t<Rng>, predicate_pred_<Fun>>)( //
+                    requires viewable_range<Rng> && forward_range<Rng> && predicate<
+                        Fun const &, range_reference_t<Rng>> && copy_constructible<Fun>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        predicate_pred_<Fun>{std::move(fun)}};
+            }
+        };
+
+        struct split_when_fn : split_when_base_fn
+        {
+            using split_when_base_fn::operator();
+
+            template<typename T>
+            constexpr auto operator()(T && t) const
+            {
+                return make_view_closure(
+                    bind_back(split_when_base_fn{}, static_cast<T &&>(t)));
+            }
+        };
+
+        /// \relates split_when_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(split_when_fn, split_when)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::split_when_view)
+
+#endif
diff --git a/inst/include/range/v3/view/stride.hpp b/inst/include/range/v3/view/stride.hpp
new file mode 100644
index 0000000..28bdbea
--- /dev/null
+++ b/inst/include/range/v3/view/stride.hpp
@@ -0,0 +1,334 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_STRIDE_HPP
+#define RANGES_V3_VIEW_STRIDE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    template<typename Rng>
+    struct stride_view;
+
+    namespace detail
+    {
+        template<typename Rng>
+        using stride_view_adaptor =
+            view_adaptor<stride_view<Rng>, Rng,
+                         is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>;
+
+        // Bidirectional stride views need to remember the distance between
+        // the penultimate iterator and the last iterator - which may be less
+        // than the stride - so that decrementing an last iterator properly
+        // produces the penultimate iterator. stride_view_base specializes on
+        // that distinction so that only Bidirectional stride views have the
+        // data member "offset_".
+        template<typename Rng, bool BidiRange>
+        struct stride_view_base_;
+        template<typename Rng>
+        using stride_view_base = stride_view_base_<Rng, (bool)bidirectional_range<Rng>>;
+
+        template<typename Rng, bool /*= bidirectional_range<Rng>*/>
+        struct stride_view_base_ : stride_view_adaptor<Rng>
+        {
+            stride_view_base_() = default;
+            constexpr stride_view_base_(Rng && rng, range_difference_t<Rng> const stride)
+              : stride_view_adaptor<Rng>{std::move(rng)}
+              , stride_{(RANGES_EXPECT(0 < stride), stride)}
+              , offset_{calc_offset(meta::bool_<sized_range<Rng>>{})}
+            {}
+
+        protected:
+            constexpr void set_offset(range_difference_t<Rng> const delta) noexcept
+            {
+                RANGES_EXPECT(0 <= delta && delta < stride_);
+                if(0 > offset_)
+                    offset_ = delta;
+                else
+                    RANGES_EXPECT(offset_ == delta);
+            }
+            constexpr void set_offset(range_difference_t<Rng> const) const noexcept
+            {}
+            constexpr range_difference_t<Rng> get_offset(bool check = true) const noexcept
+            {
+                RANGES_EXPECT(!check || 0 <= offset_);
+                return offset_;
+            }
+
+            range_difference_t<Rng> stride_;
+            range_difference_t<Rng> offset_ = -1;
+
+        private:
+            constexpr range_difference_t<Rng> calc_offset(std::true_type)
+            {
+                if(auto const rem = ranges::distance(this->base()) % stride_)
+                    return stride_ - rem;
+                else
+                    return 0;
+            }
+            constexpr range_difference_t<Rng> calc_offset(std::false_type) const noexcept
+            {
+                return -1;
+            }
+        };
+
+        template<typename Rng>
+        struct stride_view_base_<Rng, false> : stride_view_adaptor<Rng>
+        {
+            stride_view_base_() = default;
+            constexpr stride_view_base_(Rng && rng, range_difference_t<Rng> const stride)
+              : stride_view_adaptor<Rng>{std::move(rng)}
+              , stride_{(RANGES_EXPECT(0 < stride), stride)}
+            {}
+
+        protected:
+            constexpr void set_offset(range_difference_t<Rng> const) const noexcept
+            {}
+            constexpr range_difference_t<Rng> get_offset(bool = true) const noexcept
+            {
+                return 0;
+            }
+
+            range_difference_t<Rng> stride_;
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct stride_view : detail::stride_view_base<Rng>
+    {
+    private:
+        friend range_access;
+
+        // stride_view const models Range if Rng const models Range, and
+        // either (1) Rng is sized, so we can pre-calculate offset_, or (2)
+        // Rng is !Bidirectional, so it does not need offset_.
+        static constexpr bool const_iterable() noexcept
+        {
+            return range<Rng const> &&
+                   (sized_range<Rng const> || !bidirectional_range<Rng const>);
+        }
+
+        // If the underlying range doesn't model common_range, then we can't
+        // decrement the last and there's no reason to adapt the sentinel. Strictly
+        // speaking, we don't have to adapt the last iterator of input and forward
+        // ranges, but in the interests of making the resulting stride view model
+        // common_range, adapt it anyway.
+        template<bool Const>
+        static constexpr bool can_bound() noexcept
+        {
+            using CRng = meta::const_if_c<Const, Rng>;
+            return common_range<CRng> &&
+                   (sized_range<CRng> || !bidirectional_range<CRng>);
+        }
+
+        template<bool Const>
+        struct adaptor : adaptor_base
+        {
+        private:
+            friend struct adaptor<!Const>;
+            using CRng = meta::const_if_c<Const, Rng>;
+            using stride_view_t = meta::const_if_c<Const, stride_view>;
+            stride_view_t * rng_;
+
+        public:
+            adaptor() = default;
+            constexpr adaptor(stride_view_t * rng) noexcept
+              : rng_(rng)
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) adaptor(adaptor<Other> that)
+              : rng_(that.rng_)
+            {}
+            constexpr void next(iterator_t<CRng> & it)
+            {
+                auto const last = ranges::end(rng_->base());
+                RANGES_EXPECT(it != last);
+                auto const delta = ranges::advance(it, rng_->stride_, last);
+                if(it == last)
+                {
+                    rng_->set_offset(delta);
+                }
+            }
+            CPP_member
+            constexpr auto prev(iterator_t<CRng> & it) -> CPP_ret(void)( //
+                requires bidirectional_range<CRng>)
+            {
+                RANGES_EXPECT(it != ranges::begin(rng_->base()));
+                auto delta = -rng_->stride_;
+                if(it == ranges::end(rng_->base()))
+                {
+                    RANGES_EXPECT(rng_->get_offset() >= 0);
+                    delta += rng_->get_offset();
+                }
+                ranges::advance(it, delta);
+            }
+            template<typename Other>
+            constexpr auto distance_to(iterator_t<CRng> const & here,
+                                       Other const & there) const
+                -> CPP_ret(range_difference_t<Rng>)( //
+                    requires sized_sentinel_for<Other, iterator_t<CRng>>)
+            {
+                range_difference_t<Rng> delta = there - here;
+                if(delta < 0)
+                    delta -= rng_->stride_ - 1;
+                else
+                    delta += rng_->stride_ - 1;
+                return delta / rng_->stride_;
+            }
+            CPP_member
+            constexpr auto advance(iterator_t<CRng> & it,
+                                   range_difference_t<Rng> n) -> CPP_ret(void)( //
+                requires random_access_range<CRng>)
+            {
+                if(0 == n)
+                    return;
+                n *= rng_->stride_;
+                auto const last = ranges::end(rng_->base());
+                if(it == last)
+                {
+                    RANGES_EXPECT(n < 0);
+                    RANGES_EXPECT(rng_->get_offset() >= 0);
+                    n += rng_->get_offset();
+                }
+                if(0 < n)
+                {
+                    auto delta = ranges::advance(it, n, last);
+                    if(it == last)
+                    {
+                        // advance hit the last of the base range.
+                        rng_->set_offset(delta % rng_->stride_);
+                    }
+                }
+                else if(0 > n)
+                {
+#ifdef NDEBUG
+                    ranges::advance(it, n);
+#else
+                    auto const first = ranges::begin(rng_->base());
+                    auto const delta = ranges::advance(it, n, first);
+                    RANGES_EXPECT(delta == 0);
+#endif
+                }
+            }
+        };
+        constexpr auto begin_adaptor() noexcept -> adaptor<false>
+        {
+            return adaptor<false>{this};
+        }
+        CPP_member
+        constexpr auto begin_adaptor() const noexcept
+            -> CPP_ret(adaptor<true>)(requires(const_iterable()))
+        {
+            return adaptor<true>{this};
+        }
+
+        constexpr auto end_adaptor() noexcept
+            -> meta::if_c<can_bound<false>(), adaptor<false>, adaptor_base>
+        {
+            return {this};
+        }
+        CPP_member
+        constexpr auto end_adaptor() const noexcept
+            -> CPP_ret(meta::if_c<can_bound<true>(), adaptor<true>, adaptor_base>)( //
+                requires(const_iterable()))
+        {
+            return {this};
+        }
+
+    public:
+        stride_view() = default;
+        constexpr stride_view(Rng rng, range_difference_t<Rng> const stride)
+          : detail::stride_view_base<Rng>{std::move(rng), stride}
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            using size_type = range_size_t<Rng>;
+            auto const n = ranges::size(this->base());
+            return (n + static_cast<size_type>(this->stride_) - 1) /
+                   static_cast<size_type>(this->stride_);
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            using size_type = range_size_t<Rng const>;
+            auto const n = ranges::size(this->base());
+            return (n + static_cast<size_type>(this->stride_) - 1) /
+                   static_cast<size_type>(this->stride_);
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    stride_view(Rng &&, range_difference_t<Rng>)->stride_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct stride_base_fn
+        {
+            template<typename Rng>
+            constexpr auto operator()(Rng && rng, range_difference_t<Rng> step) const
+                -> CPP_ret(stride_view<all_t<Rng>>)( //
+                    requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return stride_view<all_t<Rng>>{all(static_cast<Rng &&>(rng)), step};
+            }
+        };
+
+        struct stride_fn : stride_base_fn
+        {
+            using stride_base_fn::operator();
+
+            template<typename Difference>
+            constexpr auto CPP_fun(operator())(Difference step)(
+                const //
+                requires detail::integer_like_<Difference>)
+            {
+                return make_view_closure(bind_back(stride_base_fn{}, step));
+            }
+        };
+
+        /// \relates stride_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(stride_fn, stride)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::stride_view)
+
+#endif
diff --git a/inst/include/range/v3/view/subrange.hpp b/inst/include/range/v3/view/subrange.hpp
new file mode 100644
index 0000000..6f22307
--- /dev/null
+++ b/inst/include/range/v3/view/subrange.hpp
@@ -0,0 +1,492 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//  Copyright Casey Carter 2017
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_SUBRANGE_HPP
+#define RANGES_V3_VIEW_SUBRANGE_HPP
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/dangling.hpp>
+#include <range/v3/utility/get.hpp>
+#include <range/v3/view/interface.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    enum class subrange_kind : bool
+    {
+        unsized,
+        sized
+    };
+
+    /// \cond
+    namespace detail
+    {
+        template<std::size_t N, typename T>
+        using tuple_element_fun_t = void (*)(meta::_t<std::tuple_element<N, T>> const &);
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename From, typename To)
+            concept convertible_to_not_slicing_,
+                convertible_to<From, To> &&
+                // A conversion is a slicing conversion if the source and the destination
+                // are both pointers, and if the pointed-to types differ after removing
+                // cv qualifiers.
+                (!(std::is_pointer<decay_t<From>>::value &&
+                    std::is_pointer<decay_t<To>>::value &&
+                    not_same_as_<meta::_t<std::remove_pointer<decay_t<From>>>,
+                               meta::_t<std::remove_pointer<decay_t<To>>>>))
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept pair_like_gcc_bugs_3_,
+                requires(T t, tuple_element_fun_t<0, T> p0, tuple_element_fun_t<1, T> p1)
+                (
+                    p0( get<0>(t) ),
+                    p1( get<1>(t) )
+                )
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept pair_like_gcc_bugs_2_,
+                derived_from<std::tuple_size<T>, meta::size_t<2>> &&
+                pair_like_gcc_bugs_3_<T>
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept pair_like_gcc_bugs_,
+                bool(ranges::defer::type<meta::_t<std::tuple_size<T>>> &&
+                     defer::pair_like_gcc_bugs_2_<T>)
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept get_first_and_second_,
+                requires(T &t)
+                (
+                    get<0>(t),
+                    get<1>(t)
+                )
+        );
+        CPP_def
+        (
+            template(typename T)
+            concept pair_like_,
+                (!std::is_reference<T>::value) &&
+                bool(defer::get_first_and_second_<T> &&
+                     defer::pair_like_gcc_bugs_<T>)
+        );
+        // clang-format on
+
+        // Short-circuit the PairLike concept for things known to be pairs:
+        template<typename T>
+        struct pair_like : meta::bool_<pair_like_<T>>
+        {};
+        template<typename F, typename S>
+        struct pair_like<std::pair<F, S>> : meta::bool_<true>
+        {};
+        template<typename... Ts>
+        struct pair_like<std::tuple<Ts...>> : meta::bool_<sizeof...(Ts) == 2u>
+        {};
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename T, typename U, typename V)
+            concept pair_like_convertible_from_gcc_bugs_,
+                convertible_to_not_slicing_<U, meta::_t<std::tuple_element<0, T>>> &&
+                convertible_to<V, meta::_t<std::tuple_element<1, T>>>
+        );
+        CPP_def
+        (
+            template(typename T, typename U, typename V)
+            concept pair_like_convertible_from_,
+                (!range<T>) &&
+                constructible_from<T, U, V> &&
+                bool(ranges::defer::is_true<pair_like<uncvref_t<T>>::value> &&
+                     defer::pair_like_convertible_from_gcc_bugs_<T, U, V>)
+        );
+        CPP_def
+        (
+            template(typename R, typename I, typename S)
+            concept range_convertible_to_,
+                forwarding_range_<R> &&
+                convertible_to_not_slicing_<iterator_t<R>, I> &&
+                convertible_to<sentinel_t<R>, S>
+        );
+        // clang-format on
+
+        template<typename S, typename I>
+        constexpr auto is_sized_sentinel_() noexcept -> CPP_ret(bool)( //
+            requires sentinel_for<S, I>)
+        {
+            return (bool)sized_sentinel_for<S, I>;
+        }
+
+        template<subrange_kind K, typename S, typename I>
+        constexpr bool store_size_() noexcept
+        {
+            return K == subrange_kind::sized && !(bool)sized_sentinel_for<S, I>;
+        }
+    } // namespace detail
+    /// \endcond
+
+    template<typename I, typename S = I,
+             subrange_kind K =
+                 static_cast<subrange_kind>(detail::is_sized_sentinel_<S, I>())>
+    struct subrange;
+
+    /// \cond
+    namespace _subrange_
+    {
+        struct adl_hook
+        {};
+
+        // A temporary subrange can be safely passed to ranges::begin and ranges::end.
+        template<typename I, typename S, subrange_kind K>
+        constexpr I begin(subrange<I, S, K> && r) noexcept(
+            std::is_nothrow_copy_constructible<I>::value)
+        {
+            return r.begin();
+        }
+        template<typename I, typename S, subrange_kind K>
+        constexpr I begin(subrange<I, S, K> const && r) noexcept(
+            std::is_nothrow_copy_constructible<I>::value)
+        {
+            return r.begin();
+        }
+        template<typename I, typename S, subrange_kind K>
+        constexpr S end(subrange<I, S, K> && r) noexcept(
+            std::is_nothrow_copy_constructible<S>::value)
+        {
+            return r.end();
+        }
+        template<typename I, typename S, subrange_kind K>
+        constexpr S end(subrange<I, S, K> const && r) noexcept(
+            std::is_nothrow_copy_constructible<S>::value)
+        {
+            return r.end();
+        }
+
+        template<std::size_t N, typename I, typename S, subrange_kind K>
+        constexpr auto get(subrange<I, S, K> const & r) -> CPP_ret(I)( //
+            requires(N == 0))
+        {
+            return r.begin();
+        }
+        template<std::size_t N, typename I, typename S, subrange_kind K>
+        constexpr auto get(subrange<I, S, K> const & r) -> CPP_ret(S)( //
+            requires(N == 1))
+        {
+            return r.end();
+        }
+    } // namespace _subrange_
+    /// \endcond
+
+    template<typename I, typename S, subrange_kind K>
+    struct subrange
+      : view_interface<subrange<I, S, K>,
+                       same_as<S, unreachable_sentinel_t>
+                           ? infinite
+                           : K == subrange_kind::sized ? finite : unknown>
+      , private _subrange_::adl_hook
+    {
+        CPP_assert(input_or_output_iterator<I>);
+        CPP_assert(sentinel_for<S, I>);
+        CPP_assert(K == subrange_kind::sized || !sized_sentinel_for<S, I>);
+        CPP_assert(K != subrange_kind::sized || !same_as<S, unreachable_sentinel_t>);
+
+        using size_type = detail::iter_size_t<I>;
+        using iterator = I;
+        using sentinel = S;
+
+        subrange() = default;
+
+        template<typename I2>
+        constexpr CPP_ctor(subrange)(I2 && i, S s)( //
+            requires detail::convertible_to_not_slicing_<I2, I> &&
+            (!detail::store_size_<K, S, I>()))
+          : data_{static_cast<I2 &&>(i), std::move(s)}
+        {}
+
+        template<typename I2>
+        constexpr CPP_ctor(subrange)(I2 && i, S s, size_type n)( //
+            requires detail::convertible_to_not_slicing_<I2, I> &&
+            (detail::store_size_<K, S, I>()))
+          : data_{static_cast<I2 &&>(i), std::move(s), n}
+        {
+            if(RANGES_CONSTEXPR_IF((bool)random_access_iterator<I>))
+            {
+                using D = iter_difference_t<I>;
+                RANGES_EXPECT(n <= (size_type)std::numeric_limits<D>::max());
+                RANGES_EXPECT(ranges::next(first_(), (D)n) == last_());
+            }
+        }
+        template<typename I2>
+        constexpr CPP_ctor(subrange)(I2 && i, S s, size_type n)( //
+            requires detail::convertible_to_not_slicing_<I2, I> &&
+                sized_sentinel_for<S, I>)
+          : data_{static_cast<I2 &&>(i), std::move(s)}
+        {
+            RANGES_EXPECT(static_cast<size_type>(last_() - first_()) == n);
+        }
+
+        template<typename R>
+        constexpr CPP_ctor(subrange)(R && r)(
+            requires defer::not_same_as_<R, subrange> &&
+                detail::defer::range_convertible_to_<R, I, S> &&
+                    defer::is_true<!detail::store_size_<K, S, I>()>)
+          : subrange{ranges::begin(r), ranges::end(r)}
+        {}
+
+        template<typename R>
+        constexpr CPP_ctor(subrange)(R && r)(
+            requires defer::not_same_as_<R, subrange> &&
+                detail::defer::range_convertible_to_<R, I, S> && defer::is_true<
+                    detail::store_size_<K, S, I>()> && defer::sized_range<R>)
+          : subrange{ranges::begin(r), ranges::end(r), ranges::size(r)}
+        {}
+
+        template<typename R>
+        constexpr CPP_ctor(subrange)(R && r, size_type n)(
+            requires detail::range_convertible_to_<R, I, S> &&
+            (K == subrange_kind::sized))
+          : subrange{ranges::begin(r), ranges::end(r), n}
+        {
+            if(RANGES_CONSTEXPR_IF((bool)sized_range<R>))
+            {
+                RANGES_EXPECT(n == ranges::size(r));
+            }
+        }
+
+        CPP_template(typename PairLike)( //
+            requires defer::not_same_as_<PairLike, subrange> &&
+                detail::defer::pair_like_convertible_from_<PairLike, const I &,
+                                                           const S &>) //
+            constexpr
+            operator PairLike() const
+        {
+            return PairLike(first_(), last_());
+        }
+
+        constexpr I begin() const noexcept(std::is_nothrow_copy_constructible<I>::value)
+        {
+            return first_();
+        }
+        constexpr S end() const noexcept(std::is_nothrow_copy_constructible<S>::value)
+        {
+            return last_();
+        }
+        constexpr bool empty() const
+        {
+            return first_() == last_();
+        }
+
+        CPP_member
+        constexpr auto size() const -> CPP_ret(size_type)( //
+            requires(K == subrange_kind::sized))
+        {
+            return get_size_();
+        }
+
+        RANGES_NODISCARD
+        constexpr subrange next(iter_difference_t<I> n = 1) const
+        {
+            auto tmp = *this;
+            tmp.advance(n);
+            return tmp;
+        }
+
+        CPP_member
+        RANGES_NODISCARD constexpr auto prev(iter_difference_t<I> n = 1) const
+            -> CPP_ret(subrange)( //
+                requires bidirectional_iterator<I>)
+        {
+            auto tmp = *this;
+            tmp.advance(-n);
+            return tmp;
+        }
+
+        constexpr subrange & advance(iter_difference_t<I> n)
+        {
+            set_size_(get_size_() -
+                      static_cast<size_type>(n - ranges::advance(first_(), n, last_())));
+            return *this;
+        }
+
+    private:
+        detail::if_then_t<detail::store_size_<K, S, I>(), std::tuple<I, S, size_type>,
+                          std::tuple<I, S>>
+            data_;
+
+        constexpr I & first_() noexcept
+        {
+            return std::get<0>(data_);
+        }
+        constexpr const I & first_() const noexcept
+        {
+            return std::get<0>(data_);
+        }
+        constexpr S & last_() noexcept
+        {
+            return std::get<1>(data_);
+        }
+        constexpr const S & last_() const noexcept
+        {
+            return std::get<1>(data_);
+        }
+        CPP_member
+        constexpr auto get_size_() const -> CPP_ret(size_type)( //
+            requires sized_sentinel_for<S, I>)
+        {
+            return static_cast<size_type>(last_() - first_());
+        }
+        CPP_member
+        constexpr auto get_size_() const noexcept -> CPP_ret(size_type)( //
+            requires(detail::store_size_<K, S, I>()))
+        {
+            return std::get<2>(data_);
+        }
+        static constexpr void set_size_(...) noexcept
+        {}
+        CPP_member
+        constexpr auto set_size_(size_type n) noexcept -> CPP_ret(void)( //
+            requires(detail::store_size_<K, S, I>()))
+        {
+            std::get<2>(data_) = n;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename I, typename S>
+    subrange(I, S)->subrange<I, S>;
+
+    CPP_template(typename I, typename S)(                           //
+        requires input_or_output_iterator<I> && sentinel_for<S, I>) //
+        subrange(I, S, detail::iter_size_t<I>)
+            ->subrange<I, S, subrange_kind::sized>;
+
+    CPP_template(typename R)(          //
+        requires forwarding_range_<R>) //
+        subrange(R &&)
+            ->subrange<iterator_t<R>, sentinel_t<R>,
+                       (sized_range<R> ||
+                        sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
+                           ? subrange_kind::sized
+                           : subrange_kind::unsized>;
+
+    CPP_template(typename R)(          //
+        requires forwarding_range_<R>) //
+        subrange(R &&, detail::iter_size_t<iterator_t<R>>)
+            ->subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;
+#endif
+
+    // in lieu of deduction guides, use make_subrange
+    struct make_subrange_fn
+    {
+        template<typename I, typename S>
+        constexpr auto operator()(I i, S s) const -> subrange<I, S>
+        {
+            return {i, s};
+        }
+        template<typename I, typename S>
+        constexpr auto operator()(I i, S s, detail::iter_size_t<I> n) const
+            -> CPP_ret(subrange<I, S, subrange_kind::sized>)( //
+                requires input_or_output_iterator<I> && sentinel_for<S, I>)
+        {
+            return {i, s, n};
+        }
+        template<typename R>
+        constexpr auto operator()(R && r) const -> CPP_ret(
+            subrange<iterator_t<R>, sentinel_t<R>,
+                     (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
+                         ? subrange_kind::sized
+                         : subrange_kind::unsized>)( //
+            requires forwarding_range_<R>)
+        {
+            return {(R &&) r};
+        }
+        template<typename R>
+        constexpr auto operator()(R && r, detail::iter_size_t<iterator_t<R>> n) const
+            -> CPP_ret(subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>)( //
+                requires forwarding_range_<R>)
+        {
+            return {(R &&) r, n};
+        }
+    };
+
+    /// \relates make_subrange_fn
+    /// \ingroup group-views
+    RANGES_INLINE_VARIABLE(make_subrange_fn, make_subrange)
+
+    template<typename R>
+    using safe_subrange_t = detail::maybe_dangling_<R, subrange<iterator_t<R>>>;
+
+    namespace cpp20
+    {
+        using ranges::subrange_kind;
+
+        CPP_template(typename I,                                          //
+                     typename S = I,                                      //
+                     subrange_kind K =                                    //
+                     static_cast<subrange_kind>(                          //
+                         detail::is_sized_sentinel_<S, I>()))(            //
+            requires input_or_output_iterator<I> && sentinel_for<S, I> && //
+            (K == subrange_kind::sized || !sized_sentinel_for<S, I>))     //
+            using subrange = ranges::subrange<I, S>;
+
+        using ranges::safe_subrange_t;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+RANGES_DIAGNOSTIC_PUSH
+RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
+
+namespace std
+{
+    template<typename I, typename S, ::ranges::subrange_kind K>
+    struct tuple_size<::ranges::subrange<I, S, K>> : std::integral_constant<size_t, 2>
+    {};
+    template<typename I, typename S, ::ranges::subrange_kind K>
+    struct tuple_element<0, ::ranges::subrange<I, S, K>>
+    {
+        using type = I;
+    };
+    template<typename I, typename S, ::ranges::subrange_kind K>
+    struct tuple_element<1, ::ranges::subrange<I, S, K>>
+    {
+        using type = S;
+    };
+} // namespace std
+
+RANGES_DIAGNOSTIC_POP
+
+#endif
diff --git a/inst/include/range/v3/view/tail.hpp b/inst/include/range/v3/view/tail.hpp
new file mode 100644
index 0000000..de927cf
--- /dev/null
+++ b/inst/include/range/v3/view/tail.hpp
@@ -0,0 +1,136 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TAIL_HPP
+#define RANGES_V3_VIEW_TAIL_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    namespace detail
+    {
+        template<typename T>
+        constexpr T prev_or_zero_(T n)
+        {
+            return n == 0 ? T(0) : T(n - 1);
+        }
+    } // namespace detail
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    struct tail_view
+      : view_interface<tail_view<Rng>,
+                       (range_cardinality<Rng>::value >= 0)
+                           ? detail::prev_or_zero_(range_cardinality<Rng>::value)
+                           : range_cardinality<Rng>::value>
+    {
+    private:
+        Rng rng_;
+
+    public:
+        tail_view() = default;
+        tail_view(Rng rng)
+          : rng_(static_cast<Rng &&>(rng))
+        {
+            CPP_assert(input_range<Rng>);
+        }
+        iterator_t<Rng> begin()
+        {
+            return next(ranges::begin(rng_), 1, ranges::end(rng_));
+        }
+        template<bool Const = true>
+        auto begin() const -> CPP_ret(iterator_t<meta::const_if_c<Const, Rng>>)( //
+            requires Const && range<meta::const_if_c<Const, Rng>>)
+        {
+            return next(ranges::begin(rng_), 1, ranges::end(rng_));
+        }
+        sentinel_t<Rng> end()
+        {
+            return ranges::end(rng_);
+        }
+        template<bool Const = true>
+        auto end() const -> CPP_ret(sentinel_t<meta::const_if_c<Const, Rng>>)( //
+            requires Const && range<meta::const_if_c<Const, Rng>>)
+        {
+            return ranges::end(rng_);
+        }
+        // Strange cast to bool in the requires clause is to work around gcc bug.
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires(bool(sized_range<Rng>)))
+        {
+            using size_type = range_size_t<Rng>;
+            return range_cardinality<Rng>::value >= 0
+                       ? detail::prev_or_zero_((size_type)range_cardinality<Rng>::value)
+                       : detail::prev_or_zero_(ranges::size(rng_));
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires(bool(sized_range<Rng const>)))
+        {
+            using size_type = range_size_t<Rng>;
+            return range_cardinality<Rng>::value >= 0
+                       ? detail::prev_or_zero_((size_type)range_cardinality<Rng>::value)
+                       : detail::prev_or_zero_(ranges::size(rng_));
+        }
+        Rng base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng)(       //
+        requires viewable_range<Rng>) //
+        tail_view(Rng &&)
+            ->tail_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct tail_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng) const
+                -> CPP_ret(meta::if_c<range_cardinality<Rng>::value == 0, all_t<Rng>,
+                                      tail_view<all_t<Rng>>>)( //
+                    requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return all(static_cast<Rng &&>(rng));
+            }
+        };
+
+        /// \relates tail_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<tail_fn>, tail)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::tail_view)
+
+#endif
diff --git a/inst/include/range/v3/view/take.hpp b/inst/include/range/v3/view/take.hpp
new file mode 100644
index 0000000..4b3ffa1
--- /dev/null
+++ b/inst/include/range/v3/view/take.hpp
@@ -0,0 +1,312 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TAKE_HPP
+#define RANGES_V3_VIEW_TAKE_HPP
+
+#include <type_traits>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/min.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/counted_iterator.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    template<typename Rng>
+    struct take_view : view_interface<take_view<Rng>, finite>
+    {
+    private:
+        CPP_assert(view_<Rng>);
+        Rng base_ = Rng();
+        range_difference_t<Rng> count_ = 0;
+        template<bool Const>
+        struct sentinel
+        {
+        private:
+            using Base = detail::if_then_t<Const, Rng const, Rng>;
+            using CI = counted_iterator<iterator_t<Base>>;
+            sentinel_t<Base> end_ = sentinel_t<Base>();
+
+        public:
+            sentinel() = default;
+            constexpr explicit sentinel(sentinel_t<Base> last)
+              : end_(std::move(last))
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other) &&
+                convertible_to<sentinel_t<Rng>,
+                               sentinel_t<Base>>) //
+                constexpr sentinel(sentinel<Other> that)
+              : end_(std::move(that.end_))
+            {}
+            constexpr sentinel_t<Base> base() const
+            {
+                return end_;
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator==(sentinel const & x, CI const & y)
+            {
+                return y.count() == 0 || y.base() == x.end_;
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator==(CI const & y, sentinel const & x)
+            {
+                return y.count() == 0 || y.base() == x.end_;
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator!=(sentinel const & x, CI const & y)
+            {
+                return y.count() != 0 && y.base() != x.end_;
+            }
+#ifdef RANGES_WORKAROUND_MSVC_756601
+            template<typename = void>
+#endif // RANGES_WORKAROUND_MSVC_756601
+            friend constexpr bool operator!=(CI const & y, sentinel const & x)
+            {
+                return y.count() != 0 && y.base() != x.end_;
+            }
+        };
+
+#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
+        template<typename Take>
+        static auto begin_random_access_(Take & take, std::true_type)
+        {
+            return ranges::begin(take.base_);
+        }
+        template<typename Take>
+        static auto begin_random_access_(Take & take, std::false_type)
+        {
+            auto s = static_cast<range_difference_t<Rng>>(take.size());
+            return make_counted_iterator(ranges::begin(take.base_), s);
+        }
+        template<typename Take>
+        static auto begin_sized_(Take & take, std::true_type)
+        {
+            return begin_random_access_(
+                take, meta::bool_<random_access_range<decltype((take.base_))>>{});
+        }
+        template<typename Take>
+        static auto begin_sized_(Take & take, std::false_type)
+        {
+            return make_counted_iterator(ranges::begin(take.base_), take.count_);
+        }
+
+        template<typename Take>
+        static auto end_random_access_(Take & take, std::true_type)
+        {
+            return ranges::begin(take.base_) +
+                   static_cast<range_difference_t<Rng>>(take.size());
+        }
+        static auto end_random_access_(detail::ignore_t, std::false_type)
+        {
+            return default_sentinel;
+        }
+        template<typename Take>
+        static auto end_sized_(Take & take, std::true_type, std::false_type) // sized
+        {
+            return end_random_access_(
+                take, meta::bool_<random_access_range<decltype((take.base_))>>{});
+        }
+        static auto end_sized_(detail::ignore_t, std::false_type,
+                               std::true_type) // infinite
+        {
+            return default_sentinel;
+        }
+        static auto end_sized_(take_view & take, std::false_type, std::false_type)
+        {
+            return sentinel<false>{ranges::end(take.base_)};
+        }
+        static auto end_sized_(take_view const & take, std::false_type, std::false_type)
+        {
+            return sentinel<true>{ranges::end(take.base_)};
+        }
+#endif
+    public:
+        take_view() = default;
+
+        constexpr take_view(Rng base, range_difference_t<Rng> cnt)
+          : base_(std::move(base))
+          , count_(cnt)
+        {}
+
+        constexpr Rng base() const
+        {
+            return base_;
+        }
+
+        CPP_member
+        constexpr auto CPP_fun(begin)()(requires(!simple_view<Rng>()))
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(sized_range<Rng>)
+                if constexpr(random_access_range<Rng>)
+                    return ranges::begin(base_);
+                else
+                {
+                    // cannot always delegate to size() member on GCC with ConceptsTS
+#if defined(__cpp_concepts) && __cpp_concepts <= 201507
+                    auto s = ranges::min(
+                        static_cast<range_difference_t<Rng>>(count_),
+                        static_cast<range_difference_t<Rng>>(ranges::size(base_)));
+#else
+                    auto s = static_cast<range_difference_t<Rng>>(size());
+#endif
+                    return make_counted_iterator(ranges::begin(base_), s);
+                }
+            else
+                return make_counted_iterator(ranges::begin(base_), count_);
+#else
+            return begin_sized_(*this, meta::bool_<sized_range<Rng>>{});
+#endif
+        }
+
+        CPP_member
+        constexpr auto CPP_fun(begin)()(const requires range<Rng const>)
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(sized_range<Rng const>)
+                if constexpr(random_access_range<Rng const>)
+                    return ranges::begin(base_);
+                else
+                {
+                    auto s = static_cast<range_difference_t<Rng>>(size());
+                    return make_counted_iterator(ranges::begin(base_), s);
+                }
+            else
+                return make_counted_iterator(ranges::begin(base_), count_);
+#else
+            return begin_sized_(*this, meta::bool_<sized_range<Rng const>>{});
+#endif
+        }
+
+        CPP_member
+        constexpr auto CPP_fun(end)()(requires(!simple_view<Rng>()))
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(sized_range<Rng>)
+                if constexpr(random_access_range<Rng>)
+                    return ranges::begin(base_) +
+                           static_cast<range_difference_t<Rng>>(size());
+                else
+                    return default_sentinel;
+            // Not to spec: Infinite ranges:
+            else if constexpr(is_infinite<Rng>::value)
+                return default_sentinel;
+            else
+                return sentinel<false>{ranges::end(base_)};
+#else
+            return end_sized_(*this, meta::bool_<sized_range<Rng>>{}, is_infinite<Rng>{});
+#endif
+        }
+
+        CPP_member
+        constexpr auto CPP_fun(end)()(const requires range<Rng const>)
+        {
+#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
+            if constexpr(sized_range<Rng const>)
+                if constexpr(random_access_range<Rng const>)
+                    return ranges::begin(base_) +
+                           static_cast<range_difference_t<Rng>>(size());
+                else
+                    return default_sentinel;
+            // Not to spec: Infinite ranges:
+            else if constexpr(is_infinite<Rng const>::value)
+                return default_sentinel;
+            else
+                return sentinel<true>{ranges::end(base_)};
+#else
+            return end_sized_(
+                *this, meta::bool_<sized_range<Rng const>>{}, is_infinite<Rng const>{});
+#endif
+        }
+
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            auto n = ranges::size(base_);
+            return ranges::min(n, static_cast<decltype(n)>(count_));
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            auto n = ranges::size(base_);
+            return ranges::min(n, static_cast<decltype(n)>(count_));
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng>
+    take_view(Rng &&, range_difference_t<Rng>)->take_view<views::all_t<Rng>>;
+#endif
+
+    namespace views
+    {
+        struct take_base_fn
+        {
+            template<typename Rng>
+            auto operator()(Rng && rng, range_difference_t<Rng> n) const
+                -> CPP_ret(take_view<all_t<Rng>>)( //
+                    requires viewable_range<Rng>)
+            {
+                return {all(static_cast<Rng &&>(rng)), n};
+            }
+        };
+
+        struct take_fn : take_base_fn
+        {
+            using take_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(take_base_fn{}, n));
+            }
+        };
+
+        /// \relates take_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(take_fn, take)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::take;
+        }
+        CPP_template(typename Rng)( //
+            requires view_<Rng>)    //
+            using take_view = ranges::take_view<Rng>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::take_view)
+
+#endif
diff --git a/inst/include/range/v3/view/take_exactly.hpp b/inst/include/range/v3/view/take_exactly.hpp
new file mode 100644
index 0000000..088c933
--- /dev/null
+++ b/inst/include/range/v3/view/take_exactly.hpp
@@ -0,0 +1,194 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TAKE_EXACTLY_HPP
+#define RANGES_V3_VIEW_TAKE_EXACTLY_HPP
+
+#include <type_traits>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/iterator/counted_iterator.hpp>
+#include <range/v3/iterator/default_sentinel.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/counted.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        template<typename Rng>
+        struct is_random_access_common_
+          : meta::bool_<(bool)random_access_range<Rng> && (bool)common_range<Rng>>
+        {};
+
+        // BUGBUG Per the discussion in https://github.com/ericniebler/stl2/issues/63,
+        // it's unclear if we can infer anything from random_access_range<Rng> &&
+        // common_range<Rng>
+        template<typename Rng,
+                 bool IsRandomAccessCommon /*= is_random_access_common_<Rng>::value*/>
+        struct take_exactly_view_
+          : view_interface<take_exactly_view_<Rng, IsRandomAccessCommon>, finite>
+        {
+        private:
+            Rng rng_;
+            range_difference_t<Rng> n_;
+
+        public:
+            take_exactly_view_() = default;
+            take_exactly_view_(Rng rng, range_difference_t<Rng> n)
+              : rng_(std::move(rng))
+              , n_(n)
+            {
+                RANGES_EXPECT(n >= 0);
+            }
+            counted_iterator<iterator_t<Rng>> begin()
+            {
+                return {ranges::begin(rng_), n_};
+            }
+            template<typename BaseRng = Rng>
+            auto begin() const -> CPP_ret(counted_iterator<iterator_t<BaseRng const>>)( //
+                requires range<BaseRng const>)
+            {
+                return {ranges::begin(rng_), n_};
+            }
+            default_sentinel_t end() const
+            {
+                return {};
+            }
+            auto size() const
+            {
+                return static_cast<detail::iter_size_t<iterator_t<Rng>>>(n_);
+            }
+            Rng base() const
+            {
+                return rng_;
+            }
+        };
+
+        template<typename Rng>
+        struct take_exactly_view_<Rng, true>
+          : view_interface<take_exactly_view_<Rng, true>, finite>
+        {
+        private:
+            Rng rng_;
+            range_difference_t<Rng> n_;
+
+        public:
+            take_exactly_view_() = default;
+            take_exactly_view_(Rng rng, range_difference_t<Rng> n)
+              : rng_(std::move(rng))
+              , n_(n)
+            {
+                RANGES_EXPECT(n >= 0);
+                RANGES_EXPECT(!(bool)sized_range<Rng> || n <= ranges::distance(rng_));
+            }
+            iterator_t<Rng> begin()
+            {
+                return ranges::begin(rng_);
+            }
+            iterator_t<Rng> end()
+            {
+                return ranges::begin(rng_) + n_;
+            }
+            CPP_member
+            auto CPP_fun(begin)()(const requires range<Rng const>)
+            {
+                return ranges::begin(rng_);
+            }
+            CPP_member
+            auto CPP_fun(end)()(const requires range<Rng const>)
+            {
+                return ranges::begin(rng_) + n_;
+            }
+            detail::iter_size_t<iterator_t<Rng>> size() const
+            {
+                return static_cast<detail::iter_size_t<iterator_t<Rng>>>(n_);
+            }
+            Rng base() const
+            {
+                return rng_;
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng>
+    using take_exactly_view = detail::take_exactly_view_<Rng>;
+
+    namespace views
+    {
+        struct take_exactly_base_fn
+        {
+        private:
+            template<typename Rng>
+            static constexpr take_exactly_view<all_t<Rng>> impl_(
+                Rng && rng, range_difference_t<Rng> n, input_range_tag)
+            {
+                return {all(static_cast<Rng &&>(rng)), n};
+            }
+            template<typename Rng>
+            static constexpr auto impl_(Rng && rng, range_difference_t<Rng> n,
+                                        random_access_range_tag)
+                -> CPP_ret(subrange<iterator_t<Rng>>)( //
+                    requires forwarding_range_<Rng>)
+            {
+                return {begin(rng), next(begin(rng), n)};
+            }
+
+        public:
+            template<typename Rng>
+            constexpr auto CPP_fun(operator())(Rng && rng, range_difference_t<Rng> n)(
+                const //
+                requires viewable_range<Rng> && input_range<Rng>)
+            {
+                return take_exactly_base_fn::impl_(
+                    static_cast<Rng &&>(rng), n, range_tag_of<Rng>{});
+            }
+        };
+
+        struct take_exactly_fn : take_exactly_base_fn
+        {
+            using take_exactly_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(take_exactly_base_fn{}, n));
+            }
+        };
+
+        /// \relates take_exactly_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(take_exactly_fn, take_exactly)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::detail::take_exactly_view_)
+
+#endif
diff --git a/inst/include/range/v3/view/take_last.hpp b/inst/include/range/v3/view/take_last.hpp
new file mode 100644
index 0000000..dd17a50
--- /dev/null
+++ b/inst/include/range/v3/view/take_last.hpp
@@ -0,0 +1,60 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Barry Revzin 2019-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TAKE_LAST_HPP
+#define RANGES_V3_VIEW_TAKE_LAST_HPP
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/operations.hpp>
+#include <range/v3/view/drop_exactly.hpp>
+
+namespace ranges
+{
+    namespace views
+    {
+        struct take_last_base_fn
+        {
+            template<typename Rng>
+            auto CPP_fun(operator())(Rng && rng, range_difference_t<Rng> n)(
+                const requires viewable_range<Rng> && sized_range<Rng>)
+            {
+                auto sz = ranges::distance(rng);
+                return drop_exactly(static_cast<Rng &&>(rng), sz > n ? sz - n : 0);
+            }
+        };
+
+        struct take_last_fn : take_last_base_fn
+        {
+            using take_last_base_fn::operator();
+
+            template<typename Int>
+            constexpr auto CPP_fun(operator())(Int n)(const //
+                                                      requires detail::integer_like_<Int>)
+            {
+                return make_view_closure(bind_back(take_last_base_fn{}, n));
+            }
+        };
+
+        /// \relates take_last_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(take_last_fn, take_last)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/take_while.hpp b/inst/include/range/v3/view/take_while.hpp
new file mode 100644
index 0000000..6989c11
--- /dev/null
+++ b/inst/include/range/v3/view/take_while.hpp
@@ -0,0 +1,201 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TAKE_WHILE_HPP
+#define RANGES_V3_VIEW_TAKE_WHILE_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/indirect.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Pred>
+    struct iter_take_while_view
+      : view_adaptor<iter_take_while_view<Rng, Pred>, Rng,
+                     is_finite<Rng>::value ? finite : unknown>
+    {
+    private:
+        friend range_access;
+        RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Pred> pred_;
+
+        template<bool IsConst>
+        struct sentinel_adaptor : adaptor_base
+        {
+        private:
+            friend struct sentinel_adaptor<!IsConst>;
+            using CRng = meta::const_if_c<IsConst, Rng>;
+            RANGES_NO_UNIQUE_ADDRESS semiregular_box_ref_or_val_t<Pred, IsConst> pred_;
+
+        public:
+            sentinel_adaptor() = default;
+            sentinel_adaptor(semiregular_box_ref_or_val_t<Pred, IsConst> pred)
+              : pred_(std::move(pred))
+            {}
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other))
+                sentinel_adaptor(sentinel_adaptor<Other> that)
+              : pred_(std::move(that.pred_))
+            {}
+            bool empty(iterator_t<CRng> const & it, sentinel_t<CRng> const & last) const
+            {
+                return it == last || !invoke(pred_, it);
+            }
+        };
+        sentinel_adaptor<false> end_adaptor()
+        {
+            return {pred_};
+        }
+        template<bool Const = true>
+        auto end_adaptor() const -> CPP_ret(sentinel_adaptor<Const>)( //
+            requires Const && range<meta::const_if_c<Const, Rng>> &&
+                invocable<Pred const &, iterator_t<meta::const_if_c<Const, Rng>>>)
+        {
+            return {pred_};
+        }
+
+    public:
+        iter_take_while_view() = default;
+        constexpr iter_take_while_view(Rng rng, Pred pred)
+          : iter_take_while_view::view_adaptor{std::move(rng)}
+          , pred_(std::move(pred))
+        {}
+    };
+
+    template<typename Rng, typename Pred>
+    struct take_while_view : iter_take_while_view<Rng, indirected<Pred>>
+    {
+        take_while_view() = default;
+        constexpr take_while_view(Rng rng, Pred pred)
+          : iter_take_while_view<Rng, indirected<Pred>>{std::move(rng),
+                                                        indirect(std::move(pred))}
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Fun>)
+        take_while_view(Rng &&, Fun)
+            ->take_while_view<views::all_t<Rng>, Fun>;
+#endif
+
+    namespace views
+    {
+        struct iter_take_while_base_fn
+        {
+            template<typename Rng, typename Pred>
+            constexpr auto operator()(Rng && rng, Pred pred) const
+                -> CPP_ret(iter_take_while_view<all_t<Rng>, Pred>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        predicate<Pred &, iterator_t<Rng>> && copy_constructible<Pred>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(pred)};
+            }
+        };
+
+        struct iter_take_while_fn : iter_take_while_base_fn
+        {
+            using iter_take_while_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(
+                    bind_back(iter_take_while_base_fn{}, std::move(pred)));
+            }
+        };
+
+        struct take_while_base_fn
+        {
+            template<typename Rng, typename Pred>
+            constexpr auto operator()(Rng && rng, Pred pred) const
+                -> CPP_ret(take_while_view<all_t<Rng>, Pred>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<Pred &, iterator_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(pred)};
+            }
+            template<typename Rng, typename Pred, typename Proj>
+            constexpr auto operator()(Rng && rng, Pred pred, Proj proj) const
+                -> CPP_ret(take_while_view<all_t<Rng>, composed<Pred, Proj>>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        indirect_unary_predicate<composed<Pred, Proj> &, iterator_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        compose(std::move(pred), std::move(proj))};
+            }
+        };
+
+        struct take_while_fn : take_while_base_fn
+        {
+            using take_while_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(
+                    bind_back(take_while_base_fn{}, std::move(pred)));
+            }
+            template<typename Pred, typename Proj>
+            constexpr auto CPP_fun(operator())(Pred && pred,
+                                               Proj proj)(const //
+                                                          requires(!range<Pred>))
+            {
+                return make_view_closure(bind_back(
+                    take_while_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
+            }
+        };
+
+        /// \relates iter_take_while_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(iter_take_while_fn, iter_take_while)
+
+        /// \relates take_while_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(take_while_fn, take_while)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::take_while;
+        }
+        CPP_template(typename Rng, typename Pred)( //
+            requires viewable_range<Rng> && input_range<Rng> &&
+                predicate<Pred &, iterator_t<Rng>> && copy_constructible<Pred>) //
+            using take_while_view = ranges::take_while_view<Rng, Pred>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::iter_take_while_view)
+RANGES_SATISFY_BOOST_RANGE(::ranges::take_while_view)
+
+#endif
diff --git a/inst/include/range/v3/view/tokenize.hpp b/inst/include/range/v3/view/tokenize.hpp
new file mode 100644
index 0000000..7f349e5
--- /dev/null
+++ b/inst/include/range/v3/view/tokenize.hpp
@@ -0,0 +1,191 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TOKENIZE_HPP
+#define RANGES_V3_VIEW_TOKENIZE_HPP
+
+#include <initializer_list>
+#include <regex>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Regex, typename SubMatchRange>
+    struct tokenize_view
+      : view_interface<tokenize_view<Rng, Regex, SubMatchRange>,
+                       is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
+    {
+    private:
+        CPP_assert(bidirectional_range<Rng> && view_<Rng> && common_range<Rng>);
+        CPP_assert(semiregular<Regex>);
+        CPP_assert(semiregular<SubMatchRange>);
+
+        Rng rng_;
+        Regex rex_;
+        SubMatchRange subs_;
+        std::regex_constants::match_flag_type flags_;
+        template<bool Const>
+        using iterator_t =
+            std::regex_token_iterator<iterator_t<meta::const_if_c<Const, Rng>>>;
+
+    public:
+        tokenize_view() = default;
+        tokenize_view(Rng rng, Regex rex, SubMatchRange subs,
+                      std::regex_constants::match_flag_type flags)
+          : rng_(std::move(rng))
+          , rex_(std::move(rex))
+          , subs_(std::move(subs))
+          , flags_(flags)
+        {}
+        iterator_t<simple_view<Rng>()> begin()
+        {
+            meta::const_if_c<simple_view<Rng>(), Rng> & rng = rng_;
+            return {ranges::begin(rng), ranges::end(rng), rex_, subs_, flags_};
+        }
+        template<bool Const = true>
+        auto begin() const -> CPP_ret(iterator_t<Const>)( //
+            requires range<Rng const>)
+        {
+            return {ranges::begin(rng_), ranges::end(rng_), rex_, subs_, flags_};
+        }
+        iterator_t<simple_view<Rng>()> end()
+        {
+            return {};
+        }
+        template<bool Const = true>
+        auto end() const -> CPP_ret(iterator_t<Const>)( //
+            requires range<Rng const>)
+        {
+            return {};
+        }
+        Rng base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Regex, typename SubMatchRange)(
+        requires copy_constructible<Regex> && copy_constructible<SubMatchRange>)
+        tokenize_view(Rng &&, Regex, SubMatchRange)
+            ->tokenize_view<views::all_t<Rng>, Regex, SubMatchRange>;
+#endif
+
+    namespace views
+    {
+        struct tokenize_base_fn
+        {
+            template<typename Rng, typename Regex>
+            auto operator()(Rng && rng, Regex && rex, int sub = 0,
+                            std::regex_constants::match_flag_type flags =
+                                std::regex_constants::match_default) const //
+                -> CPP_ret(tokenize_view<all_t<Rng>, detail::decay_t<Regex>, int>)(
+                    requires bidirectional_range<Rng> && common_range<Rng> && same_as<
+                        range_value_t<Rng>, typename detail::decay_t<Regex>::value_type>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        static_cast<Regex &&>(rex),
+                        sub,
+                        flags};
+            }
+
+            template<typename Rng, typename Regex>
+            auto operator()(Rng && rng, Regex && rex, std::vector<int> subs,
+                            std::regex_constants::match_flag_type flags =
+                                std::regex_constants::match_default) const //
+                -> CPP_ret(
+                    tokenize_view<all_t<Rng>, detail::decay_t<Regex>, std::vector<int>>)(
+                    requires bidirectional_range<Rng> && common_range<Rng> && same_as<
+                        range_value_t<Rng>, typename detail::decay_t<Regex>::value_type>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        static_cast<Regex &&>(rex),
+                        std::move(subs),
+                        flags};
+            }
+
+            template<typename Rng, typename Regex>
+            auto operator()(Rng && rng, Regex && rex, std::initializer_list<int> subs,
+                            std::regex_constants::match_flag_type flags =
+                                std::regex_constants::match_default) const //
+                -> CPP_ret(tokenize_view<all_t<Rng>, detail::decay_t<Regex>,
+                                         std::initializer_list<int>>)(
+                    requires bidirectional_range<Rng> && common_range<Rng> && same_as<
+                        range_value_t<Rng>, typename detail::decay_t<Regex>::value_type>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        static_cast<Regex &&>(rex),
+                        std::move(subs),
+                        flags};
+            }
+        };
+
+        struct tokenize_fn : tokenize_base_fn
+        {
+            using tokenize_base_fn::operator();
+
+            template<typename Regex>
+            constexpr auto operator()(Regex && rex, int sub = 0,
+                                      std::regex_constants::match_flag_type flags =
+                                          std::regex_constants::match_default) const
+            {
+                return make_view_closure(bind_back(
+                    tokenize_base_fn{}, static_cast<Regex &&>(rex), sub, flags));
+            }
+
+            template<typename Regex>
+            auto operator()(Regex && rex, std::vector<int> subs,
+                            std::regex_constants::match_flag_type flags =
+                                std::regex_constants::match_default) const
+            {
+                return bind_back(tokenize_base_fn{},
+                                 static_cast<Regex &&>(rex),
+                                 std::move(subs),
+                                 flags);
+            }
+
+            template<typename Regex>
+            constexpr auto operator()(Regex && rex, std::initializer_list<int> subs,
+                                      std::regex_constants::match_flag_type flags =
+                                          std::regex_constants::match_default) const
+            {
+                return make_view_closure(bind_back(
+                    tokenize_base_fn{}, static_cast<Regex &&>(rex), subs, flags));
+            }
+        };
+
+        /// \relates tokenize_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(tokenize_fn, tokenize)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::tokenize_view)
+
+#endif
diff --git a/inst/include/range/v3/view/transform.hpp b/inst/include/range/v3/view/transform.hpp
new file mode 100644
index 0000000..ed7c5b2
--- /dev/null
+++ b/inst/include/range/v3/view/transform.hpp
@@ -0,0 +1,548 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TRANSFORM_HPP
+#define RANGES_V3_VIEW_TRANSFORM_HPP
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/algorithm/max.hpp>
+#include <range/v3/algorithm/min.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/indirect.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/move.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adaptor.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        constexpr cardinality transform2_cardinality(cardinality c1, cardinality c2)
+        {
+            return c1 >= 0 || c2 >= 0
+                       ? (c1 >= 0 && c2 >= 0 ? (c1 < c2 ? c1 : c2) : finite)
+                       : c1 == finite || c2 == finite
+                             ? finite
+                             : c1 == unknown || c2 == unknown ? unknown : infinite;
+        }
+
+        // clang-format off
+        CPP_def
+        (
+            template(typename Fun, typename Rng)
+            concept iter_transform_1_readable,
+                regular_invocable<Fun &, iterator_t<Rng>> &&
+                regular_invocable<Fun &, copy_tag, iterator_t<Rng>> &&
+                regular_invocable<Fun &, move_tag, iterator_t<Rng>> &&
+                common_reference_with<
+                    invoke_result_t<Fun &, iterator_t<Rng>> &&,
+                    invoke_result_t<Fun &, copy_tag, iterator_t<Rng>> &> &&
+                common_reference_with<
+                    invoke_result_t<Fun &, iterator_t<Rng>> &&,
+                    invoke_result_t<Fun &, move_tag, iterator_t<Rng>> &&> &&
+                common_reference_with<
+                    invoke_result_t<Fun &, move_tag, iterator_t<Rng>> &&,
+                    invoke_result_t<Fun &, copy_tag, iterator_t<Rng>> const &>
+        );
+
+        CPP_def
+        (
+            template(typename Fun, typename Rng1, typename Rng2)
+            concept iter_transform_2_readable,
+                regular_invocable<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> &&
+                regular_invocable<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&
+                regular_invocable<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&
+                common_reference_with<
+                    invoke_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> &&,
+                    invoke_result_t<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> &> &&
+                common_reference_with<
+                    invoke_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> &&,
+                    invoke_result_t<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&> &&
+                common_reference_with<
+                    invoke_result_t<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&,
+                    invoke_result_t<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> const &>
+        );
+        // clang-format on
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Fun>
+    struct iter_transform_view : view_adaptor<iter_transform_view<Rng, Fun>, Rng>
+    {
+    private:
+        friend range_access;
+        RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Fun> fun_;
+        template<bool Const>
+        using use_sentinel_t =
+            meta::bool_<!common_range<meta::const_if_c<Const, Rng>> ||
+                        single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng>>>>;
+
+        template<bool IsConst>
+        struct adaptor : adaptor_base
+        {
+        private:
+            friend struct adaptor<!IsConst>;
+            using CRng = meta::const_if_c<IsConst, Rng>;
+            using fun_ref_ = semiregular_box_ref_or_val_t<Fun, IsConst>;
+            RANGES_NO_UNIQUE_ADDRESS fun_ref_ fun_;
+
+        public:
+            using value_type =
+                detail::decay_t<invoke_result_t<Fun &, copy_tag, iterator_t<CRng>>>;
+            adaptor() = default;
+            adaptor(fun_ref_ fun)
+              : fun_(std::move(fun))
+            {}
+            CPP_template(bool Other)( //
+                requires IsConst && (!Other)) adaptor(adaptor<Other> that)
+              : fun_(std::move(that.fun_))
+            {}
+
+            // clang-format off
+            auto CPP_auto_fun(read)(iterator_t<CRng> it)(const)
+            (
+                return invoke(fun_, it)
+            )
+            auto CPP_auto_fun(iter_move)(iterator_t<CRng> it)(const)
+            (
+                return invoke(fun_, move_tag{}, it)
+            )
+            // clang-format on
+        };
+
+        adaptor<false> begin_adaptor()
+        {
+            return {fun_};
+        }
+        template<bool Const = true>
+        auto begin_adaptor() const -> CPP_ret(adaptor<Const>)( //
+            requires Const && range<meta::const_if_c<Const, Rng>> &&
+                detail::iter_transform_1_readable<Fun const,
+                                                  meta::const_if_c<Const, Rng>>)
+        {
+            return {fun_};
+        }
+        meta::if_<use_sentinel_t<false>, adaptor_base, adaptor<false>> end_adaptor()
+        {
+            return {fun_};
+        }
+        template<bool Const = true>
+        auto end_adaptor() const
+            -> CPP_ret(meta::if_<use_sentinel_t<Const>, adaptor_base, adaptor<Const>>)( //
+                requires Const && range<meta::const_if_c<Const, Rng>> &&
+                    detail::iter_transform_1_readable<Fun const,
+                                                      meta::const_if_c<Const, Rng>>)
+        {
+            return {fun_};
+        }
+
+    public:
+        iter_transform_view() = default;
+        iter_transform_view(Rng rng, Fun fun)
+          : iter_transform_view::view_adaptor{std::move(rng)}
+          , fun_(std::move(fun))
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(requires sized_range<Rng>)
+        {
+            return ranges::size(this->base());
+        }
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires sized_range<Rng const>)
+        {
+            return ranges::size(this->base());
+        }
+    };
+
+    template<typename Rng, typename Fun>
+    struct transform_view : iter_transform_view<Rng, indirected<Fun>>
+    {
+        transform_view() = default;
+        transform_view(Rng rng, Fun fun)
+          : iter_transform_view<Rng, indirected<Fun>>{std::move(rng),
+                                                      indirect(std::move(fun))}
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Rng, typename Fun)(requires copy_constructible<Fun>)
+        transform_view(Rng &&, Fun)
+            ->transform_view<views::all_t<Rng>, Fun>;
+#endif
+
+    template<typename Rng1, typename Rng2, typename Fun>
+    struct iter_transform2_view
+      : view_facade<iter_transform2_view<Rng1, Rng2, Fun>,
+                    detail::transform2_cardinality(range_cardinality<Rng1>::value,
+                                                   range_cardinality<Rng2>::value)>
+    {
+    private:
+        friend range_access;
+        RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Fun> fun_;
+        Rng1 rng1_;
+        Rng2 rng2_;
+        using difference_type_ =
+            common_type_t<range_difference_t<Rng1>, range_difference_t<Rng2>>;
+
+        static constexpr cardinality my_cardinality = detail::transform2_cardinality(
+            range_cardinality<Rng1>::value, range_cardinality<Rng2>::value);
+
+        template<bool>
+        struct cursor;
+
+        template<bool Const>
+        struct sentinel
+        {
+        private:
+            friend struct cursor<Const>;
+            sentinel_t<meta::const_if_c<Const, Rng1>> end1_;
+            sentinel_t<meta::const_if_c<Const, Rng2>> end2_;
+
+        public:
+            sentinel() = default;
+            sentinel(meta::const_if_c<Const, iter_transform2_view> * parent,
+                     decltype(ranges::end))
+              : end1_(end(parent->rng1_))
+              , end2_(end(parent->rng2_))
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) sentinel(sentinel<Other> that)
+              : end1_(std::move(that.end1_))
+              , end2_(std::move(that.end2_))
+            {}
+        };
+
+        template<bool Const>
+        struct cursor
+        {
+        private:
+            using fun_ref_ = semiregular_box_ref_or_val_t<Fun, Const>;
+            using R1 = meta::const_if_c<Const, Rng1>;
+            using R2 = meta::const_if_c<Const, Rng2>;
+            fun_ref_ fun_;
+            iterator_t<R1> it1_;
+            iterator_t<R2> it2_;
+
+        public:
+            using difference_type = difference_type_;
+            using single_pass = meta::or_c<(bool)single_pass_iterator_<iterator_t<R1>>,
+                                           (bool)single_pass_iterator_<iterator_t<R2>>>;
+            using value_type =
+                detail::decay_t<invoke_result_t<meta::const_if_c<Const, Fun> &, copy_tag,
+                                                iterator_t<R1>, iterator_t<R2>>>;
+
+            cursor() = default;
+            template<typename BeginEndFn>
+            cursor(meta::const_if_c<Const, iter_transform2_view> * parent,
+                   BeginEndFn begin_end)
+              : fun_(parent->fun_)
+              , it1_(begin_end(parent->rng1_))
+              , it2_(begin_end(parent->rng2_))
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) cursor(cursor<Other> that)
+              : fun_(std::move(that.fun_))
+              , it1_(std::move(that.end1_))
+              , it2_(std::move(that.end2_))
+            {}
+            // clang-format off
+            auto CPP_auto_fun(read)()(const)
+            (
+                return invoke(fun_, it1_, it2_)
+            )
+                // clang-format on
+                void next()
+            {
+                ++it1_;
+                ++it2_;
+            }
+            CPP_member
+            auto equal(cursor const & that) const -> CPP_ret(bool)( //
+                requires forward_range<Rng1> && forward_range<Rng2>)
+            {
+                // By returning true if *any* of the iterators are equal, we allow
+                // transformed ranges to be of different lengths, stopping when the first
+                // one reaches the last.
+                return it1_ == that.it1_ || it2_ == that.it2_;
+            }
+            bool equal(sentinel<Const> const & s) const
+            {
+                // By returning true if *any* of the iterators are equal, we allow
+                // transformed ranges to be of different lengths, stopping when the first
+                // one reaches the last.
+                return it1_ == s.end1_ || it2_ == s.end2_;
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires bidirectional_range<R1> && bidirectional_range<R2>)
+            {
+                --it1_;
+                --it2_;
+            }
+            CPP_member
+            auto advance(difference_type n) -> CPP_ret(void)( //
+                requires random_access_range<R1> && random_access_range<R2>)
+            {
+                ranges::advance(it1_, n);
+                ranges::advance(it2_, n);
+            }
+            CPP_member
+            auto distance_to(cursor const & that) const -> CPP_ret(difference_type)( //
+                requires sized_sentinel_for<iterator_t<R1>, iterator_t<R1>> &&
+                    sized_sentinel_for<iterator_t<R2>, iterator_t<R2>>)
+            {
+                // Return the smallest distance (in magnitude) of any of the iterator
+                // pairs. This is to accommodate zippers of sequences of different length.
+                difference_type d1 = that.it1_ - it1_, d2 = that.it2_ - it2_;
+                return 0 < d1 ? ranges::min(d1, d2) : ranges::max(d1, d2);
+            }
+            // clang-format off
+            auto CPP_auto_fun(move)()(const)
+            (
+                return invoke(fun_, move_tag{}, it1_, it2_)
+            )
+            // clang-format on
+        };
+
+        template<bool Const>
+        using end_cursor_t = meta::if_c<
+            common_range<meta::const_if_c<Const, Rng1>> &&
+                common_range<meta::const_if_c<Const, Rng2>> &&
+                !single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng1>>> &&
+                !single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng2>>>,
+            cursor<Const>, sentinel<Const>>;
+
+        cursor<simple_view<Rng1>() && simple_view<Rng2>()> begin_cursor()
+        {
+            return {this, ranges::begin};
+        }
+        end_cursor_t<simple_view<Rng1>() && simple_view<Rng2>()> end_cursor()
+        {
+            return {this, ranges::end};
+        }
+        template<bool Const = true>
+        auto begin_cursor() const -> CPP_ret(cursor<true>)( //
+            requires Const && range<meta::const_if_c<Const, Rng1>> &&
+                range<meta::const_if_c<Const, Rng2>> && detail::iter_transform_2_readable<
+                    Fun const, meta::const_if_c<Const, Rng1>,
+                    meta::const_if_c<Const, Rng2>>)
+        {
+            return {this, ranges::begin};
+        }
+        template<bool Const = true>
+        auto end_cursor() const -> CPP_ret(end_cursor_t<Const>)( //
+            requires Const && range<meta::const_if_c<Const, Rng1>> &&
+                range<meta::const_if_c<Const, Rng2>> && detail::iter_transform_2_readable<
+                    Fun const, meta::const_if_c<Const, Rng1>,
+                    meta::const_if_c<Const, Rng2>>)
+        {
+            return {this, ranges::end};
+        }
+        template<typename Self>
+        static constexpr auto size_(Self & self)
+        {
+            using size_type = common_type_t<range_size_t<Rng1>, range_size_t<Rng2>>;
+            return ranges::min(static_cast<size_type>(ranges::size(self.rng1_)),
+                               static_cast<size_type>(ranges::size(self.rng2_)));
+        }
+
+        template<bool B>
+        using R1 = meta::invoke<detail::dependent_<B>, Rng1>;
+        template<bool B>
+        using R2 = meta::invoke<detail::dependent_<B>, Rng2>;
+
+    public:
+        iter_transform2_view() = default;
+        constexpr iter_transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
+          : fun_(std::move(fun))
+          , rng1_(std::move(rng1))
+          , rng2_(std::move(rng2))
+        {}
+        CPP_member
+        static constexpr auto size() -> CPP_ret(std::size_t)( //
+            requires(my_cardinality >= 0))
+        {
+            return static_cast<std::size_t>(my_cardinality);
+        }
+        CPP_template(bool True = true)( //
+            requires(my_cardinality < 0) && sized_range<Rng1 const> &&
+            sized_range<Rng2 const> &&
+            common_with<range_size_t<R1<True>>, range_size_t<R2<True>>>) //
+            constexpr auto size() const
+        {
+            return size_(*this);
+        }
+        CPP_template(bool True = true)( //
+            requires(my_cardinality < 0) && sized_range<Rng1> && sized_range<Rng2> &&
+            common_with<range_size_t<R1<True>>, range_size_t<R2<True>>>) //
+            constexpr auto size()
+        {
+            return size_(*this);
+        }
+    };
+
+    template<typename Rng1, typename Rng2, typename Fun>
+    struct transform2_view : iter_transform2_view<Rng1, Rng2, indirected<Fun>>
+    {
+        transform2_view() = default;
+        constexpr transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
+          : iter_transform2_view<Rng1, Rng2, indirected<Fun>>{std::move(rng1),
+                                                              std::move(rng2),
+                                                              indirect(std::move(fun))}
+        {}
+    };
+
+    namespace views
+    {
+        struct iter_transform_base_fn
+        {
+            template<typename Rng, typename Fun>
+            constexpr auto operator()(Rng && rng, Fun fun) const
+                -> CPP_ret(iter_transform_view<all_t<Rng>, Fun>)( //
+                    requires viewable_range<Rng> && input_range<Rng> &&
+                        copy_constructible<Fun> &&
+                            detail::iter_transform_1_readable<Fun, Rng>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(fun)};
+            }
+
+            template<typename Rng1, typename Rng2, typename Fun>
+            constexpr auto operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
+                -> CPP_ret(iter_transform2_view<all_t<Rng1>, all_t<Rng2>, Fun>)( //
+                    requires viewable_range<Rng1> && input_range<Rng1> && viewable_range<
+                        Rng2> && input_range<Rng2> && copy_constructible<Fun> &&
+                        common_with<range_difference_t<Rng1>, range_difference_t<Rng1>> &&
+                            detail::iter_transform_2_readable<Fun, Rng1, Rng2>)
+            {
+                return {all(static_cast<Rng1 &&>(rng1)),
+                        all(static_cast<Rng2 &&>(rng2)),
+                        std::move(fun)};
+            }
+        };
+
+        struct iter_transform_fn : iter_transform_base_fn
+        {
+            using iter_transform_base_fn::operator();
+
+            template<typename Fun>
+            constexpr auto operator()(Fun fun) const
+            {
+                return make_view_closure(
+                    bind_back(iter_transform_base_fn{}, std::move(fun)));
+            }
+        };
+
+        /// \relates iter_transform_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(iter_transform_fn, iter_transform)
+
+        // Don't forget to update views::for_each whenever this set
+        // of concepts changes
+        // clang-format off
+        CPP_def
+        (
+            template(typename Rng, typename Fun)
+            concept transformable_range,
+                viewable_range<Rng> && input_range<Rng> &&
+                copy_constructible<Fun> &&
+                regular_invocable<Fun &, range_reference_t<Rng>> &&
+                (!std::is_void<indirect_result_t<Fun &, iterator_t<Rng>>>::value)
+        );
+
+        CPP_def
+        (
+            template(typename Rng1, typename Rng2, typename Fun)
+            concept transformable_ranges,
+                viewable_range<Rng1> && input_range<Rng1> &&
+                viewable_range<Rng2> && input_range<Rng2> &&
+                copy_constructible<Fun> &&
+                (!std::is_void<
+                    indirect_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>>>::value)
+        );
+        // clang-format on
+
+        struct transform_base_fn
+        {
+            template<typename Rng, typename Fun>
+            constexpr auto operator()(Rng && rng, Fun fun) const
+                -> CPP_ret(transform_view<all_t<Rng>, Fun>)( //
+                    requires transformable_range<Rng, Fun>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(fun)};
+            }
+
+            template<typename Rng1, typename Rng2, typename Fun>
+            constexpr auto operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
+                -> CPP_ret(transform2_view<all_t<Rng1>, all_t<Rng2>, Fun>)( //
+                    requires transformable_ranges<Rng1, Rng2, Fun>)
+            {
+                return {all(static_cast<Rng1 &&>(rng1)),
+                        all(static_cast<Rng2 &&>(rng2)),
+                        std::move(fun)};
+            }
+        };
+
+        struct transform_fn : transform_base_fn
+        {
+            using transform_base_fn::operator();
+
+            template<typename Fun>
+            constexpr auto operator()(Fun fun) const
+            {
+                return make_view_closure(bind_back(transform_base_fn{}, std::move(fun)));
+            }
+        };
+
+        /// \relates transform_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(transform_fn, transform)
+    } // namespace views
+
+    namespace cpp20
+    {
+        namespace views
+        {
+            using ranges::views::transform;
+        }
+        CPP_template(typename Rng, typename F)( //
+            requires input_range<Rng> && copy_constructible<F> && view_<Rng> &&
+                std::is_object<F>::value &&
+                    regular_invocable<F &, iter_reference_t<iterator_t<Rng>>>) //
+            using transform_view = ranges::transform_view<Rng, F>;
+    } // namespace cpp20
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::iter_transform_view)
+RANGES_SATISFY_BOOST_RANGE(::ranges::transform_view)
+
+#endif
diff --git a/inst/include/range/v3/view/trim.hpp b/inst/include/range/v3/view/trim.hpp
new file mode 100644
index 0000000..2aca933
--- /dev/null
+++ b/inst/include/range/v3/view/trim.hpp
@@ -0,0 +1,150 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Johel Guerrero 2019
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_TRIM_HPP
+#define RANGES_V3_VIEW_TRIM_HPP
+
+#include <utility>
+
+#include <concepts/concepts.hpp>
+
+#include <range/v3/algorithm/find_if_not.hpp>
+#include <range/v3/detail/config.hpp>
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/primitives.hpp>
+#include <range/v3/utility/optional.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/interface.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename Rng, typename Pred>
+    struct trim_view : view_interface<trim_view<Rng, Pred>>
+    {
+    private:
+        Rng rng_;
+        semiregular_box_t<Pred> pred_;
+        detail::non_propagating_cache<iterator_t<Rng>> begin_;
+        detail::non_propagating_cache<iterator_t<Rng>> end_;
+
+    public:
+        CPP_assert(bidirectional_range<Rng> && view_<Rng> && indirect_unary_predicate<
+                   Pred, iterator_t<Rng>> && common_range<Rng>);
+
+        trim_view() = default;
+        constexpr trim_view(Rng rng, Pred pred)
+          : rng_(std::move(rng))
+          , pred_(std::move(pred))
+        {}
+
+        iterator_t<Rng> begin()
+        {
+            if(!begin_)
+                begin_ = find_if_not(rng_, std::ref(pred_));
+            return *begin_;
+        }
+        iterator_t<Rng> end()
+        {
+            if(!end_)
+            {
+                const auto first = begin();
+                auto last = ranges::end(rng_);
+                while(last != first)
+                    if(!invoke(pred_, *--last))
+                    {
+                        ++last;
+                        break;
+                    }
+                end_ = std::move(last);
+            }
+            return *end_;
+        }
+
+        Rng base() const
+        {
+            return rng_;
+        }
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename Rng, typename Pred>
+    trim_view(Rng &&, Pred)->trim_view<views::all_t<Rng>, Pred>;
+#endif
+
+    template<typename Rng, typename Pred>
+    RANGES_INLINE_VAR constexpr bool disable_sized_range<trim_view<Rng, Pred>> = true;
+
+    namespace views
+    {
+        struct trim_base_fn
+        {
+            template<typename Rng, typename Pred>
+            constexpr auto operator()(Rng && rng, Pred pred) const //
+                -> CPP_ret(trim_view<all_t<Rng>, Pred>)(           //
+                    requires viewable_range<Rng> && bidirectional_range<Rng> &&
+                        indirect_unary_predicate<Pred, iterator_t<Rng>> &&
+                            common_range<Rng>)
+            {
+                return {all(static_cast<Rng &&>(rng)), std::move(pred)};
+            }
+            template<typename Rng, typename Pred, typename Proj>
+            constexpr auto operator()(Rng && rng, Pred pred, Proj proj) const
+                -> CPP_ret(trim_view<all_t<Rng>, composed<Pred, Proj>>)( //
+                    requires viewable_range<Rng> && bidirectional_range<Rng> &&
+                        indirect_unary_predicate<composed<Pred, Proj>, iterator_t<Rng>> &&
+                            common_range<Rng>)
+            {
+                return {all(static_cast<Rng &&>(rng)),
+                        compose(std::move(pred), std::move(proj))};
+            }
+        };
+
+        struct trim_fn : trim_base_fn
+        {
+            using trim_base_fn::operator();
+
+            template<typename Pred>
+            constexpr auto operator()(Pred pred) const
+            {
+                return make_view_closure(bind_back(trim_base_fn{}, std::move(pred)));
+            }
+            template<typename Pred, typename Proj>
+            constexpr auto CPP_fun(operator())(Pred && pred,
+                                               Proj proj)(const //
+                                                          requires(!range<Pred>))
+            {
+                return make_view_closure(bind_back(
+                    trim_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
+            }
+        };
+
+        /// \relates trim_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(trim_fn, trim)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::trim_view)
+
+#endif // RANGES_V3_VIEW_TRIM_HPP
diff --git a/inst/include/range/v3/view/unbounded.hpp b/inst/include/range/v3/view/unbounded.hpp
new file mode 100644
index 0000000..d70ee73
--- /dev/null
+++ b/inst/include/range/v3/view/unbounded.hpp
@@ -0,0 +1,68 @@
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_UNBOUNDED_HPP
+#define RANGES_V3_VIEW_UNBOUNDED_HPP
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/unreachable_sentinel.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/interface.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    template<typename I>
+    struct unbounded_view : view_interface<unbounded_view<I>, infinite>
+    {
+    private:
+        I it_;
+
+    public:
+        unbounded_view() = default;
+        constexpr explicit unbounded_view(I it)
+          : it_(detail::move(it))
+        {}
+        constexpr I begin() const
+        {
+            return it_;
+        }
+        constexpr unreachable_sentinel_t end() const
+        {
+            return {};
+        }
+    };
+
+    namespace views
+    {
+        struct unbounded_fn
+        {
+            template<typename I>
+            constexpr auto operator()(I it) const -> CPP_ret(unbounded_view<I>)( //
+                requires input_iterator<I>)
+            {
+                return unbounded_view<I>{detail::move(it)};
+            }
+        };
+
+        /// \relates unbounded_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(unbounded_fn, unbounded)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::unbounded_view)
+
+#endif
diff --git a/inst/include/range/v3/view/unique.hpp b/inst/include/range/v3/view/unique.hpp
new file mode 100644
index 0000000..5f06484
--- /dev/null
+++ b/inst/include/range/v3/view/unique.hpp
@@ -0,0 +1,68 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_UNIQUE_HPP
+#define RANGES_V3_VIEW_UNIQUE_HPP
+
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/not_fn.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/view/adjacent_filter.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/view.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+    namespace views
+    {
+        struct unique_base_fn
+        {
+            template<typename Rng, typename C = equal_to>
+            constexpr auto operator()(Rng && rng, C pred = {}) const
+                -> CPP_ret(adjacent_filter_view<all_t<Rng>, logical_negate<C>>)( //
+                    requires viewable_range<Rng> && forward_range<Rng> &&
+                        indirect_relation<C, iterator_t<Rng>>)
+            {
+                return {all(static_cast<Rng &&>(rng)), not_fn(pred)};
+            }
+        };
+
+        struct unique_fn : unique_base_fn
+        {
+            using unique_base_fn::operator();
+
+            template<typename C>
+            constexpr auto CPP_fun(operator())(C && pred)(const //
+                                                          requires(!range<C>))
+            {
+                return make_view_closure(
+                    bind_back(unique_base_fn{}, static_cast<C &&>(pred)));
+            }
+        };
+
+        /// \relates unique_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(view_closure<unique_fn>, unique)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/view.hpp b/inst/include/range/v3/view/view.hpp
new file mode 100644
index 0000000..82de7e0
--- /dev/null
+++ b/inst/include/range/v3/view/view.hpp
@@ -0,0 +1,260 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_VIEW_HPP
+#define RANGES_V3_VIEW_VIEW_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/compose.hpp>
+#include <range/v3/functional/concepts.hpp>
+#include <range/v3/functional/pipeable.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/static_const.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-views
+    /// @{
+
+    /// \cond
+    namespace detail
+    {
+        struct dereference_fn
+        {
+            // clang-format off
+            template<typename I>
+            constexpr auto CPP_auto_fun(operator())(I &&i) (const)
+            (
+                return *(I &&) i
+            )
+            // clang-format on
+        };
+    } // namespace detail
+      /// \endcond
+
+    // clang-format off
+    CPP_def
+    (
+        template(typename Rng)
+        concept simple_view_,
+            view_<Rng> &&
+            range<Rng const> &&
+            same_as<iterator_t<Rng>, iterator_t<Rng const>> &&
+            same_as<sentinel_t<Rng>, sentinel_t<Rng const>>
+    );
+    // clang-format on
+
+    template<typename Rng>
+    constexpr bool simple_view() noexcept
+    {
+        return (bool)simple_view_<Rng>;
+    }
+
+    struct make_view_closure_fn
+    {
+        template<typename Fun>
+        constexpr views::view_closure<Fun> operator()(Fun fun) const
+        {
+            return views::view_closure<Fun>{static_cast<Fun &&>(fun)};
+        }
+    };
+
+    /// \ingroup group-views
+    /// \sa make_view_fn
+    RANGES_INLINE_VARIABLE(make_view_closure_fn, make_view_closure)
+
+    namespace views
+    {
+        struct RANGES_STRUCT_WITH_ADL_BARRIER(view_closure_base)
+        {
+            // Piping requires viewable_ranges.
+            CPP_template(typename Rng, typename ViewFn)(                              //
+                requires defer::viewable_range<Rng> && defer::invocable<ViewFn, Rng>) //
+                friend constexpr auto
+                operator|(Rng && rng, view_closure<ViewFn> vw)
+            {
+                return static_cast<ViewFn &&>(vw)(static_cast<Rng &&>(rng));
+            }
+
+#ifndef RANGES_WORKAROUND_CLANG_43400
+            // This overload is deleted because when piping a range into an
+            // view, it must be moved in.
+            template<typename Rng, typename ViewFn>         // **************************
+            friend constexpr auto                           // **************************
+            operator|(Rng &&, view_closure<ViewFn> const &) // ******* READ THIS ********
+                                                            // **** IF YOUR COMPILE *****
+                -> CPP_broken_friend_ret(Rng)(              // ****** BREAKS HERE *******
+                    requires range<Rng> &&                  // **************************
+                    (!viewable_range<Rng>)) = delete;       // **************************
+            // **************************************************************************
+            // *    When piping a range into an adaptor, the range must satisfy the     *
+            // *    "viewable_range" concept. A range is viewable when either or both   *
+            // *    of these things are true:                                           *
+            // *      - The range is an lvalue (not a temporary object), OR             *
+            // *      - The range is a view (not a container).                          *
+            // **************************************************************************
+#endif
+
+            template<typename ViewFn, typename Pipeable>
+            friend constexpr auto operator|(view_closure<ViewFn> vw, Pipeable pipe)
+                -> CPP_broken_friend_ret(view_closure<composed<Pipeable, ViewFn>>)(
+                    requires(is_pipeable_v<Pipeable>))
+            {
+                return make_view_closure(
+                    compose(static_cast<Pipeable &&>(pipe), static_cast<ViewFn &&>(vw)));
+            }
+        };
+
+#ifdef RANGES_WORKAROUND_CLANG_43400
+        namespace RANGES_ADL_BARRIER_FOR(view_closure_base)
+        {
+            // This overload is deleted because when piping a range into an
+            // view, it must be moved in.
+            template<typename Rng, typename ViewFn>         // **************************
+            constexpr auto                                  // **************************
+            operator|(Rng &&, view_closure<ViewFn> const &) // ******* READ THIS ********
+                                                            // **** IF YOUR COMPILE *****
+                ->CPP_ret(Rng)(                             // ****** BREAKS HERE *******
+                    requires range<Rng> &&                  // **************************
+                    (!viewable_range<Rng>)) = delete;       // **************************
+            // **************************************************************************
+            // *    When piping a range into an adaptor, the range must satisfy the     *
+            // *    "viewable_range" concept. A range is viewable when either or both   *
+            // *    of these things are true:                                           *
+            // *      - The range is an lvalue (not a temporary object), OR             *
+            // *      - The range is a view (not a container).                          *
+            // **************************************************************************
+        } // namespace )
+#endif    // RANGES_WORKAROUND_CLANG_43400
+
+        template<typename ViewFn>
+        struct RANGES_EMPTY_BASES view_closure
+          : view_closure_base
+          , ViewFn
+        {
+            view_closure() = default;
+
+            constexpr explicit view_closure(ViewFn fn)
+              : ViewFn(static_cast<ViewFn &&>(fn))
+            {}
+        };
+
+        /// \cond
+        /// DEPRECATED STUFF
+        struct view_access_
+        {
+            template<typename ViewFn>
+            struct impl
+            {
+                // clang-format off
+                template<typename... Ts, typename V = ViewFn>
+                static constexpr auto CPP_auto_fun(bind)(Ts &&... ts)
+                (
+                    return V::bind(static_cast<Ts &&>(ts)...)
+                )
+                // clang-format on
+            };
+        };
+
+        using view_access RANGES_DEPRECATED(
+            "view_access and views::view<> are deprecated. Please "
+            "replace view<> with view_closure<> and discontinue use of view_access.") =
+            view_access_;
+
+        template<typename>
+        struct old_view_;
+
+        struct make_view_fn_
+        {
+            template<typename Fun>
+            constexpr old_view_<Fun> operator()(Fun fun) const
+            {
+                return old_view_<Fun>{static_cast<Fun &&>(fun)};
+            }
+        };
+        using make_view_fn RANGES_DEPRECATED(
+            "make_view_fn is deprecated. Please use "
+            "make_view_closure instead.") = make_view_fn_;
+
+        namespace
+        {
+            RANGES_DEPRECATED(
+                "make_view and views::view<> has been deprecated. Please switch to "
+                "make_view_closure and views::view_closure.")
+            RANGES_INLINE_VAR constexpr auto & make_view =
+                static_const<make_view_fn_>::value;
+        } // namespace
+
+        template<typename ViewFn>
+        struct old_view_ : pipeable_base
+        {
+        private:
+            ViewFn vw_;
+            friend pipeable_access;
+
+            // Piping requires range arguments or lvalue containers.
+            template<typename Rng, typename Vw>
+            static constexpr auto CPP_fun(pipe)(Rng && rng, Vw && v)( //
+                requires viewable_range<Rng> && invocable<ViewFn &, Rng>)
+            {
+                return v.vw_(static_cast<Rng &&>(rng));
+            }
+
+        public:
+            old_view_() = default;
+
+            constexpr explicit old_view_(ViewFn a) noexcept(
+                std::is_nothrow_move_constructible<ViewFn>::value)
+              : vw_(std::move(a))
+            {}
+
+            // Calling directly requires a viewable_range.
+            template<typename Rng, typename... Rest>
+            constexpr auto operator()(Rng && rng, Rest &&... rest) const -> CPP_ret(
+                invoke_result_t<ViewFn const &, Rng, Rest...>)( //
+                requires viewable_range<Rng> && invocable<ViewFn const &, Rng, Rest...>)
+            {
+                return vw_(static_cast<Rng &&>(rng), static_cast<Rest &&>(rest)...);
+            }
+
+            // Currying overload.
+            // clang-format off
+            template<typename... Ts, typename V = ViewFn>
+            constexpr auto CPP_auto_fun(operator())(Ts &&... ts)(const)
+            (
+                return make_view_fn_{}(
+                    view_access_::impl<V>::bind(vw_, static_cast<Ts &&>(ts)...))
+            )
+            // clang-format on
+        };
+
+        template<typename ViewFn>
+        using view RANGES_DEPRECATED(
+            "The views::view<> template is deprecated. Please switch to view_closure") =
+            old_view_<ViewFn>;
+        /// \endcond
+    } // namespace views
+
+    template<typename ViewFn>
+    RANGES_INLINE_VAR constexpr bool is_pipeable_v<views::view_closure<ViewFn>> = true;
+    /// @}
+} // namespace ranges
+
+#endif
diff --git a/inst/include/range/v3/view/zip.hpp b/inst/include/range/v3/view/zip.hpp
new file mode 100644
index 0000000..be389a1
--- /dev/null
+++ b/inst/include/range/v3/view/zip.hpp
@@ -0,0 +1,156 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ZIP_HPP
+#define RANGES_V3_VIEW_ZIP_HPP
+
+#include <tuple>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/iterator/concepts.hpp>
+#include <range/v3/iterator/traits.hpp>
+#include <range/v3/utility/common_tuple.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/empty.hpp>
+#include <range/v3/view/zip_with.hpp>
+
+RANGES_DISABLE_WARNINGS
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        struct indirect_zip_fn_
+        {
+            // tuple value
+            template<typename... Its>
+            [[noreturn]] auto operator()(copy_tag, Its...) const
+                -> CPP_ret(std::tuple<iter_value_t<Its>...>)( //
+                    requires and_v<readable<Its>...> && (sizeof...(Its) != 2))
+            {
+                RANGES_EXPECT(false);
+            }
+
+            // tuple reference
+            template<typename... Its>
+            auto operator()(Its const &... its) const
+                noexcept(meta::and_c<noexcept(iter_reference_t<Its>(*its))...>::value)
+                    -> CPP_ret(common_tuple<iter_reference_t<Its>...>)( //
+                        requires and_v<readable<Its>...> && (sizeof...(Its) != 2))
+            {
+                return common_tuple<iter_reference_t<Its>...>{*its...};
+            }
+
+            // tuple rvalue reference
+            template<typename... Its>
+            auto operator()(move_tag, Its const &... its) const
+                noexcept(meta::and_c<noexcept(
+                             iter_rvalue_reference_t<Its>(iter_move(its)))...>::value)
+                    -> CPP_ret(common_tuple<iter_rvalue_reference_t<Its>...>)( //
+                        requires and_v<readable<Its>...> && (sizeof...(Its) != 2))
+            {
+                return common_tuple<iter_rvalue_reference_t<Its>...>{iter_move(its)...};
+            }
+
+            // pair value
+            template<typename It1, typename It2>
+            [[noreturn]] auto operator()(copy_tag, It1, It2) const
+                -> CPP_ret(std::pair<iter_value_t<It1>, iter_value_t<It2>>)( //
+                    requires readable<It1> && readable<It2>)
+            {
+                RANGES_EXPECT(false);
+            }
+
+            // pair reference
+            template<typename It1, typename It2>
+            auto operator()(It1 const & it1, It2 const & it2) const noexcept(
+                noexcept(iter_reference_t<It1>(*it1)) &&
+                noexcept(iter_reference_t<It2>(*it2)))
+                -> CPP_ret(common_pair<iter_reference_t<It1>, iter_reference_t<It2>>)( //
+                    requires readable<It1> && readable<It2>)
+            {
+                return {*it1, *it2};
+            }
+
+            // pair rvalue reference
+            template<typename It1, typename It2>
+            auto operator()(move_tag, It1 const & it1, It2 const & it2) const
+                noexcept(noexcept(iter_rvalue_reference_t<It1>(iter_move(it1))) &&
+                         noexcept(iter_rvalue_reference_t<It2>(iter_move(it2))))
+                    -> CPP_ret(common_pair<iter_rvalue_reference_t<It1>,
+                                           iter_rvalue_reference_t<It2>>)( //
+                        requires readable<It1> && readable<It2>)
+            {
+                return {iter_move(it1), iter_move(it2)};
+            }
+        };
+    } // namespace detail
+    /// \endcond
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename... Rngs>
+    struct zip_view : iter_zip_with_view<detail::indirect_zip_fn_, Rngs...>
+    {
+        CPP_assert(sizeof...(Rngs) != 0);
+
+        zip_view() = default;
+        explicit zip_view(Rngs... rngs)
+          : iter_zip_with_view<detail::indirect_zip_fn_, Rngs...>{
+                detail::indirect_zip_fn_{},
+                std::move(rngs)...}
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    template<typename... Rng>
+    zip_view(Rng &&...)->zip_view<views::all_t<Rng>...>;
+#endif
+
+    namespace views
+    {
+        struct zip_fn
+        {
+            template<typename... Rngs>
+            auto operator()(Rngs &&... rngs) const -> CPP_ret(
+                zip_view<all_t<Rngs>...>)( //
+                requires and_v<viewable_range<Rngs>...> && and_v<input_range<Rngs>...> &&
+                (sizeof...(Rngs) != 0))
+            {
+                return zip_view<all_t<Rngs>...>{all(static_cast<Rngs &&>(rngs))...};
+            }
+
+            constexpr empty_view<std::tuple<>> operator()() const noexcept
+            {
+                return {};
+            }
+        };
+
+        /// \relates zip_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(zip_fn, zip)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+RANGES_RE_ENABLE_WARNINGS
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::zip_view)
+
+#endif
diff --git a/inst/include/range/v3/view/zip_with.hpp b/inst/include/range/v3/view/zip_with.hpp
new file mode 100644
index 0000000..c15db1d
--- /dev/null
+++ b/inst/include/range/v3/view/zip_with.hpp
@@ -0,0 +1,433 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VIEW_ZIP_WITH_HPP
+#define RANGES_V3_VIEW_ZIP_WITH_HPP
+
+#include <limits>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <meta/meta.hpp>
+
+#include <range/v3/range_fwd.hpp>
+
+#include <range/v3/functional/bind_back.hpp>
+#include <range/v3/functional/indirect.hpp>
+#include <range/v3/functional/invoke.hpp>
+#include <range/v3/iterator/operations.hpp>
+#include <range/v3/range/access.hpp>
+#include <range/v3/range/concepts.hpp>
+#include <range/v3/range/traits.hpp>
+#include <range/v3/utility/common_type.hpp>
+#include <range/v3/utility/semiregular_box.hpp>
+#include <range/v3/utility/static_const.hpp>
+#include <range/v3/utility/tuple_algorithm.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/empty.hpp>
+#include <range/v3/view/facade.hpp>
+
+namespace ranges
+{
+    /// \cond
+    namespace detail
+    {
+        struct equal_to_
+        {
+            template<typename T, typename U>
+            bool operator()(T const & t, U const & u) const
+            {
+                return static_cast<bool>(t == u);
+            }
+        };
+        RANGES_INLINE_VARIABLE(equal_to_, equal_to)
+
+        struct dec_
+        {
+            template<typename T>
+            void operator()(T & t) const
+            {
+                --t;
+            }
+        };
+        RANGES_INLINE_VARIABLE(dec_, dec)
+
+        struct inc_
+        {
+            template<typename T>
+            void operator()(T & t) const
+            {
+                ++t;
+            }
+        };
+        RANGES_INLINE_VARIABLE(inc_, inc)
+
+        struct _advance_
+        {
+            template<typename I, typename Diff>
+            auto operator()(I & i, Diff n) const -> CPP_ret(void)( //
+                requires input_or_output_iterator<I> && integer_like_<Diff>)
+            {
+                advance(i, static_cast<iter_difference_t<I>>(n));
+            }
+        };
+        RANGES_INLINE_VARIABLE(_advance_, advance_)
+
+        struct distance_to_
+        {
+            template<typename T>
+            constexpr auto operator()(T const & t, T const & u) const -> decltype(u - t)
+            {
+                return u - t;
+            }
+        };
+        RANGES_INLINE_VARIABLE(distance_to_, distance_to)
+
+        struct _min_
+        {
+            template<typename T, typename U>
+            constexpr auto operator()(T const & t, U const & u) const
+                -> decltype(true ? t : u)
+            {
+                return u < t ? u : t;
+            }
+        };
+        RANGES_INLINE_VARIABLE(_min_, min_)
+
+        struct _max_
+        {
+            template<typename T, typename U>
+            constexpr auto operator()(T const & t, U const & u) const
+                -> decltype(true ? u : t)
+            {
+                return u < t ? t : u;
+            }
+        };
+        RANGES_INLINE_VARIABLE(_max_, max_)
+
+        template<typename State, typename Value>
+        using zip_cardinality = std::integral_constant<
+            cardinality, State::value >= 0 || Value::value >= 0
+                             ? (State::value >= 0 && Value::value >= 0
+                                    ? min_(State::value, Value::value)
+                                    : finite)
+                             : State::value == finite || Value::value == finite
+                                   ? finite
+                                   : State::value == unknown || Value::value == unknown
+                                         ? unknown
+                                         : infinite>;
+    } // namespace detail
+    /// \endcond
+
+    namespace views
+    {
+        // clang-format off
+        CPP_def
+        (
+            template(typename Fun, typename ...Rngs)
+            (concept zippable_with)(Fun, Rngs...),
+                and_v<input_range<Rngs>...> &&
+                copy_constructible<Fun> &&
+                invocable<Fun&, iterator_t<Rngs>...> &&
+                invocable<Fun&, copy_tag, iterator_t<Rngs>...> &&
+                invocable<Fun&, move_tag, iterator_t<Rngs>...>
+        );
+        // clang-format on
+    } // namespace views
+
+    /// \addtogroup group-views
+    /// @{
+    template<typename Fun, typename... Rngs>
+    struct iter_zip_with_view
+      : view_facade<iter_zip_with_view<Fun, Rngs...>,
+                    meta::fold<meta::list<range_cardinality<Rngs>...>,
+                               std::integral_constant<cardinality, infinite>,
+                               meta::quote<detail::zip_cardinality>>::value>
+    {
+    private:
+        CPP_assert(sizeof...(Rngs) != 0);
+        friend range_access;
+
+        semiregular_box_t<Fun> fun_;
+        std::tuple<Rngs...> rngs_;
+        using difference_type_ = common_type_t<range_difference_t<Rngs>...>;
+
+        template<bool Const>
+        struct cursor;
+
+        template<bool Const>
+        struct sentinel
+        {
+        private:
+            friend struct cursor<Const>;
+            friend struct sentinel<!Const>;
+            std::tuple<sentinel_t<meta::const_if_c<Const, Rngs>>...> ends_;
+
+        public:
+            sentinel() = default;
+            sentinel(detail::ignore_t,
+                     std::tuple<sentinel_t<meta::const_if_c<Const, Rngs>>...> ends)
+              : ends_(std::move(ends))
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) sentinel(sentinel<Other> that)
+              : ends_(std::move(that.ends_))
+            {}
+        };
+
+        template<bool Const>
+        struct cursor
+        {
+        private:
+            friend struct cursor<!Const>;
+            using fun_ref_ = semiregular_box_ref_or_val_t<Fun, Const>;
+            fun_ref_ fun_;
+            std::tuple<iterator_t<meta::const_if_c<Const, Rngs>>...> its_;
+
+        public:
+            using difference_type =
+                common_type_t<range_difference_t<meta::const_if_c<Const, Rngs>>...>;
+            using single_pass = meta::or_c<(
+                bool)single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rngs>>>...>;
+            using value_type = detail::decay_t<invoke_result_t<
+                fun_ref_ &, copy_tag, iterator_t<meta::const_if_c<Const, Rngs>>...>>;
+
+            cursor() = default;
+            cursor(fun_ref_ fun,
+                   std::tuple<iterator_t<meta::const_if_c<Const, Rngs>>...> its)
+              : fun_(std::move(fun))
+              , its_(std::move(its))
+            {}
+            CPP_template(bool Other)( //
+                requires Const && (!Other)) cursor(cursor<Other> that)
+              : fun_(std::move(that.fun_))
+              , its_(std::move(that.its_))
+            {}
+            // clang-format off
+            auto CPP_auto_fun(read)()(const)
+            (
+                return tuple_apply(fun_, its_)
+            )
+                // clang-format on
+                void next()
+            {
+                tuple_for_each(its_, detail::inc);
+            }
+            CPP_member
+            auto equal(cursor const & that) const -> CPP_ret(bool)( //
+                requires and_v<
+                    sentinel_for<iterator_t<meta::const_if_c<Const, Rngs>>,
+                                 iterator_t<meta::const_if_c<Const, Rngs>>>...>)
+            {
+                // By returning true if *any* of the iterators are equal, we allow
+                // zipped ranges to be of different lengths, stopping when the first
+                // one reaches the last.
+                return tuple_foldl(tuple_transform(its_, that.its_, detail::equal_to),
+                                   false,
+                                   [](bool a, bool b) { return a || b; });
+            }
+            bool equal(sentinel<Const> const & s) const
+            {
+                // By returning true if *any* of the iterators are equal, we allow
+                // zipped ranges to be of different lengths, stopping when the first
+                // one reaches the last.
+                return tuple_foldl(tuple_transform(its_, s.ends_, detail::equal_to),
+                                   false,
+                                   [](bool a, bool b) { return a || b; });
+            }
+            CPP_member
+            auto prev() -> CPP_ret(void)( //
+                requires and_v<bidirectional_range<meta::const_if_c<Const, Rngs>>...>)
+            {
+                tuple_for_each(its_, detail::dec);
+            }
+            CPP_member
+            auto advance(difference_type n) -> CPP_ret(void)( //
+                requires and_v<random_access_range<meta::const_if_c<Const, Rngs>>...>)
+            {
+                tuple_for_each(its_, bind_back(detail::advance_, n));
+            }
+            CPP_member
+            auto distance_to(cursor const & that) const -> CPP_ret(difference_type)( //
+                requires and_v<
+                    sized_sentinel_for<iterator_t<meta::const_if_c<Const, Rngs>>,
+                                       iterator_t<meta::const_if_c<Const, Rngs>>>...>)
+            {
+                // Return the smallest distance (in magnitude) of any of the iterator
+                // pairs. This is to accommodate zippers of sequences of different length.
+                if(0 < std::get<0>(that.its_) - std::get<0>(its_))
+                    return tuple_foldl(
+                        tuple_transform(its_, that.its_, detail::distance_to),
+                        (std::numeric_limits<difference_type>::max)(),
+                        detail::min_);
+                else
+                    return tuple_foldl(
+                        tuple_transform(its_, that.its_, detail::distance_to),
+                        (std::numeric_limits<difference_type>::min)(),
+                        detail::max_);
+            }
+            // clang-format off
+            template<std::size_t... Is>
+            auto CPP_auto_fun(move_)(meta::index_sequence<Is...>)(const)
+            (
+                return invoke(fun_, move_tag{}, std::get<Is>(its_)...)
+            )
+                // clang-format on
+                auto move() const noexcept(noexcept(std::declval<cursor const &>().move_(
+                    meta::make_index_sequence<sizeof...(Rngs)>{})))
+                    -> decltype(std::declval<cursor const &>().move_(
+                        meta::make_index_sequence<sizeof...(Rngs)>{}))
+            {
+                return move_(meta::make_index_sequence<sizeof...(Rngs)>{});
+            }
+        };
+
+        template<bool Const>
+        using end_cursor_t =
+            meta::if_c<concepts::and_v<(bool)common_range<Rngs>...,
+                                       !(bool)single_pass_iterator_<iterator_t<Rngs>>...>,
+                       cursor<Const>, sentinel<Const>>;
+
+        cursor<false> begin_cursor()
+        {
+            return {fun_, tuple_transform(rngs_, ranges::begin)};
+        }
+        end_cursor_t<false> end_cursor()
+        {
+            return {fun_, tuple_transform(rngs_, ranges::end)};
+        }
+        template<bool Const = true>
+        auto begin_cursor() const -> CPP_ret(cursor<Const>)( //
+            requires Const && and_v<range<Rngs const>...> &&
+                views::zippable_with<Fun, meta::if_c<Const, Rngs const>...>)
+        {
+            return {fun_, tuple_transform(rngs_, ranges::begin)};
+        }
+        template<bool Const = true>
+        auto end_cursor() const -> CPP_ret(end_cursor_t<Const>)( //
+            requires Const && and_v<range<Rngs const>...> &&
+                views::zippable_with<Fun, meta::if_c<Const, Rngs const>...>)
+        {
+            return {fun_, tuple_transform(rngs_, ranges::end)};
+        }
+
+    public:
+        iter_zip_with_view() = default;
+        explicit iter_zip_with_view(Rngs... rngs)
+          : fun_(Fun{})
+          , rngs_{std::move(rngs)...}
+        {}
+        explicit iter_zip_with_view(Fun fun, Rngs... rngs)
+          : fun_(std::move(fun))
+          , rngs_{std::move(rngs)...}
+        {}
+        CPP_member
+        constexpr auto CPP_fun(size)()(const requires and_v<sized_range<Rngs const>...>)
+        {
+            using size_type = common_type_t<range_size_t<Rngs const>...>;
+            return range_cardinality<iter_zip_with_view>::value >= 0
+                       ? size_type{(
+                             std::size_t)range_cardinality<iter_zip_with_view>::value}
+                       : tuple_foldl(tuple_transform(rngs_,
+                                                     [](auto && r) -> size_type {
+                                                         return ranges::size(r);
+                                                     }),
+                                     (std::numeric_limits<size_type>::max)(),
+                                     detail::min_);
+        }
+    };
+
+    template<typename Fun, typename... Rngs>
+    struct zip_with_view : iter_zip_with_view<indirected<Fun>, Rngs...>
+    {
+        CPP_assert(sizeof...(Rngs) != 0);
+
+        zip_with_view() = default;
+        explicit zip_with_view(Rngs... rngs)
+          : iter_zip_with_view<indirected<Fun>, Rngs...>{{Fun{}}, std::move(rngs)...}
+        {}
+        explicit zip_with_view(Fun fun, Rngs... rngs)
+          : iter_zip_with_view<indirected<Fun>, Rngs...>{{std::move(fun)},
+                                                         std::move(rngs)...}
+        {}
+    };
+
+#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
+    CPP_template(typename Fun, typename... Rng)(requires copy_constructible<Fun>)
+        zip_with_view(Fun, Rng &&...)
+            ->zip_with_view<Fun, views::all_t<Rng>...>;
+#endif
+
+    namespace views
+    {
+        struct iter_zip_with_fn
+        {
+            template<typename... Rngs, typename Fun>
+            auto operator()(Fun fun, Rngs &&... rngs) const -> CPP_ret(
+                iter_zip_with_view<Fun, all_t<Rngs>...>)( //
+                requires and_v<viewable_range<Rngs>...> && zippable_with<Fun, Rngs...> &&
+                (sizeof...(Rngs) != 0))
+            {
+                return iter_zip_with_view<Fun, all_t<Rngs>...>{
+                    std::move(fun), all(static_cast<Rngs &&>(rngs))...};
+            }
+
+            template<typename Fun>
+            constexpr auto operator()(Fun) const noexcept
+                -> CPP_ret(empty_view<std::tuple<>>)( //
+                    requires zippable_with<Fun>)
+            {
+                return {};
+            }
+        };
+
+        /// \relates iter_zip_with_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(iter_zip_with_fn, iter_zip_with)
+
+        struct zip_with_fn
+        {
+            template<typename... Rngs, typename Fun>
+            auto operator()(Fun fun, Rngs &&... rngs) const
+                -> CPP_ret(zip_with_view<Fun, all_t<Rngs>...>)( //
+                    requires and_v<viewable_range<Rngs>...> &&
+                        and_v<input_range<Rngs>...> && copy_constructible<Fun> &&
+                            invocable<Fun &, range_reference_t<Rngs>...> &&
+                    (sizeof...(Rngs) != 0))
+            {
+                return zip_with_view<Fun, all_t<Rngs>...>{
+                    std::move(fun), all(static_cast<Rngs &&>(rngs))...};
+            }
+
+            template<typename Fun>
+            constexpr auto operator()(Fun) const noexcept
+                -> CPP_ret(empty_view<std::tuple<>>)( //
+                    requires copy_constructible<Fun> && invocable<Fun &>)
+            {
+                return {};
+            }
+        };
+
+        /// \relates zip_with_fn
+        /// \ingroup group-views
+        RANGES_INLINE_VARIABLE(zip_with_fn, zip_with)
+    } // namespace views
+    /// @}
+} // namespace ranges
+
+#include <range/v3/detail/satisfy_boost_range.hpp>
+RANGES_SATISFY_BOOST_RANGE(::ranges::iter_zip_with_view)
+RANGES_SATISFY_BOOST_RANGE(::ranges::zip_with_view)
+
+#endif
diff --git a/inst/include/range/v3/view_adaptor.hpp b/inst/include/range/v3/view_adaptor.hpp
new file mode 100644
index 0000000..6f30c95
--- /dev/null
+++ b/inst/include/range/v3/view_adaptor.hpp
@@ -0,0 +1,21 @@
+// Range v3 library
+//
+// Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_OLD_VIEW_ADAPTOR_HPP
+#define RANGES_V3_OLD_VIEW_ADAPTOR_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/view/adaptor.hpp> instead.")
+
+#include <range/v3/view/adaptor.hpp>
+
+#endif
diff --git a/inst/include/range/v3/view_facade.hpp b/inst/include/range/v3/view_facade.hpp
new file mode 100644
index 0000000..ddfaa06
--- /dev/null
+++ b/inst/include/range/v3/view_facade.hpp
@@ -0,0 +1,21 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_OLD_VIEW_FACADE_HPP
+#define RANGES_V3_OLD_VIEW_FACADE_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/view/facade.hpp> instead.")
+
+#include <range/v3/view/facade.hpp>
+
+#endif
diff --git a/inst/include/range/v3/view_interface.hpp b/inst/include/range/v3/view_interface.hpp
new file mode 100644
index 0000000..cd6e52d
--- /dev/null
+++ b/inst/include/range/v3/view_interface.hpp
@@ -0,0 +1,21 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+#ifndef RANGES_V3_OLD_VIEW_INTERFACE_HPP
+#define RANGES_V3_OLD_VIEW_INTERFACE_HPP
+
+#include <range/v3/detail/config.hpp>
+RANGES_DEPRECATED_HEADER(
+    "This header is deprecated. Please #include <range/v3/view/interface.hpp> instead.")
+
+#include <range/v3/view/interface.hpp>
+
+#endif
diff --git a/inst/include/rutils/rutils.hpp b/inst/include/rutils/rutils.hpp
new file mode 100644
index 0000000..c6bf140
--- /dev/null
+++ b/inst/include/rutils/rutils.hpp
@@ -0,0 +1,9 @@
+#pragma once
+#include <Rcpp.h>
+#include <optional>
+
+template<typename A,typename B>
+inline Rcpp::List wrap_pair(std::pair<A,B> p,std::optional<std::string> name_a=std::nullopt,std::optional<std::string> name_b=std::nullopt){
+  using namespace Rcpp;
+  return List::create(_[name_a.value_or("")]=wrap(p.first),_[name_b.value_or("")]=wrap(p.second));
+}
diff --git a/inst/include/std/detail/associated_types.hpp b/inst/include/std/detail/associated_types.hpp
new file mode 100644
index 0000000..2057485
--- /dev/null
+++ b/inst/include/std/detail/associated_types.hpp
@@ -0,0 +1,300 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2013-2014, 2016-present
+//  Copyright Casey Carter 2016
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_STD_DETAIL_ASSOCIATED_TYPES_HPP
+#define RANGES_V3_STD_DETAIL_ASSOCIATED_TYPES_HPP
+
+#include <climits>
+#include <cstdint>
+
+#include <range/v3/detail/config.hpp>
+
+namespace ranges
+{
+    /// \addtogroup group-iterator
+    /// @{
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    /// \cond
+    namespace detail
+    {
+        struct nil_
+        {};
+
+        template<typename T, typename...>
+        using always_ = T;
+
+#if defined(_MSC_VER) && !defined(__clang__) && !defined(__EDG__)
+        // MSVC laughs at your silly micro-optimizations and implements
+        // conditional_t, enable_if_t, is_object_v, and is_integral_v in the
+        // compiler.
+        template<bool B, typename T, typename U>
+        using if_then_t = std::conditional_t<B, T, U>;
+        using std::enable_if;
+        using std::enable_if_t;
+#else  // ^^^ MSVC / not MSVC vvv
+        template<bool>
+        struct if_then
+        {
+            template<typename, typename U>
+            using apply = U;
+        };
+        template<>
+        struct if_then<true>
+        {
+            template<typename T, typename>
+            using apply = T;
+        };
+        template<bool B, typename T, typename U>
+        using if_then_t = typename if_then<B>::template apply<T, U>;
+
+        template<bool>
+        struct enable_if
+        {};
+        template<>
+        struct enable_if<true>
+        {
+            template<typename T>
+            using apply = T;
+        };
+        template<bool B, typename T = void>
+        using enable_if_t = typename enable_if<B>::template apply<T>;
+
+#ifndef __clang__
+        // NB: insufficient for MSVC, which (non-conformingly) allows function
+        // pointers to implicitly convert to void*.
+        void is_objptr_(void const volatile *);
+
+        // std::is_object, optimized for compile time.
+        template<typename T>
+        constexpr bool is_object_(long)
+        {
+            return false;
+        }
+        template<typename T>
+        constexpr bool is_object_(int, T * (*q)(T &) = nullptr, T * p = nullptr,
+                                  decltype(detail::is_objptr_(q(*p))) * = nullptr)
+        {
+            return (void)p, (void)q, true;
+        }
+#endif // !__clang__
+
+        template<typename T>
+        constexpr bool is_integral_(...)
+        {
+            return false;
+        }
+        template<typename T, T = 1>
+        constexpr bool is_integral_(long)
+        {
+            return true;
+        }
+#if defined(__cpp_nontype_template_parameter_class) && \
+    __cpp_nontype_template_parameter_class > 0
+        template<typename T>
+        constexpr bool is_integral_(int, int T::* = nullptr)
+        {
+            return false;
+        }
+#endif
+#endif // detect MSVC
+
+        template<typename T>
+        struct with_difference_type_
+        {
+            using difference_type = T;
+        };
+
+        template<typename T>
+        using difference_result_t =
+            decltype(std::declval<T const &>() - std::declval<T const &>());
+
+        template<typename, typename = void>
+        struct incrementable_traits_2_
+        {};
+
+        template<typename T>
+        struct incrementable_traits_2_<
+            T,
+#if (defined(_MSC_VER) && !defined(__clang__) && !defined(__EDG__)) || \
+    defined(RANGES_WORKAROUND_GCC_91923)
+            std::enable_if_t<std::is_integral_v<difference_result_t<T>>>>
+#else  // ^^^ MSVC / not MSVC vvv
+            always_<void, int[is_integral_<difference_result_t<T>>(0)]>>
+#endif // detect MSVC
+        {
+            using difference_type = std::make_signed_t<difference_result_t<T>>;
+        };
+
+        template<typename T, typename = void>
+        struct incrementable_traits_1_ : incrementable_traits_2_<T>
+        {};
+
+        template<typename T>
+        struct incrementable_traits_1_<T *>
+#ifdef __clang__
+          : if_then_t<__is_object(T), with_difference_type_<std::ptrdiff_t>, nil_>
+#elif defined(_MSC_VER) && !defined(__EDG__)
+          : std::conditional_t<std::is_object_v<T>, with_difference_type_<std::ptrdiff_t>, nil_>
+#else // ^^^ MSVC / not MSVC vvv
+          : if_then_t<is_object_<T>(0), with_difference_type_<std::ptrdiff_t>, nil_>
+#endif // detect MSVC
+        {};
+
+        template<typename T>
+        struct incrementable_traits_1_<T, always_<void, typename T::difference_type>>
+        {
+            using difference_type = typename T::difference_type;
+        };
+    } // namespace detail
+    /// \endcond
+
+    template<typename T>
+    struct incrementable_traits : detail::incrementable_traits_1_<T>
+    {};
+
+    template<typename T>
+    struct incrementable_traits<T const> : incrementable_traits<T>
+    {};
+
+    /// \cond
+    namespace detail
+    {
+#ifdef __clang__
+        template<typename T, bool = __is_object(T)>
+#elif defined(_MSC_VER) && !defined(__EDG__)
+        template<typename T, bool = std::is_object_v<T>>
+#else // ^^^ MSVC / not MSVC vvv
+        template<typename T, bool = is_object_<T>(0)>
+#endif // detect MSVC
+        struct with_value_type_
+        {};
+        template<typename T>
+        struct with_value_type_<T, true>
+        {
+            using value_type = T;
+        };
+        template<typename T>
+        struct with_value_type_<T const, true>
+        {
+            using value_type = T;
+        };
+        template<typename T>
+        struct with_value_type_<T volatile, true>
+        {
+            using value_type = T;
+        };
+        template<typename T>
+        struct with_value_type_<T const volatile, true>
+        {
+            using value_type = T;
+        };
+        template<typename, typename = void>
+        struct readable_traits_2_
+        {};
+        template<typename T>
+        struct readable_traits_2_<T, always_<void, typename T::element_type>>
+          : with_value_type_<typename T::element_type>
+        {};
+        template<typename T, typename = void>
+        struct readable_traits_1_ : readable_traits_2_<T>
+        {};
+        template<typename T>
+        struct readable_traits_1_<T[]> : with_value_type_<T>
+        {};
+        template<typename T, std::size_t N>
+        struct readable_traits_1_<T[N]> : with_value_type_<T>
+        {};
+        template<typename T>
+        struct readable_traits_1_<T *> : detail::with_value_type_<T>
+        {};
+        template<typename T>
+        struct readable_traits_1_<T, always_<void, typename T::value_type>>
+          : with_value_type_<typename T::value_type>
+        {};
+    } // namespace detail
+    /// \endcond
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    // Not to spec:
+    // * For class types with both member value_type and element_type, value_type is
+    //   preferred (see ericniebler/stl2#299).
+    template<typename T>
+    struct readable_traits : detail::readable_traits_1_<T>
+    {};
+
+    template<typename T>
+    struct readable_traits<T const> : readable_traits<T>
+    {};
+
+    /// \cond
+    namespace detail
+    {
+        template<typename D = std::ptrdiff_t>
+        struct std_output_iterator_traits
+        {
+            using iterator_category = std::output_iterator_tag;
+            using difference_type = D;
+            using value_type = void;
+            using reference = void;
+            using pointer = void;
+        };
+
+        // For testing whether a particular instantiation of std::iterator_traits
+        // is user-specified or not.
+#if defined(_MSVC_STL_UPDATE) && defined(__cpp_lib_concepts) && _MSVC_STL_UPDATE >= 201908L
+        template<typename I>
+        inline constexpr bool is_std_iterator_traits_specialized_v =
+            !std::_Is_from_primary<std::iterator_traits<I>>;
+#else
+#if defined(__GLIBCXX__)
+        template<typename I>
+        char (&is_std_iterator_traits_specialized_impl_(std::__iterator_traits<I> *))[2];
+        template<typename I>
+        char is_std_iterator_traits_specialized_impl_(void *);
+#elif defined(_LIBCPP_VERSION)
+        template<typename I, bool B>
+        char (
+            &is_std_iterator_traits_specialized_impl_(std::__iterator_traits<I, B> *))[2];
+        template<typename I>
+        char is_std_iterator_traits_specialized_impl_(void *);
+#elif defined(_MSVC_STL_VERSION)
+        template<typename I>
+        char (&is_std_iterator_traits_specialized_impl_(
+            std::_Iterator_traits_base<I> *))[2];
+        template<typename I>
+        char is_std_iterator_traits_specialized_impl_(void *);
+#else
+        template<typename I>
+        char (&is_std_iterator_traits_specialized_impl_(void *))[2];
+#endif
+        template<typename, typename T>
+        char (&is_std_iterator_traits_specialized_impl_(std::iterator_traits<T *> *))[2];
+
+        template<typename I>
+        RANGES_INLINE_VAR constexpr bool is_std_iterator_traits_specialized_v =
+            1 == sizeof(is_std_iterator_traits_specialized_impl_<I>(
+                     static_cast<std::iterator_traits<I> *>(nullptr)));
+
+        // The standard iterator_traits<T *> specialization(s) do not count
+        // as user-specialized. This will no longer be necessary in C++20.
+        // This helps with `T volatile*` and `void *`.
+        template<typename T>
+        RANGES_INLINE_VAR constexpr bool is_std_iterator_traits_specialized_v<T *> =
+            false;
+#endif
+    } // namespace detail
+    /// \endcond
+} // namespace ranges
+
+#endif
diff --git a/inst/include/std/iterator b/inst/include/std/iterator
new file mode 100644
index 0000000..856bf6b
--- /dev/null
+++ b/inst/include/std/iterator
@@ -0,0 +1,274 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2018-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_STD_ITERATOR
+#define RANGES_V3_STD_ITERATOR
+
+#if defined(__GNUC__)
+#include_next <iterator>
+#elif defined(_MSC_VER)
+#include <../include/iterator> // HACKHACK
+#else
+#error "Cannot use range-v3 STL deep integration on this platform."
+#endif
+
+#if RANGES_DEEP_STL_INTEGRATION
+
+#include <range/v3/detail/config.hpp>
+#include <std/detail/associated_types.hpp>
+
+namespace ranges
+{
+    template<typename I>
+    struct incrementable_traits;
+
+    template<typename I>
+    struct readable_traits;
+
+    /// \cond
+    namespace detail
+    {
+        template<typename I>
+        typename incrementable_traits<I>::difference_type cpp17_difference_type_(int);
+        template<typename I>
+        void cpp17_difference_type_(long);
+
+        template<typename I>
+        typename I::pointer cpp17_pointer_type_(int);
+        template<typename I>
+        auto cpp17_pointer_type_(long, I *pi = nullptr) -> decltype(pi->operator->());
+        template<typename I>
+        void cpp17_pointer_type_(...);
+
+        template<typename I>
+        typename I::reference cpp17_reference_type_(int);
+        template<typename I>
+        auto cpp17_reference_type_(long, I *pi = nullptr) -> decltype(**pi);
+
+        template<typename I>
+        auto cpp17_iterator_category_4_(long)
+        {
+            return std::bidirectional_iterator_tag{};
+        }
+        // Satisfies Cpp17RandomAccessIterator?
+        template<typename I>
+        auto cpp17_iterator_category_4_(
+            int,
+            I *pi = nullptr,
+            typename incrementable_traits<I>::difference_type d = 0,
+            always_<
+                void,
+                int[RANGES_IS_SAME(decltype(*pi += d), I &)],
+                int[RANGES_IS_SAME(decltype(*pi -= d), I &)],
+                int[RANGES_IS_SAME(decltype(*pi + d), I)],
+                int[RANGES_IS_SAME(decltype(*pi - d), I)],
+                int[RANGES_IS_SAME(decltype(d + *pi), I)],
+                int[RANGES_IS_SAME(decltype(*pi - *pi), decltype(d))],
+                int[RANGES_IS_SAME(decltype((*pi)[d]), decltype(**pi))],
+                decltype(*pi < *pi ? true : false),
+                decltype(*pi > *pi ? true : false),
+                decltype(*pi <= *pi ? true : false),
+                decltype(*pi >= *pi ? true : false)
+            > * = nullptr)
+        {
+            return std::random_access_iterator_tag{};
+        }
+
+        template<typename I>
+        auto cpp17_iterator_category_3_(long)
+        {
+            return std::forward_iterator_tag{};
+        }
+        // Satisfies Cpp17BidirectionalIterator?
+        template<typename I>
+        auto cpp17_iterator_category_3_(
+            int,
+            I *pi = nullptr,
+            void (*fn)(I const &) = nullptr,
+            always_<
+                void,
+                decltype(fn((*pi)--)), // i-- convertible to I const &
+                int[RANGES_IS_SAME(decltype(--*pi), I &)], // --i has type I &
+                // *i has the same type as *i--
+                int[RANGES_IS_SAME(decltype(**pi), decltype(*(*pi)--))]
+            > * = nullptr)
+        {
+            return cpp17_iterator_category_4_<I>(0);
+        }
+
+        template<typename I>
+        auto cpp17_iterator_category_2_(long)
+        {
+            return std::input_iterator_tag{};
+        }
+        // Satisfies Cpp17ForwardIterator?
+        template<typename I>
+        auto cpp17_iterator_category_2_(
+            int,
+            I *pi = nullptr,
+            void (*fn)(I const &) = nullptr,
+            typename readable_traits<I>::value_type *pv = nullptr,
+            typename readable_traits<I>::value_type const *pcv = nullptr,
+            always_<
+                void,
+                decltype(I{}), // Default constructible
+                decltype(fn((*pi)++)), // i++ convertible to I const &
+                // *i has the same type as *i++
+                int[RANGES_IS_SAME(decltype(**pi), decltype(*(*pi)++))],
+                // *i is a real reference to value_type
+#ifdef RANGES_WORKAROUND_MSVC_793042
+                enable_if_t<RANGES_IS_SAME(decltype(**pi), decltype(*pv)) ||
+                            RANGES_IS_SAME(decltype(**pi), decltype(*pcv)) ||
+                            RANGES_IS_SAME(decltype(**pi), typename readable_traits<I>::value_type &&) ||
+                            RANGES_IS_SAME(decltype(**pi), typename readable_traits<I>::value_type const &&)>
+#else // ^^^ workaround / no workaround vvv
+                int[RANGES_IS_SAME(decltype(**pi), decltype(*pv)) ||
+                    RANGES_IS_SAME(decltype(**pi), decltype(*pcv)) ||
+                    RANGES_IS_SAME(decltype(**pi), typename readable_traits<I>::value_type &&) ||
+                    RANGES_IS_SAME(decltype(**pi), typename readable_traits<I>::value_type const &&)]
+#endif // RANGES_WORKAROUND_MSVC_793042
+            > * = nullptr)
+        {
+            return cpp17_iterator_category_3_<I>(0);
+        }
+
+        template<typename I>
+        using cpp17_readable_iterator_category_t =
+            decltype(detail::cpp17_iterator_category_2_<I>(0));
+
+        template<typename I>
+        auto cpp17_iterator_category_(long)
+        {
+            return cpp17_iterator_category_2_<I>(0);
+        }
+        // Explicitly declares its category?
+        template<typename I>
+        typename I::iterator_category cpp17_iterator_category_(int)
+        {
+            return {};
+        }
+
+        template<typename I>
+        auto std_iterator_traits_impl_2_(long)
+        {
+            return std_output_iterator_traits<
+                decltype(detail::cpp17_difference_type_<I>(0))>{};
+        }
+        // Satisfies Cpp17InputIterator?
+        template<typename I>
+        auto std_iterator_traits_impl_2_(
+            int,
+            I *pi = nullptr,
+            typename incrementable_traits<I>::difference_type d = 0,
+            typename readable_traits<I>::value_type const *pcv = nullptr,
+            always_<
+                void,
+                int[decltype(d)(-1) < decltype(d)(0)], // signed difference type
+                decltype(decltype(*pcv)(**pi)),        // sensible reference/value type
+                decltype(decltype(*pcv)(*(*pi)++)),    // sensible post-increment result
+                decltype(*pi == *pi ? true : false),   // equality comparable
+                decltype(*pi != *pi ? true : false)    //     "        "
+            > * = nullptr)
+        {
+            using D = typename incrementable_traits<I>::difference_type;
+            struct yes_traits
+            {
+                using difference_type = D;
+                using value_type = typename readable_traits<I>::value_type;
+                using reference = decltype(cpp17_reference_type_<I>(0));
+                using pointer = decltype(cpp17_pointer_type_<I>(0));
+                using iterator_category = decltype(cpp17_iterator_category_<I>(0));
+            };
+            struct no_traits
+            {};
+            return if_then_t<is_integral_<D>(0), yes_traits, no_traits>{};
+        }
+
+        template<typename I>
+        nil_ std_iterator_traits_impl_(long)
+        {
+            return {};
+        }
+        // Satisfies Cpp17Iterator?
+        template<typename I>
+        auto std_iterator_traits_impl_(
+            int,
+            I *pi = nullptr,
+            void (*nv)(...) = nullptr,
+            always_<
+                void,
+                decltype(nv(**pi)),
+                int[RANGES_IS_SAME(decltype(++*pi), I &)],
+                decltype(nv(*(*pi)++))
+            > * = nullptr)
+        {
+            return std_iterator_traits_impl_2_<I>(0);
+        }
+
+        template<typename T>
+        constexpr bool has_iterator_typedefs_impl_(
+            int,
+            always_<
+                void,
+                typename T::difference_type,
+                typename T::value_type,
+                typename T::pointer,
+                typename T::reference,
+                typename T::iterator_category
+            > * = nullptr)
+        {
+            return true;
+        }
+        template<typename T>
+        constexpr bool has_iterator_typedefs_impl_(long)
+        {
+            return false;
+        }
+    }
+    /// \endcond
+}
+
+// Hijack the primary std::iterator_traits template from each of the 3 major
+// standard library implementations
+RANGES_BEGIN_NAMESPACE_STD
+RANGES_BEGIN_NAMESPACE_VERSION
+#if defined(__GLIBCXX__)
+    template<typename I>
+    struct __iterator_traits<
+        I,
+        ::ranges::detail::enable_if_t<!::ranges::detail::has_iterator_typedefs_impl_<I>(0)>>
+      : decltype(::ranges::detail::std_iterator_traits_impl_<I>(0))
+    {};
+#elif defined(_LIBCPP_VERSION)
+    template<typename I>
+    struct __iterator_traits<I, false> // doesn't have I::iterator_category
+      : decltype(::ranges::detail::std_iterator_traits_impl_<I>(0))
+    {};
+#elif defined(_MSVC_STL_VERSION)
+    template<typename I>
+    struct _Iterator_traits_base<
+        I,
+#ifdef RANGES_WORKAROUND_MSVC_792338
+        ::ranges::detail::enable_if_t<decltype(bool_constant<
+            !::ranges::detail::has_iterator_typedefs_impl_<I>(0)>{})::value>>
+#else // ^^^ workaround / no workaround vvv
+        ::ranges::detail::enable_if_t<!::ranges::detail::has_iterator_typedefs_impl_<I>(0)>>
+#endif // RANGES_WORKAROUND_MSVC_792338
+      : decltype(::ranges::detail::std_iterator_traits_impl_<I>(0))
+    {};
+#endif
+RANGES_END_NAMESPACE_VERSION
+RANGES_END_NAMESPACE_STD
+
+#endif // RANGES_DEEP_STL_INTEGRATION
+
+#endif // RANGES_V3_STD_ITERATOR
diff --git a/inst/include/xtensor-blas/xblas.hpp b/inst/include/xtensor-blas/xblas.hpp
new file mode 100644
index 0000000..a7b358c
--- /dev/null
+++ b/inst/include/xtensor-blas/xblas.hpp
@@ -0,0 +1,238 @@
+/***************************************************************************
+* Copyright (c) 2016, Wolf Vollprecht, Johan Mabille and Sylvain Corlay    *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#ifndef XBLAS_HPP
+#define XBLAS_HPP
+
+#include <algorithm>
+
+#include "xtensor/xarray.hpp"
+#include "xtensor/xcomplex.hpp"
+#include "xtensor/xio.hpp"
+#include "xtensor/xtensor.hpp"
+#include "xtensor/xutils.hpp"
+
+#include "xtensor-blas/xblas_config.hpp"
+#include "xtensor-blas/xblas_utils.hpp"
+
+#include "xflens/cxxblas/cxxblas.cxx"
+
+namespace xt
+{
+
+namespace blas
+{
+    /**
+     * Calculate the 1-norm of a vector
+     *
+     * @param a vector of n elements
+     * @returns scalar result
+     */
+    template <class E, class R>
+    void asum(const xexpression<E>& a, R& result)
+    {
+        auto&& ad = view_eval<E::static_layout>(a.derived_cast());
+        XTENSOR_ASSERT(ad.dimension() == 1);
+
+        cxxblas::asum<blas_index_t>(
+            static_cast<blas_index_t>(ad.shape()[0]),
+            ad.data() + ad.data_offset(),
+            stride_front(ad),
+            result
+        );
+    }
+
+    /**
+     * Calculate the 2-norm of a vector
+     *
+     * @param a vector of n elements
+     * @returns scalar result
+     */
+    template <class E, class R>
+    void nrm2(const xexpression<E>& a, R& result)
+    {
+        auto&& ad = view_eval<E::static_layout>(a.derived_cast());
+        XTENSOR_ASSERT(ad.dimension() == 1);
+
+        cxxblas::nrm2<blas_index_t>(
+            static_cast<blas_index_t>(ad.shape()[0]),
+            ad.data() + ad.data_offset(),
+            stride_front(ad),
+            result
+        );
+    }
+
+    /**
+     * Calculate the dot product between two vectors, conjugating
+     * the first argument \em a in the case of complex vectors.
+     *
+     * @param a vector of n elements
+     * @param b vector of n elements
+     * @returns scalar result
+     */
+    template <class E1, class E2, class R>
+    void dot(const xexpression<E1>& a, const xexpression<E2>& b,
+             R& result)
+    {
+        auto&& ad = view_eval<E1::static_layout>(a.derived_cast());
+        auto&& bd = view_eval<E2::static_layout>(b.derived_cast());
+        XTENSOR_ASSERT(ad.dimension() == 1);
+
+        cxxblas::dot<blas_index_t>(
+            static_cast<blas_index_t>(ad.shape()[0]),
+            ad.data() + ad.data_offset(),
+            stride_front(ad),
+            bd.data() + bd.data_offset(),
+            stride_front(bd),
+            result
+        );
+    }
+
+    /**
+     * Calculate the dot product between two complex vectors, not conjugating the
+     * first argument \em a.
+     *
+     * @param a vector of n elements
+     * @param b vector of n elements
+     * @returns scalar result
+     */
+    template <class E1, class E2, class R>
+    void dotu(const xexpression<E1>& a, const xexpression<E2>& b, R& result)
+    {
+        auto&& ad = view_eval<E1::static_layout>(a.derived_cast());
+        auto&& bd = view_eval<E2::static_layout>(b.derived_cast());
+        XTENSOR_ASSERT(ad.dimension() == 1);
+
+        cxxblas::dotu<blas_index_t>(
+            static_cast<blas_index_t>(ad.shape()[0]),
+            ad.data() + ad.data_offset(),
+            stride_front(ad),
+            bd.data() + bd.data_offset(),
+            stride_front(bd),
+            result
+        );
+    }
+
+    /**
+     * Calculate the general matrix times vector product according to
+     * ``y := alpha * A * x + beta * y``.
+     *
+     * @param A matrix of n x m elements
+     * @param x vector of n elements
+     * @param transpose select if A should be transposed
+     * @param alpha scalar scale factor
+     * @returns the resulting vector
+     */
+    template <class E1, class E2, class R, class value_type = typename E1::value_type>
+    void gemv(const xexpression<E1>& A, const xexpression<E2>& x,
+              R& result,
+              bool transpose_A = false,
+              const value_type& alpha = value_type(1.0),
+              const value_type& beta = value_type(0.0))
+    {
+        auto&& dA = view_eval<E1::static_layout>(A.derived_cast());
+        auto&& dx = view_eval<E2::static_layout>(x.derived_cast());
+
+        cxxblas::gemv<blas_index_t>(
+            get_blas_storage_order(result),
+            transpose_A ? cxxblas::Transpose::Trans : cxxblas::Transpose::NoTrans,
+            static_cast<blas_index_t>(dA.shape()[0]),
+            static_cast<blas_index_t>(dA.shape()[1]),
+            alpha,
+            dA.data() + dA.data_offset(),
+            get_leading_stride(dA),
+            dx.data() + dx.data_offset(),
+            get_leading_stride(dx),
+            beta,
+            result.data() + result.data_offset(),
+            get_leading_stride(result)
+        );
+    }
+
+    /**
+     * Calculate the matrix-matrix product of matrix @A and matrix @B
+     *
+     * C := alpha * A * B + beta * C
+     *
+     * @param A matrix of m-by-n elements
+     * @param B matrix of n-by-k elements
+     * @param transpose_A transpose A on the fly
+     * @param transpose_B transpose B on the fly
+     * @param alpha scale factor for A * B (defaults to 1)
+     * @param beta scale factor for C (defaults to 0)
+     */
+    template <class E, class F, class R, class value_type = typename E::value_type>
+    void gemm(const xexpression<E>& A, const xexpression<F>& B, R& result,
+              char transpose_A = false,
+              char transpose_B = false,
+              const value_type& alpha = value_type(1.0),
+              const value_type& beta = value_type(0.0))
+    {
+        static_assert(R::static_layout != layout_type::dynamic, "GEMM result layout cannot be dynamic.");
+        auto&& dA = view_eval<R::static_layout>(A.derived_cast());
+        auto&& dB = view_eval<R::static_layout>(B.derived_cast());
+
+        XTENSOR_ASSERT(dA.layout() == dB.layout());
+        XTENSOR_ASSERT(result.layout() == dA.layout());
+        XTENSOR_ASSERT(dA.dimension() == 2);
+        XTENSOR_ASSERT(dB.dimension() == 2);
+
+        cxxblas::gemm<blas_index_t>(
+            get_blas_storage_order(result),
+            transpose_A ? cxxblas::Transpose::Trans : cxxblas::Transpose::NoTrans,
+            transpose_B ? cxxblas::Transpose::Trans : cxxblas::Transpose::NoTrans,
+            static_cast<blas_index_t>(transpose_A ? dA.shape()[1] : dA.shape()[0]),
+            static_cast<blas_index_t>(transpose_B ? dB.shape()[0] : dB.shape()[1]),
+            static_cast<blas_index_t>(transpose_B ? dB.shape()[1] : dB.shape()[0]),
+            alpha,
+            dA.data() + dA.data_offset(),
+            get_leading_stride(dA),
+            dB.data() + dB.data_offset(),
+            get_leading_stride(dB),
+            beta,
+            result.data() + result.data_offset(),
+            get_leading_stride(result)
+        );
+    }
+
+    /**
+     * Calculate the outer product of vector x and y.
+     * According to A:= alpha * x * y' + A
+     *
+     * @param x vector of n elements
+     * @param y vector of m elements
+     * @param alpha scalar scale factor
+     * @returns matrix of n-by-m elements
+     */
+    template <class E1, class E2, class R, class value_type = typename E1::value_type>
+    void ger(const xexpression<E1>& x, const xexpression<E2>& y,
+             R& result,
+             const value_type& alpha = value_type(1.0))
+    {
+        auto&& dx = view_eval(x.derived_cast());
+        auto&& dy = view_eval(y.derived_cast());
+
+        XTENSOR_ASSERT(dx.dimension() == 1);
+        XTENSOR_ASSERT(dy.dimension() == 1);
+
+        cxxblas::ger<blas_index_t>(
+            get_blas_storage_order(result),
+            static_cast<blas_index_t>(dx.shape()[0]),
+            static_cast<blas_index_t>(dy.shape()[0]),
+            alpha,
+            dx.data() + dx.data_offset(),
+            static_cast<blas_index_t>(dx.strides().front()),
+            dy.data() + dy.data_offset(),
+            static_cast<blas_index_t>(dy.strides().front()),
+            result.data() + result.data_offset(),
+            static_cast<blas_index_t>(result.strides().front())
+        );
+    }
+}
+}
+#endif
diff --git a/inst/include/xtensor-blas/xblas_config.hpp b/inst/include/xtensor-blas/xblas_config.hpp
new file mode 100644
index 0000000..fcffd8d
--- /dev/null
+++ b/inst/include/xtensor-blas/xblas_config.hpp
@@ -0,0 +1,37 @@
+/***************************************************************************
+* Copyright (c) 2016, Johan Mabille and Sylvain Corlay                     *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#ifndef XBLAS_CONFIG_HPP
+#define XBLAS_CONFIG_HPP
+
+#define XTENSOR_BLAS_VERSION_MAJOR 0
+#define XTENSOR_BLAS_VERSION_MINOR 15
+#define XTENSOR_BLAS_VERSION_PATCH 1
+
+#ifndef XTENSOR_USE_FLENS_BLAS
+#define HAVE_CBLAS 1
+#endif
+
+#ifndef USE_CXXLAPACK
+#define USE_CXXLAPACK
+#endif
+
+#ifndef BLAS_IDX
+#define BLAS_IDX int
+#endif
+
+#ifdef __CLING__
+#include "xtensor-blas/xblas_config_cling.hpp"
+#endif
+
+namespace xt
+{
+    using blas_index_t = BLAS_IDX;
+}
+
+#endif
diff --git a/inst/include/xtensor-blas/xblas_config_cling.hpp.in b/inst/include/xtensor-blas/xblas_config_cling.hpp.in
new file mode 100644
index 0000000..d6f30a1
--- /dev/null
+++ b/inst/include/xtensor-blas/xblas_config_cling.hpp.in
@@ -0,0 +1,25 @@
+/***************************************************************************
+* Copyright (c) 2016, Wolf Vollprecht, Johan Mabille and Sylvain Corlay    *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#ifndef XBLAS_CONFIG_CLING_HPP
+#define XBLAS_CONFIG_CLING_HPP
+
+#pragma cling add_library_path(@XTENSOR_BLAS_CLING_LIBRARY_DIR_64@)
+#pragma cling add_library_path(@XTENSOR_BLAS_CLING_LIBRARY_DIR_32@)
+#pragma cling add_library_path(@XTENSOR_BLAS_CLING_LIBRARY_DIR@)
+
+#ifndef XTENSOR_USE_FLENS_BLAS
+
+#define HAVE_CBLAS 1
+
+#pragma cling load("libblas")
+#pragma cling load("liblapack")
+
+#endif
+
+#endif
\ No newline at end of file
diff --git a/inst/include/xtensor-blas/xblas_utils.hpp b/inst/include/xtensor-blas/xblas_utils.hpp
new file mode 100644
index 0000000..f7c999a
--- /dev/null
+++ b/inst/include/xtensor-blas/xblas_utils.hpp
@@ -0,0 +1,183 @@
+/***************************************************************************
+* Copyright (c) 2016, Wolf Vollprecht, Johan Mabille and Sylvain Corlay    *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#ifndef XBLAS_UTILS_HPP
+#define XBLAS_UTILS_HPP
+
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+
+#include "xtensor-blas/xblas_config.hpp"
+#include "xflens/cxxblas/typedefs.h"
+#include "xtensor/xutils.hpp"
+
+#ifndef DEFAULT_LEADING_STRIDE_BEHAVIOR
+#define DEFAULT_LEADING_STRIDE_BEHAVIOR throw std::runtime_error("No valid layout chosen.");
+#endif
+
+#ifndef DEFAULT_STORAGE_ORDER_BEHAVIOR
+#define DEFAULT_STORAGE_ORDER_BEHAVIOR throw std::runtime_error("Cannot handle layout_type of e.");
+#endif
+
+namespace xt
+{
+    template <layout_type L = layout_type::row_major, class T>
+    inline auto view_eval(T&& t)
+        -> std::enable_if_t<has_data_interface<std::decay_t<T>>::value && std::decay_t<T>::static_layout == L, T&&>
+    {
+        return std::forward<T>(t);
+    }
+
+    namespace detail
+    {
+        constexpr layout_type layout_remove_any(const layout_type layout)
+        {
+            return layout == layout_type::any ? XTENSOR_DEFAULT_LAYOUT : layout;
+        }
+    }
+
+    template <layout_type L = layout_type::row_major, class T, class I = std::decay_t<T>>
+    inline auto view_eval(T&& t)
+        -> std::enable_if_t<(!has_data_interface<std::decay_t<T>>::value || I::static_layout != L)
+                            && detail::is_array<typename I::shape_type>::value,
+                            xtensor<typename I::value_type,
+                                    std::tuple_size<typename I::shape_type>::value,
+                                    detail::layout_remove_any(L)>>
+    {
+        return t;
+    }
+
+    template <layout_type L = layout_type::row_major, class T, class I = std::decay_t<T>>
+    inline auto view_eval(T&& t)
+        -> std::enable_if_t<(!has_data_interface<std::decay_t<T>>::value || I::static_layout != L) &&
+                            !detail::is_array<typename I::shape_type>::value,
+                            xarray<typename I::value_type, detail::layout_remove_any(L)>>
+    {
+        return t;
+    }
+
+    template <layout_type L = layout_type::row_major, class T>
+    inline auto copy_to_layout(T&& t)
+        -> std::enable_if_t<std::decay_t<T>::static_layout == L, T>
+    {
+        return t;
+    }
+
+    template <layout_type L = layout_type::row_major, class T, class I = std::decay_t<T>>
+    inline auto copy_to_layout(T&& t)
+        -> std::enable_if_t<std::decay_t<T>::static_layout != L && detail::is_array<typename I::shape_type>::value,
+                            xtensor<typename I::value_type, std::tuple_size<typename I::shape_type>::value, L>>
+    {
+        return t;
+    }
+
+    template <layout_type L = layout_type::row_major, class T, class I = std::decay_t<T>>
+    inline auto copy_to_layout(T&& t)
+        -> std::enable_if_t<std::decay_t<T>::static_layout != L && !detail::is_array<typename I::shape_type>::value,
+                            xarray<typename I::value_type, L>>
+    {
+        return t;
+    }
+
+    template <class E>
+    inline cxxblas::StorageOrder get_blas_storage_order(const E& e)
+    {
+        if (e.layout() == layout_type::row_major)
+        {
+            return cxxblas::StorageOrder::RowMajor;
+        }
+        else if (e.layout() == layout_type::column_major)
+        {
+            return cxxblas::StorageOrder::ColMajor;
+        }
+        DEFAULT_STORAGE_ORDER_BEHAVIOR;
+    }
+
+    /**
+     * Get leading stride
+     */
+
+    template <class A, std::enable_if_t<A::static_layout == layout_type::row_major>* = nullptr>
+    inline BLAS_IDX get_leading_stride(const A& a)
+    {
+        return static_cast<BLAS_IDX>(a.strides().front() == 0 ? a.shape().back() : a.strides().front());
+    }
+
+    template <class A, std::enable_if_t<A::static_layout == layout_type::column_major>* = nullptr>
+    inline BLAS_IDX get_leading_stride(const A& a)
+    {
+        return static_cast<BLAS_IDX>(a.strides().back() == 0 ? a.shape().front() : a.strides().back());
+    }
+
+    template <class A, std::enable_if_t<A::static_layout != layout_type::row_major && A::static_layout != layout_type::column_major>* = nullptr>
+    inline BLAS_IDX get_leading_stride(const A& a)
+    {
+        if (a.layout() == layout_type::row_major)
+        {
+            return static_cast<BLAS_IDX>(a.strides().front() == 0 ? a.shape().back() : a.strides().front());
+        }
+        else if (a.layout() == layout_type::column_major)
+        {
+            return static_cast<BLAS_IDX>(a.strides().back() == 0 ? a.shape().front() : a.strides().back());
+        }
+        DEFAULT_LEADING_STRIDE_BEHAVIOR;
+    }
+
+    /********************
+     * Get front stride *
+     ********************/
+
+    template <class E>
+    inline blas_index_t stride_front(const E& e)
+    {
+        if (E::static_layout == layout_type::column_major)
+        {
+            return blas_index_t(1);
+        }
+        else
+        {
+            return static_cast<blas_index_t>(e.strides().front() == 0 ? 1 : e.strides().front());
+        }
+    }
+
+    /*******************
+     * Get back stride *
+     *******************/
+
+    template <class E>
+    inline blas_index_t stride_back(const E& e)
+    {
+        if (E::static_layout == layout_type::row_major)
+        {
+            return blas_index_t(1);
+        }
+        else
+        {
+            return static_cast<blas_index_t>(e.strides().back() == 0 ? 1 : e.strides().back());
+        }
+    }
+
+    /*******************************
+     * is_xfunction implementation *
+     *******************************/
+
+    namespace detail
+    {
+        template<class xF, class xR, class fE, class... xE>
+        std::true_type  is_xfunction_impl(const xfunction<xF, xR, fE, xE...>&);
+
+        std::false_type is_xfunction_impl(...);
+    }
+
+    template<typename T>
+    constexpr bool is_xfunction(T&& t) {
+        return decltype(detail::is_xfunction_impl(t))::value;
+    }
+}
+#endif
diff --git a/inst/include/xtensor-blas/xlapack.hpp b/inst/include/xtensor-blas/xlapack.hpp
new file mode 100644
index 0000000..e7a0be4
--- /dev/null
+++ b/inst/include/xtensor-blas/xlapack.hpp
@@ -0,0 +1,812 @@
+/***************************************************************************
+* Copyright (c) 2016, Wolf Vollprecht, Johan Mabille and Sylvain Corlay    *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#ifndef XLAPACK_HPP
+#define XLAPACK_HPP
+
+#include <algorithm>
+
+#include "xtl/xcomplex.hpp"
+
+#include "xtensor/xarray.hpp"
+#include "xtensor/xcomplex.hpp"
+#include "xtensor/xio.hpp"
+#include "xtensor/xstorage.hpp"
+#include "xtensor/xtensor.hpp"
+#include "xtensor/xutils.hpp"
+
+#include "xflens/cxxlapack/cxxlapack.cxx"
+
+#include "xtensor-blas/xblas_config.hpp"
+#include "xtensor-blas/xblas_utils.hpp"
+
+namespace xt
+{
+
+namespace lapack
+{
+    /**
+     * Interface to LAPACK gesv.
+     */
+    template <class E, class F>
+    int gesv(E& A, F& b)
+    {
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+        XTENSOR_ASSERT(b.dimension() <= 2);
+        XTENSOR_ASSERT(b.layout() == layout_type::column_major);
+
+        uvector<blas_index_t> piv(A.shape()[0]);
+
+        blas_index_t b_dim = b.dimension() > 1 ? static_cast<blas_index_t>(b.shape().back()) : 1;
+        blas_index_t b_stride = b_dim == 1 ? static_cast<blas_index_t>(b.shape().front()) : stride_back(b);
+
+        int info = cxxlapack::gesv<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            b_dim,
+            A.data(),
+            stride_back(A),
+            piv.data(),
+            b.data(),
+            b_stride
+        );
+
+        return info;
+    }
+
+    template <class E, class F>
+    auto getrf(E& A, F& piv)
+    {
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        int info = cxxlapack::getrf<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            A.data(),
+            stride_back(A),
+            piv.data()
+        );
+
+        return info;
+    }
+
+    template <class E, class T>
+    inline auto orgqr(E& A, T& tau, blas_index_t n = -1)
+    {
+        using value_type = typename E::value_type;
+
+        uvector<value_type> work(1);
+
+        if (n == -1)
+        {
+            n = static_cast<blas_index_t>(A.shape()[1]);
+        }
+
+        int info = cxxlapack::orgqr<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            n,
+            static_cast<blas_index_t>(tau.size()),
+            A.data(),
+            stride_back(A),
+            tau.data(),
+            work.data(),
+            static_cast<blas_index_t>(-1)
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for orgqr.");
+        }
+
+        work.resize((std::size_t) work[0]);
+
+        info = cxxlapack::orgqr<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            n,
+            static_cast<blas_index_t>(tau.size()),
+            A.data(),
+            stride_back(A),
+            tau.data(),
+            work.data(),
+            static_cast<blas_index_t>(work.size())
+        );
+
+        return info;
+    }
+
+    template <class E, class T>
+    inline auto ungqr(E& A, T& tau, blas_index_t n = -1)
+    {
+        using value_type = typename E::value_type;
+
+        uvector<value_type> work(1);
+
+        if (n == -1)
+        {
+            n = static_cast<blas_index_t>(A.shape()[1]);
+        }
+
+        int info = cxxlapack::ungqr<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            n,
+            static_cast<blas_index_t>(tau.size()),
+            A.data(),
+            stride_back(A),
+            tau.data(),
+            work.data(),
+            static_cast<blas_index_t>(-1)
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for ungqr.");
+        }
+
+        work.resize((std::size_t) std::real(work[0]));
+
+        info = cxxlapack::ungqr<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            n,
+            static_cast<blas_index_t>(tau.size()),
+            A.data(),
+            stride_back(A),
+            tau.data(),
+            work.data(),
+            static_cast<blas_index_t>(work.size())
+        );
+
+        return info;
+    }
+
+    template <class E, class T>
+    int geqrf(E& A, T& tau)
+    {
+        using value_type = typename E::value_type;
+
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        uvector<value_type> work(1);
+
+        int info = cxxlapack::geqrf<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            A.data(),
+            stride_back(A),
+            tau.data(),
+            work.data(),
+            static_cast<blas_index_t>(-1)
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for geqrf.");
+        }
+
+        work.resize((std::size_t) std::real(work[0]));
+
+        info = cxxlapack::geqrf<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            A.data(),
+            stride_back(A),
+            tau.data(),
+            work.data(),
+            static_cast<blas_index_t>(work.size())
+        );
+
+        return info;
+    }
+
+    namespace detail
+    {
+        template <class U, class VT>
+        inline auto init_u_vt(U& u, VT& vt, char jobz, std::size_t m, std::size_t n)
+        {
+            // rules for sgesdd
+            // u:
+            //   if jobz == 'O' and M >= N, u is not referenced
+            //   if jobz == 'N', u is also not referenced
+            // vt:
+            //   if jobz == 'O' and M < N vt is not referenced
+            //   if jobz == 'N', vt is also not referenced
+            if (jobz == 'A' || (jobz == 'O' && m < n))
+            {
+                u.resize({m, m});
+            }
+            if (jobz == 'A' || (jobz == 'O' && m >= n))
+            {
+                vt.resize({n, n});
+            }
+            if (jobz == 'S')
+            {
+                u.resize({m, std::min(m, n)});
+                vt.resize({std::min(m, n), n});
+            }
+            if (jobz == 'N')
+            {
+                // u AND vt are unreferenced -- can't use strides().back()...
+                return std::make_pair(1, 1);
+            }
+            if (jobz == 'O')
+            {
+                // u OR vt are unreferenced -- can't use strides().back()...
+                return m >= n ? std::make_pair(1, stride_back(vt)) :
+                                std::make_pair(stride_back(u), 1);
+            }
+            return std::make_pair(stride_back(u), stride_back(vt));
+        }
+    }
+
+    template <class E, std::enable_if_t<!xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto gesdd(E& A, char jobz = 'A')
+    {
+        using value_type = typename E::value_type;
+        using xtype1 = xtensor<value_type, 1, layout_type::column_major>;
+        using xtype2 = xtensor<value_type, 2, layout_type::column_major>;
+
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        uvector<value_type> work(1);
+
+        std::size_t m = A.shape()[0];
+        std::size_t n = A.shape()[1];
+
+        xtype1 s;
+        s.resize({ std::max(std::size_t(1), std::min(m, n)) });
+
+        xtype2 u, vt;
+    
+        blas_index_t u_stride, vt_stride;
+        std::tie(u_stride, vt_stride) = detail::init_u_vt(u, vt, jobz, m, n);
+
+        uvector<blas_index_t> iwork(8 * std::min(m, n));
+
+        int info = cxxlapack::gesdd<blas_index_t>(
+            jobz,
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            A.data(),
+            stride_back(A),
+            s.data(),
+            u.data(),
+            u_stride,
+            vt.data(),
+            vt_stride,
+            work.data(),
+            static_cast<blas_index_t>(-1),
+            iwork.data()
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for real gesdd.");
+        }
+
+        work.resize((std::size_t) work[0]);
+
+        info = cxxlapack::gesdd<blas_index_t>(
+            jobz,
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            A.data(),
+            stride_back(A),
+            s.data(),
+            u.data(),
+            u_stride,
+            vt.data(),
+            vt_stride,
+            work.data(),
+            static_cast<blas_index_t>(work.size()),
+            iwork.data()
+        );
+
+        return std::make_tuple(std::move(info), std::move(u), std::move(s), std::move(vt));
+    }
+
+    // Complex variant of gesdd
+    template <class E, std::enable_if_t<xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto gesdd(E& A, char jobz = 'A')
+    {
+        using value_type = typename E::value_type;
+        using underlying_value_type = typename value_type::value_type;
+        using xtype1 = xtensor<underlying_value_type, 1, layout_type::column_major>;
+        using xtype2 = xtensor<value_type, 2, layout_type::column_major>;
+
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        std::size_t m = A.shape()[0];
+        std::size_t n = A.shape()[1];
+
+        uvector<value_type> work(1);
+        uvector<underlying_value_type> rwork(1);
+        uvector<blas_index_t> iwork(8 * std::min(m, n));
+
+        std::size_t mx = std::max(m, n);
+        std::size_t mn = std::min(m, n);
+        if (jobz == 'N')
+        {
+            rwork.resize(5 * mn);
+        }
+        else if (mx > mn)
+        {
+            // TODO verify size
+            rwork.resize(5 * mn * mn + 5 * mn);
+        }
+        else
+        {
+            // TODO verify size
+            rwork.resize(std::max(5 * mn * mn + 5 * mn, 2 * mx * mn + 2 * mn * mn + mn));
+        }
+
+        xtype1 s;
+        s.resize({ std::max(std::size_t(1), std::min(m, n)) });
+
+        xtype2 u, vt;
+
+        blas_index_t u_stride, vt_stride;
+        std::tie(u_stride, vt_stride) = detail::init_u_vt(u, vt, jobz, m, n);
+
+        int info = cxxlapack::gesdd<blas_index_t>(
+            jobz,
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            A.data(),
+            stride_back(A),
+            s.data(),
+            u.data(),
+            u_stride,
+            vt.data(),
+            vt_stride,
+            work.data(),
+            static_cast<blas_index_t>(-1),
+            rwork.data(),
+            iwork.data()
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for complex gesdd.");
+        }
+        work.resize((std::size_t) std::real(work[0]));
+
+        info = cxxlapack::gesdd<blas_index_t>(
+            jobz,
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            A.data(),
+            stride_back(A),
+            s.data(),
+            u.data(),
+            u_stride,
+            vt.data(),
+            vt_stride,
+            work.data(),
+            static_cast<blas_index_t>(work.size()),
+            rwork.data(),
+            iwork.data()
+        );
+
+        return std::make_tuple(std::move(info), std::move(u), std::move(s), std::move(vt));
+    }
+
+
+    template <class E>
+    int potr(E& A, char uplo = 'L')
+    {
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        int info = cxxlapack::potrf<blas_index_t>(
+            uplo,
+            static_cast<blas_index_t>(A.shape()[0]),
+            A.data(),
+            stride_back(A)
+        );
+
+        return info;
+    }
+
+    /**
+     * Interface to LAPACK getri.
+     *
+     * @param A matrix to invert
+     * @return inverse of A
+     */
+    template <class E>
+    int getri(E& A, uvector<blas_index_t>& piv)
+    {
+        using value_type = typename E::value_type;
+
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        uvector<value_type> work(1);
+
+        // get work size
+        int info = cxxlapack::getri<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            A.data(),
+            stride_back(A),
+            piv.data(),
+            work.data(),
+            static_cast<blas_index_t>(-1)
+        );
+
+        if (info > 0)
+        {
+            throw std::runtime_error("Could not find workspace size for getri.");
+        }
+
+        work.resize(std::size_t(std::real(work[0])));
+
+        info = cxxlapack::getri<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            A.data(),
+            stride_back(A),
+            piv.data(),
+            work.data(),
+            static_cast<blas_index_t>(work.size())
+        );
+
+        return info;
+    }
+
+    /**
+     * Interface to LAPACK geev.
+     * @returns info
+     */
+    template <class E, class W, class V>
+    int geev(E& A, char jobvl, char jobvr, W& wr, W& wi, V& VL, V& VR)
+    {
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        using value_type = typename E::value_type;
+        using xtype = xtensor<value_type, 2, layout_type::column_major>;
+
+        const auto N = A.shape()[0];
+        uvector<value_type> work(1);
+
+        int info = cxxlapack::geev<blas_index_t>(
+            jobvl,
+            jobvr,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            wr.data(),
+            wi.data(),
+            VL.data(),
+            stride_back(VL),
+            VR.data(),
+            stride_back(VR),
+            work.data(),
+            static_cast<blas_index_t>(-1)
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for geev.");
+        }
+
+        work.resize(std::size_t(work[0]));
+
+        info = cxxlapack::geev<blas_index_t>(
+            jobvl,
+            jobvr,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            wr.data(),
+            wi.data(),
+            VL.data(),
+            stride_back(VL),
+            VR.data(),
+            stride_back(VR),
+            work.data(),
+            static_cast<blas_index_t>(work.size())
+        );
+
+        return info;
+    }
+
+    /**
+     * Interface to LAPACK syevd.
+     * @returns info
+     */
+    template <class E, class W>
+    int syevd(E& A, char jobz, char uplo, W& w)
+    {
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        using value_type = typename E::value_type;
+        using xtype = xtensor<value_type, 2, layout_type::column_major>;
+
+        auto N = A.shape()[0];
+        uvector<value_type> work(1);
+        uvector<blas_index_t> iwork(1);
+
+        int info = cxxlapack::syevd<blas_index_t>(
+            jobz,
+            uplo,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            w.data(),
+            work.data(),
+            static_cast<blas_index_t>(-1),
+            iwork.data(),
+            static_cast<blas_index_t>(-1)
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for syevd.");
+        }
+
+        work.resize(std::size_t(work[0]));
+        iwork.resize(std::size_t(iwork[0]));
+
+        info = cxxlapack::syevd<blas_index_t>(
+            jobz,
+            uplo,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            w.data(),
+            work.data(),
+            static_cast<blas_index_t>(work.size()),
+            iwork.data(),
+            static_cast<blas_index_t>(iwork.size())
+        );
+
+        return info;
+    }
+
+    /**
+     * Complex version of geev
+     */
+    template <class E, class W, class V>
+    int geev(E& A, char jobvl, char jobvr, W& w, V& VL, V& VR)
+    {
+        // TODO implement for complex numbers
+
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        using value_type = typename E::value_type;
+        using underlying_value_type = typename value_type::value_type;
+        using xtype = xtensor<value_type, 2, layout_type::column_major>;
+
+        const auto N = A.shape()[0];
+        uvector<value_type> work(1);
+        uvector<underlying_value_type> rwork(2 * N);
+
+        int info = cxxlapack::geev<blas_index_t>(
+            jobvl,
+            jobvr,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            w.data(),
+            VL.data(),
+            stride_back(VL),
+            VR.data(),
+            stride_back(VR),
+            work.data(),
+            -1,
+            rwork.data()
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for geev.");
+        }
+
+        work.resize(std::size_t(std::real(work[0])));
+
+        info = cxxlapack::geev<blas_index_t>(
+            jobvl,
+            jobvr,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            w.data(),
+            VL.data(),
+            stride_back(VL),
+            VR.data(),
+            stride_back(VR),
+            work.data(),
+            static_cast<blas_index_t>(work.size()),
+            rwork.data()
+        );
+
+        return info;
+    }
+
+    template <class E, class W>
+    int heevd(E& A, char jobz, char uplo, W& w)
+    {
+        XTENSOR_ASSERT(A.dimension() == 2);
+        XTENSOR_ASSERT(A.layout() == layout_type::column_major);
+
+        using value_type = typename E::value_type;
+        using underlying_value_type = typename value_type::value_type;
+        using xtype = xtensor<value_type, 2, layout_type::column_major>;
+
+        auto N = A.shape()[0];
+        uvector<value_type> work(1);
+        uvector<underlying_value_type> rwork(1);
+        uvector<blas_index_t> iwork(1);
+
+        int info = cxxlapack::heevd<blas_index_t>(
+            jobz,
+            uplo,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            w.data(),
+            work.data(),
+            static_cast<blas_index_t>(-1),
+            rwork.data(),
+            static_cast<blas_index_t>(-1),
+            iwork.data(),
+            static_cast<blas_index_t>(-1)
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for heevd.");
+        }
+
+        work.resize(std::size_t(std::real(work[0])));
+        rwork.resize(std::size_t(rwork[0]));
+        iwork.resize(std::size_t(iwork[0]));
+
+        info = cxxlapack::heevd<blas_index_t>(
+            jobz,
+            uplo,
+            static_cast<blas_index_t>(N),
+            A.data(),
+            stride_back(A),
+            w.data(),
+            work.data(),
+            static_cast<blas_index_t>(work.size()),
+            rwork.data(),
+            static_cast<blas_index_t>(rwork.size()),
+            iwork.data(),
+            static_cast<blas_index_t>(iwork.size())
+        );
+
+        return info;
+    }
+
+    template <class E, class F, class S, std::enable_if_t<!xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    int gelsd(E& A, F& b, S& s, blas_index_t& rank, double rcond)
+    {
+        using value_type = typename E::value_type;
+
+        uvector<value_type> work(1);
+        uvector<blas_index_t> iwork(1);
+
+        blas_index_t b_dim = b.dimension() > 1 ? static_cast<blas_index_t>(b.shape().back()) : 1;
+
+        std::size_t m = A.shape()[0];
+        std::size_t n = A.shape()[1];
+
+        blas_index_t b_stride = (blas_index_t) std::max(std::max(std::size_t(1), m), n);
+
+        int info = cxxlapack::gelsd<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            b_dim,
+            A.data(),
+            stride_back(A),
+            b.data(),
+            b_stride,
+            s.data(),
+            rcond,
+            rank,
+            work.data(),
+            static_cast<blas_index_t>(-1),
+            iwork.data()
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for gelsd.");
+        }
+
+        work.resize(std::size_t(work[0]));
+        iwork.resize(std::size_t(iwork[0]));
+
+        info = cxxlapack::gelsd<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            b_dim,
+            A.data(),
+            stride_back(A),
+            b.data(),
+            b_stride,
+            s.data(),
+            rcond,
+            rank,
+            work.data(),
+            static_cast<blas_index_t>(work.size()),
+            iwork.data()
+        );
+
+        return info;
+    }
+
+    template <class E, class F, class S, std::enable_if_t<xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    int gelsd(E& A, F& b, S& s, blas_index_t& rank, double rcond = -1)
+    {
+        using value_type = typename E::value_type;
+        using underlying_value_type = typename value_type::value_type;
+
+        uvector<value_type> work(1);
+        uvector<underlying_value_type> rwork(1);
+        uvector<blas_index_t> iwork(1);
+
+        blas_index_t b_dim = b.dimension() > 1 ? static_cast<blas_index_t>(b.shape().back()) : 1;
+        blas_index_t b_stride = b_dim == 1 ? static_cast<blas_index_t>(b.shape().front()) : stride_back(b);
+
+        int info = cxxlapack::gelsd<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            b_dim,
+            A.data(),
+            stride_back(A),
+            b.data(),
+            b_stride,
+            s.data(),
+            rcond,
+            rank,
+            work.data(),
+            static_cast<blas_index_t>(-1),
+            rwork.data(),
+            iwork.data()
+        );
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Could not find workspace size for gelsd.");
+        }
+
+        work.resize(std::size_t(std::real(work[0])));
+        rwork.resize(std::size_t(rwork[0]));
+        iwork.resize(std::size_t(iwork[0]));
+
+        info = cxxlapack::gelsd<blas_index_t>(
+            static_cast<blas_index_t>(A.shape()[0]),
+            static_cast<blas_index_t>(A.shape()[1]),
+            b_dim,
+            A.data(),
+            stride_back(A),
+            b.data(),
+            b_stride,
+            s.data(),
+            rcond,
+            rank,
+            work.data(),
+            static_cast<blas_index_t>(work.size()),
+            rwork.data(),
+            iwork.data()
+        );
+
+        return info;
+    }
+}
+
+}
+#endif
diff --git a/inst/include/xtensor-blas/xlinalg.hpp b/inst/include/xtensor-blas/xlinalg.hpp
new file mode 100644
index 0000000..fb56a1d
--- /dev/null
+++ b/inst/include/xtensor-blas/xlinalg.hpp
@@ -0,0 +1,1715 @@
+/***************************************************************************
+* Copyright (c) 2016, Wolf Vollprecht, Johan Mabille and Sylvain Corlay    *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#ifndef XLINALG_HPP
+#define XLINALG_HPP
+
+#include <algorithm>
+#include <limits>
+#include <sstream>
+#include <chrono>
+
+#include "xtl/xcomplex.hpp"
+
+#include "xtensor/xarray.hpp"
+#include "xtensor/xcomplex.hpp"
+#include "xtensor/xeval.hpp"
+#include "xtensor/xio.hpp"
+#include "xtensor/xstrided_view.hpp"
+#include "xtensor/xtensor.hpp"
+#include "xtensor/xutils.hpp"
+#include "xtensor/xview.hpp"
+
+#include "xtensor-blas/xblas.hpp"
+#include "xtensor-blas/xlapack.hpp"
+#include "xtensor-blas/xblas_utils.hpp"
+
+namespace xt
+{
+namespace linalg
+{
+
+    /// Selects special norm orders
+    enum class normorder {
+        frob,    ///< Frobenius norm
+        nuc,     ///< Nuclear norm
+        inf,     ///< Positive infinity norm
+        neg_inf  ///< Negative infinity norm
+    };
+
+    /**
+     * Calculate norm of vector, or matrix
+     *
+     * @param vec input vector
+     * @param ord order of norm. This can be any integer for a vector
+     *            or [-2,-1,1,2] for a matrix.
+     * @return scalar result
+     *
+     * @tparam type of xexpression
+     */
+    template <class E>
+    auto norm(const xexpression<E>& vec, int ord)
+    {
+        using value_type = typename E::value_type;
+        using underlying_value_type = xtl::complex_value_type_t<value_type>;
+
+        const auto& v = vec.derived_cast();
+
+        underlying_value_type result = 0;
+        if (v.dimension() == 1)
+        {
+            if (ord == 1)
+            {
+                if (xtl::is_complex<value_type>::value)
+                {
+                    for (std::size_t i = 0; i < v.size(); ++i)
+                    {
+                        result += std::abs(v(i));
+                    }
+                }
+                else
+                {
+                    blas::asum(v, result);
+                }
+            }
+            else if (ord == 2)
+            {
+                blas::nrm2(v, result);
+            }
+            else if (ord == 0)
+            {
+                for (std::size_t i = 0; i < v.size(); ++i)
+                {
+                    result += (v(i) != underlying_value_type(0));
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < v.size(); ++i)
+                {
+                    result += std::abs(std::pow(v(i), ord));
+                }
+                result = std::pow(result, 1./ (double) ord);
+            }
+            return result;
+        }
+        else if (v.dimension() == 2)
+        {
+            if (ord == 1 || ord == -1)
+            {
+                xtensor<underlying_value_type, 1> s = sum(abs(v), {0});
+                if (ord == 1)
+                {
+                    return *std::max_element(s.begin(), s.end());
+                }
+                else
+                {
+                    return *std::min_element(s.begin(), s.end());
+                }
+            }
+            if (ord == 2 || ord == -2)
+            {
+                auto M = copy_to_layout<layout_type::column_major>(v);
+                auto gesdd_res = lapack::gesdd(M, 'N');
+                auto& s = std::get<2>(gesdd_res);
+                if (ord == 2)
+                {
+                    return *std::max_element(s.begin(), s.end());
+                }
+                else
+                {
+                    return *std::min_element(s.begin(), s.end());
+                }
+            }
+        }
+        std::stringstream ss;
+        ss << "Norm " << ord << " not implemented!" << std::endl;
+        throw std::runtime_error(ss.str());
+    }
+
+    /**
+     * Calculate matrix or vector norm using \ref normorder.
+     *
+     * @param vec The matrix or vector to take the norm of
+     * @param ord normorder (frob, nuc, inf, neg_inf)
+     *
+     * @return norm value
+     */
+    template <class E>
+    auto norm(const xexpression<E>& vec, normorder ord)
+    {
+        using value_type = xtl::complex_value_type_t<typename E::value_type>;
+
+        const auto& v = vec.derived_cast();
+        if (v.dimension() == 2)
+        {
+            if (ord == normorder::frob)
+            {
+                return std::sqrt(sum(pow(abs(v), 2))());
+            }
+            if (ord == normorder::nuc)
+            {
+                auto M = copy_to_layout<layout_type::column_major>(v);
+                auto gesdd_res = lapack::gesdd(M, 'N');
+                auto& s = std::get<2>(gesdd_res);
+                return std::accumulate(s.begin(), s.end(), value_type(0));
+            }
+            if (ord == normorder::inf || ord == normorder::neg_inf)
+            {
+                xtensor<value_type, 1> s = xt::sum(abs(v), {1});
+                if (ord == normorder::inf)
+                {
+                    return *std::max_element(s.begin(), s.end());
+                }
+                else
+                {
+                    return *std::min_element(s.begin(), s.end());
+                }
+            }
+        }
+        else if (v.dimension() == 1)
+        {
+            if (ord == normorder::inf || ord == normorder::neg_inf)
+            {
+                auto s = abs(v);
+                if (ord == normorder::inf)
+                {
+                    return *std::max_element(s.begin(), s.end());
+                }
+                else
+                {
+                    return *std::min_element(s.begin(), s.end());
+                }
+            }
+        }
+        std::stringstream ss;
+        ss << "Norm not implemented!" << std::endl;
+        throw std::runtime_error(ss.str());
+    }
+
+    /**
+     * Calculate default norm (2-norm for vector, Frobenius norm for matrix)
+     *
+     * @param vec Input vector or matrix
+     * @return norm
+     */
+    template <class E>
+    typename E::value_type norm(const xexpression<E>& vec)
+    {
+        const auto& v = vec.derived_cast();
+        if (v.dimension() == 1)
+        {
+            return norm(vec, 2);
+        }
+        else
+        {
+            return norm(vec, normorder::frob);
+        }
+    }
+
+    /**
+     * Solve a linear matrix equation, or system of linear scalar equations.
+     * Computes the “exact” solution, x, of the well-determined, i.e., full rank,
+     * linear matrix equation ax = b.
+     *
+     * @param a Coefficient matrix
+     * @param b Ordinate or “dependent variable” values.
+     * @return Solution to the system a x = b. Returned shape is identical to b.
+     */
+    template <class E1, class E2>
+    auto solve(const xexpression<E1>& A, const xexpression<E2>& b)
+    {
+        auto dA = copy_to_layout<layout_type::column_major>(A.derived_cast());
+        auto db = copy_to_layout<layout_type::column_major>(b.derived_cast());
+
+        int info = lapack::gesv(dA, db);
+
+        if (info != 0)
+        {
+            throw std::runtime_error("The solution could not be computed");
+        }
+
+        return db;
+    }
+
+    /**
+     * Compute the (multiplicative) inverse of a matrix.
+     *
+     * @param A xexpression to be inverted
+     * @return (Multiplicative) inverse of the matrix a.
+     */
+    template <class E1>
+    auto inv(const xexpression<E1>& A)
+    {
+        auto dA = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        uvector<blas_index_t> piv(std::min(dA.shape()[0], dA.shape()[1]));
+
+        // DEV note: numpy uses gesv here, instead of getrf and getri. Might
+        //           be interesting to investigate if there is a perf or accuracy
+        //           difference.
+        int info = lapack::getrf(dA, piv);
+        if (info > 0)
+        {
+            throw std::runtime_error("Singular matrix not invertible (getrf).");
+        }
+
+        info = lapack::getri(dA, piv);
+        if (info > 0)
+        {
+            throw std::runtime_error("Singular matrix not invertible (getri).");
+        }
+        return dA;
+    }
+
+    /**
+     * Calculate the condition number of matrix M
+     */
+    template <class E>
+    auto cond(const xexpression<E>& M, int ord)
+    {
+        return norm(M, ord) * norm(inv(M), ord);
+    }
+
+    template <class E>
+    auto cond(const xexpression<E>& M, normorder ord)
+    {
+        return norm(M, ord) * norm(inv(M), ord);
+    }
+
+    /**
+     * Compute the eigenvalues and right eigenvectors of a square array.
+     *
+     * @param Matrix for which the eigenvalues and right eigenvectors will be computed
+     * @return (eigenvalues, eigenvectors) tuple. The first element corresponds to the eigenvalues,
+     *         each repeated according to its multiplicity. The eigenvalues are not necessarily
+     *         ordered. The second (1) element are the normalized (unit “length”) eigenvectors,
+     *         such that the column v[:, i] corresponds to the eigenvalue w[i].
+     */
+    template <class E, std::enable_if_t<!xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eig(const xexpression<E>& A)
+    {
+        using underlying_type = typename E::value_type;
+        using value_type = typename E::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<value_type, 1, layout_type::column_major> wr(vN), wi(vN);
+
+        std::array<std::size_t, 2> shp = {N, N};
+        xtensor<value_type, 2, layout_type::column_major> VL(shp), VR(shp);
+
+        // jobvl N: left eigenvectors of A are not computed
+        // jobvr V: then right eigenvectors of A are computed
+        int info = lapack::geev(M, 'N', 'V', wr, wi, VL, VR);
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Eigenvalue calculation did not converge.");
+        }
+
+        auto eig_vecs = xtensor<std::complex<underlying_type>, 2>::from_shape({ N, N });
+        auto eig_vals = xtensor<std::complex<underlying_type>, 1>::from_shape({ N });
+
+        xt::real(eig_vals) = wr;
+        xt::imag(eig_vals) = wi;
+
+        for (std::size_t i = 0; i < N; ++i)
+        {
+            for (std::size_t j = 0; j < N; ++j)
+            {
+                if (wi(j) != 0)
+                {
+                    eig_vecs(i, j)     = std::complex<underlying_type>(VR(i, j),  VR(i, j + 1));
+                    eig_vecs(i, j + 1) = std::complex<underlying_type>(VR(i, j), -VR(i, j + 1));
+                    ++j;
+                }
+                else
+                {
+                    eig_vecs(i, j) = std::complex<underlying_type>(VR(i, j), 0);
+                }
+            }
+        }
+
+        return std::make_tuple(std::move(eig_vals), std::move(eig_vecs));
+    }
+
+    template <class E, std::enable_if_t<xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eig(const xexpression<E>& A)
+    {
+        using value_type = typename E::value_type;
+        using underlying_type = typename value_type::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<value_type, 1, layout_type::column_major> w(vN);
+
+        std::array<std::size_t, 2> shp({N, N});
+        xtensor<value_type, 2, layout_type::column_major> VL(shp), VR(shp);
+
+        // jobvl N: left eigenvectors of A are not computed
+        // jobvr V: then right eigenvectors of A are computed
+        int info = lapack::geev(M, 'N', 'V', w, VL, VR);
+
+        if (info != 0)
+        {
+            throw std::runtime_error("Eigenvalue calculation did not converge.");
+        }
+
+        return std::make_tuple(std::move(w), std::move(VR));
+    }
+
+    /**
+     * Compute the eigenvalues and eigenvectors of a square Hermitian or real symmetric xexpression.
+     *
+     * @param A Matrix for which the eigenvalues and right eigenvectors are computed
+     * @return xtensor containing the eigenvalues.
+     */
+    template <class E, std::enable_if_t<!xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eigh(const xexpression<E>& A, char UPLO = 'L')
+    {
+        using value_type = typename E::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<value_type, 1, layout_type::column_major> w(vN);
+
+        int info = lapack::syevd(M, 'V', UPLO, w);
+        if (info != 0)
+        {
+            throw std::runtime_error("Eigenvalue computation did not converge.");
+        }
+
+        return std::make_tuple(std::move(w), std::move(M));
+    }
+
+    template <class E, std::enable_if_t<xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eigh(const xexpression<E>& A, char UPLO = 'L')
+    {
+        using value_type = typename E::value_type;
+        using underlying_value_type = typename value_type::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<underlying_value_type, 1, layout_type::column_major> w(vN);
+
+        int info = lapack::heevd(M, 'V', UPLO, w);
+        if (info != 0)
+        {
+            throw std::runtime_error("Eigenvalue computation did not converge.");
+        }
+
+        return std::make_tuple(std::move(w), std::move(M));
+    }
+
+    /**
+     * Compute the eigenvalues of a square xexpression.
+     *
+     * @param A Matrix for which the eigenvalues are computed
+     * @return xtensor containing the eigenvalues.
+     */
+    template <class E, std::enable_if_t<!xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eigvals(const xexpression<E>& A)
+    {
+        using value_type = typename E::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<value_type, 1, layout_type::column_major> wr(vN);
+        xtensor<value_type, 1, layout_type::column_major> wi(vN);
+
+        // TODO check if we can remove allocation and pass nullptr as VL / VR
+        std::array<std::size_t, 2> shp({N, N});
+        xtensor<value_type, 2, layout_type::column_major> VL(shp);
+        xtensor<value_type, 2, layout_type::column_major> VR(shp);
+
+        auto geev_res = lapack::geev(M, 'N', 'N', wr, wi, VL, VR);
+
+        xtensor<std::complex<value_type>, 1> eig_vals;
+        eig_vals.resize({N});
+
+        xt::real(eig_vals) = wr;
+        xt::imag(eig_vals) = wi;
+
+        return eig_vals;
+    }
+
+    template <class E, std::enable_if_t<xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eigvals(const xexpression<E>& A)
+    {
+        using value_type = typename E::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<value_type, 1, layout_type::column_major> w(vN);
+
+        // TODO check if we can remove allocation and pass nullptr as VL / VR
+        std::array<std::size_t, 2> shp({N, N});
+        xtensor<value_type, 2, layout_type::column_major> VL(shp);
+        xtensor<value_type, 2, layout_type::column_major> VR(shp);
+
+        auto geev_res = lapack::geev(M, 'N', 'N', w, VL, VR);
+
+        using value_type = typename E::value_type;
+
+        return w;
+    }
+
+    /**
+     * Compute the eigenvalues of a Hermitian or real symmetric matrix xexpression.
+     *
+     * @param Matrix for which the eigenvalues are computed
+     * @return xtensor containing the eigenvalues.
+     */
+    template <class E, std::enable_if_t<!xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eigvalsh(const xexpression<E>& A, char UPLO = 'L')
+    {
+        using value_type = typename E::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<value_type, 1, layout_type::column_major> w(vN);
+
+        int info = lapack::syevd(M, 'N', UPLO, w);
+        if (info != 0)
+        {
+            throw std::runtime_error("Eigenvalue computation did not converge.");
+        }
+
+        return w;
+    }
+
+    template <class E, std::enable_if_t<xtl::is_complex<typename E::value_type>::value>* = nullptr>
+    auto eigvalsh(const xexpression<E>& A, char UPLO = 'L')
+    {
+        using value_type = typename E::value_type;
+        using underlying_value_type = typename value_type::value_type;
+
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        std::size_t N = M.shape()[0];
+        std::array<std::size_t, 1> vN = {N};
+        xtensor<underlying_value_type, 1, layout_type::column_major> w(vN);
+
+        int info = lapack::heevd(M, 'N', UPLO, w);
+        if (info != 0)
+        {
+            throw std::runtime_error("Eigenvalue computation did not converge.");
+        }
+
+        return w;
+    }
+
+    namespace detail
+    {
+        template <class A>
+        struct offset_iter_without_axis
+        {
+
+            using shape_type = typename A::shape_type;
+            using size_type = typename A::size_type;
+            using index_type = xindex_type_t<shape_type>;
+
+            offset_iter_without_axis(const A& a, std::size_t axis)
+                : m_a(a), m_axis(axis)
+            {
+                resize_container(m_idx, a.dimension());
+                m_offset = 0;
+            }
+
+            inline bool next()
+            {
+                int dim = (int) m_a.dimension();
+                for (int i = dim - 1; i >= 0; --i)
+                {
+                    if (i == (int) m_axis)
+                    {
+                        // skip
+                    }
+                    else if (m_idx[i] == m_a.shape()[i] - 1)
+                    {
+                        m_offset -= m_idx[i] * m_a.strides()[i];
+                        m_idx[i] = 0;
+                        if (i == 0 || m_axis == 0 && i == 1)
+                        {
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        ++m_idx[i];
+                        m_offset += m_a.strides()[i];
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            inline size_type offset() const
+            {
+                return m_offset;
+            }
+
+        private:
+            const A& m_a;
+            index_type m_idx;
+            size_type m_axis;
+            size_type m_offset;
+        };
+    }
+
+    /**
+     * Non-broadcasting dot function.
+     * In the case of two 1D vectors, computes the vector dot
+     * product. In the case of complex vectors, computes the dot
+     * product without conjugating the first argument.
+     * If \em t or \em o is a 2D matrix, computes the matrix-times-vector
+     * product. If both \em t and \em o ar 2D matrices, computes
+     * the matrix-product.
+     *
+     * @param t input array
+     * @param o input array
+     *
+     * @return resulting array
+     */
+    template <class T, class O>
+    auto dot(const xexpression<T>& xt, const xexpression<O>& xo)
+    {
+        using value_type = std::common_type_t<typename T::value_type, typename O::value_type>;
+
+        using return_type = std::conditional_t<(T::static_layout == O::static_layout) &&
+                                               (T::static_layout != layout_type::dynamic && T::static_layout != layout_type::any),
+                                               xarray<value_type, T::static_layout>,
+                                               xarray<value_type, XTENSOR_DEFAULT_LAYOUT>>;
+        return_type result;
+
+        auto&& t = view_eval<T::static_layout>(xt.derived_cast());
+        auto&& o = view_eval<O::static_layout>(xo.derived_cast());
+
+        if (t.dimension() == 1 && o.dimension() == 1)
+        {
+            result.resize(std::vector<std::size_t>{1});
+            if (t.shape()[0] != o.shape()[0])
+            {
+                throw std::runtime_error("Dot: shape mismatch.");
+            }
+
+            if (xtl::is_complex<typename T::value_type>::value)
+            {
+                blas::dotu(t, o, result(0));
+            }
+            else
+            {
+                blas::dot(t, o, result(0));
+            }
+            return result;
+        }
+        else
+        {
+            if (t.dimension() == 2 && o.dimension() == 1)
+            {
+                XTENSOR_ASSERT(t.layout() == layout_type::row_major || t.layout() == layout_type::column_major);
+                XTENSOR_ASSERT(std::min(t.strides()[0], t.strides()[1]) <= 1);
+
+                if (t.shape()[1] != o.shape()[0])
+                {
+                    throw std::runtime_error("Dot: shape mismatch.");
+                }
+
+                result.resize({t.shape()[0]});
+
+                blas_index_t shape_x, shape_y;
+                cxxblas::Transpose trans;
+                if (result.layout() != t.layout())
+                {
+                    shape_x = static_cast<blas_index_t>(t.shape()[1]);
+                    shape_y = static_cast<blas_index_t>(t.shape()[0]);
+                    trans = cxxblas::Transpose::Trans;
+                }
+                else
+                {
+                    shape_x = static_cast<blas_index_t>(t.shape()[0]);
+                    shape_y = static_cast<blas_index_t>(t.shape()[1]);
+                    trans = cxxblas::Transpose::NoTrans;
+                }
+
+                cxxblas::gemv<blas_index_t>(
+                    get_blas_storage_order(result),
+                    trans,
+                    shape_x,
+                    shape_y,
+                    value_type(1.0),
+                    t.data() + t.data_offset(),
+                    get_leading_stride(t),
+                    o.data() + o.data_offset(),
+                    get_leading_stride(o),
+                    value_type(0.0),
+                    result.data(),
+                    get_leading_stride(result)
+                );
+            }
+            else if (t.dimension() == 1 && o.dimension() == 2)
+            {
+                XTENSOR_ASSERT(o.layout() == layout_type::row_major || o.layout() == layout_type::column_major);
+                XTENSOR_ASSERT(std::min(o.strides()[0], o.strides()[1]) <= 1);
+
+                if (t.shape()[0] != o.shape()[0])
+                {
+                    throw std::runtime_error("Dot: shape mismatch.");
+                }
+
+                result.resize({o.shape()[1]});
+
+                blas_index_t shape_x, shape_y;
+                cxxblas::Transpose trans;
+                if (result.layout() != o.layout())
+                {
+                    shape_x = static_cast<blas_index_t>(o.shape()[1]);
+                    shape_y = static_cast<blas_index_t>(o.shape()[0]);
+                    trans = cxxblas::Transpose::NoTrans;
+                }
+                else
+                {
+                    shape_x = static_cast<blas_index_t>(o.shape()[0]);
+                    shape_y = static_cast<blas_index_t>(o.shape()[1]);
+                    trans = cxxblas::Transpose::Trans;
+                }
+
+                cxxblas::gemv<blas_index_t>(
+                    get_blas_storage_order(result),
+                    trans,
+                    shape_x,
+                    shape_y,
+                    value_type(1.0),
+                    o.data() + o.data_offset(),
+                    get_leading_stride(o),
+                    t.data() + t.data_offset(),
+                    get_leading_stride(t),
+                    value_type(0.0),
+                    result.data(),
+                    get_leading_stride(result)
+                );
+            }
+            else if (t.dimension() == 2 && o.dimension() == 2)
+            {
+                XTENSOR_ASSERT(o.layout() == layout_type::row_major || o.layout() == layout_type::column_major);
+                XTENSOR_ASSERT(std::min(o.strides()[0], o.strides()[1]) <= 1);
+                XTENSOR_ASSERT(t.layout() == layout_type::row_major || t.layout() == layout_type::column_major);
+                XTENSOR_ASSERT(std::min(t.strides()[0], t.strides()[1]) <= 1);
+
+                if (t.shape()[1] != o.shape()[0])
+                {
+                    throw std::runtime_error("Dot: shape mismatch.");
+                }
+
+                cxxblas::Transpose transpose_A = cxxblas::Transpose::NoTrans,
+                                   transpose_B = cxxblas::Transpose::NoTrans;
+
+                if (result.layout() != t.layout())
+                {
+                    transpose_A = cxxblas::Transpose::Trans;
+                }
+                if (result.layout() != o.layout())
+                {
+                    transpose_B = cxxblas::Transpose::Trans;
+                }
+
+                // This adds a fast path for A * A' by calling SYRK and only computing
+                // the upper triangle
+                if (std::is_same<typename T::value_type, typename O::value_type>::value &&
+                    (static_cast<const void*>(t.data() + t.data_offset()) == static_cast<const void*>(o.data() + o.data_offset())) &&
+                    ((transpose_A == cxxblas::Transpose::Trans && transpose_B == cxxblas::Transpose::NoTrans) ||
+                     (transpose_A == cxxblas::Transpose::NoTrans && transpose_B == cxxblas::Transpose::Trans)))
+                {
+                    // TODO add check to compare strides & shape
+
+                    result.resize({t.shape()[0], t.shape()[0]});
+
+                    cxxblas::syrk<blas_index_t>(
+                        get_blas_storage_order(result),
+                        cxxblas::StorageUpLo::Upper,
+                        transpose_A,
+                        static_cast<blas_index_t>(t.shape()[0]),
+                        static_cast<blas_index_t>(t.shape()[1]),
+                        value_type(1.0),
+                        t.data() + t.data_offset(),
+                        get_leading_stride(t),
+                        value_type(0.0),
+                        result.data(),
+                        get_leading_stride(result)
+                    );
+
+                    for (std::size_t i = 0; i < t.shape()[0]; ++i)
+                    {
+                        for (std::size_t j = i + 1; j < t.shape()[0]; ++j)
+                        {
+                            result(j, i) = result(i, j);
+                        }
+                    }
+                    return result;
+                }
+
+                result.resize({t.shape()[0], o.shape()[1]});
+
+                cxxblas::gemm<blas_index_t>(
+                    get_blas_storage_order(result),
+                    transpose_A,
+                    transpose_B,
+                    static_cast<blas_index_t>(t.shape()[0]),
+                    static_cast<blas_index_t>(o.shape()[1]),
+                    static_cast<blas_index_t>(o.shape()[0]),
+                    value_type(1.0),
+                    t.data() + t.data_offset(),
+                    get_leading_stride(t),
+                    o.data() + o.data_offset(),
+                    get_leading_stride(o),
+                    value_type(0.0),
+                    result.data(),
+                    get_leading_stride(result)
+                );
+            }
+            else
+            {
+                // TODO more testing for different layouts!
+                std::size_t l = t.shape().back();
+                std::size_t match_dim = 0;
+
+                if (o.dimension() > 1)
+                {
+                    match_dim = o.dimension() - 2;
+                }
+                if (o.shape()[match_dim] != l)
+                {
+                    throw std::runtime_error("Dot: shape mismatch.");
+                }
+
+                blas_index_t a_dim = static_cast<blas_index_t>(t.dimension());
+                blas_index_t b_dim = static_cast<blas_index_t>(o.dimension());
+
+                blas_index_t nd = a_dim + b_dim - 2;
+
+                std::size_t j = 0;
+                std::vector<std::size_t> dimensions((std::size_t) nd);
+
+                for (blas_index_t i = 0; i < a_dim - 1; ++i)
+                {
+                    dimensions[j++] = t.shape()[i];
+                }
+                for (blas_index_t i = 0; i < b_dim - 2; ++i)
+                {
+                    dimensions[j++] = o.shape()[i];
+                }
+                if (b_dim > 1)
+                {
+                    dimensions[j++] = o.shape().back();
+                }
+
+                result.resize(dimensions);
+
+                blas_index_t a_stride = static_cast<blas_index_t>(t.strides().back());
+                blas_index_t b_stride = static_cast<blas_index_t>(o.strides()[match_dim]);
+
+                auto a_iter = detail::offset_iter_without_axis<std::decay_t<decltype(t)>>(t, t.dimension() - 1);
+                auto b_iter = detail::offset_iter_without_axis<std::decay_t<decltype(o)>>(o, match_dim);
+
+                value_type temp;
+                auto result_it = result.begin();
+
+                do
+                {
+                    do
+                    {
+                        cxxblas::dot<blas_index_t>(
+                            static_cast<blas_index_t>(l),
+                            t.data() + a_iter.offset(),
+                            a_stride,
+                            o.data() + b_iter.offset(),
+                            b_stride,
+                            temp
+                        );
+                        *(result_it++) = temp;
+
+                    } while (b_iter.next());
+
+                } while (a_iter.next());
+
+            }
+            return result;
+        }
+    }
+
+    /**
+     * Computes the dot product for two vectors.
+     *
+     * Behaves different from \ref dot in the case of complex
+     * vectors. If vectors are complex, vdot conjugates the first
+     * argument \em t.
+     * Note: Unlike NumPy, xtensor-blas currently doesn't flatten
+     * the input arguments.
+     *
+     * @param t input vector (1D)
+     * @param o input vector (1D)
+     *
+     * @return resulting array
+     */
+    template <class T, class O>
+    auto vdot(const xexpression<T>& a, const xexpression<O>& b) {
+
+        using common_type = std::common_type_t<typename T::value_type, typename O::value_type>;
+
+        XTENSOR_ASSERT(a.derived_cast().dimension() == 1);
+        XTENSOR_ASSERT(b.derived_cast().dimension() == 1);
+
+        common_type result = 0;
+        blas::dot(a, b, result);
+
+        return result;
+    }
+
+    /**
+     * Compute the outer product of two vectors.
+     *
+     * @param t input vector (1D)
+     * @param o input vector (1D)
+     *
+     * @return resulting array
+     */
+    template <class T, class O>
+    auto outer(const xexpression<T>& a, const xexpression<O>& b) {
+        using common_type = std::common_type_t<typename T::value_type, typename O::value_type>;
+        using return_type = xtensor<common_type, 2>;
+
+        XTENSOR_ASSERT(a.derived_cast().dimension() == 1);
+        XTENSOR_ASSERT(b.derived_cast().dimension() == 1);
+
+        typename return_type::shape_type s = {a.derived_cast().shape()[0], b.derived_cast().shape()[0]};
+        return_type result(s, common_type(0));
+
+        blas::ger(a, b, result);
+
+        return result;
+    }
+
+    /**
+     * Compute the determinant by utilizing LU factorization
+     *
+     * @param A matrix for which determinant is to be computed
+     * @returns determinant of the \em A
+     */
+    template <class T>
+    auto det(const xexpression<T>& A)
+    {
+        using value_type = typename T::value_type;
+        xtensor<value_type, 2, layout_type::column_major> LU = A.derived_cast();
+
+        uvector<blas_index_t> piv(std::min(LU.shape()[0], LU.shape()[1]));
+
+        int res = lapack::getrf(LU, piv);
+
+        value_type result(1);
+        for (std::size_t i = 0; i < piv.size(); ++i)
+        {
+            if (piv[i] != int(i + 1))
+            {
+                result *= value_type(-1);
+            }
+        }
+
+        for (std::size_t i = 0; i < LU.shape()[0]; ++i)
+        {
+            result *= LU(i, i);
+        }
+        return result;
+    }
+
+    /**
+     * Compute the sign and (natural) logarithm of the determinant of an xexpression.
+     *
+     * If an array has a very small or very large determinant, then a call to det may
+     * overflow or underflow. This routine is more robust against such issues, because
+     * it computes the logarithm of the determinant rather than the determinant itself.
+     *
+     * @param A matrix for which determinant is to be computed
+     * @returns tuple containing (sign, determinant)
+     */
+    template <class T, std::enable_if_t<xtl::is_complex<typename T::value_type>::value, int> = 0>
+    auto slogdet(const xexpression<T>& A)
+    {
+        using value_type = typename T::value_type;
+
+        xtensor<value_type, 2, layout_type::column_major> LU = A.derived_cast();
+        uvector<blas_index_t> piv(std::min(LU.shape()[0], LU.shape()[1]));
+
+        int info = lapack::getrf(LU, piv);
+
+        if (info != 0)
+        {
+            throw std::runtime_error("LU factorization did not compute.");
+        }
+
+        value_type result(0);
+        int sign = 0;
+        for (std::size_t i = 0; i < piv.size(); ++i)
+        {
+            sign += (piv[i] != int(i + 1));
+        }
+
+        value_type v_sign = (sign % 2) ? -1 : 1;
+
+        for (std::size_t i = 0; i < LU.shape()[0]; ++i)
+        {
+            auto abs_elem = std::abs(LU(i, i));
+            v_sign *= (LU(i, i) / abs_elem);
+            result += std::log(abs_elem);
+        }
+        return std::make_tuple(std::move(v_sign), std::move(result));
+    }
+
+    /// @cond DOXYGEN_INCLUDE_SFINAE
+    template <class T, std::enable_if_t<!xtl::is_complex<typename T::value_type>::value, int> = 0>
+    auto slogdet(const xexpression<T>& A)
+    {
+        using value_type = typename T::value_type;
+        xtensor<value_type, 2, layout_type::column_major> LU = A.derived_cast();
+        uvector<blas_index_t> piv(std::min(LU.shape()[0], LU.shape()[1]));
+
+        int info = lapack::getrf(LU, piv);
+
+        if (info != 0)
+        {
+            return std::make_tuple(value_type(0),
+                                   -std::numeric_limits<value_type>::infinity());
+        }
+
+        value_type result(0);
+        int sign = 0;
+
+        for (std::size_t i = 0; i < piv.size(); ++i)
+        {
+            sign += (piv[i] != int(i + 1));
+        }
+
+        for (std::size_t i = 0; i < LU.shape()[0]; ++i)
+        {
+            value_type abs_el = LU(i, i);
+            if (abs_el < 0)
+            {
+                sign += 1;
+                abs_el = -abs_el;
+            }
+            result += std::log(abs_el);
+        }
+
+        value_type v_sign = (sign % 2) ? -1 : 1;
+        return std::make_tuple(std::move(v_sign), std::move(result));
+    }
+    /// @endcond
+
+    namespace detail
+    {
+        template <class E, class T>
+        inline auto call_gqr(E& A, T& tau, blas_index_t n)
+            -> std::enable_if_t<!xtl::is_complex<typename E::value_type>::value>
+        {
+            int info = lapack::orgqr(A, tau, n);
+            if (info > 0)
+            {
+                throw std::runtime_error("Could not find Q (orgqr).");
+            }
+        }
+
+        template <class E, class T>
+        inline auto call_gqr(E& A, T& tau, blas_index_t n)
+            -> std::enable_if_t<xtl::is_complex<typename E::value_type>::value>
+        {
+            int info = lapack::ungqr(A, tau, n);
+            if (info > 0)
+            {
+                throw std::runtime_error("Could not find Q (ungqr).");
+            }
+        }
+    }
+
+    namespace xblas_detail
+    {
+        template <class T>
+        inline void triu_inplace(T& R)
+        {
+            for (std::size_t i = 0; i < R.shape()[0]; ++i)
+            {
+                for (std::size_t j = 0; j < i && j < R.shape()[1]; j++)
+                {
+                    R(i, j) = 0;
+                }
+            }
+        }
+    }
+
+    /// Select the mode for the qr decomposition ``K = min(M, K)``
+    enum class qrmode {
+        reduced,  ///< return Q, R with dimensions (M, K), (K, N) (default)
+        complete, ///< return Q, R with dimensions (M, M), (M, N)
+        r,        ///< return empty Q and R with dimensions (0, 0), (K, N)
+        raw       ///< return H, Tau with dimensions (N, M), (K, 1)
+    };
+
+    /**
+     * Compute the QR decomposition of \em A.
+     * @param t The matrix to calculate Q and R for
+     * @return std::tuple with Q and R
+     */
+    template <class T>
+    auto qr(const xexpression<T>& A, qrmode mode = qrmode::reduced)
+    {
+        using value_type = typename T::value_type;
+        using xtype = xarray<value_type, layout_type::column_major>;
+
+        xtype R = A.derived_cast();
+
+        std::size_t M = R.shape()[0];
+        std::size_t N = R.shape()[1];
+        std::size_t K = std::min(M, N);
+
+        auto tau = xarray<value_type, layout_type::column_major>::from_shape({K});
+        int info = lapack::geqrf(R, tau);
+
+        if (info != 0)
+        {
+            throw std::runtime_error("QR decomposition failed.");
+        }
+
+        // explicitly set shape/size == 0!
+        auto Q = xtype::from_shape({0});
+
+        if (mode == qrmode::r)
+        {
+            R = xt::view(R, range(0, K), all());
+            xblas_detail::triu_inplace(R);
+            return std::make_tuple(std::move(Q), std::move(R));
+        }
+
+        if (mode == qrmode::raw)
+        {
+            R = transpose(R);
+            return std::make_tuple(std::move(R), std::move(tau));
+        }
+
+        blas_index_t mc;
+
+        if (mode == qrmode::complete && M > N)
+        {
+            mc = (blas_index_t) M;
+            Q.resize({M, M});
+        }
+        else
+        {
+            mc = (blas_index_t) K;
+            Q.resize({M, N});
+        }
+
+        xt::view(Q, all(), range(0, N)) = R;
+        detail::call_gqr(Q, tau, mc);
+
+        Q = xt::view(Q, all(), range(0, mc));
+        R = xt::view(R, range(0, mc), all());
+
+        xblas_detail::triu_inplace(R);
+
+        return std::make_tuple(std::move(Q), std::move(R));
+    }
+
+    /**
+     * Compute the Cholesky decomposition of \em A.
+     * @return the decomposed matrix
+     */
+    template <class T>
+    auto cholesky(const xexpression<T>& A)
+    {
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        int info = lapack::potr(M, 'L');
+
+        if (info > 0)
+        {
+            throw std::runtime_error("Cholesky decomposition failed.");
+        }
+
+        // delete upper triangle
+        XTENSOR_ASSERT(M.shape()[0] > 1 && M.shape()[1] > 1);
+
+        for (std::size_t i = 0; i < M.shape()[0]; ++i)
+        {
+            for (std::size_t j = i + 1; j < M.shape()[1]; ++j)
+            {
+                M(i, j) = 0;
+            }
+        }
+
+        return M;
+    }
+
+    /**
+     * Compute the SVD decomposition of \em A.
+     * @return tuple containing S, V, and D
+     */
+    template <class T>
+    auto svd(const xexpression<T>& A, bool full_matrices = true, bool compute_uv = true)
+    {
+        auto M = copy_to_layout<layout_type::column_major>(A.derived_cast());
+
+        char job_type = 'A';
+        if (!compute_uv)
+        {
+            job_type = 'N';
+        }
+        else if (!full_matrices && compute_uv)
+        {
+            job_type = 'S';
+        }
+
+        auto result = lapack::gesdd(M, job_type);
+
+        if (std::get<0>(result) > 0)
+        {
+            throw std::runtime_error("SVD decomposition failed.");
+        }
+
+        return std::make_tuple(std::move(std::get<1>(result)), std::move(std::get<2>(result)), std::move(std::get<3>(result)));
+    }
+
+    /**
+     * Calculate Moore-Rose pseudo inverse using LAPACK SVD.
+     */
+    template <class T>
+    auto pinv(const xexpression<T>& A, double rcond = 1e-15)
+    {
+        using value_type = typename T::value_type;
+        const auto& dA = A.derived_cast();
+
+        xtensor<value_type, 2, layout_type::column_major> M = xt::conj(dA);
+
+        auto gesdd_res = svd(M, false, true);
+
+        auto u = std::move(std::get<0>(gesdd_res));
+        auto s = std::move(std::get<1>(gesdd_res));
+        auto vt = std::move(std::get<2>(gesdd_res));
+
+        using real_value_type = typename decltype(s)::value_type;
+        real_value_type cutoff = static_cast<real_value_type>(rcond) * (*std::max_element(s.begin(), s.end()));
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            if (s(i) > cutoff)
+            {
+                s(i) = real_value_type(1.) / s(i);
+            }
+            else
+            {
+                s(i) = 0;
+            }
+        }
+        auto ut = xt::transpose(u);
+        auto vww = xt::view(s, xt::all(), xt::newaxis());
+        auto m = xt::eval(vww * ut);
+        auto vtt = xt::transpose(vt);
+        auto result = dot(vtt, m);
+        return result;
+    }
+
+    /**
+     * Calculate matrix power A**n
+     *
+     * @param mat  The matrix
+     * @param n    The exponent
+     *
+     * @return resulting array
+     */
+    template <class E>
+    auto matrix_power(const xexpression<E>& A, long n)
+    {
+        using input_type = std::decay_t<E>;
+        using value_type = typename input_type::value_type;
+        using xtype = xtensor<value_type, 2>;
+
+        // copy input matrix
+        xtype mat = A.derived_cast();
+
+        XTENSOR_ASSERT(mat.dimension() == 2);
+        XTENSOR_ASSERT(mat.shape()[0] == mat.shape()[1]);
+
+        xtype res(mat.shape());
+        if (n == 0)
+        {
+            res = eye(mat.shape()[0]);
+            return res;
+        }
+        else if (n < 0)
+        {
+            mat = inv(mat);
+            n = -n;
+        }
+
+
+        xtype temp(mat.shape());
+        res = mat;
+        if (n <= 3)
+        {
+            for (int i = 0; i < n - 1; ++i)
+            {
+                blas::gemm(res, mat, temp);
+                res = temp;
+            }
+            return res;
+        }
+
+        // if n > 3, do a binary decomposition (copied from NumPy)
+        long bits, var = n, i = 0;
+        for(bits = 0; var != 0; ++bits)
+        {
+            var >>= 1;
+        }
+        while (~n & (1 << i))
+        {
+            blas::gemm(mat, mat, temp);
+            temp = res;
+            ++i;
+        }
+        ++i;
+        res = mat;
+        for (; i < bits; ++i)
+        {
+            blas::gemm(mat, mat, temp);
+            mat = temp;
+            if (n & (1 << i))
+            {
+                blas::gemm(res, mat, temp);
+                res = temp;
+            }
+        }
+        return res;
+    }
+
+
+    /**
+     * Compute the trace of a xexpression.
+     */
+    template <class T>
+    auto trace(const xexpression<T>& M, int offset = 0, int axis1 = 0, int axis2 = 1)
+    {
+        const auto& dM = M.derived_cast();
+        auto d = xt::diagonal(dM, offset, axis1, axis2);
+
+        std::size_t dim = d.dimension();
+        if (dim == 1)
+        {
+            return xt::xarray<double>(xt::sum(d)());
+        }
+        else
+        {
+            return xt::xarray<double>(xt::sum(d, {dim - 1}));
+        }
+    }
+
+    /**
+     * Calculate the Kronecker product between two 2D xexpressions.
+     */
+    template <class T, class E>
+    auto kron(const xexpression<T>& a, const xexpression<E>& b)
+    {
+        using value_type = std::common_type_t<typename T::value_type, typename E::value_type>;
+
+        const auto& da = a.derived_cast();
+        const auto& db = b.derived_cast();
+
+        XTENSOR_ASSERT(da.dimension() == 2);
+        XTENSOR_ASSERT(db.dimension() == 2);
+
+        std::array<std::size_t, 2> shp = { da.shape()[0] * db.shape()[0], da.shape()[1] * db.shape()[1] };
+        xtensor<value_type, 2> res(shp);
+
+        for (std::size_t i = 0; i < da.shape()[0]; ++i)
+        {
+            for (std::size_t j = 0; j < da.shape()[1]; ++j)
+            {
+                for (std::size_t k = 0; k < db.shape()[0]; ++k)
+                {
+                    for (std::size_t h = 0; h < db.shape()[1]; ++h)
+                    {
+                        res(i * db.shape()[0] + k, j * db.shape()[1] + h) = da(i, j) * db(k, h);
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+
+    /**
+     * Calculate the matrix rank of \ref m.
+     * If tol == -1, the tolerance is automatically computed.
+     *
+     * @param m matrix for which rank is calculated
+     * @param tol tolerance for finding rank
+     */
+    template <class T>
+    int matrix_rank(const xexpression<T>& m, double tol = -1.0)
+    {
+        using value_type = typename T::value_type;
+        xtensor<value_type, 2, layout_type::column_major> M = m.derived_cast();
+
+        auto svd_res = svd(m, true, false);
+        auto s = std::get<1>(svd_res);
+        auto max_el = std::max_element(s.begin(), s.end());
+
+        if (tol == -1.0)
+        {
+            tol = (*max_el) * static_cast<double>(std::max(M.shape()[0], M.shape()[1])) * std::numeric_limits<value_type>::epsilon();
+        }
+
+        int sm = 0;
+        for (const auto& el : s)
+        {
+            if (el > tol)
+            {
+                ++sm;
+            }
+        }
+        return sm;
+    }
+
+    /**
+     * Calculate the least-squares solution to a linear matrix equation.
+     *
+     * @param A coefficient matrix
+     * @param b Ordinate, or dependent variable values. If b is two-dimensional,
+     *          the least-squares solution is calculated for each of the K columns of b.
+     * @param rcond Cut-off ratio for small singular values of \em A.
+     *              For the purposes of rank determination, singular values are treated
+     *              as zero if they are smaller than rcond times the largest singular value of a.
+     *
+     * @return tuple containing (x, residuals, rank, s) where:
+     *         \em x is the least squares solution. Note that the solution is always returned as
+     *               a 2D matrix where the columns are the solutions (even for a 1D \em b).
+     *         \em s Sums of residuals; squared Euclidean 2-norm for each column in b - a*x.
+     *               If the rank of \em A is < N or M <= N, this is an empty xtensor.
+     *         \em rank the rank of \em A
+     *         \em s singular values of \em A
+     */
+    template <class T, class E>
+    auto lstsq(const xexpression<T>& A, const xexpression<E>& b, double rcond = -1.0)
+    {
+        using value_type = typename T::value_type;
+        using underlying_value_type = xtl::complex_value_type_t<typename T::value_type>;
+
+        xtensor<value_type, 2, layout_type::column_major> dA = A.derived_cast();
+
+        std::size_t M = dA.shape()[0];
+        std::size_t N = dA.shape()[1];
+
+        auto& b_ref = b.derived_cast();
+
+        if (dA.dimension() != 2)
+        {
+            throw std::runtime_error("Expected 2D expression for A");
+        }
+
+        if (!(b_ref.dimension() <= 2))
+        {
+            throw std::runtime_error("Expected 1- or 2D expression for A.");
+        }
+
+        if (b_ref.shape()[0] != M)
+        {
+            throw std::runtime_error("Shape of 'b' for lstsq does not match.");
+        }
+
+        // find number of rhs
+        std::size_t nrhs = (b_ref.dimension() == 1) ? 1 : b_ref.shape()[1];
+
+        // as the dgelsd docs say, on entry it's M-by-nrhs, then result N-by-nrhs
+        // that is why we need to allocate *MORE* space than just b here for M > N
+        auto db = xarray<value_type, layout_type::column_major>::from_shape({ std::max(M, N), nrhs });
+
+        bool is_1d = false;
+        if (b_ref.dimension() == 1)
+        {
+            is_1d = true;
+            xt::view(db, range(0, M), xt::all()) = xt::view(b_ref, xt::all(), xt::newaxis());
+        }
+        else
+        {
+            xt::view(db, range(0, M), xt::all()) = b_ref;
+        }
+
+        auto s = xtensor<underlying_value_type, 1, layout_type::column_major>::from_shape({ std::min(M, N) });
+
+        blas_index_t rank;
+
+        int info = lapack::gelsd(dA, db, s, rank, rcond);
+
+        std::array<std::size_t, 1> residuals_shp = {0};
+        auto residuals = xtensor<underlying_value_type, 1>::from_shape({0});
+
+        if (std::size_t(rank) == N && M > N)
+        {
+            residuals.resize({ db.shape()[1] });
+            for (std::size_t i = 0; i < db.shape()[1]; ++i)
+            {
+                underlying_value_type temp = 0;
+                for (std::size_t j = N; j < db.shape()[0]; ++j)
+                {
+                    temp += std::pow(std::abs(db(j, i)), 2);
+                }
+                residuals(i) = temp;
+            }
+        }
+
+        auto vdb = view(db, range(std::size_t(0), N), xt::all());
+        db = vdb;
+        if (is_1d)
+        {
+            db = xt::squeeze(db);
+        }
+
+        return std::make_tuple(std::move(db), std::move(residuals), std::move(rank), std::move(s));
+    }
+
+    /**
+     * @brief Non-broadcasting cross product between two vectors.
+     *
+     * Calculate cross product between two 1D vectors with 2- or 3 entries.
+     * If only two entries are available, the third entry is assumed to be 0.
+     *
+     * @param a input vector
+     * @param b input vector
+     * @return resulting array
+     */
+    template <class E1, class E2>
+    auto cross(const xexpression<E1>& a, const xexpression<E2>& b)
+    {
+        using return_type = xtensor<typename E1::value_type, 1>;
+        auto res = return_type::from_shape({ 3 });
+        const E1& da = a.derived_cast();
+        const E2& db = b.derived_cast();
+
+        if (da.size() == 3 && db.size() == 3)
+        {
+            res(0) = da(1) * db(2) - da(2) * db(1);
+            res(1) = da(2) * db(0) - da(0) * db(2);
+            res(2) = da(0) * db(1) - da(1) * db(0);
+        }
+        else if (da.size() == 2 && db.size() == 3)
+        {
+            res(0) =   da(1) * db(2);
+            res(1) = -(da(0) * db(2));
+            res(2) =   da(0) * db(1) - da(1) * db(0);
+        }
+        else if (da.size() == 3 && db.size() == 2)
+        {
+            res(0) = -(da(2) * db(1));
+            res(1) =   da(2) * db(0);
+            res(2) =   da(0) * db(1) - da(1) * db(0);
+        }
+        else if (da.size() == 2 && db.size() == 2)
+        {
+            res(0) = 0;
+            res(1) = 0;
+            res(2) = da(0) * db(1) - da(1) * db(0);
+        }
+        else
+        {
+            throw std::runtime_error("a or b did not have appropriate size 2 or 3.");
+        }
+        return res;
+    }
+
+    /**
+     * @brief Compute tensor dot product along specified axes for arrays
+     *
+     * Compute the sum of products along the last \em naxes axes of a and first
+     * \em naxes axes of b.
+     *
+     * @param xa input array
+     * @param xb input array
+     * @param naxes the number of axes to sum over
+     * @return resulting array
+     */
+    template <class T, class O>
+    auto tensordot(const xexpression<T>& xa, const xexpression<O>& xb, std::size_t naxes = 2)
+    {
+        using value_type = std::common_type_t<typename T::value_type, typename O::value_type>;
+        using result_type = std::conditional_t<T::static_layout == O::static_layout &&
+                                               (T::static_layout != layout_type::dynamic && T::static_layout != layout_type::any),
+                                               xarray<value_type, T::static_layout>,
+                                               xarray<value_type, XTENSOR_DEFAULT_LAYOUT>>;
+
+        result_type result;
+        auto&& a = view_eval<T::static_layout>(xa.derived_cast());
+        auto&& b = view_eval<O::static_layout>(xb.derived_cast());
+        if (naxes == 0)
+        {
+            // special case tensor outer product product
+            xt::dynamic_shape<std::size_t> result_shape(a.dimension() + b.dimension());
+            std::size_t j = 0;
+            for (std::size_t i = 0; i < a.dimension(); ++i)
+            {
+                result_shape[j++] = a.shape()[i];
+            }
+
+            for (std::size_t i = 0; i < b.dimension(); ++i)
+            {
+                result_shape[j++] = b.shape()[i];
+            }
+            // flatten a/b
+            auto vec_a = xt::ravel<T::static_layout>(a);
+            auto vec_b = xt::ravel<O::static_layout>(b);
+            // take the outer product of the two vectors
+            result = outer(vec_a, vec_b);
+            // reshape the result
+            result.reshape(result_shape);
+        }
+        else
+        {
+            // Sum of products over last n axes of A and the first n axis of b
+            XTENSOR_ASSERT(a.dimension() >= naxes);
+            XTENSOR_ASSERT(b.dimension() >= naxes);
+
+            auto as_it = a.shape().begin() + (a.dimension() - naxes);
+            auto bs_it = b.shape().begin();
+            std::size_t sum_len = 1;
+            for (std::size_t i = 0; i < naxes; ++i)
+            {
+                auto a_val = *as_it;
+                auto b_val = *bs_it;
+                // check for axes size match
+                if (a_val != b_val)
+                {
+                    throw std::runtime_error("Shape mismatch for sum");
+                }
+                else
+                {
+                    sum_len *= a_val;
+                }
+                ++as_it;
+                ++bs_it;
+            }
+            xt::dynamic_shape<std::size_t> result_shape;
+            std::size_t keep_a_len = 1;
+            for (auto it = a.shape().begin(); it != a.shape().begin() + (a.dimension() - naxes); ++it)
+            {
+                std::size_t len = *it;
+                keep_a_len *= len;
+                result_shape.push_back(len);
+            }
+            std::size_t keep_b_len = 1;
+            for (auto it = b.shape().begin() + naxes; it != b.shape().end(); ++it)
+            {
+                std::size_t len = *it;
+                keep_b_len *= len;
+                result_shape.push_back(len);
+            }
+            xarray<value_type, T::static_layout> a_mat = a;
+            a_mat.reshape({keep_a_len, sum_len});
+            xarray<value_type, O::static_layout> b_mat = b;
+            b_mat.reshape({sum_len, keep_b_len});
+            result = dot(a_mat, b_mat);
+            if(result_shape.empty())
+            {
+                result.reshape({1});
+            }
+            else
+            {
+                result.reshape(result_shape);
+            }
+
+        }
+        return result;
+    }
+
+    /**
+     * @brief Compute tensor dot product along specified axes for arrays
+     *
+     * Compute the sum of products along the axes \em ax_a for a and \em ax_b for b
+     *
+     * @param xa input array
+     * @param xb input array
+     * @param ax_a axes to sum over for \em a
+     * @param ax_b axes to sum over for \em b
+     * @return resulting array
+     */
+    template <class T, class O>
+    auto tensordot(const xexpression<T>& xa, const xexpression<O>& xb, const std::vector<std::size_t>& ax_a,
+                   const std::vector<std::size_t>& ax_b)
+    {
+        auto&& a = view_eval<T::static_layout>(xa.derived_cast());
+        auto&& b = view_eval<O::static_layout>(xb.derived_cast());
+        XTENSOR_ASSERT(ax_a.size() == ax_b.size());
+        XTENSOR_ASSERT(ax_a.size() < a.dimension());
+        XTENSOR_ASSERT(ax_b.size() < b.dimension());
+        std::size_t n_ax = ax_a.size();
+        for (std::size_t i = 0; i < n_ax; ++i)
+        {
+            XTENSOR_ASSERT(ax_a[i] < a.dimension());
+            XTENSOR_ASSERT(ax_b[i] < b.dimension());
+        }
+
+        // Move the axes to sum over to the end of a
+        xt::dynamic_shape<std::size_t> newaxes_a;
+        xt::dynamic_shape<std::size_t> result_shape;
+        for (std::size_t i = 0; i < a.dimension(); ++i)
+        {
+            auto a_ax_it = std::find(ax_a.begin(), ax_a.end(), i);
+            // first pass if i is not in ax_a, add to newaxes_a
+            if (a_ax_it == ax_a.end())
+            {
+                newaxes_a.push_back(i);
+            }
+        }
+        for (auto& a_ax_it : ax_a)
+        {
+            newaxes_a.push_back(a_ax_it);
+        }
+
+        // Move the axes to sum over to the start of b
+        xt::dynamic_shape<std::size_t> newaxes_b;
+        for(auto& b_ax_it : ax_b)
+        {
+            newaxes_b.push_back(b_ax_it);
+        }
+        for (std::size_t i = 0; i < b.dimension(); ++i)
+        {
+            auto b_ax_it = std::find(ax_b.begin(), ax_b.end(), i);
+            // seccond pass if i is not in ax_b add to newaxes_b
+            if (b_ax_it == ax_b.end())
+            {
+                newaxes_b.push_back(i);
+            }
+        }
+        auto a_t = xt::transpose(a, newaxes_a);
+        auto b_t = xt::transpose(b, newaxes_b);
+
+        // the integer arg form of tensordot will handle the reshape of output for us
+        return tensordot(a_t, b_t, n_ax);
+    }
+}
+}
+#endif
diff --git a/inst/include/zstd/zstd_h5plugin.h b/inst/include/zstd/zstd_h5plugin.h
index 30e1931..b85087d 100644
--- a/inst/include/zstd/zstd_h5plugin.h
+++ b/inst/include/zstd/zstd_h5plugin.h
@@ -1,3 +1,4 @@
+#pragma once
 #include "hdf5.h"
 
 #if defined(_MSC_VER)
diff --git a/inst/m4/ax_lib_hdf5.m4 b/inst/m4/ax_lib_hdf5.m4
index 56a777d..a16d4d9 100755
--- a/inst/m4/ax_lib_hdf5.m4
+++ b/inst/m4/ax_lib_hdf5.m4
@@ -95,8 +95,11 @@
 
 AC_DEFUN([AX_LIB_HDF5], [
 
-AC_REQUIRE([AC_PROG_SED])
+
 AC_REQUIRE([AC_PROG_AWK])
+
+AC_REQUIRE([AC_PROG_SED])
+
 AC_REQUIRE([AC_PROG_GREP])
 
 dnl Check first argument is one of the recognized values.
@@ -194,8 +197,7 @@ HDF5 support is being disabled (equivalent to --with-hdf5=no).
         dnl these are empty. Lets roll them both into one.
 
         dnl Look for "HDF5 Version: X.Y.Z"
-        HDF5_VERSION=$(eval $H5CC -showconfig | $GREP 'HDF5 Version:' \
-            | $AWK '{print $[]3}')
+        HDF5_VERSION=$(eval $H5CC -showconfig | $GREP 'HDF5 Version:' | $AWK '{print $[]3}')
         HDF5_MAJOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. '{print $[]1}')
         HDF5_MINOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $[]2'})
         HDF5_REVISION_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $[]3'})
diff --git a/inst/m4/hh_hdf5rlib.m4 b/inst/m4/hh_hdf5rlib.m4
index 9b03cab..76a1b86 100644
--- a/inst/m4/hh_hdf5rlib.m4
+++ b/inst/m4/hh_hdf5rlib.m4
@@ -22,30 +22,20 @@ AC_REQUIRE([AC_PROG_SED])
 AC_REQUIRE([AC_PROG_AWK])
 AC_REQUIRE([AC_PROG_GREP])
 
-HDF5RLIB_INSTALLED=$(echo 'cat(suppressWarnings(require(hdf5rLib, quietly=TRUE, character.only=FALSE, warn.conflicts=FALSE)))' |\
-"${R_HOME}/bin/R" --vanilla --slave)
 
 
-if test "$HDF5RLIB_INSTALLED" != "TRUE"; then
-   with_hdf5rLib="no"
-else
-   with_hdf5rLib="yes"
-   ## get the relevant variables so that headers can be found and static library can be linked
-   HDF5RLIB_LIBPATH=$(echo 'cat(hdf5rLib:::.pkgLibPath())' | "${R_HOME}/bin/R" --vanilla --slave)
-   HDF5RLIB_INCLUDEPATH=$(echo 'cat(hdf5rLib:::.pkgIncludePath())' | "${R_HOME}/bin/R" --vanilla --slave)
-
-   HDF5_MAJOR_VERSION=$(echo 'cat(hdf5rLib:::.pkgMajorVersion())' | "${R_HOME}/bin/R" --vanilla --slave)
-   HDF5_MINOR_VERSION=$(echo 'cat(hdf5rLib:::.pkgMinorVersion())' | "${R_HOME}/bin/R" --vanilla --slave)
-
-   HDF5_LIBS='-L"'${HDF5RLIB_LIBPATH}'" -lhdf5_hl-static -lhdf5-static -lz -lm'
- #  HDF5_CPPFLAGS='-I'"${HDF5RLIB_INCLUDEPATH}"' -DWINDOWS'
-
-   AC_SUBST([HDF5_LIBS])
-#   AC_SUBST([HDF5_CPPFLAGS])
-   AC_SUBST([HDF5_MAJOR_VERSION])
-   AC_SUBST([HDF5_MINOR_VERSION])
-fi
-
+with_rhdf5lib="yes"
+HDF5R_LIBS=$(echo 'cat(Rhdf5lib::pkgconfig("PKG_C_HL_LIBS"))' | "${R_HOME}/bin/R" --vanilla --slave)
+HDF5R_CPPFLAGS=$(echo 'cat("-I",system.file("include/",package = "Rhdf5lib"))' | "${R_HOME}/bin/R" --vanilla --slave)
+HDF5_VERSION=$(echo 'cat(Rhdf5lib::getHdf5Version())' | "${R_HOME}/bin/R" --vanilla --slave)
+HDF5_MAJOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. '{print $[]1}')
+HDF5_MINOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $[]2'})
+HDF5_REVISION_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $[]3'})
+AC_MSG_RESULT([Found Rhdf5lib with version: $HDF5_MAJOR_VERSION.$HDF5_MINOR_VERSION])
+AC_SUBST([HDF5R_LIBS])
+AC_SUBST([HDF5R_CPPFLAGS])
+AC_SUBST([HDF5_MAJOR_VERSION])
+AC_SUBST([HDF5_MINOR_VERSION])
 
 
 ])
diff --git a/inst/m4/m4/#hh_hdf5rlib.m4# b/inst/m4/m4/#hh_hdf5rlib.m4#
new file mode 100644
index 0000000..bbaad0a
--- /dev/null
+++ b/inst/m4/m4/#hh_hdf5rlib.m4#
@@ -0,0 +1,51 @@
+
+#############################################################################
+##
+## Copyright 2016 Novartis Institutes for BioMedical Research Inc.
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+#############################################################################
+
+AC_DEFUN([HH_HDF5RLIB], [
+
+AC_REQUIRE([AC_PROG_SED])
+AC_REQUIRE([AC_PROG_AWK])
+AC_REQUIRE([AC_PROG_GREP])
+
+HDF5RLIB_INSTALLED=$(echo 'cat(suppressWarnings(require(hdf5rLib, quietly=TRUE, character.only=FALSE, warn.conflicts=FALSE)))' |\
+"${R_HOME}/bin/R" --vanilla --slave)
+
+
+if test "$HDF5RLIB_INSTALLED" != "TRUE"; then
+   with_hdf5rLib="no"
+else
+   with_hdf5rLib="yes"
+   ## get the relevant variables so that headers can be found and static library can be linked
+   HDF5RLIB_LIBPATH=$(echo 'cat(hdf5rLib:::.pkgLibPath())' | "${R_HOME}/bin/R" --vanilla --slave)
+   HDF5RLIB_INCLUDEPATH=$(echo 'cat(hdf5rLib:::.pkgIncludePath())' | "${R_HOME}/bin/R" --vanilla --slave)
+
+   HDF5_MAJOR_VERSION=$(echo 'cat(hdf5rLib:::.pkgMajorVersion())' | "${R_HOME}/bin/R" --vanilla --slave)
+   HDF5_MINOR_VERSION=$(echo 'cat(hdf5rLib:::.pkgMinorVersion())' | "${R_HOME}/bin/R" --vanilla --slave)
+
+   HDF5_LIBS='-L"'${HDF5RLIB_LIBPATH}'" -lhdf5_hl-static -lhdf5-static -lz -lm'
+   HDF5_CPPFLAGS='-I'"${HDF5RLIB_INCLUDEPATH}"' -DWINDOWS'
+
+   AC_SUBST([HDF5_LIBS])
+   AC_SUBST([HDF5_CPPFLAGS])
+   AC_SUBST([HDF5_MAJOR_VERSION])
+   AC_SUBST([HDF5_MINOR_VERSION])
+fi
+
+
+
+])
diff --git a/inst/m4/m4/ax_compare_version.m4 b/inst/m4/m4/ax_compare_version.m4
new file mode 100755
index 0000000..74dc0fd
--- /dev/null
+++ b/inst/m4/m4/ax_compare_version.m4
@@ -0,0 +1,177 @@
+# ===========================================================================
+#    http://www.gnu.org/software/autoconf-archive/ax_compare_version.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_COMPARE_VERSION(VERSION_A, OP, VERSION_B, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+#
+# DESCRIPTION
+#
+#   This macro compares two version strings. Due to the various number of
+#   minor-version numbers that can exist, and the fact that string
+#   comparisons are not compatible with numeric comparisons, this is not
+#   necessarily trivial to do in a autoconf script. This macro makes doing
+#   these comparisons easy.
+#
+#   The six basic comparisons are available, as well as checking equality
+#   limited to a certain number of minor-version levels.
+#
+#   The operator OP determines what type of comparison to do, and can be one
+#   of:
+#
+#    eq  - equal (test A == B)
+#    ne  - not equal (test A != B)
+#    le  - less than or equal (test A <= B)
+#    ge  - greater than or equal (test A >= B)
+#    lt  - less than (test A < B)
+#    gt  - greater than (test A > B)
+#
+#   Additionally, the eq and ne operator can have a number after it to limit
+#   the test to that number of minor versions.
+#
+#    eq0 - equal up to the length of the shorter version
+#    ne0 - not equal up to the length of the shorter version
+#    eqN - equal up to N sub-version levels
+#    neN - not equal up to N sub-version levels
+#
+#   When the condition is true, shell commands ACTION-IF-TRUE are run,
+#   otherwise shell commands ACTION-IF-FALSE are run. The environment
+#   variable 'ax_compare_version' is always set to either 'true' or 'false'
+#   as well.
+#
+#   Examples:
+#
+#     AX_COMPARE_VERSION([3.15.7],[lt],[3.15.8])
+#     AX_COMPARE_VERSION([3.15],[lt],[3.15.8])
+#
+#   would both be true.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq],[3.15.8])
+#     AX_COMPARE_VERSION([3.15],[gt],[3.15.8])
+#
+#   would both be false.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq2],[3.15.8])
+#
+#   would be true because it is only comparing two minor versions.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq0],[3.15])
+#
+#   would be true because it is only comparing the lesser number of minor
+#   versions of the two values.
+#
+#   Note: The characters that separate the version numbers do not matter. An
+#   empty string is the same as version 0. OP is evaluated by autoconf, not
+#   configure, so must be a string, not a variable.
+#
+#   The author would like to acknowledge Guido Draheim whose advice about
+#   the m4_case and m4_ifvaln functions make this macro only include the
+#   portions necessary to perform the specific comparison specified by the
+#   OP argument in the final configure script.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Tim Toolan <toolan@ele.uri.edu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 11
+
+dnl #########################################################################
+AC_DEFUN([AX_COMPARE_VERSION], [
+  AC_REQUIRE([AC_PROG_AWK])
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+  AS_VAR_PUSHDEF([A],[ax_compare_version_A])
+  A=`echo "$1" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
+                     -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/[[^0-9]]//g'`
+
+  AS_VAR_PUSHDEF([B],[ax_compare_version_B])
+  B=`echo "$3" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
+                     -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/[[^0-9]]//g'`
+
+  dnl # In the case of le, ge, lt, and gt, the strings are sorted as necessary
+  dnl # then the first line is used to determine if the condition is true.
+  dnl # The sed right after the echo is to remove any indented white space.
+  m4_case(m4_tolower($2),
+  [lt],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/false/;s/x${B}/true/;1q"`
+  ],
+  [gt],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort | sed "s/x${A}/false/;s/x${B}/true/;1q"`
+  ],
+  [le],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort | sed "s/x${A}/true/;s/x${B}/false/;1q"`
+  ],
+  [ge],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/true/;s/x${B}/false/;1q"`
+  ],[
+    dnl Split the operator from the subversion count if present.
+    m4_bmatch(m4_substr($2,2),
+    [0],[
+      # A count of zero means use the length of the shorter version.
+      # Determine the number of characters in A and B.
+      ax_compare_version_len_A=`echo "$A" | $AWK '{print(length)}'`
+      ax_compare_version_len_B=`echo "$B" | $AWK '{print(length)}'`
+
+      # Set A to no more than B's length and B to no more than A's length.
+      A=`echo "$A" | sed "s/\(.\{$ax_compare_version_len_B\}\).*/\1/"`
+      B=`echo "$B" | sed "s/\(.\{$ax_compare_version_len_A\}\).*/\1/"`
+    ],
+    [[0-9]+],[
+      # A count greater than zero means use only that many subversions
+      A=`echo "$A" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
+      B=`echo "$B" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
+    ],
+    [.+],[
+      AC_WARNING(
+        [illegal OP numeric parameter: $2])
+    ],[])
+
+    # Pad zeros at end of numbers to make same length.
+    ax_compare_version_tmp_A="$A`echo $B | sed 's/./0/g'`"
+    B="$B`echo $A | sed 's/./0/g'`"
+    A="$ax_compare_version_tmp_A"
+
+    # Check for equality or inequality as necessary.
+    m4_case(m4_tolower(m4_substr($2,0,2)),
+    [eq],[
+      test "x$A" = "x$B" && ax_compare_version=true
+    ],
+    [ne],[
+      test "x$A" != "x$B" && ax_compare_version=true
+    ],[
+      AC_WARNING([illegal OP parameter: $2])
+    ])
+  ])
+
+  AS_VAR_POPDEF([A])dnl
+  AS_VAR_POPDEF([B])dnl
+
+  dnl # Execute ACTION-IF-TRUE / ACTION-IF-FALSE.
+  if test "$ax_compare_version" = "true" ; then
+    m4_ifvaln([$4],[$4],[:])dnl
+    m4_ifvaln([$5],[else $5])dnl
+  fi
+]) dnl AX_COMPARE_VERSION
diff --git a/inst/m4/m4/ax_lib_hdf5.m4 b/inst/m4/m4/ax_lib_hdf5.m4
new file mode 100755
index 0000000..56a777d
--- /dev/null
+++ b/inst/m4/m4/ax_lib_hdf5.m4
@@ -0,0 +1,330 @@
+# ===========================================================================
+#        http://www.gnu.org/software/autoconf-archive/ax_lib_hdf5.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_LIB_HDF5([serial/parallel])
+#
+# DESCRIPTION
+#
+#   This macro provides tests of the availability of HDF5 library.
+#
+#   The optional macro argument should be either 'serial' or 'parallel'. The
+#   former only looks for serial HDF5 installations via h5cc. The latter
+#   only looks for parallel HDF5 installations via h5pcc. If the optional
+#   argument is omitted, serial installations will be preferred over
+#   parallel ones.
+#
+#   The macro adds a --with-hdf5 option accepting one of three values:
+#
+#     no   - do not check for the HDF5 library.
+#     yes  - do check for HDF5 library in standard locations.
+#     path - complete path to the HDF5 helper script h5cc or h5pcc.
+#
+#   If HDF5 is successfully found, this macro calls
+#
+#     AC_SUBST(HDF5_VERSION)
+#     AC_SUBST(HDF5_CC)
+#     AC_SUBST(HDF5_CFLAGS)
+#     AC_SUBST(HDF5_CPPFLAGS)
+#     AC_SUBST(HDF5_LDFLAGS)
+#     AC_SUBST(HDF5_LIBS)
+#     AC_SUBST(HDF5_FC)
+#     AC_SUBST(HDF5_FFLAGS)
+#     AC_SUBST(HDF5_FLIBS)
+#     AC_DEFINE(HAVE_HDF5)
+#
+#   and sets with_hdf5="yes".  Additionally, the macro sets
+#   with_hdf5_fortran="yes" if a matching Fortran wrapper script is found.
+#   Note that Autconf's Fortran support is not used to perform this check.
+#   H5CC and H5FC will contain the appropriate serial or parallel HDF5
+#   wrapper script locations.
+#
+#   If HDF5 is disabled or not found, this macros sets with_hdf5="no" and
+#   with_hdf5_fortran="no".
+#
+#   Your configuration script can test $with_hdf to take any further
+#   actions. HDF5_{C,CPP,LD}FLAGS may be used when building with C or C++.
+#   HDF5_F{FLAGS,LIBS} should be used when building Fortran applications.
+#
+#   To use the macro, one would code one of the following in "configure.ac"
+#   before AC_OUTPUT:
+#
+#     1) dnl Check for HDF5 support
+#        AX_LIB_HDF5()
+#
+#     2) dnl Check for serial HDF5 support
+#        AX_LIB_HDF5([serial])
+#
+#     3) dnl Check for parallel HDF5 support
+#        AX_LIB_HDF5([parallel])
+#
+#   One could test $with_hdf5 for the outcome or display it as follows
+#
+#     echo "HDF5 support:  $with_hdf5"
+#
+#   You could also for example, override the default CC in "configure.ac" to
+#   enforce compilation with the compiler that HDF5 uses:
+#
+#     AX_LIB_HDF5([parallel])
+#     if test "$with_hdf5" = "yes"; then
+#             CC="$HDF5_CC"
+#     else
+#             AC_MSG_ERROR([Unable to find HDF5, we need parallel HDF5.])
+#     fi
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Timothy Brown <tbrown@freeshell.org>
+#   Copyright (c) 2010 Rhys Ulerich <rhys.ulerich@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 12
+
+# This code was adapted by Holger Hoefling on May 2nd 2016 to also 
+# substitute variables HDF5_MAJOR_VERSION, HDF5_MINOR_VERSION 
+# as well as HDF5_REVISION_VERSION so that the 3 parts of the
+# version number are available separately for testing 
+# Also changed to check for hdf5_hl header library existence
+
+
+AC_DEFUN([AX_LIB_HDF5], [
+
+AC_REQUIRE([AC_PROG_SED])
+AC_REQUIRE([AC_PROG_AWK])
+AC_REQUIRE([AC_PROG_GREP])
+
+dnl Check first argument is one of the recognized values.
+dnl Fail eagerly if is incorrect as this simplifies case statements below.
+if   test "m4_normalize(m4_default([$1],[]))" = ""        ; then
+    : # Recognized value
+elif test "m4_normalize(m4_default([$1],[]))" = "serial"  ; then
+    : # Recognized value
+elif test "m4_normalize(m4_default([$1],[]))" = "parallel"; then
+    : # Recognized value
+else
+    AC_MSG_ERROR([
+Unrecognized value for AX[]_LIB_HDF5 within configure.ac.
+If supplied, argument 1 must be either 'serial' or 'parallel'.
+])
+fi
+
+dnl Add a default --with-hdf5 configuration option.
+AC_ARG_WITH([hdf5],
+  AS_HELP_STRING(
+    [--with-hdf5=[yes/no/PATH]],
+    m4_case(m4_normalize([$1]),
+            [serial],   [location of h5cc for serial HDF5 configuration],
+            [parallel], [location of h5pcc for parallel HDF5 configuration],
+            [location of h5cc or h5pcc for HDF5 configuration])
+  ),
+  [if test "$withval" = "no"; then
+     with_hdf5="no"
+   elif test "$withval" = "yes"; then
+     with_hdf5="yes"
+   else
+     with_hdf5="yes"
+     H5CC="$withval"
+   fi],
+   [with_hdf5="yes"]
+)
+
+dnl Set defaults to blank
+HDF5_CC=""
+HDF5_VERSION=""
+HDF5_CFLAGS=""
+HDF5_CPPFLAGS=""
+HDF5_LDFLAGS=""
+HDF5_LIBS=""
+HDF5_FC=""
+HDF5_FFLAGS=""
+HDF5_FLIBS=""
+
+dnl Try and find hdf5 compiler tools and options.
+if test "$with_hdf5" = "yes"; then
+    if test -z "$H5CC"; then
+        dnl Check to see if H5CC is in the path.
+        AC_PATH_PROGS(
+            [H5CC],
+            m4_case(m4_normalize([$1]),
+                [serial],   [h5cc],
+                [parallel], [h5pcc],
+                [h5cc h5pcc]),
+            [])
+    else
+        AC_MSG_CHECKING([Using provided HDF5 C wrapper])
+        AC_MSG_RESULT([$H5CC])
+    fi
+    AC_MSG_CHECKING([for HDF5 libraries])
+    if test ! -f "$H5CC" || test ! -x "$H5CC"; then
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN(m4_case(m4_normalize([$1]),
+            [serial],  [
+Unable to locate serial HDF5 compilation helper script 'h5cc'.
+Please specify --with-hdf5=<LOCATION> as the full path to h5cc.
+HDF5 support is being disabled (equivalent to --with-hdf5=no).
+],            [parallel],[
+Unable to locate parallel HDF5 compilation helper script 'h5pcc'.
+Please specify --with-hdf5=<LOCATION> as the full path to h5pcc.
+HDF5 support is being disabled (equivalent to --with-hdf5=no).
+],            [
+Unable to locate HDF5 compilation helper scripts 'h5cc' or 'h5pcc'.
+Please specify --with-hdf5=<LOCATION> as the full path to h5cc or h5pcc.
+HDF5 support is being disabled (equivalent to --with-hdf5=no).
+]))
+        with_hdf5="no"
+        with_hdf5_fortran="no"
+    else
+        dnl Get the h5cc output
+        HDF5_SHOW=$(eval $H5CC -show)
+
+        dnl Get the actual compiler used
+        HDF5_CC=$(eval $H5CC -show | $AWK '{print $[]1}')
+        if test "$HDF5_CC" = "ccache"; then
+            HDF5_CC=$(eval $H5CC -show | $AWK '{print $[]2}')
+        fi
+
+        dnl h5cc provides both AM_ and non-AM_ options
+        dnl depending on how it was compiled either one of
+        dnl these are empty. Lets roll them both into one.
+
+        dnl Look for "HDF5 Version: X.Y.Z"
+        HDF5_VERSION=$(eval $H5CC -showconfig | $GREP 'HDF5 Version:' \
+            | $AWK '{print $[]3}')
+        HDF5_MAJOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. '{print $[]1}')
+        HDF5_MINOR_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $[]2'})
+        HDF5_REVISION_VERSION=$(echo $HDF5_VERSION | $AWK -F \. {'print $[]3'})
+
+        dnl A ideal situation would be where everything we needed was
+        dnl in the AM_* variables. However most systems are not like this
+        dnl and seem to have the values in the non-AM variables.
+        dnl
+        dnl We try the following to find the flags:
+        dnl (1) Look for "NAME:" tags
+        dnl (2) Look for "H5_NAME:" tags
+        dnl (3) Look for "AM_NAME:" tags
+        dnl
+        HDF5_tmp_flags=$(eval $H5CC -showconfig \
+            | $GREP 'FLAGS\|Extra libraries:' \
+            | $AWK -F: '{printf("%s "), $[]2}' )
+
+        dnl Find the installation directory and append include/
+        HDF5_tmp_inst=$(eval $H5CC -showconfig \
+            | $GREP 'Installation point:' \
+            | $AWK '{print $[]NF}' )
+
+        dnl Add this to the CPPFLAGS
+        HDF5_CPPFLAGS="-I${HDF5_tmp_inst}/include"
+
+        dnl Now sort the flags out based upon their prefixes
+        for arg in $HDF5_SHOW $HDF5_tmp_flags ; do
+          case "$arg" in
+            -I*) echo $HDF5_CPPFLAGS | $GREP -e "$arg" 2>&1 >/dev/null \
+                  || HDF5_CPPFLAGS="$arg $HDF5_CPPFLAGS"
+              ;;
+            -L*) echo $HDF5_LDFLAGS | $GREP -e "$arg" 2>&1 >/dev/null \
+                  || HDF5_LDFLAGS="$arg $HDF5_LDFLAGS"
+              ;;
+            -l*) echo $HDF5_LIBS | $GREP -e "$arg" 2>&1 >/dev/null \
+                  || HDF5_LIBS="$arg $HDF5_LIBS"
+              ;;
+          esac
+        done
+
+        HDF5_LIBS="$HDF5_LIBS -lhdf5"
+        AC_MSG_RESULT([yes (version $[HDF5_VERSION])])
+
+        dnl See if we can compile
+        AC_LANG_PUSH([C])
+        ax_lib_hdf5_save_CC=$CC
+        ax_lib_hdf5_save_CPPFLAGS=$CPPFLAGS
+        ax_lib_hdf5_save_LIBS=$LIBS
+        ax_lib_hdf5_save_LDFLAGS=$LDFLAGS
+        CC=$HDF5_CC
+        CPPFLAGS=$HDF5_CPPFLAGS
+        LIBS=$HDF5_LIBS
+        LDFLAGS=$HDF5_LDFLAGS
+        AC_CHECK_HEADER([hdf5.h], [ac_cv_hadf5_h=yes], [ac_cv_hadf5_h=no])
+        AC_CHECK_LIB([hdf5], [H5Fcreate], [ac_cv_libhdf5=yes],
+                     [ac_cv_libhdf5=no])
+        if test "$ac_cv_hadf5_h" = "no" && test "$ac_cv_libhdf5" = "no" ; then
+          AC_MSG_WARN([Unable to compile HDF5 test program])
+        fi
+        AC_CHECK_HEADER([hdf5_hl.h], [ac_cv_hadf5_hl_h=yes], [ac_cv_hadf5_hl_h=no], [#include <hdf5.h>])
+        AC_CHECK_LIB([hdf5_hl], [H5LTpath_valid], [ac_cv_libhdf5_hl=yes],
+                     [ac_cv_libhdf5_hl=no])
+        if test "$ac_cv_hadf5_hl_h" = "no" && test "$ac_cv_libhdf5_hl" = "no"; then
+          AC_MSG_WARN([Unable to compile HDF5_HL test program])
+        fi
+        dnl Look for HDF5's high level library
+        AC_HAVE_LIBRARY([hdf5_hl], [HDF5_LIBS="$HDF5_LIBS -lhdf5_hl"], [], [])
+
+        CC=$ax_lib_hdf5_save_CC
+        CPPFLAGS=$ax_lib_hdf5_save_CPPFLAGS
+        LIBS=$ax_lib_hdf5_save_LIBS
+        LDFLAGS=$ax_lib_hdf5_save_LDFLAGS
+        AC_LANG_POP([C])
+
+        AC_MSG_CHECKING([for matching HDF5 Fortran wrapper])
+        dnl Presume HDF5 Fortran wrapper is just a name variant from H5CC
+        H5FC=$(eval echo -n $H5CC | $SED -n 's/cc$/fc/p')
+        if test -x "$H5FC"; then
+            AC_MSG_RESULT([$H5FC])
+            with_hdf5_fortran="yes"
+            AC_SUBST([H5FC])
+
+            dnl Again, pry any remaining -Idir/-Ldir from compiler wrapper
+            for arg in `$H5FC -show`
+            do
+              case "$arg" in #(
+                -I*) echo $HDF5_FFLAGS | $GREP -e "$arg" >/dev/null \
+                      || HDF5_FFLAGS="$arg $HDF5_FFLAGS"
+                  ;;#(
+                -L*) echo $HDF5_FFLAGS | $GREP -e "$arg" >/dev/null \
+                      || HDF5_FFLAGS="$arg $HDF5_FFLAGS"
+                     dnl HDF5 installs .mod files in with libraries,
+                     dnl but some compilers need to find them with -I
+                     echo $HDF5_FFLAGS | $GREP -e "-I${arg#-L}" >/dev/null \
+                      || HDF5_FFLAGS="-I${arg#-L} $HDF5_FFLAGS"
+                  ;;
+              esac
+            done
+
+            dnl Make Fortran link line by inserting Fortran libraries
+            for arg in $HDF5_LIBS
+            do
+              case "$arg" in #(
+                -lhdf5_hl) HDF5_FLIBS="$HDF5_FLIBS -lhdf5hl_fortran $arg"
+                  ;; #(
+                -lhdf5)    HDF5_FLIBS="$HDF5_FLIBS -lhdf5_fortran $arg"
+                  ;; #(
+                *) HDF5_FLIBS="$HDF5_FLIBS $arg"
+                  ;;
+              esac
+            done
+        else
+            AC_MSG_RESULT([no])
+            with_hdf5_fortran="no"
+        fi
+
+	AC_SUBST([HDF5_VERSION])
+	AC_SUBST([HDF5_MAJOR_VERSION])
+	AC_SUBST([HDF5_MINOR_VERSION])
+	AC_SUBST([HDF5_REVISION_VERSION])
+	AC_SUBST([HDF5_CC])
+	AC_SUBST([HDF5_CFLAGS])
+	AC_SUBST([HDF5_CPPFLAGS])
+	AC_SUBST([HDF5_LDFLAGS])
+	AC_SUBST([HDF5_LIBS])
+	AC_SUBST([HDF5_FC])
+	AC_SUBST([HDF5_FFLAGS])
+	AC_SUBST([HDF5_FLIBS])
+	AC_DEFINE([HAVE_HDF5], [1], [Defined if you have HDF5 support])
+    fi
+fi
+])
diff --git a/inst/m4/m4/hh_hdf5rlib.m4 b/inst/m4/m4/hh_hdf5rlib.m4
new file mode 100644
index 0000000..bbaad0a
--- /dev/null
+++ b/inst/m4/m4/hh_hdf5rlib.m4
@@ -0,0 +1,51 @@
+
+#############################################################################
+##
+## Copyright 2016 Novartis Institutes for BioMedical Research Inc.
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+#############################################################################
+
+AC_DEFUN([HH_HDF5RLIB], [
+
+AC_REQUIRE([AC_PROG_SED])
+AC_REQUIRE([AC_PROG_AWK])
+AC_REQUIRE([AC_PROG_GREP])
+
+HDF5RLIB_INSTALLED=$(echo 'cat(suppressWarnings(require(hdf5rLib, quietly=TRUE, character.only=FALSE, warn.conflicts=FALSE)))' |\
+"${R_HOME}/bin/R" --vanilla --slave)
+
+
+if test "$HDF5RLIB_INSTALLED" != "TRUE"; then
+   with_hdf5rLib="no"
+else
+   with_hdf5rLib="yes"
+   ## get the relevant variables so that headers can be found and static library can be linked
+   HDF5RLIB_LIBPATH=$(echo 'cat(hdf5rLib:::.pkgLibPath())' | "${R_HOME}/bin/R" --vanilla --slave)
+   HDF5RLIB_INCLUDEPATH=$(echo 'cat(hdf5rLib:::.pkgIncludePath())' | "${R_HOME}/bin/R" --vanilla --slave)
+
+   HDF5_MAJOR_VERSION=$(echo 'cat(hdf5rLib:::.pkgMajorVersion())' | "${R_HOME}/bin/R" --vanilla --slave)
+   HDF5_MINOR_VERSION=$(echo 'cat(hdf5rLib:::.pkgMinorVersion())' | "${R_HOME}/bin/R" --vanilla --slave)
+
+   HDF5_LIBS='-L"'${HDF5RLIB_LIBPATH}'" -lhdf5_hl-static -lhdf5-static -lz -lm'
+   HDF5_CPPFLAGS='-I'"${HDF5RLIB_INCLUDEPATH}"' -DWINDOWS'
+
+   AC_SUBST([HDF5_LIBS])
+   AC_SUBST([HDF5_CPPFLAGS])
+   AC_SUBST([HDF5_MAJOR_VERSION])
+   AC_SUBST([HDF5_MINOR_VERSION])
+fi
+
+
+
+])
diff --git a/man/delim2h5.Rd b/man/delim2h5.Rd
new file mode 100644
index 0000000..a2a9c52
--- /dev/null
+++ b/man/delim2h5.Rd
@@ -0,0 +1,34 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utils.R
+\name{delim2h5}
+\alias{delim2h5}
+\title{Convert to HDF5 with a custom callback}
+\usage{
+delim2h5(
+  input_file,
+  output_file,
+  h5_args = list(datapath = "/"),
+  callback_fun = write_df_h5,
+  id_col = NULL,
+  ...
+)
+}
+\arguments{
+\item{h5_args}{... args for write_df_h5 unpacked and passed to `callback_fun`}
+
+\item{callback_fun}{function with signature matching function(df,filename,datapath,...) (defaults to `write_df_h5`)}
+
+\item{...}{}
+}
+\value{
+
+}
+\description{
+Convert to HDF5 with a custom callback
+}
+\examples{
+
+temp_h5 <- fs::file_temp(ext="h5")
+delim2h5(readr::readr_example("mtcars.csv"),temp_h5,delim="/")
+new_data  <- read_df_h5(temp_h5)
+}
diff --git a/man/rle2offset.Rd b/man/rle2offset.Rd
new file mode 100644
index 0000000..4fc83e4
--- /dev/null
+++ b/man/rle2offset.Rd
@@ -0,0 +1,28 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utils.R
+\name{rle2offset}
+\alias{rle2offset}
+\title{Convert RLE-encoded vector to offset+size dataframe}
+\usage{
+rle2offset(x, na_replace = -1)
+}
+\arguments{
+\item{x}{either a vector of class `rle`, or a vector that can be converte to one via (`rle(x)`)}
+
+\item{na_replace}{value to replace NA (rle doesn't play well with NA)}
+}
+\value{
+tibble with columns `value`,`offset` and `datasize`
+}
+\description{
+Convert RLE-encoded vector to offset+size dataframe
+}
+\examples{
+x <- rev(rep(6:10, 1:5))
+x_na <- c(NA,NA,NA,rev(rep(6:10, 1:5)))
+x_n3 <- c(-3,-3,-3,rev(rep(6:10, 1:5)))
+print(rle2offset(rle(x)))
+stopifnot(
+  identical(rle2offset(rle(x)),rle2offset(x)),
+  identical(rle2offset(x_na,na_replace=-3),rle2offset(x_n3)))
+}
diff --git a/src/Makevars b/src/Makevars
deleted file mode 100644
index 34b942a..0000000
--- a/src/Makevars
+++ /dev/null
@@ -1,9 +0,0 @@
-CXX_STD = CXX11
-HDF5_LIBS=`echo 'Rhdf5lib::pkgconfig("PKG_C_LIBS")'|\
-    "${R_HOME}/bin/R" --vanilla --slave`
-ZSTD_LIBS=`echo 'rzstdlib::pkgconfig("PKG_C_LIBS")'|\
-    "${R_HOME}/bin/R" --vanilla --slave`
-
-PKG_LIBS += $(HDF5_LIBS) $(ZSTD_LIBS)
-PKG_LIBS += $(shell ${R_HOME}/bin/Rscript -e "RcppParallel::RcppParallelLibs()") 
-PKG_CPPFLAGS += -I../inst/include -DUSE_MKL
diff --git a/src/Makevars.in b/src/Makevars.in
new file mode 100644
index 0000000..f835924
--- /dev/null
+++ b/src/Makevars.in
@@ -0,0 +1,4 @@
+PKG_LIBS += @HDF5R_LIBS@
+#PKG_LIBS += $(shell ${R_HOME}/bin/Rscript -e "RcppParallel::RcppParallelLibs()")
+PKG_CPPFLAGS += -I../inst/include @HDF5R_CPPFLAGS@
+PKG_CFLAGS += @HDF5R_CFLAGS@
diff --git a/src/R6.cpp b/src/R6.cpp
index 8caf18d..e92745e 100644
--- a/src/R6.cpp
+++ b/src/R6.cpp
@@ -36,7 +36,7 @@ void  release_group( Rcpp::XPtr<HighFive::Group> p){
 
 //[[Rcpp::export]]
 SEXP get_file_object(Rcpp::XPtr<HighFive::File> f, const std::string object_name){
-  using obj_var=boost::variant<HighFive::DataSet,HighFive::Group>;
+  using obj_var=std::variant<HighFive::DataSet,HighFive::Group>;
   return(Rcpp::XPtr<obj_var>(new obj_var(f->getObject(Path(object_name)))));
 }
 //[[Rcpp::export]]
@@ -48,20 +48,3 @@ SEXP get_group(Rcpp::XPtr<HighFive::File> f, const std::string object_name){
   return(Rcpp::XPtr<HighFive::Group>(new HighFive::Group(f->getGroup(Path(object_name)))));
 }
 
-
-
-
-  
-  
-
-
-
-
-
-
-
-
-// bool xptr_release( XPtr< std::vector<int> > p) {
-//     p.release();
-//     return !p;
-// }
diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp
index 899be2a..95139cf 100644
--- a/src/RcppExports.cpp
+++ b/src/RcppExports.cpp
@@ -97,6 +97,74 @@ BEGIN_RCPP
     return rcpp_result_gen;
 END_RCPP
 }
+// read_matrix_rl
+Rcpp::List read_matrix_rl(const std::string filename, const std::string datapath, SEXP rows, SEXP cols);
+RcppExport SEXP _EigenH5_read_matrix_rl(SEXP filenameSEXP, SEXP datapathSEXP, SEXP rowsSEXP, SEXP colsSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::RNGScope rcpp_rngScope_gen;
+    Rcpp::traits::input_parameter< const std::string >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type datapath(datapathSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type rows(rowsSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type cols(colsSEXP);
+    rcpp_result_gen = Rcpp::wrap(read_matrix_rl(filename, datapath, rows, cols));
+    return rcpp_result_gen;
+END_RCPP
+}
+// read_matrix_v
+SEXP read_matrix_v(const std::string filename, const std::string datapath, SEXP rows, SEXP cols);
+RcppExport SEXP _EigenH5_read_matrix_v(SEXP filenameSEXP, SEXP datapathSEXP, SEXP rowsSEXP, SEXP colsSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::RNGScope rcpp_rngScope_gen;
+    Rcpp::traits::input_parameter< const std::string >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type datapath(datapathSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type rows(rowsSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type cols(colsSEXP);
+    rcpp_result_gen = Rcpp::wrap(read_matrix_v(filename, datapath, rows, cols));
+    return rcpp_result_gen;
+END_RCPP
+}
+// read_vector_v
+SEXP read_vector_v(const std::string filename, const std::string datapath, SEXP rows);
+RcppExport SEXP _EigenH5_read_vector_v(SEXP filenameSEXP, SEXP datapathSEXP, SEXP rowsSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::RNGScope rcpp_rngScope_gen;
+    Rcpp::traits::input_parameter< const std::string >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type datapath(datapathSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type rows(rowsSEXP);
+    rcpp_result_gen = Rcpp::wrap(read_vector_v(filename, datapath, rows));
+    return rcpp_result_gen;
+END_RCPP
+}
+// update_matrix_v
+void update_matrix_v(Rcpp::RObject data, const std::string filename, const std::string datapath, SEXP rows, SEXP cols);
+RcppExport SEXP _EigenH5_update_matrix_v(SEXP dataSEXP, SEXP filenameSEXP, SEXP datapathSEXP, SEXP rowsSEXP, SEXP colsSEXP) {
+BEGIN_RCPP
+    Rcpp::RNGScope rcpp_rngScope_gen;
+    Rcpp::traits::input_parameter< Rcpp::RObject >::type data(dataSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type datapath(datapathSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type rows(rowsSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type cols(colsSEXP);
+    update_matrix_v(data, filename, datapath, rows, cols);
+    return R_NilValue;
+END_RCPP
+}
+// update_vector_v
+void update_vector_v(Rcpp::RObject data, const std::string filename, const std::string datapath, SEXP rows);
+RcppExport SEXP _EigenH5_update_vector_v(SEXP dataSEXP, SEXP filenameSEXP, SEXP datapathSEXP, SEXP rowsSEXP) {
+BEGIN_RCPP
+    Rcpp::RNGScope rcpp_rngScope_gen;
+    Rcpp::traits::input_parameter< Rcpp::RObject >::type data(dataSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type datapath(datapathSEXP);
+    Rcpp::traits::input_parameter< SEXP >::type rows(rowsSEXP);
+    update_vector_v(data, filename, datapath, rows);
+    return R_NilValue;
+END_RCPP
+}
 // openFileHandleRead
 std::string openFileHandleRead(const std::string filepath);
 static SEXP _EigenH5_openFileHandleRead_try(SEXP filepathSEXP) {
@@ -165,6 +233,72 @@ RcppExport SEXP _EigenH5_closeFileHandle(SEXP fhSEXP) {
     UNPROTECT(1);
     return rcpp_result_gen;
 }
+// has_blosc
+bool has_blosc();
+static SEXP _EigenH5_has_blosc_try() {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    rcpp_result_gen = Rcpp::wrap(has_blosc());
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _EigenH5_has_blosc() {
+    SEXP rcpp_result_gen;
+    {
+        Rcpp::RNGScope rcpp_rngScope_gen;
+        rcpp_result_gen = PROTECT(_EigenH5_has_blosc_try());
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error(CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
+// has_lzf
+bool has_lzf();
+static SEXP _EigenH5_has_lzf_try() {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    rcpp_result_gen = Rcpp::wrap(has_lzf());
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _EigenH5_has_lzf() {
+    SEXP rcpp_result_gen;
+    {
+        Rcpp::RNGScope rcpp_rngScope_gen;
+        rcpp_result_gen = PROTECT(_EigenH5_has_lzf_try());
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error(CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
 // start_blosc
 void start_blosc();
 static SEXP _EigenH5_start_blosc_try() {
@@ -481,6 +615,41 @@ RcppExport SEXP _EigenH5_write_attribute_h5(SEXP dataSEXP, SEXP filenameSEXP, SE
     UNPROTECT(1);
     return rcpp_result_gen;
 }
+// read_R_attribute_h5
+SEXP read_R_attribute_h5(const std::string& filename, std::string datapath);
+static SEXP _EigenH5_read_R_attribute_h5_try(SEXP filenameSEXP, SEXP datapathSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::traits::input_parameter< const std::string& >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< std::string >::type datapath(datapathSEXP);
+    rcpp_result_gen = Rcpp::wrap(read_R_attribute_h5(filename, datapath));
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _EigenH5_read_R_attribute_h5(SEXP filenameSEXP, SEXP datapathSEXP) {
+    SEXP rcpp_result_gen;
+    {
+        Rcpp::RNGScope rcpp_rngScope_gen;
+        rcpp_result_gen = PROTECT(_EigenH5_read_R_attribute_h5_try(filenameSEXP, datapathSEXP));
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error(CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
 // read_attribute_h5
 SEXP read_attribute_h5(const std::string& filename, std::string datapath);
 static SEXP _EigenH5_read_attribute_h5_try(SEXP filenameSEXP, SEXP datapathSEXP) {
@@ -553,6 +722,77 @@ RcppExport SEXP _EigenH5_create_dataset_h5(SEXP filenameSEXP, SEXP datapathSEXP,
     UNPROTECT(1);
     return rcpp_result_gen;
 }
+// fast_str2int
+Rcpp::IntegerVector fast_str2int(Rcpp::StringVector input, const int offset, const int na_val);
+static SEXP _EigenH5_fast_str2int_try(SEXP inputSEXP, SEXP offsetSEXP, SEXP na_valSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::traits::input_parameter< Rcpp::StringVector >::type input(inputSEXP);
+    Rcpp::traits::input_parameter< const int >::type offset(offsetSEXP);
+    Rcpp::traits::input_parameter< const int >::type na_val(na_valSEXP);
+    rcpp_result_gen = Rcpp::wrap(fast_str2int(input, offset, na_val));
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _EigenH5_fast_str2int(SEXP inputSEXP, SEXP offsetSEXP, SEXP na_valSEXP) {
+    SEXP rcpp_result_gen;
+    {
+        Rcpp::RNGScope rcpp_rngScope_gen;
+        rcpp_result_gen = PROTECT(_EigenH5_fast_str2int_try(inputSEXP, offsetSEXP, na_valSEXP));
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error(CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
+// fast_str2ascii
+Rcpp::IntegerVector fast_str2ascii(Rcpp::StringVector input, int offset);
+static SEXP _EigenH5_fast_str2ascii_try(SEXP inputSEXP, SEXP offsetSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::traits::input_parameter< Rcpp::StringVector >::type input(inputSEXP);
+    Rcpp::traits::input_parameter< int >::type offset(offsetSEXP);
+    rcpp_result_gen = Rcpp::wrap(fast_str2ascii(input, offset));
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _EigenH5_fast_str2ascii(SEXP inputSEXP, SEXP offsetSEXP) {
+    SEXP rcpp_result_gen;
+    {
+        Rcpp::RNGScope rcpp_rngScope_gen;
+        rcpp_result_gen = PROTECT(_EigenH5_fast_str2ascii_try(inputSEXP, offsetSEXP));
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error(CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
 // link_objects_h5
 void link_objects_h5(Rcpp::StringVector filename_from, const std::string filename_to, Rcpp::StringVector datapath_from, Rcpp::StringVector datapath_to);
 static SEXP _EigenH5_link_objects_h5_try(SEXP filename_fromSEXP, SEXP filename_toSEXP, SEXP datapath_fromSEXP, SEXP datapath_toSEXP) {
@@ -867,6 +1107,41 @@ RcppExport SEXP _EigenH5_isObject(SEXP filenameSEXP, SEXP datanameSEXP) {
     UNPROTECT(1);
     return rcpp_result_gen;
 }
+// ArrayTypeSize
+int ArrayTypeSize(const std::string filename, std::string dataname);
+static SEXP _EigenH5_ArrayTypeSize_try(SEXP filenameSEXP, SEXP datanameSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::traits::input_parameter< const std::string >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< std::string >::type dataname(datanameSEXP);
+    rcpp_result_gen = Rcpp::wrap(ArrayTypeSize(filename, dataname));
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _EigenH5_ArrayTypeSize(SEXP filenameSEXP, SEXP datanameSEXP) {
+    SEXP rcpp_result_gen;
+    {
+        Rcpp::RNGScope rcpp_rngScope_gen;
+        rcpp_result_gen = PROTECT(_EigenH5_ArrayTypeSize_try(filenameSEXP, datanameSEXP));
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error(CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
 // isDataSet
 bool isDataSet(const std::string filename, std::string dataname);
 static SEXP _EigenH5_isDataSet_try(SEXP filenameSEXP, SEXP datanameSEXP) {
@@ -974,12 +1249,12 @@ RcppExport SEXP _EigenH5_ls_h5(SEXP filenameSEXP, SEXP groupnameSEXP, SEXP full_
     return rcpp_result_gen;
 }
 // typeof_h5
-Rcpp::StringVector typeof_h5(const std::string& filename, const std::string& datapath);
+Rcpp::StringVector typeof_h5(const std::string filename, const std::string datapath);
 static SEXP _EigenH5_typeof_h5_try(SEXP filenameSEXP, SEXP datapathSEXP) {
 BEGIN_RCPP
     Rcpp::RObject rcpp_result_gen;
-    Rcpp::traits::input_parameter< const std::string& >::type filename(filenameSEXP);
-    Rcpp::traits::input_parameter< const std::string& >::type datapath(datapathSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< const std::string >::type datapath(datapathSEXP);
     rcpp_result_gen = Rcpp::wrap(typeof_h5(filename, datapath));
     return rcpp_result_gen;
 END_RCPP_RETURN_ERROR
@@ -1008,6 +1283,41 @@ RcppExport SEXP _EigenH5_typeof_h5(SEXP filenameSEXP, SEXP datapathSEXP) {
     UNPROTECT(1);
     return rcpp_result_gen;
 }
+// info_h5
+Rcpp::List info_h5(const Rcpp::StringVector filename, Rcpp::StringVector datapaths);
+static SEXP _EigenH5_info_h5_try(SEXP filenameSEXP, SEXP datapathsSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::traits::input_parameter< const Rcpp::StringVector >::type filename(filenameSEXP);
+    Rcpp::traits::input_parameter< Rcpp::StringVector >::type datapaths(datapathsSEXP);
+    rcpp_result_gen = Rcpp::wrap(info_h5(filename, datapaths));
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _EigenH5_info_h5(SEXP filenameSEXP, SEXP datapathsSEXP) {
+    SEXP rcpp_result_gen;
+    {
+        Rcpp::RNGScope rcpp_rngScope_gen;
+        rcpp_result_gen = PROTECT(_EigenH5_info_h5_try(filenameSEXP, datapathsSEXP));
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error(CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
 // file_acc_ct
 Rcpp::DataFrame file_acc_ct(const std::string filename);
 static SEXP _EigenH5_file_acc_ct_try(SEXP filenameSEXP) {
@@ -1120,6 +1430,8 @@ static int _EigenH5_RcppExport_validate(const char* sig) {
     if (signatures.empty()) {
         signatures.insert("std::string(*openFileHandleRead)(const std::string)");
         signatures.insert("size_t(*closeFileHandle)(const std::string)");
+        signatures.insert("bool(*has_blosc)()");
+        signatures.insert("bool(*has_lzf)()");
         signatures.insert("void(*start_blosc)()");
         signatures.insert("bool(*check_blosc)()");
         signatures.insert("int(*len)(RObject)");
@@ -1129,8 +1441,11 @@ static int _EigenH5_RcppExport_validate(const char* sig) {
         signatures.insert("bool(*update_matrix)(RObject,const std::string,std::string,const Rcpp::List&)");
         signatures.insert("bool(*update_vector)(RObject,std::string,std::string,Rcpp::List)");
         signatures.insert("bool(*write_attribute_h5)(const RObject&,const std::string&,std::string)");
+        signatures.insert("SEXP(*read_R_attribute_h5)(const std::string&,std::string)");
         signatures.insert("SEXP(*read_attribute_h5)(const std::string&,std::string)");
         signatures.insert("bool(*create_dataset_h5)(const std::string&,std::string,const RObject&,Rcpp::List)");
+        signatures.insert("Rcpp::IntegerVector(*fast_str2int)(Rcpp::StringVector,const int,const int)");
+        signatures.insert("Rcpp::IntegerVector(*fast_str2ascii)(Rcpp::StringVector,int)");
         signatures.insert("void(*link_objects_h5)(Rcpp::StringVector,const std::string,Rcpp::StringVector,Rcpp::StringVector)");
         signatures.insert("void(*create_file_h5)(const std::string)");
         signatures.insert("Rcpp::IntegerVector(*dataset_chunks)(const std::string,const std::string)");
@@ -1140,10 +1455,12 @@ static int _EigenH5_RcppExport_validate(const char* sig) {
         signatures.insert("Rcpp::IntegerVector(*guess_chunks)(const std::vector<int>)");
         signatures.insert("bool(*exists_h5)(const std::string,const std::string,const std::string)");
         signatures.insert("bool(*isObject)(const std::string,std::string)");
+        signatures.insert("int(*ArrayTypeSize)(const std::string,std::string)");
         signatures.insert("bool(*isDataSet)(const std::string,std::string)");
         signatures.insert("bool(*isGroup)(const std::string,std::string)");
         signatures.insert("Rcpp::StringVector(*ls_h5_exp)(const std::string,Rcpp::CharacterVector,bool)");
-        signatures.insert("Rcpp::StringVector(*typeof_h5)(const std::string&,const std::string&)");
+        signatures.insert("Rcpp::StringVector(*typeof_h5)(const std::string,const std::string)");
+        signatures.insert("Rcpp::List(*info_h5)(const Rcpp::StringVector,Rcpp::StringVector)");
         signatures.insert("Rcpp::DataFrame(*file_acc_ct)(const std::string)");
         signatures.insert("Rcpp::IntegerVector(*dim_h5)(const std::string&,const std::string)");
         signatures.insert("void(*concat_mats)(const std::string,const std::string,Rcpp::List,int)");
@@ -1155,6 +1472,8 @@ static int _EigenH5_RcppExport_validate(const char* sig) {
 RcppExport SEXP _EigenH5_RcppExport_registerCCallable() { 
     R_RegisterCCallable("EigenH5", "_EigenH5_openFileHandleRead", (DL_FUNC)_EigenH5_openFileHandleRead_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_closeFileHandle", (DL_FUNC)_EigenH5_closeFileHandle_try);
+    R_RegisterCCallable("EigenH5", "_EigenH5_has_blosc", (DL_FUNC)_EigenH5_has_blosc_try);
+    R_RegisterCCallable("EigenH5", "_EigenH5_has_lzf", (DL_FUNC)_EigenH5_has_lzf_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_start_blosc", (DL_FUNC)_EigenH5_start_blosc_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_check_blosc", (DL_FUNC)_EigenH5_check_blosc_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_len", (DL_FUNC)_EigenH5_len_try);
@@ -1164,8 +1483,11 @@ RcppExport SEXP _EigenH5_RcppExport_registerCCallable() {
     R_RegisterCCallable("EigenH5", "_EigenH5_update_matrix", (DL_FUNC)_EigenH5_update_matrix_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_update_vector", (DL_FUNC)_EigenH5_update_vector_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_write_attribute_h5", (DL_FUNC)_EigenH5_write_attribute_h5_try);
+    R_RegisterCCallable("EigenH5", "_EigenH5_read_R_attribute_h5", (DL_FUNC)_EigenH5_read_R_attribute_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_read_attribute_h5", (DL_FUNC)_EigenH5_read_attribute_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_create_dataset_h5", (DL_FUNC)_EigenH5_create_dataset_h5_try);
+    R_RegisterCCallable("EigenH5", "_EigenH5_fast_str2int", (DL_FUNC)_EigenH5_fast_str2int_try);
+    R_RegisterCCallable("EigenH5", "_EigenH5_fast_str2ascii", (DL_FUNC)_EigenH5_fast_str2ascii_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_link_objects_h5", (DL_FUNC)_EigenH5_link_objects_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_create_file_h5", (DL_FUNC)_EigenH5_create_file_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_dataset_chunks", (DL_FUNC)_EigenH5_dataset_chunks_try);
@@ -1175,10 +1497,12 @@ RcppExport SEXP _EigenH5_RcppExport_registerCCallable() {
     R_RegisterCCallable("EigenH5", "_EigenH5_guess_chunks", (DL_FUNC)_EigenH5_guess_chunks_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_exists_h5", (DL_FUNC)_EigenH5_exists_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_isObject", (DL_FUNC)_EigenH5_isObject_try);
+    R_RegisterCCallable("EigenH5", "_EigenH5_ArrayTypeSize", (DL_FUNC)_EigenH5_ArrayTypeSize_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_isDataSet", (DL_FUNC)_EigenH5_isDataSet_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_isGroup", (DL_FUNC)_EigenH5_isGroup_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_ls_h5_exp", (DL_FUNC)_EigenH5_ls_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_typeof_h5", (DL_FUNC)_EigenH5_typeof_h5_try);
+    R_RegisterCCallable("EigenH5", "_EigenH5_info_h5", (DL_FUNC)_EigenH5_info_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_file_acc_ct", (DL_FUNC)_EigenH5_file_acc_ct_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_dim_h5", (DL_FUNC)_EigenH5_dim_h5_try);
     R_RegisterCCallable("EigenH5", "_EigenH5_concat_mats", (DL_FUNC)_EigenH5_concat_mats_try);
@@ -1197,8 +1521,15 @@ static const R_CallMethodDef CallEntries[] = {
     {"_EigenH5_get_file_object", (DL_FUNC) &_EigenH5_get_file_object, 2},
     {"_EigenH5_get_dataset", (DL_FUNC) &_EigenH5_get_dataset, 2},
     {"_EigenH5_get_group", (DL_FUNC) &_EigenH5_get_group, 2},
+    {"_EigenH5_read_matrix_rl", (DL_FUNC) &_EigenH5_read_matrix_rl, 4},
+    {"_EigenH5_read_matrix_v", (DL_FUNC) &_EigenH5_read_matrix_v, 4},
+    {"_EigenH5_read_vector_v", (DL_FUNC) &_EigenH5_read_vector_v, 3},
+    {"_EigenH5_update_matrix_v", (DL_FUNC) &_EigenH5_update_matrix_v, 5},
+    {"_EigenH5_update_vector_v", (DL_FUNC) &_EigenH5_update_vector_v, 4},
     {"_EigenH5_openFileHandleRead", (DL_FUNC) &_EigenH5_openFileHandleRead, 1},
     {"_EigenH5_closeFileHandle", (DL_FUNC) &_EigenH5_closeFileHandle, 1},
+    {"_EigenH5_has_blosc", (DL_FUNC) &_EigenH5_has_blosc, 0},
+    {"_EigenH5_has_lzf", (DL_FUNC) &_EigenH5_has_lzf, 0},
     {"_EigenH5_start_blosc", (DL_FUNC) &_EigenH5_start_blosc, 0},
     {"_EigenH5_check_blosc", (DL_FUNC) &_EigenH5_check_blosc, 0},
     {"_EigenH5_len", (DL_FUNC) &_EigenH5_len, 1},
@@ -1208,8 +1539,11 @@ static const R_CallMethodDef CallEntries[] = {
     {"_EigenH5_update_matrix", (DL_FUNC) &_EigenH5_update_matrix, 4},
     {"_EigenH5_update_vector", (DL_FUNC) &_EigenH5_update_vector, 4},
     {"_EigenH5_write_attribute_h5", (DL_FUNC) &_EigenH5_write_attribute_h5, 3},
+    {"_EigenH5_read_R_attribute_h5", (DL_FUNC) &_EigenH5_read_R_attribute_h5, 2},
     {"_EigenH5_read_attribute_h5", (DL_FUNC) &_EigenH5_read_attribute_h5, 2},
     {"_EigenH5_create_dataset_h5", (DL_FUNC) &_EigenH5_create_dataset_h5, 4},
+    {"_EigenH5_fast_str2int", (DL_FUNC) &_EigenH5_fast_str2int, 3},
+    {"_EigenH5_fast_str2ascii", (DL_FUNC) &_EigenH5_fast_str2ascii, 2},
     {"_EigenH5_link_objects_h5", (DL_FUNC) &_EigenH5_link_objects_h5, 4},
     {"_EigenH5_create_file_h5", (DL_FUNC) &_EigenH5_create_file_h5, 1},
     {"_EigenH5_dataset_chunks", (DL_FUNC) &_EigenH5_dataset_chunks, 2},
@@ -1219,15 +1553,17 @@ static const R_CallMethodDef CallEntries[] = {
     {"_EigenH5_guess_chunks", (DL_FUNC) &_EigenH5_guess_chunks, 1},
     {"_EigenH5_exists_h5", (DL_FUNC) &_EigenH5_exists_h5, 3},
     {"_EigenH5_isObject", (DL_FUNC) &_EigenH5_isObject, 2},
+    {"_EigenH5_ArrayTypeSize", (DL_FUNC) &_EigenH5_ArrayTypeSize, 2},
     {"_EigenH5_isDataSet", (DL_FUNC) &_EigenH5_isDataSet, 2},
     {"_EigenH5_isGroup", (DL_FUNC) &_EigenH5_isGroup, 2},
     {"_EigenH5_ls_h5", (DL_FUNC) &_EigenH5_ls_h5, 3},
     {"_EigenH5_typeof_h5", (DL_FUNC) &_EigenH5_typeof_h5, 2},
+    {"_EigenH5_info_h5", (DL_FUNC) &_EigenH5_info_h5, 2},
     {"_EigenH5_file_acc_ct", (DL_FUNC) &_EigenH5_file_acc_ct, 1},
     {"_EigenH5_dim_h5", (DL_FUNC) &_EigenH5_dim_h5, 2},
     {"_EigenH5_concat_mats", (DL_FUNC) &_EigenH5_concat_mats, 4},
     {"_EigenH5_RcppExport_registerCCallable", (DL_FUNC) &_EigenH5_RcppExport_registerCCallable, 0},
-    {"run_testthat_tests",                    (DL_FUNC) &run_testthat_tests,                    0},
+    {"run_testthat_tests", (DL_FUNC) &run_testthat_tests, 0},
     {NULL, NULL, 0}
 };
 
diff --git a/src/altrep_methods.cpp b/src/altrep_methods.cpp
new file mode 100644
index 0000000..d095571
--- /dev/null
+++ b/src/altrep_methods.cpp
@@ -0,0 +1,97 @@
+// [[Rcpp::depends(BH)]]
+#include <cstdbool>
+#include <variant>
+#include <R.h>
+#include <Rcpp.h>
+#include <Rinternals.h>
+#include <Rversion.h>
+
+// because we need to initialize the altrep class
+#include <R_ext/Rdynload.h>
+
+#if R_VERSION < R_Version(3, 6, 0)
+
+// workaround because R's <R_ext/Altrep.h> not so conveniently uses `class`
+// as a variable name, and C++ is not happy about that
+//
+// SEXP R_new_altrep(R_altrep_class_t class, SEXP data1, SEXP data2);
+//
+#define class klass
+
+// Because functions declared in <R_ext/Altrep.h> have C linkage
+extern "C" {
+#include <R_ext/Altrep.h>
+}
+
+// undo the workaround
+#undef class
+
+#else
+#include <R_ext/Altrep.h>
+#endif
+
+// #include <EigenH5.h>
+
+bool is_compact_seq(SEXP x) {
+
+  if(!ALTREP(x)){
+
+    return false;
+  }
+  R_xlen_t info_l=::Rf_xlength(R_altrep_data1(x));
+  if(info_l!=3){
+
+    return false;
+  }
+
+  return true;
+}
+
+
+
+bool is_compact_forward(SEXP x){
+  if(!ALTREP(x)){
+
+    return false;
+  }
+  const auto info = R_altrep_data1(x);
+  R_xlen_t info_l=::Rf_xlength(info);
+  if(info_l!=3){
+    return false;
+  }
+  if(((int) REAL0(info)[2])!=1){
+    return false;
+  }
+  return true;
+}
+
+std::pair<int,std::optional<int>> altrep_pair(SEXP x){
+  if(!is_compact_seq(x)){
+    Rcpp::stop("x is not a compact sequence!");
+  }
+  const auto ard = R_altrep_data1(x);
+  const auto ardd = REAL0(ard);
+  const int seq_size =(int)ardd[0];
+  const int seq_start= (int)ardd[1]-1;
+
+  return(std::make_pair(seq_start,seq_size));
+}
+
+
+std::variant<std::pair<int,std::optional<int>> ,Rcpp::IntegerVector> dispatch_subset(SEXP x){
+
+  auto my_t = TYPEOF(x);
+  if(my_t!=INTSXP){
+    Rcpp::stop("cannot dispatch non-integer types (yet)");
+  }
+  R_xlen_t info_l=::Rf_xlength(x);
+  if(info_l==0){
+    return(std::make_pair(0,std::nullopt));
+  }
+  if(is_compact_forward(x)){
+    auto ap= altrep_pair(x);
+    return(ap);
+  }
+  Rcpp::IntegerVector av=Rcpp::as<Rcpp::IntegerVector>(x);
+  return(av);
+}
diff --git a/src/bitstream.h b/src/bitstream.h
new file mode 100644
index 0000000..7bdb060
--- /dev/null
+++ b/src/bitstream.h
@@ -0,0 +1,459 @@
+/* ******************************************************************
+   bitstream
+   Part of FSE library
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef BITSTREAM_H_MODULE
+#define BITSTREAM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*
+*  This API consists of small unitary functions, which must be inlined for best performance.
+*  Since link-time-optimization is not available for all compilers,
+*  these functions are defined into a .h to be included.
+*/
+
+/*-****************************************
+*  Dependencies
+******************************************/
+#include "mem.h"            /* unaligned access routines */
+#include "debug.h"          /* assert(), DEBUGLOG(), RAWLOG() */
+#include "error_private.h"  /* error codes and messages */
+
+
+/*=========================================
+*  Target specific
+=========================================*/
+#if defined(__BMI__) && defined(__GNUC__)
+#  include <immintrin.h>   /* support for bextr (experimental) */
+#elif defined(__ICCARM__)
+#  include <intrinsics.h>
+#endif
+
+#define STREAM_ACCUMULATOR_MIN_32  25
+#define STREAM_ACCUMULATOR_MIN_64  57
+#define STREAM_ACCUMULATOR_MIN    ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))
+
+
+/*-******************************************
+*  bitStream encoding API (write forward)
+********************************************/
+/* bitStream can mix input from multiple sources.
+ * A critical property of these streams is that they encode and decode in **reverse** direction.
+ * So the first bit sequence you add will be the last to be read, like a LIFO stack.
+ */
+typedef struct {
+    size_t bitContainer;
+    unsigned bitPos;
+    char*  startPtr;
+    char*  ptr;
+    char*  endPtr;
+} BIT_CStream_t;
+
+MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);
+MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
+MEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC);
+MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
+
+/* Start with initCStream, providing the size of buffer to write into.
+*  bitStream will never write outside of this buffer.
+*  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
+*
+*  bits are first added to a local register.
+*  Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
+*  Writing data into memory is an explicit operation, performed by the flushBits function.
+*  Hence keep track how many bits are potentially stored into local register to avoid register overflow.
+*  After a flushBits, a maximum of 7 bits might still be stored into local register.
+*
+*  Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers.
+*
+*  Last operation is to close the bitStream.
+*  The function returns the final size of CStream in bytes.
+*  If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
+*/
+
+
+/*-********************************************
+*  bitStream decoding API (read backward)
+**********************************************/
+typedef struct {
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+    const char* limitPtr;
+} BIT_DStream_t;
+
+typedef enum { BIT_DStream_unfinished = 0,
+               BIT_DStream_endOfBuffer = 1,
+               BIT_DStream_completed = 2,
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
+
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
+
+
+/* Start by invoking BIT_initDStream().
+*  A chunk of the bitStream is then stored into a local register.
+*  Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
+*  You can then retrieve bitFields stored into the local register, **in reverse order**.
+*  Local register is explicitly reloaded from memory by the BIT_reloadDStream() method.
+*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
+*  Otherwise, it can be less than that, so proceed accordingly.
+*  Checking if DStream has reached its end can be performed with BIT_endOfDStream().
+*/
+
+
+/*-****************************************
+*  unsafe API
+******************************************/
+MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
+/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */
+
+MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
+/* unsafe version; does not check buffer overflow */
+
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
+/* faster, but works only if nbBits >= 1 */
+
+
+
+/*-**************************************************************
+*  Internal functions
+****************************************************************/
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
+{
+    assert(val != 0);
+    {
+#   if defined(_MSC_VER)   /* Visual */
+        unsigned long r=0;
+        _BitScanReverse ( &r, val );
+        return (unsigned) r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+        return 31 - __builtin_clz (val);
+#   elif defined(__ICCARM__)    /* IAR Intrinsic */
+        return 31 - __CLZ(val);
+#   else   /* Software version */
+        static const unsigned DeBruijnClz[32] = { 0,  9,  1, 10, 13, 21,  2, 29,
+                                                 11, 14, 16, 18, 22, 25,  3, 30,
+                                                  8, 12, 20, 28, 15, 17, 24,  7,
+                                                 19, 27, 23,  6, 26,  5,  4, 31 };
+        U32 v = val;
+        v |= v >> 1;
+        v |= v >> 2;
+        v |= v >> 4;
+        v |= v >> 8;
+        v |= v >> 16;
+        return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+#   endif
+    }
+}
+
+/*=====    Local Constants   =====*/
+static const unsigned BIT_mask[] = {
+    0,          1,         3,         7,         0xF,       0x1F,
+    0x3F,       0x7F,      0xFF,      0x1FF,     0x3FF,     0x7FF,
+    0xFFF,      0x1FFF,    0x3FFF,    0x7FFF,    0xFFFF,    0x1FFFF,
+    0x3FFFF,    0x7FFFF,   0xFFFFF,   0x1FFFFF,  0x3FFFFF,  0x7FFFFF,
+    0xFFFFFF,   0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF,
+    0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */
+#define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0]))
+
+/*-**************************************************************
+*  bitStream encoding
+****************************************************************/
+/*! BIT_initCStream() :
+ *  `dstCapacity` must be > sizeof(size_t)
+ *  @return : 0 if success,
+ *            otherwise an error code (can be tested using ERR_isError()) */
+MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
+                                  void* startPtr, size_t dstCapacity)
+{
+    bitC->bitContainer = 0;
+    bitC->bitPos = 0;
+    bitC->startPtr = (char*)startPtr;
+    bitC->ptr = bitC->startPtr;
+    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer);
+    if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall);
+    return 0;
+}
+
+/*! BIT_addBits() :
+ *  can add up to 31 bits into `bitC`.
+ *  Note : does not check for register overflow ! */
+MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
+                            size_t value, unsigned nbBits)
+{
+    MEM_STATIC_ASSERT(BIT_MASK_SIZE == 32);
+    assert(nbBits < BIT_MASK_SIZE);
+    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
+    bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos;
+    bitC->bitPos += nbBits;
+}
+
+/*! BIT_addBitsFast() :
+ *  works only if `value` is _clean_,
+ *  meaning all high bits above nbBits are 0 */
+MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC,
+                                size_t value, unsigned nbBits)
+{
+    assert((value>>nbBits) == 0);
+    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
+    bitC->bitContainer |= value << bitC->bitPos;
+    bitC->bitPos += nbBits;
+}
+
+/*! BIT_flushBitsFast() :
+ *  assumption : bitContainer has not overflowed
+ *  unsafe version; does not check buffer overflow */
+MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
+{
+    size_t const nbBytes = bitC->bitPos >> 3;
+    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
+    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
+    bitC->ptr += nbBytes;
+    assert(bitC->ptr <= bitC->endPtr);
+    bitC->bitPos &= 7;
+    bitC->bitContainer >>= nbBytes*8;
+}
+
+/*! BIT_flushBits() :
+ *  assumption : bitContainer has not overflowed
+ *  safe version; check for buffer overflow, and prevents it.
+ *  note : does not signal buffer overflow.
+ *  overflow will be revealed later on using BIT_closeCStream() */
+MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
+{
+    size_t const nbBytes = bitC->bitPos >> 3;
+    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
+    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
+    bitC->ptr += nbBytes;
+    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
+    bitC->bitPos &= 7;
+    bitC->bitContainer >>= nbBytes*8;
+}
+
+/*! BIT_closeCStream() :
+ *  @return : size of CStream, in bytes,
+ *            or 0 if it could not fit into dstBuffer */
+MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
+{
+    BIT_addBitsFast(bitC, 1, 1);   /* endMark */
+    BIT_flushBits(bitC);
+    if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */
+    return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
+}
+
+
+/*-********************************************************
+*  bitStream decoding
+**********************************************************/
+/*! BIT_initDStream() :
+ *  Initialize a BIT_DStream_t.
+ * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
+ * `srcSize` must be the *exact* size of the bitStream, in bytes.
+ * @return : size of stream (== srcSize), or an errorCode if a problem is detected
+ */
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
+
+    bitD->start = (const char*)srcBuffer;
+    bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
+
+    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+          bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
+          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
+    } else {
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+        case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
+                /* fall-through */
+
+        case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
+                /* fall-through */
+
+        case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
+                /* fall-through */
+
+        case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
+                /* fall-through */
+
+        case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
+                /* fall-through */
+
+        case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8;
+                /* fall-through */
+
+        default: break;
+        }
+        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+            bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
+            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
+        }
+        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+
+MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start)
+{
+    return bitContainer >> start;
+}
+
+MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
+{
+    U32 const regMask = sizeof(bitContainer)*8 - 1;
+    /* if start > regMask, bitstream is corrupted, and result is undefined */
+    assert(nbBits < BIT_MASK_SIZE);
+    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
+}
+
+MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
+{
+    assert(nbBits < BIT_MASK_SIZE);
+    return bitContainer & BIT_mask[nbBits];
+}
+
+/*! BIT_lookBits() :
+ *  Provides next n bits from local register.
+ *  local register is not modified.
+ *  On 32-bits, maxNbBits==24.
+ *  On 64-bits, maxNbBits==56.
+ * @return : value extracted */
+MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
+{
+    /* arbitrate between double-shift and shift+mask */
+#if 1
+    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
+     * bitstream is likely corrupted, and result is undefined */
+    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
+#else
+    /* this code path is slower on my os-x laptop */
+    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
+#endif
+}
+
+/*! BIT_lookBitsFast() :
+ *  unsafe version; only works if nbBits >= 1 */
+MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
+{
+    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
+    assert(nbBits >= 1);
+    return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
+}
+
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+/*! BIT_readBits() :
+ *  Read (consume) next n bits from local register and update.
+ *  Pay attention to not read more than nbBits contained into local register.
+ * @return : extracted value. */
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
+{
+    size_t const value = BIT_lookBits(bitD, nbBits);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*! BIT_readBitsFast() :
+ *  unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
+{
+    size_t const value = BIT_lookBitsFast(bitD, nbBits);
+    assert(nbBits >= 1);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*! BIT_reloadDStream() :
+ *  Refill `bitD` from buffer previously set in BIT_initDStream() .
+ *  This function is safe, it guarantees it will not read beyond src buffer.
+ * @return : status of `BIT_DStream_t` internal register.
+ *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* overflow detected, like end of stream */
+        return BIT_DStream_overflow;
+
+    if (bitD->ptr >= bitD->limitPtr) {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        return BIT_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start) {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
+        return BIT_DStream_completed;
+    }
+    /* start < ptr < limitPtr */
+    {   U32 nbBytes = bitD->bitsConsumed >> 3;
+        BIT_DStream_status result = BIT_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start) {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = BIT_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
+        return result;
+    }
+}
+
+/*! BIT_endOfDStream() :
+ * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
+ */
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
+{
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* BITSTREAM_H_MODULE */
diff --git a/src/blosc_filter.c b/src/blosc_filter.c
index 8b7d42d..1b5ef32 100644
--- a/src/blosc_filter.c
+++ b/src/blosc_filter.c
@@ -13,6 +13,8 @@
 #ifdef USE_BLOSC
 #include "blosc_filter.h"
 #include "hdf5.h"
+
+#include <H5Epubgen.h>
 #include <string.h>
 
 
@@ -55,7 +57,7 @@ int register_blosc(char **version, char **date){
 
     retval = H5Zregister(&filter_class);
     if(retval<0){
-        PUSH_ERR("register_blosc", H5E_CANTREGISTER, "Can't register Blosc filter");
+        PUSH_ERR("register_blosc", retval, "Can't register Blosc filter");
     }
     if (version != NULL && date != NULL) {
         *version = strdup(BLOSC_VERSION_STRING);
@@ -216,7 +218,7 @@ size_t blosc_filter(unsigned flags, size_t cd_nelmts,
       goto failed;
     }
 
-    blosc_set_compressor(compname);
+
     status = blosc_compress(clevel, doshuffle, typesize, nbytes,
                             *buf, outbuf, nbytes);
     if (status < 0) {
diff --git a/src/chunk_io.cpp b/src/chunk_io.cpp
new file mode 100644
index 0000000..1ec423a
--- /dev/null
+++ b/src/chunk_io.cpp
@@ -0,0 +1,641 @@
+#include "EigenH5.h"
+#include <variant>
+#include<eigenh5/indexers.hpp>
+//[[depends(RcppEigen)]]
+//[[Rcpp::plugins(cpp11)]]
+// [[Rcpp::depends(BH)]]
+
+
+
+
+
+
+template <typename D,typename T>
+class VecShuttle {
+  const T &Chunks;
+  const size_t total_data_size;
+  const size_t chunksize;
+  const size_t elem_size;
+  using tensor_type=typename xtm_t<D>::buffvec_type;
+  using rtensor_type=typename xtm_t<D>::retvec_type;
+
+  tensor_type chunk_buffer;
+  std::vector<std::byte> raw_chunk_buffer;
+  using shape_type = typename tensor_type::shape_type;
+public:
+  VecShuttle(const T& Chunks_,const size_t elem_size_=1):
+    Chunks(Chunks_),
+    total_data_size(Chunks.total_size()),
+    chunksize(Chunks.total_chunksize()),
+    elem_size(elem_size_),
+    chunk_buffer([](size_t chunksize_,size_t elem_size_){
+		   if constexpr(std::is_arithmetic_v<D>){
+return tensor_type(shape_type{chunksize_});
+ }else{
+		     return(tensor_type({chunksize_,elem_size_}));
+		   }
+		 }(chunksize,elem_size)),
+    raw_chunk_buffer(chunksize*sizeof(typename tensor_type::value_type)*elem_size)
+  {}
+ rtensor_type create_retvec(){
+    if constexpr(std::is_arithmetic_v<D>){
+   using rshape_type = typename rtensor_type::shape_type;
+    return(rtensor_type(rshape_type{static_cast<int>(total_data_size)}));
+    }else{
+      return(rtensor_type(static_cast<int>(total_data_size)));
+    }
+ }
+
+
+  template<typename Z>
+  rtensor_type read_vector(Z &decomp,const HighFive::DataSet& d){
+    rtensor_type retvec=create_retvec();
+    for(auto &tchunk:Chunks){
+      auto res = d.read_raw_chunk(raw_chunk_buffer,{tchunk.disk_offset()});
+      decomp.decompress(chunk_buffer.data(),chunk_buffer.size()*sizeof(typename tensor_type::value_type),raw_chunk_buffer.data(),res);
+      if constexpr(!std::is_arithmetic_v<D>){
+	  const auto rsize = tchunk.chunk_size();
+	  xt::xtensor<char,1> tbuff(xt::xtensor<char,1>::shape_type{elem_size});
+	  std::string ts;
+	  for(int i=0;i< rsize; i++){
+		tbuff=xt::view(chunk_buffer,tchunk.chunk_i(i),xt::all());
+		ts=std::string(reinterpret_cast<char*>(tbuff.data()));
+		retvec(tchunk.mem_i(i))=ts;
+		std::fill(tbuff.begin(), tbuff.end(), 0);
+	      }
+	}else{
+	if constexpr(std::is_same_v<T,chunk_chunker>){
+
+	      xt::view(retvec,tchunk.mem_slice())=
+		xt::view(chunk_buffer,tchunk.chunk_slice());
+	    }else{
+	  xt::dynamic_view(retvec,{tchunk.mem_slice()})=
+	    xt::dynamic_view(chunk_buffer,{tchunk.chunk_slice()});
+	}
+      }
+    }
+    return retvec;
+  }
+
+  template<typename Z>
+  void write_vector(const rtensor_type & retmat,Z &decomp,const HighFive::DataSet& d){
+    for(auto &tchunk_r:Chunks){
+      if constexpr(!std::is_arithmetic_v<D>){
+
+	  const auto rsize = tchunk_r.chunk_size();
+	  xt::xtensor<char,1> tbuff(xt::xtensor<char,1>::shape_type{elem_size});
+	  std::string ts;
+	  for(int i=0;i< rsize; i++){
+	    std::fill(tbuff.begin(), tbuff.end(), 0);
+	    ts=Rcpp::as<std::string>(retmat(tchunk_r.mem_i(i)));
+	    std::memcpy(tbuff.data(),ts.data(),ts.size());
+	    xt::view(chunk_buffer,tchunk_r.chunk_i(i),xt::all())=tbuff;
+	  }
+	}else{
+
+	if constexpr(std::is_same_v<T,chunk_chunker>){
+	    xt::view(chunk_buffer,tchunk_r.chunk_slice())=
+	      xt::view(retmat,tchunk_r.mem_slice());
+	  }else{
+	  xt::dynamic_view(chunk_buffer,{tchunk_r.chunk_slice()})=
+	    xt::dynamic_view(retmat,{tchunk_r.mem_slice()});
+	}
+      }
+      auto res = decomp.compress(raw_chunk_buffer.data(),raw_chunk_buffer.size(),chunk_buffer.data(),chunk_buffer.size()*sizeof(typename tensor_type::value_type));
+      d.write_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset()},res);
+    }
+  }
+};
+
+
+
+
+template <typename D,typename TA, typename TB>
+class MatrixShuttle {
+  const TA& RowChunks;
+  const TB& ColChunks;
+  const size_t total_data_rowsize;
+  const size_t total_data_colsize;
+  const size_t chunksize_rows;
+  const size_t chunksize_cols;
+  const size_t elem_size;
+  using tensor_type=typename xtm_t<D>::buffmat_type;
+  using rtensor_type=typename xtm_t<D>::retmat_type;
+  tensor_type chunk_buffer;
+  std::vector<std::byte> raw_chunk_buffer;
+
+public:
+  MatrixShuttle(const  TA& RowChunks_,const TB& ColChunks_, const size_t elem_size_=1):
+    RowChunks(RowChunks_),
+    ColChunks(ColChunks_),
+    total_data_rowsize(RowChunks.total_size()),
+    total_data_colsize(ColChunks.total_size()),
+    chunksize_rows(RowChunks.total_chunksize()),
+    chunksize_cols(ColChunks.total_chunksize()),
+    elem_size(elem_size_),
+    chunk_buffer([](size_t chunksize_rows_,size_t chunksize_cols_,size_t elem_size_){
+		   if constexpr(std::is_arithmetic_v<D>){
+return tensor_type({chunksize_rows_,chunksize_cols_});
+ }else{
+		     return(tensor_type({chunksize_rows_,elem_size_,chunksize_cols_}));
+		   }
+		 }(chunksize_rows,chunksize_cols,elem_size)),
+    raw_chunk_buffer(chunksize_rows*elem_size*chunksize_cols*sizeof(typename tensor_type::value_type))
+  {}
+
+  rtensor_type create_retmat(){
+    if constexpr(std::is_arithmetic_v<D>){
+    return(rtensor_type({static_cast<int>(total_data_rowsize),static_cast<int>(total_data_colsize)}));
+    }else{
+      return(rtensor_type(static_cast<int>(total_data_rowsize),static_cast<int>(total_data_colsize)));
+    }
+  }
+
+  template<typename Z>
+  rtensor_type read_matrix(Z &decomp,const HighFive::DataSet& d){
+    auto retmat=create_retmat();
+    for(auto &tchunk_r:RowChunks){
+      for(auto &tchunk_c:ColChunks){
+
+
+	auto res = d.read_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset(),tchunk_c.disk_offset()});
+	decomp.decompress(chunk_buffer.data(),chunk_buffer.size()*sizeof(typename tensor_type::value_type),raw_chunk_buffer.data(),res);
+
+	if constexpr(!std::is_arithmetic_v<D>){
+	      const size_t rsize = tchunk_r.chunk_size();
+	      const size_t csize = tchunk_c.chunk_size();
+	      xt::xtensor<char,1> tbuff(xt::xtensor<char,1>::shape_type{elem_size});
+	      std::string ts;
+	      for(int i=0;i< rsize; i++){
+		for(int j=0; j<csize; j++){
+		  tbuff=xt::view(chunk_buffer,tchunk_r.chunk_i(i),xt::all(),tchunk_c.chunk_i(j));
+		  ts=std::string(reinterpret_cast<char*>(tbuff.data()));
+		    retmat(tchunk_r.mem_i(i),tchunk_c.mem_i(j))=ts;
+		  std::fill(tbuff.begin(), tbuff.end(), 0);
+		}
+	      }
+	  }else{
+	  if constexpr(std::is_same_v<TB,chunk_chunker> && std::is_same_v<TA,chunk_chunker>){
+
+	      xt::view(retmat,tchunk_r.mem_slice(),tchunk_c.mem_slice())=
+		xt::view(chunk_buffer,tchunk_r.chunk_slice(),tchunk_c.chunk_slice());
+	    }else{
+	    xt::dynamic_view(retmat,{tchunk_r.mem_slice(),tchunk_c.mem_slice()})=
+	      xt::dynamic_view(chunk_buffer,{tchunk_r.chunk_slice(),tchunk_c.chunk_slice()});
+	  }
+	}
+      }
+    }
+    return retmat;
+  }
+  template<typename Z>
+  void write_matrix(const rtensor_type& retmat,Z &decomp,const HighFive::DataSet& d){
+
+    int rc=0;
+    int cc=0;
+    for(auto &tchunk_r:RowChunks){
+      cc=0;
+      for(auto &tchunk_c:ColChunks){
+	if constexpr(!std::is_arithmetic_v<D>){
+	    xt::xtensor<char,1> tbuff(xt::xtensor<char,1>::shape_type{elem_size});
+	    std::string ts;
+	    const size_t rsize = tchunk_r.chunk_size();
+	    const size_t csize = tchunk_c.chunk_size();
+	    for(int i=0;i< rsize; i++){
+	      for(int j=0; j<csize; j++){
+		std::fill(tbuff.begin(), tbuff.end(), 0);
+		ts=Rcpp::as<std::string>(retmat(tchunk_r.mem_i(i),tchunk_c.mem_i(j)));
+		std::memcpy(tbuff.data(),ts.data(),ts.size());
+
+		#ifdef DEBUG
+		if(xt::view(chunk_buffer,tchunk_r.chunk_i(i),xt::all(),tchunk_c.chunk_i(j)).size()<tbuff.size()){
+		  Rcpp::Rcerr<<"i is: "<<i<<" and j is: "<<j<<std::endl;
+		  Rcpp::stop("you're about to do some illegal copying (so instead I stopped)");
+		}
+		#endif
+
+		xt::view(chunk_buffer,tchunk_r.chunk_i(i),xt::all(),tchunk_c.chunk_i(j))=tbuff;
+
+	      }
+	    }
+	  }else{
+	  if constexpr(std::is_same_v<TB,chunk_chunker> && std::is_same_v<TA,chunk_chunker>){
+	      xt::view(chunk_buffer,tchunk_r.chunk_slice(),tchunk_c.chunk_slice())=
+		xt::view(retmat,tchunk_r.mem_slice(),tchunk_c.mem_slice());
+	    }else{
+	    xt::dynamic_view(chunk_buffer,{tchunk_r.chunk_slice(),tchunk_c.chunk_slice()})=
+	      xt::dynamic_view(retmat,{tchunk_r.mem_slice(),tchunk_c.mem_slice()});
+	  }
+	}
+	auto res = decomp.compress(raw_chunk_buffer.data(),raw_chunk_buffer.size(),
+				   chunk_buffer.data(),chunk_buffer.size()*sizeof(typename tensor_type::value_type));
+	d.write_raw_chunk(raw_chunk_buffer,{tchunk_r.disk_offset(),tchunk_c.disk_offset()},res);
+	cc++;
+      }
+      rc++;
+    }
+  }
+};
+
+
+class VecDim{
+public:
+  const std::array<size_t,1> dimsize;
+  const std::array<size_t,1> chunksize;
+  VecDim(std::vector<size_t> dim_d,std::vector<size_t> dim_c):dimsize(std::array<size_t,1>{dim_d[0]}),
+							      chunksize(std::array<size_t,1>{dim_c[0]}){}
+  // VecDim(std::array<size_t,1> dimsize_,std::array<size_t,1> chunksize_):dimsize(dimsize_),
+  // 									chunksize(chunksize_){}
+};
+
+class MatDim{
+public:
+  const std::array<size_t,2> dimsize;
+  const std::array<size_t,2> chunksize;
+  //  MatDim(std::array<size_t,2> dimsize_,std::array<size_t,2> chunksize_): dimsize(dimsize_),chunksize(chunksize_){}
+  MatDim(std::vector<size_t> dim_d,std::vector<size_t> dim_c):dimsize(std::array<size_t,2>{dim_d[0],dim_d[1]}),
+							      chunksize(std::array<size_t,2>{dim_c[0],dim_c[1]}){}
+};
+
+template<typename T>
+class DataSet_V{
+
+public:
+  const T Dim;
+  std::variant<int,double,std::string> data_type;
+  std::variant<NoCompressor,LzfCompressor,BloscCompressor,GzipCompressor,ZstdCompressor> decompressor;
+  std::vector<std::string> R_attrs;
+
+
+  DataSet_V(const HighFive::DataSet &dset):Dim(dset.getDataDimensions(),dset.getFilter().get_chunksizes()),
+					   decompressor(dset.getFilter().getDecompressor()),
+                                           R_attrs(list_R_attr(dset))
+  {
+
+    auto ret_t = typeof_h5_dset(dset);
+    switch(ret_t){
+    case INTSXP: {
+      data_type=int();
+      break;
+    }
+    case REALSXP: {
+      data_type=double();
+      break;
+    }
+    case STRSXP: {
+      data_type=std::string();
+      break;
+    }
+    default:{
+      Rcpp::stop("can't create type");
+      break;
+    }
+    }
+    //    decompressor = dset.getFilter().getDecompressor();
+  }
+};
+
+
+template<typename T>
+class DataSet_VNS{
+
+public:
+  const T Dim;
+  std::variant<int,double> data_type;
+  std::variant<NoCompressor,LzfCompressor,BloscCompressor,GzipCompressor,ZstdCompressor> decompressor;
+
+
+  DataSet_VNS(const HighFive::DataSet &dset):Dim(dset.getDataDimensions(),dset.getFilter().get_chunksizes()),
+					   decompressor(dset.getFilter().getDecompressor()){
+
+    auto ret_t = typeof_h5_dset(dset);
+    switch(ret_t){
+    case INTSXP: {
+      data_type=int();
+      break;
+    }
+    case REALSXP: {
+      data_type=double();
+      break;
+    }
+    default:{
+      Rcpp::stop("can't create type");
+      break;
+    }
+    }
+    //    decompressor = dset.getFilter().getDecompressor();
+  }
+};
+
+
+
+class VisitVectorRead
+{
+public:
+  const HighFive::DataSet &d;
+  const VecDim Dim;
+  VisitVectorRead(const HighFive::DataSet &d_, const VecDim Dim_,const bool read_attributes=false):d(d_),Dim(Dim_){}
+  template<typename Q,typename Z,typename T>
+  SEXP operator()(Q ret,Z& decomp,T rowdat)const{
+    using RT=typename t2chunk_t<T>::c_type;
+    RT rows(Dim.dimsize[0],Dim.chunksize[0],rowdat);
+    if constexpr(std::is_same_v<Q,std::string>){
+      auto elem_size = H5Tget_size(d.getDataType().getId());
+      VecShuttle<Q,RT> mover(rows,elem_size);
+      return(Rcpp::as<typename xtm_t<Q>::rrvec_type>(mover.template read_vector<Z>(decomp,d)));
+    }else{
+      VecShuttle<Q,RT> mover(rows,1);
+      auto ret=Rcpp::as<typename xtm_t<Q>::rrvec_type>(mover.template read_vector<Z>(decomp,d));
+      ret.attr("dim") =  R_NilValue;
+      return(ret);
+    }
+  }
+};
+
+
+
+
+class VisitMatrixRead
+
+{
+public:
+  const HighFive::DataSet &d;
+  const MatDim Dim;
+  VisitMatrixRead(const HighFive::DataSet &d_,const MatDim Dim_):d(d_),Dim(Dim_){}
+  template<typename Q,typename Z,typename RT,typename CT>
+  SEXP operator()(Q ret,Z& decomp,RT rowdat,CT coldat)const{
+    using RRT=typename t2chunk_t<RT>::c_type;
+    using CCT=typename t2chunk_t<CT>::c_type;
+    const RRT rows(Dim.dimsize[0],Dim.chunksize[0],rowdat);
+    const CCT cols(Dim.dimsize[1],Dim.chunksize[1],coldat);
+    if constexpr(std::is_same_v<Q,std::string>){
+    auto elem_size = H5Tget_size(d.getDataType().getId());
+    MatrixShuttle<Q,RRT,CCT> mover(rows,cols,elem_size);
+    return(mover.template read_matrix<Z>(decomp,d));
+    }else{
+      MatrixShuttle<Q,RRT,CCT> mover(rows,cols,1);
+    return(mover.template read_matrix<Z>(decomp,d));
+    }
+
+  }
+};
+
+
+
+class VisitMatrixReadRL
+{
+public:
+  const HighFive::DataSet &d;
+  const MatDim Dim;
+  VisitMatrixReadRL(const HighFive::DataSet &d_,const MatDim Dim_):d(d_),Dim(Dim_){}
+  template<typename Q,typename Z,typename RT,typename CT>
+  auto operator()(Q ret,Z& decomp,RT rowdat,CT coldat)const{
+    using RRT=typename t2chunk_t<RT>::c_type;
+    using CCT=typename t2chunk_t<CT>::c_type;
+
+    using tensor_type=typename xtm_t<Q>::buffmat_type;
+    using rtensor_type=typename xtm_t<Q>::retmat_type;
+    using shape_type = typename tensor_type::shape_type;
+    const RRT rows(Dim.dimsize[0],Dim.chunksize[0],rowdat);
+    const CCT cols(Dim.dimsize[1],Dim.chunksize[1],coldat);
+    DataSet_Context<Q> dsc(d);
+    if constexpr(!std::is_same_v<Q,std::string>){
+	auto rl = Rcpp::List::import_transform(rows.begin(),rows.end(),[&decomp,&dsc,&cols](const auto rr){
+
+								  auto ctc=static_cast<unsigned long>(cols.total_chunksize());
+								  rtensor_type row_mat({static_cast<int>(rr.chunk_size()),static_cast<int>(cols.total_size())});
+								  tensor_type buff_mat(shape_type{rr.disk_size(),ctc});
+								  auto read_lambda=[&row_mat,&buff_mat,&decomp](const auto& tchunk_r,const auto& tchunk_c,const void* raw_data,std::optional<size_t> res,size_t elem_size){
+										     decomp.decompress(buff_mat.data(),buff_mat.size()*sizeof(typename tensor_type::value_type),raw_data,res);
+										     if constexpr(std::is_same_v<typename RRT::chunk_type,chunk_chunker> && std::is_same_v<typename CCT::chunk_type,chunk_chunker>){
+											 xt::view(row_mat,xt::all(),tchunk_c.mem_slice())=
+											   xt::view(buff_mat,tchunk_r.chunk_slice(),tchunk_c.chunk_slice());
+										       }else{
+										       xt::dynamic_view(row_mat,{xt::all(),tchunk_c.mem_slice()})=
+											 xt::dynamic_view(buff_mat,{tchunk_r.chunk_slice(),tchunk_c.chunk_slice()});
+										     }
+										   };
+								  for(const auto& cb:cols){
+								    dsc.read_dataset(rr,cb,read_lambda);
+								  }
+								  return row_mat;
+								       });
+	return rl;
+
+    }
+  }
+};
+
+
+
+
+
+//[[Rcpp::export]]
+Rcpp::List read_matrix_rl(const std::string filename,  const std::string datapath, SEXP rows,SEXP cols){
+
+   auto drow=dispatch_subset(rows);
+  auto dcol=dispatch_subset(cols);
+  auto dp=root_path(datapath);
+
+  HighFive::File file(filename,HighFive::File::ReadOnly);
+
+  auto groupname = dp.parent_path();
+  auto dataname = dp.filename();
+  auto dset = file.getDataSet(dp);
+  DataSet_VNS<MatDim> dsv(dset);
+  auto data_t =dsv.data_type;
+  auto &decomp = dsv.decompressor;
+  return(std::visit(VisitMatrixReadRL(dset,dsv.Dim),data_t,decomp,drow,dcol));
+
+}
+
+
+
+
+
+//[[Rcpp::export]]
+SEXP read_matrix_v(const std::string filename,  const std::string datapath, SEXP rows,SEXP cols){
+
+  auto drow=dispatch_subset(rows);
+  auto dcol=dispatch_subset(cols);
+  auto dp=root_path(datapath);
+
+  HighFive::File file(filename,HighFive::File::ReadOnly);
+
+  auto groupname = dp.parent_path();
+  auto dataname = dp.filename();
+  auto dset = file.getDataSet(dp);
+  DataSet_V<MatDim> dsv(dset);
+  auto data_t =dsv.data_type;
+  auto &decomp = dsv.decompressor;
+  return(std::visit(VisitMatrixRead(dset,dsv.Dim),data_t,decomp,drow,dcol));
+}
+
+
+
+//[[Rcpp::export]]
+SEXP read_vector_v(const std::string filename,  const std::string datapath, SEXP rows){
+
+  auto drow=dispatch_subset(rows);
+  auto dp=root_path(datapath);
+
+  HighFive::File file(filename,HighFive::File::ReadOnly);
+
+  auto groupname = dp.parent_path();
+  auto dataname = dp.filename();
+  auto dset = file.getDataSet(dp);
+  DataSet_V<VecDim> dsv(dset);
+  auto data_t =dsv.data_type;
+  auto &decomp = dsv.decompressor;
+
+  Rcpp::RObject ret(std::visit(VisitVectorRead(dset,dsv.Dim),data_t,decomp,drow));
+  if(!dsv.R_attrs.empty()){
+    for(auto &attr : dsv.R_attrs){
+      ret.attr(attr.substr(2))=read_attribute(dset,attr);
+    }
+  }
+  return(ret);
+}
+
+std::variant<xt::rtensor<int,2>,xt::rtensor<double,2>,Rcpp::StringMatrix> xtensor_mat(Rcpp::RObject data){
+  auto my_t = data.sexp_type();
+  switch (my_t){
+  case INTSXP: {
+    return(Rcpp::as<xt::rtensor<int,2>>(data));
+  }
+  case REALSXP: {
+    return(Rcpp::as<xt::rtensor<double,2>>(data));
+  }
+  case STRSXP:{
+    return(Rcpp::as<Rcpp::StringMatrix>(data));
+  }
+  default:{
+    Rcpp::stop("Can currently only read and write numeric, integer and string types");
+    return(Rcpp::as<xt::rtensor<double,2>>(data));
+  }
+  }
+
+}
+
+
+
+std::variant<xt::rtensor<int,1>,xt::rtensor<double,1>,Rcpp::StringVector> xtensor_vec(Rcpp::RObject data){
+  auto my_t = data.sexp_type();
+  switch (my_t){
+  case INTSXP: {
+    return(Rcpp::as<xt::rtensor<int,1>>(data));
+  }
+  case REALSXP: {
+    return(Rcpp::as<xt::rtensor<double,1>>(data));
+  }
+  case STRSXP: {
+    return Rcpp::as<Rcpp::StringVector>(data);
+  }
+  default:{
+    Rcpp::stop("Can currently only read and write numeric and integer types");
+    return(Rcpp::as<xt::rtensor<double,1> >(data));
+  }
+
+  }
+}
+
+
+
+class VisitMatrixWrite
+
+{
+public:
+  const HighFive::DataSet &d;
+  const MatDim Dim;
+  VisitMatrixWrite(const HighFive::DataSet &d_,const MatDim Dim_):d(d_),Dim(Dim_){}
+  template<typename Q,typename Z,typename RT,typename CT>
+  void operator()(Q &write,Z& decomp,RT rowdat,CT coldat)const{
+    using RRT=typename t2chunk_t<RT>::c_type;
+    using CCT=typename t2chunk_t<CT>::c_type;
+
+    const RRT rows(Dim.dimsize[0],Dim.chunksize[0],rowdat,true);
+    const CCT cols(Dim.dimsize[1],Dim.chunksize[1],coldat,true);
+    if constexpr(std::is_same_v<Q,Rcpp::StringMatrix>){
+    auto elem_size = H5Tget_size(d.getDataType().getId());
+    MatrixShuttle<std::string,RRT,CCT> mover(rows,cols,elem_size);
+    mover.template write_matrix<Z>(write,decomp,d);
+    }else{
+      using QR=typename Q::value_type;
+      MatrixShuttle<QR,RRT,CCT> mover(rows,cols,1);
+      mover.template write_matrix<Z>(write,decomp,d);
+    }
+  // return(read_matrix_tt<Q,Z,RT,CT>(d,Dim.dimsize,Dim.chunksize,decomp,rowdat,coldat));
+  }
+};
+
+
+
+class VisitVectorWrite
+{
+public:
+  const HighFive::DataSet &d;
+  const VecDim Dim;
+  VisitVectorWrite(const HighFive::DataSet &d_, const VecDim Dim_):d(d_),Dim(Dim_){}
+  template<typename Q,typename Z,typename T>
+  void operator()(Q &write,Z& decomp,T rowdat)const{
+
+    using RT=typename t2chunk_t<T>::c_type;
+    RT rows(Dim.dimsize[0],Dim.chunksize[0],rowdat,true);
+    if constexpr(std::is_same_v<Q,Rcpp::StringVector>){
+    auto elem_size = H5Tget_size(d.getDataType().getId());
+    VecShuttle<std::string,RT> mover(rows,elem_size);
+    mover.template write_vector<Z>(write,decomp,d);
+    }else{
+      using QT = typename Q::value_type;
+      VecShuttle<QT,RT> mover(rows,1);
+      mover.template write_vector<Z>(write,decomp,d);
+    }
+  }
+};
+
+
+
+//[[Rcpp::export]]
+ void update_matrix_v(Rcpp::RObject data,const std::string filename,  const std::string datapath, SEXP rows,SEXP cols){
+  auto drow=dispatch_subset(rows);
+  auto dcol=dispatch_subset(cols);
+  auto dp=root_path(datapath);
+
+  HighFive::File file(filename,HighFive::File::ReadWrite);
+
+  auto w_t=xtensor_mat(data);
+  auto groupname = dp.parent_path();
+  auto dataname = dp.filename();
+  auto dset = file.getDataSet(dp);
+  DataSet_V<MatDim> dsv(dset);
+  //  auto data_t =dsv.data_type;
+  auto &decomp = dsv.decompressor;
+  return(std::visit(VisitMatrixWrite(dset,dsv.Dim),w_t,decomp,drow,dcol));
+}
+
+
+
+//[[Rcpp::export]]
+void update_vector_v(Rcpp::RObject data,const std::string filename,  const std::string datapath, SEXP rows){
+
+  auto drow=dispatch_subset(rows);
+  auto dp=root_path(datapath);
+  auto data_a =	Rcpp::as<Rcpp::Nullable<Rcpp::IntegerVector> >(data.attr("dim"));
+
+  HighFive::File file(filename,HighFive::File::ReadWrite);
+  auto w_t=xtensor_vec(data);
+  auto groupname = dp.parent_path();
+  auto dataname = dp.filename();
+  auto dset = file.getDataSet(dp);
+  DataSet_V<VecDim> dsv(dset);
+  //  auto data_t =dsv.data_type;
+  auto &decomp = dsv.decompressor;
+
+
+  std::visit(VisitVectorWrite(dset,dsv.Dim),w_t,decomp,drow);
+  if(data_a.isNull()){
+    data.attr("dim")=R_NilValue;
+  }
+    //
+    //    Rcpp::Rcout<<Rcpp::wrap(data.attr("dim"))<<data_a<<std::endl;
+}
diff --git a/src/compiler.h b/src/compiler.h
new file mode 100644
index 0000000..6686b83
--- /dev/null
+++ b/src/compiler.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_COMPILER_H
+#define ZSTD_COMPILER_H
+
+/*-*******************************************************
+*  Compiler specifics
+*********************************************************/
+/* force inlining */
+
+#if !defined(ZSTD_NO_INLINE)
+#if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#  define INLINE_KEYWORD inline
+#else
+#  define INLINE_KEYWORD
+#endif
+
+#if defined(__GNUC__) || defined(__ICCARM__)
+#  define FORCE_INLINE_ATTR __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#  define FORCE_INLINE_ATTR __forceinline
+#else
+#  define FORCE_INLINE_ATTR
+#endif
+
+#else
+
+#define INLINE_KEYWORD
+#define FORCE_INLINE_ATTR
+
+#endif
+
+/**
+ * FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant
+ * parameters. They must be inlined for the compiler to eliminate the constant
+ * branches.
+ */
+#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
+/**
+ * HINT_INLINE is used to help the compiler generate better code. It is *not*
+ * used for "templates", so it can be tweaked based on the compilers
+ * performance.
+ *
+ * gcc-4.8 and gcc-4.9 have been shown to benefit from leaving off the
+ * always_inline attribute.
+ *
+ * clang up to 5.0.0 (trunk) benefit tremendously from the always_inline
+ * attribute.
+ */
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8 && __GNUC__ < 5
+#  define HINT_INLINE static INLINE_KEYWORD
+#else
+#  define HINT_INLINE static INLINE_KEYWORD FORCE_INLINE_ATTR
+#endif
+
+/* force no inlining */
+#ifdef _MSC_VER
+#  define FORCE_NOINLINE static __declspec(noinline)
+#else
+#  if defined(__GNUC__) || defined(__ICCARM__)
+#    define FORCE_NOINLINE static __attribute__((__noinline__))
+#  else
+#    define FORCE_NOINLINE static
+#  endif
+#endif
+
+/* target attribute */
+#ifndef __has_attribute
+  #define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+#if defined(__GNUC__) || defined(__ICCARM__)
+#  define TARGET_ATTRIBUTE(target) __attribute__((__target__(target)))
+#else
+#  define TARGET_ATTRIBUTE(target)
+#endif
+
+/* Enable runtime BMI2 dispatch based on the CPU.
+ * Enabled for clang & gcc >=4.8 on x86 when BMI2 isn't enabled by default.
+ */
+#ifndef DYNAMIC_BMI2
+  #if ((defined(__clang__) && __has_attribute(__target__)) \
+      || (defined(__GNUC__) \
+          && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))) \
+      && (defined(__x86_64__) || defined(_M_X86)) \
+      && !defined(__BMI2__)
+  #  define DYNAMIC_BMI2 1
+  #else
+  #  define DYNAMIC_BMI2 0
+  #endif
+#endif
+
+/* prefetch
+ * can be disabled, by declaring NO_PREFETCH build macro */
+#if defined(NO_PREFETCH)
+#  define PREFETCH_L1(ptr)  (void)(ptr)  /* disabled */
+#  define PREFETCH_L2(ptr)  (void)(ptr)  /* disabled */
+#else
+#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86))  /* _mm_prefetch() is not defined outside of x86/x64 */
+#    include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
+#    define PREFETCH_L1(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
+#    define PREFETCH_L2(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T1)
+#  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )
+#    define PREFETCH_L1(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)
+#    define PREFETCH_L2(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */)
+#  else
+#    define PREFETCH_L1(ptr) (void)(ptr)  /* disabled */
+#    define PREFETCH_L2(ptr) (void)(ptr)  /* disabled */
+#  endif
+#endif  /* NO_PREFETCH */
+
+#define CACHELINE_SIZE 64
+
+#define PREFETCH_AREA(p, s)  {            \
+    const char* const _ptr = (const char*)(p);  \
+    size_t const _size = (size_t)(s);     \
+    size_t _pos;                          \
+    for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) {  \
+        PREFETCH_L2(_ptr + _pos);         \
+    }                                     \
+}
+
+/* vectorization */
+#if !defined(__clang__) && defined(__GNUC__)
+#  define DONT_VECTORIZE __attribute__((optimize("no-tree-vectorize")))
+#else
+#  define DONT_VECTORIZE
+#endif
+
+/* disable warnings */
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4100)        /* disable: C4100: unreferenced formal parameter */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#endif
+
+#endif /* ZSTD_COMPILER_H */
diff --git a/src/cover.c b/src/cover.c
new file mode 100644
index 0000000..6219967
--- /dev/null
+++ b/src/cover.c
@@ -0,0 +1,1237 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* *****************************************************************************
+ * Constructs a dictionary using a heuristic based on the following paper:
+ *
+ * Liao, Petri, Moffat, Wirth
+ * Effective Construction of Relative Lempel-Ziv Dictionaries
+ * Published in WWW 2016.
+ *
+ * Adapted from code originally written by @ot (Giuseppe Ottaviano).
+ ******************************************************************************/
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include <stdio.h>  /* fprintf */
+#include <stdlib.h> /* malloc, free, qsort */
+#include <string.h> /* memset */
+#include <time.h>   /* clock */
+
+#include "mem.h" /* read */
+#include "pool.h"
+#include "threading.h"
+#include "cover.h"
+#include "zstd_internal.h" /* includes zstd.h */
+#ifndef ZDICT_STATIC_LINKING_ONLY
+#define ZDICT_STATIC_LINKING_ONLY
+#endif
+#include "zdict.h"
+
+/*-*************************************
+*  Constants
+***************************************/
+#define COVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))
+#define DEFAULT_SPLITPOINT 1.0
+
+/*-*************************************
+*  Console display
+***************************************/
+static int g_displayLevel = 2;
+#define DISPLAY(...)                                                           \
+  {                                                                            \
+    fprintf(stderr, __VA_ARGS__);                                              \
+    fflush(stderr);                                                            \
+  }
+#define LOCALDISPLAYLEVEL(displayLevel, l, ...)                                \
+  if (displayLevel >= l) {                                                     \
+    DISPLAY(__VA_ARGS__);                                                      \
+  } /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */
+#define DISPLAYLEVEL(l, ...) LOCALDISPLAYLEVEL(g_displayLevel, l, __VA_ARGS__)
+
+#define LOCALDISPLAYUPDATE(displayLevel, l, ...)                               \
+  if (displayLevel >= l) {                                                     \
+    if ((clock() - g_time > refreshRate) || (displayLevel >= 4)) {             \
+      g_time = clock();                                                        \
+      DISPLAY(__VA_ARGS__);                                                    \
+    }                                                                          \
+  }
+#define DISPLAYUPDATE(l, ...) LOCALDISPLAYUPDATE(g_displayLevel, l, __VA_ARGS__)
+static const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;
+static clock_t g_time = 0;
+
+/*-*************************************
+* Hash table
+***************************************
+* A small specialized hash map for storing activeDmers.
+* The map does not resize, so if it becomes full it will loop forever.
+* Thus, the map must be large enough to store every value.
+* The map implements linear probing and keeps its load less than 0.5.
+*/
+
+#define MAP_EMPTY_VALUE ((U32)-1)
+typedef struct COVER_map_pair_t_s {
+  U32 key;
+  U32 value;
+} COVER_map_pair_t;
+
+typedef struct COVER_map_s {
+  COVER_map_pair_t *data;
+  U32 sizeLog;
+  U32 size;
+  U32 sizeMask;
+} COVER_map_t;
+
+/**
+ * Clear the map.
+ */
+static void COVER_map_clear(COVER_map_t *map) {
+  memset(map->data, MAP_EMPTY_VALUE, map->size * sizeof(COVER_map_pair_t));
+}
+
+/**
+ * Initializes a map of the given size.
+ * Returns 1 on success and 0 on failure.
+ * The map must be destroyed with COVER_map_destroy().
+ * The map is only guaranteed to be large enough to hold size elements.
+ */
+static int COVER_map_init(COVER_map_t *map, U32 size) {
+  map->sizeLog = ZSTD_highbit32(size) + 2;
+  map->size = (U32)1 << map->sizeLog;
+  map->sizeMask = map->size - 1;
+  map->data = (COVER_map_pair_t *)malloc(map->size * sizeof(COVER_map_pair_t));
+  if (!map->data) {
+    map->sizeLog = 0;
+    map->size = 0;
+    return 0;
+  }
+  COVER_map_clear(map);
+  return 1;
+}
+
+/**
+ * Internal hash function
+ */
+static const U32 prime4bytes = 2654435761U;
+static U32 COVER_map_hash(COVER_map_t *map, U32 key) {
+  return (key * prime4bytes) >> (32 - map->sizeLog);
+}
+
+/**
+ * Helper function that returns the index that a key should be placed into.
+ */
+static U32 COVER_map_index(COVER_map_t *map, U32 key) {
+  const U32 hash = COVER_map_hash(map, key);
+  U32 i;
+  for (i = hash;; i = (i + 1) & map->sizeMask) {
+    COVER_map_pair_t *pos = &map->data[i];
+    if (pos->value == MAP_EMPTY_VALUE) {
+      return i;
+    }
+    if (pos->key == key) {
+      return i;
+    }
+  }
+}
+
+/**
+ * Returns the pointer to the value for key.
+ * If key is not in the map, it is inserted and the value is set to 0.
+ * The map must not be full.
+ */
+static U32 *COVER_map_at(COVER_map_t *map, U32 key) {
+  COVER_map_pair_t *pos = &map->data[COVER_map_index(map, key)];
+  if (pos->value == MAP_EMPTY_VALUE) {
+    pos->key = key;
+    pos->value = 0;
+  }
+  return &pos->value;
+}
+
+/**
+ * Deletes key from the map if present.
+ */
+static void COVER_map_remove(COVER_map_t *map, U32 key) {
+  U32 i = COVER_map_index(map, key);
+  COVER_map_pair_t *del = &map->data[i];
+  U32 shift = 1;
+  if (del->value == MAP_EMPTY_VALUE) {
+    return;
+  }
+  for (i = (i + 1) & map->sizeMask;; i = (i + 1) & map->sizeMask) {
+    COVER_map_pair_t *const pos = &map->data[i];
+    /* If the position is empty we are done */
+    if (pos->value == MAP_EMPTY_VALUE) {
+      del->value = MAP_EMPTY_VALUE;
+      return;
+    }
+    /* If pos can be moved to del do so */
+    if (((i - COVER_map_hash(map, pos->key)) & map->sizeMask) >= shift) {
+      del->key = pos->key;
+      del->value = pos->value;
+      del = pos;
+      shift = 1;
+    } else {
+      ++shift;
+    }
+  }
+}
+
+/**
+ * Destroys a map that is inited with COVER_map_init().
+ */
+static void COVER_map_destroy(COVER_map_t *map) {
+  if (map->data) {
+    free(map->data);
+  }
+  map->data = NULL;
+  map->size = 0;
+}
+
+/*-*************************************
+* Context
+***************************************/
+
+typedef struct {
+  const BYTE *samples;
+  size_t *offsets;
+  const size_t *samplesSizes;
+  size_t nbSamples;
+  size_t nbTrainSamples;
+  size_t nbTestSamples;
+  U32 *suffix;
+  size_t suffixSize;
+  U32 *freqs;
+  U32 *dmerAt;
+  unsigned d;
+} COVER_ctx_t;
+
+/* We need a global context for qsort... */
+static COVER_ctx_t *g_ctx = NULL;
+
+/*-*************************************
+*  Helper functions
+***************************************/
+
+/**
+ * Returns the sum of the sample sizes.
+ */
+size_t COVER_sum(const size_t *samplesSizes, unsigned nbSamples) {
+  size_t sum = 0;
+  unsigned i;
+  for (i = 0; i < nbSamples; ++i) {
+    sum += samplesSizes[i];
+  }
+  return sum;
+}
+
+/**
+ * Returns -1 if the dmer at lp is less than the dmer at rp.
+ * Return 0 if the dmers at lp and rp are equal.
+ * Returns 1 if the dmer at lp is greater than the dmer at rp.
+ */
+static int COVER_cmp(COVER_ctx_t *ctx, const void *lp, const void *rp) {
+  U32 const lhs = *(U32 const *)lp;
+  U32 const rhs = *(U32 const *)rp;
+  return memcmp(ctx->samples + lhs, ctx->samples + rhs, ctx->d);
+}
+/**
+ * Faster version for d <= 8.
+ */
+static int COVER_cmp8(COVER_ctx_t *ctx, const void *lp, const void *rp) {
+  U64 const mask = (ctx->d == 8) ? (U64)-1 : (((U64)1 << (8 * ctx->d)) - 1);
+  U64 const lhs = MEM_readLE64(ctx->samples + *(U32 const *)lp) & mask;
+  U64 const rhs = MEM_readLE64(ctx->samples + *(U32 const *)rp) & mask;
+  if (lhs < rhs) {
+    return -1;
+  }
+  return (lhs > rhs);
+}
+
+/**
+ * Same as COVER_cmp() except ties are broken by pointer value
+ * NOTE: g_ctx must be set to call this function.  A global is required because
+ * qsort doesn't take an opaque pointer.
+ */
+static int COVER_strict_cmp(const void *lp, const void *rp) {
+  int result = COVER_cmp(g_ctx, lp, rp);
+  if (result == 0) {
+    result = lp < rp ? -1 : 1;
+  }
+  return result;
+}
+/**
+ * Faster version for d <= 8.
+ */
+static int COVER_strict_cmp8(const void *lp, const void *rp) {
+  int result = COVER_cmp8(g_ctx, lp, rp);
+  if (result == 0) {
+    result = lp < rp ? -1 : 1;
+  }
+  return result;
+}
+
+/**
+ * Returns the first pointer in [first, last) whose element does not compare
+ * less than value.  If no such element exists it returns last.
+ */
+static const size_t *COVER_lower_bound(const size_t *first, const size_t *last,
+                                       size_t value) {
+  size_t count = last - first;
+  while (count != 0) {
+    size_t step = count / 2;
+    const size_t *ptr = first;
+    ptr += step;
+    if (*ptr < value) {
+      first = ++ptr;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+/**
+ * Generic groupBy function.
+ * Groups an array sorted by cmp into groups with equivalent values.
+ * Calls grp for each group.
+ */
+static void
+COVER_groupBy(const void *data, size_t count, size_t size, COVER_ctx_t *ctx,
+              int (*cmp)(COVER_ctx_t *, const void *, const void *),
+              void (*grp)(COVER_ctx_t *, const void *, const void *)) {
+  const BYTE *ptr = (const BYTE *)data;
+  size_t num = 0;
+  while (num < count) {
+    const BYTE *grpEnd = ptr + size;
+    ++num;
+    while (num < count && cmp(ctx, ptr, grpEnd) == 0) {
+      grpEnd += size;
+      ++num;
+    }
+    grp(ctx, ptr, grpEnd);
+    ptr = grpEnd;
+  }
+}
+
+/*-*************************************
+*  Cover functions
+***************************************/
+
+/**
+ * Called on each group of positions with the same dmer.
+ * Counts the frequency of each dmer and saves it in the suffix array.
+ * Fills `ctx->dmerAt`.
+ */
+static void COVER_group(COVER_ctx_t *ctx, const void *group,
+                        const void *groupEnd) {
+  /* The group consists of all the positions with the same first d bytes. */
+  const U32 *grpPtr = (const U32 *)group;
+  const U32 *grpEnd = (const U32 *)groupEnd;
+  /* The dmerId is how we will reference this dmer.
+   * This allows us to map the whole dmer space to a much smaller space, the
+   * size of the suffix array.
+   */
+  const U32 dmerId = (U32)(grpPtr - ctx->suffix);
+  /* Count the number of samples this dmer shows up in */
+  U32 freq = 0;
+  /* Details */
+  const size_t *curOffsetPtr = ctx->offsets;
+  const size_t *offsetsEnd = ctx->offsets + ctx->nbSamples;
+  /* Once *grpPtr >= curSampleEnd this occurrence of the dmer is in a
+   * different sample than the last.
+   */
+  size_t curSampleEnd = ctx->offsets[0];
+  for (; grpPtr != grpEnd; ++grpPtr) {
+    /* Save the dmerId for this position so we can get back to it. */
+    ctx->dmerAt[*grpPtr] = dmerId;
+    /* Dictionaries only help for the first reference to the dmer.
+     * After that zstd can reference the match from the previous reference.
+     * So only count each dmer once for each sample it is in.
+     */
+    if (*grpPtr < curSampleEnd) {
+      continue;
+    }
+    freq += 1;
+    /* Binary search to find the end of the sample *grpPtr is in.
+     * In the common case that grpPtr + 1 == grpEnd we can skip the binary
+     * search because the loop is over.
+     */
+    if (grpPtr + 1 != grpEnd) {
+      const size_t *sampleEndPtr =
+          COVER_lower_bound(curOffsetPtr, offsetsEnd, *grpPtr);
+      curSampleEnd = *sampleEndPtr;
+      curOffsetPtr = sampleEndPtr + 1;
+    }
+  }
+  /* At this point we are never going to look at this segment of the suffix
+   * array again.  We take advantage of this fact to save memory.
+   * We store the frequency of the dmer in the first position of the group,
+   * which is dmerId.
+   */
+  ctx->suffix[dmerId] = freq;
+}
+
+
+/**
+ * Selects the best segment in an epoch.
+ * Segments of are scored according to the function:
+ *
+ * Let F(d) be the frequency of dmer d.
+ * Let S_i be the dmer at position i of segment S which has length k.
+ *
+ *     Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1})
+ *
+ * Once the dmer d is in the dictionary we set F(d) = 0.
+ */
+static COVER_segment_t COVER_selectSegment(const COVER_ctx_t *ctx, U32 *freqs,
+                                           COVER_map_t *activeDmers, U32 begin,
+                                           U32 end,
+                                           ZDICT_cover_params_t parameters) {
+  /* Constants */
+  const U32 k = parameters.k;
+  const U32 d = parameters.d;
+  const U32 dmersInK = k - d + 1;
+  /* Try each segment (activeSegment) and save the best (bestSegment) */
+  COVER_segment_t bestSegment = {0, 0, 0};
+  COVER_segment_t activeSegment;
+  /* Reset the activeDmers in the segment */
+  COVER_map_clear(activeDmers);
+  /* The activeSegment starts at the beginning of the epoch. */
+  activeSegment.begin = begin;
+  activeSegment.end = begin;
+  activeSegment.score = 0;
+  /* Slide the activeSegment through the whole epoch.
+   * Save the best segment in bestSegment.
+   */
+  while (activeSegment.end < end) {
+    /* The dmerId for the dmer at the next position */
+    U32 newDmer = ctx->dmerAt[activeSegment.end];
+    /* The entry in activeDmers for this dmerId */
+    U32 *newDmerOcc = COVER_map_at(activeDmers, newDmer);
+    /* If the dmer isn't already present in the segment add its score. */
+    if (*newDmerOcc == 0) {
+      /* The paper suggest using the L-0.5 norm, but experiments show that it
+       * doesn't help.
+       */
+      activeSegment.score += freqs[newDmer];
+    }
+    /* Add the dmer to the segment */
+    activeSegment.end += 1;
+    *newDmerOcc += 1;
+
+    /* If the window is now too large, drop the first position */
+    if (activeSegment.end - activeSegment.begin == dmersInK + 1) {
+      U32 delDmer = ctx->dmerAt[activeSegment.begin];
+      U32 *delDmerOcc = COVER_map_at(activeDmers, delDmer);
+      activeSegment.begin += 1;
+      *delDmerOcc -= 1;
+      /* If this is the last occurrence of the dmer, subtract its score */
+      if (*delDmerOcc == 0) {
+        COVER_map_remove(activeDmers, delDmer);
+        activeSegment.score -= freqs[delDmer];
+      }
+    }
+
+    /* If this segment is the best so far save it */
+    if (activeSegment.score > bestSegment.score) {
+      bestSegment = activeSegment;
+    }
+  }
+  {
+    /* Trim off the zero frequency head and tail from the segment. */
+    U32 newBegin = bestSegment.end;
+    U32 newEnd = bestSegment.begin;
+    U32 pos;
+    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {
+      U32 freq = freqs[ctx->dmerAt[pos]];
+      if (freq != 0) {
+        newBegin = MIN(newBegin, pos);
+        newEnd = pos + 1;
+      }
+    }
+    bestSegment.begin = newBegin;
+    bestSegment.end = newEnd;
+  }
+  {
+    /* Zero out the frequency of each dmer covered by the chosen segment. */
+    U32 pos;
+    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {
+      freqs[ctx->dmerAt[pos]] = 0;
+    }
+  }
+  return bestSegment;
+}
+
+/**
+ * Check the validity of the parameters.
+ * Returns non-zero if the parameters are valid and 0 otherwise.
+ */
+static int COVER_checkParameters(ZDICT_cover_params_t parameters,
+                                 size_t maxDictSize) {
+  /* k and d are required parameters */
+  if (parameters.d == 0 || parameters.k == 0) {
+    return 0;
+  }
+  /* k <= maxDictSize */
+  if (parameters.k > maxDictSize) {
+    return 0;
+  }
+  /* d <= k */
+  if (parameters.d > parameters.k) {
+    return 0;
+  }
+  /* 0 < splitPoint <= 1 */
+  if (parameters.splitPoint <= 0 || parameters.splitPoint > 1){
+    return 0;
+  }
+  return 1;
+}
+
+/**
+ * Clean up a context initialized with `COVER_ctx_init()`.
+ */
+static void COVER_ctx_destroy(COVER_ctx_t *ctx) {
+  if (!ctx) {
+    return;
+  }
+  if (ctx->suffix) {
+    free(ctx->suffix);
+    ctx->suffix = NULL;
+  }
+  if (ctx->freqs) {
+    free(ctx->freqs);
+    ctx->freqs = NULL;
+  }
+  if (ctx->dmerAt) {
+    free(ctx->dmerAt);
+    ctx->dmerAt = NULL;
+  }
+  if (ctx->offsets) {
+    free(ctx->offsets);
+    ctx->offsets = NULL;
+  }
+}
+
+/**
+ * Prepare a context for dictionary building.
+ * The context is only dependent on the parameter `d` and can used multiple
+ * times.
+ * Returns 0 on success or error code on error.
+ * The context must be destroyed with `COVER_ctx_destroy()`.
+ */
+static size_t COVER_ctx_init(COVER_ctx_t *ctx, const void *samplesBuffer,
+                          const size_t *samplesSizes, unsigned nbSamples,
+                          unsigned d, double splitPoint) {
+  const BYTE *const samples = (const BYTE *)samplesBuffer;
+  const size_t totalSamplesSize = COVER_sum(samplesSizes, nbSamples);
+  /* Split samples into testing and training sets */
+  const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples;
+  const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;
+  const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;
+  const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;
+  /* Checks */
+  if (totalSamplesSize < MAX(d, sizeof(U64)) ||
+      totalSamplesSize >= (size_t)COVER_MAX_SAMPLES_SIZE) {
+    DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n",
+                 (unsigned)(totalSamplesSize>>20), (COVER_MAX_SAMPLES_SIZE >> 20));
+    return ERROR(srcSize_wrong);
+  }
+  /* Check if there are at least 5 training samples */
+  if (nbTrainSamples < 5) {
+    DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid.", nbTrainSamples);
+    return ERROR(srcSize_wrong);
+  }
+  /* Check if there's testing sample */
+  if (nbTestSamples < 1) {
+    DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.", nbTestSamples);
+    return ERROR(srcSize_wrong);
+  }
+  /* Zero the context */
+  memset(ctx, 0, sizeof(*ctx));
+  DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples,
+               (unsigned)trainingSamplesSize);
+  DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples,
+               (unsigned)testSamplesSize);
+  ctx->samples = samples;
+  ctx->samplesSizes = samplesSizes;
+  ctx->nbSamples = nbSamples;
+  ctx->nbTrainSamples = nbTrainSamples;
+  ctx->nbTestSamples = nbTestSamples;
+  /* Partial suffix array */
+  ctx->suffixSize = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;
+  ctx->suffix = (U32 *)malloc(ctx->suffixSize * sizeof(U32));
+  /* Maps index to the dmerID */
+  ctx->dmerAt = (U32 *)malloc(ctx->suffixSize * sizeof(U32));
+  /* The offsets of each file */
+  ctx->offsets = (size_t *)malloc((nbSamples + 1) * sizeof(size_t));
+  if (!ctx->suffix || !ctx->dmerAt || !ctx->offsets) {
+    DISPLAYLEVEL(1, "Failed to allocate scratch buffers\n");
+    COVER_ctx_destroy(ctx);
+    return ERROR(memory_allocation);
+  }
+  ctx->freqs = NULL;
+  ctx->d = d;
+
+  /* Fill offsets from the samplesSizes */
+  {
+    U32 i;
+    ctx->offsets[0] = 0;
+    for (i = 1; i <= nbSamples; ++i) {
+      ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1];
+    }
+  }
+  DISPLAYLEVEL(2, "Constructing partial suffix array\n");
+  {
+    /* suffix is a partial suffix array.
+     * It only sorts suffixes by their first parameters.d bytes.
+     * The sort is stable, so each dmer group is sorted by position in input.
+     */
+    U32 i;
+    for (i = 0; i < ctx->suffixSize; ++i) {
+      ctx->suffix[i] = i;
+    }
+    /* qsort doesn't take an opaque pointer, so pass as a global.
+     * On OpenBSD qsort() is not guaranteed to be stable, their mergesort() is.
+     */
+    g_ctx = ctx;
+#if defined(__OpenBSD__)
+    mergesort(ctx->suffix, ctx->suffixSize, sizeof(U32),
+          (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));
+#else
+    qsort(ctx->suffix, ctx->suffixSize, sizeof(U32),
+          (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));
+#endif
+  }
+  DISPLAYLEVEL(2, "Computing frequencies\n");
+  /* For each dmer group (group of positions with the same first d bytes):
+   * 1. For each position we set dmerAt[position] = dmerID.  The dmerID is
+   *    (groupBeginPtr - suffix).  This allows us to go from position to
+   *    dmerID so we can look up values in freq.
+   * 2. We calculate how many samples the dmer occurs in and save it in
+   *    freqs[dmerId].
+   */
+  COVER_groupBy(ctx->suffix, ctx->suffixSize, sizeof(U32), ctx,
+                (ctx->d <= 8 ? &COVER_cmp8 : &COVER_cmp), &COVER_group);
+  ctx->freqs = ctx->suffix;
+  ctx->suffix = NULL;
+  return 0;
+}
+
+void COVER_warnOnSmallCorpus(size_t maxDictSize, size_t nbDmers, int displayLevel)
+{
+  const double ratio = (double)nbDmers / maxDictSize;
+  if (ratio >= 10) {
+      return;
+  }
+  LOCALDISPLAYLEVEL(displayLevel, 1,
+                    "WARNING: The maximum dictionary size %u is too large "
+                    "compared to the source size %u! "
+                    "size(source)/size(dictionary) = %f, but it should be >= "
+                    "10! This may lead to a subpar dictionary! We recommend "
+                    "training on sources at least 10x, and up to 100x the "
+                    "size of the dictionary!\n", (U32)maxDictSize,
+                    (U32)nbDmers, ratio);
+}
+
+COVER_epoch_info_t COVER_computeEpochs(U32 maxDictSize,
+                                       U32 nbDmers, U32 k, U32 passes)
+{
+  const U32 minEpochSize = k * 10;
+  COVER_epoch_info_t epochs;
+  epochs.num = MAX(1, maxDictSize / k / passes);
+  epochs.size = nbDmers / epochs.num;
+  if (epochs.size >= minEpochSize) {
+      assert(epochs.size * epochs.num <= nbDmers);
+      return epochs;
+  }
+  epochs.size = MIN(minEpochSize, nbDmers);
+  epochs.num = nbDmers / epochs.size;
+  assert(epochs.size * epochs.num <= nbDmers);
+  return epochs;
+}
+
+/**
+ * Given the prepared context build the dictionary.
+ */
+static size_t COVER_buildDictionary(const COVER_ctx_t *ctx, U32 *freqs,
+                                    COVER_map_t *activeDmers, void *dictBuffer,
+                                    size_t dictBufferCapacity,
+                                    ZDICT_cover_params_t parameters) {
+  BYTE *const dict = (BYTE *)dictBuffer;
+  size_t tail = dictBufferCapacity;
+  /* Divide the data into epochs. We will select one segment from each epoch. */
+  const COVER_epoch_info_t epochs = COVER_computeEpochs(
+      (U32)dictBufferCapacity, (U32)ctx->suffixSize, parameters.k, 4);
+  const size_t maxZeroScoreRun = MAX(10, MIN(100, epochs.num >> 3));
+  size_t zeroScoreRun = 0;
+  size_t epoch;
+  DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n",
+                (U32)epochs.num, (U32)epochs.size);
+  /* Loop through the epochs until there are no more segments or the dictionary
+   * is full.
+   */
+  for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs.num) {
+    const U32 epochBegin = (U32)(epoch * epochs.size);
+    const U32 epochEnd = epochBegin + epochs.size;
+    size_t segmentSize;
+    /* Select a segment */
+    COVER_segment_t segment = COVER_selectSegment(
+        ctx, freqs, activeDmers, epochBegin, epochEnd, parameters);
+    /* If the segment covers no dmers, then we are out of content.
+     * There may be new content in other epochs, for continue for some time.
+     */
+    if (segment.score == 0) {
+      if (++zeroScoreRun >= maxZeroScoreRun) {
+          break;
+      }
+      continue;
+    }
+    zeroScoreRun = 0;
+    /* Trim the segment if necessary and if it is too small then we are done */
+    segmentSize = MIN(segment.end - segment.begin + parameters.d - 1, tail);
+    if (segmentSize < parameters.d) {
+      break;
+    }
+    /* We fill the dictionary from the back to allow the best segments to be
+     * referenced with the smallest offsets.
+     */
+    tail -= segmentSize;
+    memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);
+    DISPLAYUPDATE(
+        2, "\r%u%%       ",
+        (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));
+  }
+  DISPLAYLEVEL(2, "\r%79s\r", "");
+  return tail;
+}
+
+ZDICTLIB_API size_t ZDICT_trainFromBuffer_cover(
+    void *dictBuffer, size_t dictBufferCapacity,
+    const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples,
+    ZDICT_cover_params_t parameters)
+{
+  BYTE* const dict = (BYTE*)dictBuffer;
+  COVER_ctx_t ctx;
+  COVER_map_t activeDmers;
+  parameters.splitPoint = 1.0;
+  /* Initialize global data */
+  g_displayLevel = parameters.zParams.notificationLevel;
+  /* Checks */
+  if (!COVER_checkParameters(parameters, dictBufferCapacity)) {
+    DISPLAYLEVEL(1, "Cover parameters incorrect\n");
+    return ERROR(parameter_outOfBound);
+  }
+  if (nbSamples == 0) {
+    DISPLAYLEVEL(1, "Cover must have at least one input file\n");
+    return ERROR(srcSize_wrong);
+  }
+  if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
+    DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n",
+                 ZDICT_DICTSIZE_MIN);
+    return ERROR(dstSize_tooSmall);
+  }
+  /* Initialize context and activeDmers */
+  {
+    size_t const initVal = COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples,
+                      parameters.d, parameters.splitPoint);
+    if (ZSTD_isError(initVal)) {
+      return initVal;
+    }
+  }
+  COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.suffixSize, g_displayLevel);
+  if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) {
+    DISPLAYLEVEL(1, "Failed to allocate dmer map: out of memory\n");
+    COVER_ctx_destroy(&ctx);
+    return ERROR(memory_allocation);
+  }
+
+  DISPLAYLEVEL(2, "Building dictionary\n");
+  {
+    const size_t tail =
+        COVER_buildDictionary(&ctx, ctx.freqs, &activeDmers, dictBuffer,
+                              dictBufferCapacity, parameters);
+    const size_t dictionarySize = ZDICT_finalizeDictionary(
+        dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,
+        samplesBuffer, samplesSizes, nbSamples, parameters.zParams);
+    if (!ZSTD_isError(dictionarySize)) {
+      DISPLAYLEVEL(2, "Constructed dictionary of size %u\n",
+                   (unsigned)dictionarySize);
+    }
+    COVER_ctx_destroy(&ctx);
+    COVER_map_destroy(&activeDmers);
+    return dictionarySize;
+  }
+}
+
+
+
+size_t COVER_checkTotalCompressedSize(const ZDICT_cover_params_t parameters,
+                                    const size_t *samplesSizes, const BYTE *samples,
+                                    size_t *offsets,
+                                    size_t nbTrainSamples, size_t nbSamples,
+                                    BYTE *const dict, size_t dictBufferCapacity) {
+  size_t totalCompressedSize = ERROR(GENERIC);
+  /* Pointers */
+  ZSTD_CCtx *cctx;
+  ZSTD_CDict *cdict;
+  void *dst;
+  /* Local variables */
+  size_t dstCapacity;
+  size_t i;
+  /* Allocate dst with enough space to compress the maximum sized sample */
+  {
+    size_t maxSampleSize = 0;
+    i = parameters.splitPoint < 1.0 ? nbTrainSamples : 0;
+    for (; i < nbSamples; ++i) {
+      maxSampleSize = MAX(samplesSizes[i], maxSampleSize);
+    }
+    dstCapacity = ZSTD_compressBound(maxSampleSize);
+    dst = malloc(dstCapacity);
+  }
+  /* Create the cctx and cdict */
+  cctx = ZSTD_createCCtx();
+  cdict = ZSTD_createCDict(dict, dictBufferCapacity,
+                           parameters.zParams.compressionLevel);
+  if (!dst || !cctx || !cdict) {
+    goto _compressCleanup;
+  }
+  /* Compress each sample and sum their sizes (or error) */
+  totalCompressedSize = dictBufferCapacity;
+  i = parameters.splitPoint < 1.0 ? nbTrainSamples : 0;
+  for (; i < nbSamples; ++i) {
+    const size_t size = ZSTD_compress_usingCDict(
+        cctx, dst, dstCapacity, samples + offsets[i],
+        samplesSizes[i], cdict);
+    if (ZSTD_isError(size)) {
+      totalCompressedSize = size;
+      goto _compressCleanup;
+    }
+    totalCompressedSize += size;
+  }
+_compressCleanup:
+  ZSTD_freeCCtx(cctx);
+  ZSTD_freeCDict(cdict);
+  if (dst) {
+    free(dst);
+  }
+  return totalCompressedSize;
+}
+
+
+/**
+ * Initialize the `COVER_best_t`.
+ */
+void COVER_best_init(COVER_best_t *best) {
+  if (best==NULL) return; /* compatible with init on NULL */
+  (void)ZSTD_pthread_mutex_init(&best->mutex, NULL);
+  (void)ZSTD_pthread_cond_init(&best->cond, NULL);
+  best->liveJobs = 0;
+  best->dict = NULL;
+  best->dictSize = 0;
+  best->compressedSize = (size_t)-1;
+  memset(&best->parameters, 0, sizeof(best->parameters));
+}
+
+/**
+ * Wait until liveJobs == 0.
+ */
+void COVER_best_wait(COVER_best_t *best) {
+  if (!best) {
+    return;
+  }
+  ZSTD_pthread_mutex_lock(&best->mutex);
+  while (best->liveJobs != 0) {
+    ZSTD_pthread_cond_wait(&best->cond, &best->mutex);
+  }
+  ZSTD_pthread_mutex_unlock(&best->mutex);
+}
+
+/**
+ * Call COVER_best_wait() and then destroy the COVER_best_t.
+ */
+void COVER_best_destroy(COVER_best_t *best) {
+  if (!best) {
+    return;
+  }
+  COVER_best_wait(best);
+  if (best->dict) {
+    free(best->dict);
+  }
+  ZSTD_pthread_mutex_destroy(&best->mutex);
+  ZSTD_pthread_cond_destroy(&best->cond);
+}
+
+/**
+ * Called when a thread is about to be launched.
+ * Increments liveJobs.
+ */
+void COVER_best_start(COVER_best_t *best) {
+  if (!best) {
+    return;
+  }
+  ZSTD_pthread_mutex_lock(&best->mutex);
+  ++best->liveJobs;
+  ZSTD_pthread_mutex_unlock(&best->mutex);
+}
+
+/**
+ * Called when a thread finishes executing, both on error or success.
+ * Decrements liveJobs and signals any waiting threads if liveJobs == 0.
+ * If this dictionary is the best so far save it and its parameters.
+ */
+void COVER_best_finish(COVER_best_t *best, ZDICT_cover_params_t parameters,
+                              COVER_dictSelection_t selection) {
+  void* dict = selection.dictContent;
+  size_t compressedSize = selection.totalCompressedSize;
+  size_t dictSize = selection.dictSize;
+  if (!best) {
+    return;
+  }
+  {
+    size_t liveJobs;
+    ZSTD_pthread_mutex_lock(&best->mutex);
+    --best->liveJobs;
+    liveJobs = best->liveJobs;
+    /* If the new dictionary is better */
+    if (compressedSize < best->compressedSize) {
+      /* Allocate space if necessary */
+      if (!best->dict || best->dictSize < dictSize) {
+        if (best->dict) {
+          free(best->dict);
+        }
+        best->dict = malloc(dictSize);
+        if (!best->dict) {
+          best->compressedSize = ERROR(GENERIC);
+          best->dictSize = 0;
+          ZSTD_pthread_cond_signal(&best->cond);
+          ZSTD_pthread_mutex_unlock(&best->mutex);
+          return;
+        }
+      }
+      /* Save the dictionary, parameters, and size */
+      if (!dict) {
+        return;
+      }
+      memcpy(best->dict, dict, dictSize);
+      best->dictSize = dictSize;
+      best->parameters = parameters;
+      best->compressedSize = compressedSize;
+    }
+    if (liveJobs == 0) {
+      ZSTD_pthread_cond_broadcast(&best->cond);
+    }
+    ZSTD_pthread_mutex_unlock(&best->mutex);
+  }
+}
+
+COVER_dictSelection_t COVER_dictSelectionError(size_t error) {
+    COVER_dictSelection_t selection = { NULL, 0, error };
+    return selection;
+}
+
+unsigned COVER_dictSelectionIsError(COVER_dictSelection_t selection) {
+  return (ZSTD_isError(selection.totalCompressedSize) || !selection.dictContent);
+}
+
+void COVER_dictSelectionFree(COVER_dictSelection_t selection){
+  free(selection.dictContent);
+}
+
+COVER_dictSelection_t COVER_selectDict(BYTE* customDictContent,
+        size_t dictContentSize, const BYTE* samplesBuffer, const size_t* samplesSizes, unsigned nbFinalizeSamples,
+        size_t nbCheckSamples, size_t nbSamples, ZDICT_cover_params_t params, size_t* offsets, size_t totalCompressedSize) {
+
+  size_t largestDict = 0;
+  size_t largestCompressed = 0;
+  BYTE* customDictContentEnd = customDictContent + dictContentSize;
+
+  BYTE * largestDictbuffer = (BYTE *)malloc(dictContentSize);
+  BYTE * candidateDictBuffer = (BYTE *)malloc(dictContentSize);
+  double regressionTolerance = ((double)params.shrinkDictMaxRegression / 100.0) + 1.00;
+
+  if (!largestDictbuffer || !candidateDictBuffer) {
+    free(largestDictbuffer);
+    free(candidateDictBuffer);
+    return COVER_dictSelectionError(dictContentSize);
+  }
+
+  /* Initial dictionary size and compressed size */
+  memcpy(largestDictbuffer, customDictContent, dictContentSize);
+  dictContentSize = ZDICT_finalizeDictionary(
+    largestDictbuffer, dictContentSize, customDictContent, dictContentSize,
+    samplesBuffer, samplesSizes, nbFinalizeSamples, params.zParams);
+
+  if (ZDICT_isError(dictContentSize)) {
+    free(largestDictbuffer);
+    free(candidateDictBuffer);
+    return COVER_dictSelectionError(dictContentSize);
+  }
+
+  totalCompressedSize = COVER_checkTotalCompressedSize(params, samplesSizes,
+                                                       samplesBuffer, offsets,
+                                                       nbCheckSamples, nbSamples,
+                                                       largestDictbuffer, dictContentSize);
+
+  if (ZSTD_isError(totalCompressedSize)) {
+    free(largestDictbuffer);
+    free(candidateDictBuffer);
+    return COVER_dictSelectionError(totalCompressedSize);
+  }
+
+  if (params.shrinkDict == 0) {
+    COVER_dictSelection_t selection = { largestDictbuffer, dictContentSize, totalCompressedSize };
+    free(candidateDictBuffer);
+    return selection;
+  }
+
+  largestDict = dictContentSize;
+  largestCompressed = totalCompressedSize;
+  dictContentSize = ZDICT_DICTSIZE_MIN;
+
+  /* Largest dict is initially at least ZDICT_DICTSIZE_MIN */
+  while (dictContentSize < largestDict) {
+    memcpy(candidateDictBuffer, largestDictbuffer, largestDict);
+    dictContentSize = ZDICT_finalizeDictionary(
+      candidateDictBuffer, dictContentSize, customDictContentEnd - dictContentSize, dictContentSize,
+      samplesBuffer, samplesSizes, nbFinalizeSamples, params.zParams);
+
+    if (ZDICT_isError(dictContentSize)) {
+      free(largestDictbuffer);
+      free(candidateDictBuffer);
+      return COVER_dictSelectionError(dictContentSize);
+
+    }
+
+    totalCompressedSize = COVER_checkTotalCompressedSize(params, samplesSizes,
+                                                         samplesBuffer, offsets,
+                                                         nbCheckSamples, nbSamples,
+                                                         candidateDictBuffer, dictContentSize);
+
+    if (ZSTD_isError(totalCompressedSize)) {
+      free(largestDictbuffer);
+      free(candidateDictBuffer);
+      return COVER_dictSelectionError(totalCompressedSize);
+    }
+
+    if (totalCompressedSize <= largestCompressed * regressionTolerance) {
+      COVER_dictSelection_t selection = { candidateDictBuffer, dictContentSize, totalCompressedSize };
+      free(largestDictbuffer);
+      return selection;
+    }
+    dictContentSize *= 2;
+  }
+  dictContentSize = largestDict;
+  totalCompressedSize = largestCompressed;
+  {
+    COVER_dictSelection_t selection = { largestDictbuffer, dictContentSize, totalCompressedSize };
+    free(candidateDictBuffer);
+    return selection;
+  }
+}
+
+/**
+ * Parameters for COVER_tryParameters().
+ */
+typedef struct COVER_tryParameters_data_s {
+  const COVER_ctx_t *ctx;
+  COVER_best_t *best;
+  size_t dictBufferCapacity;
+  ZDICT_cover_params_t parameters;
+} COVER_tryParameters_data_t;
+
+/**
+ * Tries a set of parameters and updates the COVER_best_t with the results.
+ * This function is thread safe if zstd is compiled with multithreaded support.
+ * It takes its parameters as an *OWNING* opaque pointer to support threading.
+ */
+static void COVER_tryParameters(void *opaque) {
+  /* Save parameters as local variables */
+  COVER_tryParameters_data_t *const data = (COVER_tryParameters_data_t *)opaque;
+  const COVER_ctx_t *const ctx = data->ctx;
+  const ZDICT_cover_params_t parameters = data->parameters;
+  size_t dictBufferCapacity = data->dictBufferCapacity;
+  size_t totalCompressedSize = ERROR(GENERIC);
+  /* Allocate space for hash table, dict, and freqs */
+  COVER_map_t activeDmers;
+  BYTE *const dict = (BYTE * const)malloc(dictBufferCapacity);
+  COVER_dictSelection_t selection = COVER_dictSelectionError(ERROR(GENERIC));
+  U32 *freqs = (U32 *)malloc(ctx->suffixSize * sizeof(U32));
+  if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) {
+    DISPLAYLEVEL(1, "Failed to allocate dmer map: out of memory\n");
+    goto _cleanup;
+  }
+  if (!dict || !freqs) {
+    DISPLAYLEVEL(1, "Failed to allocate buffers: out of memory\n");
+    goto _cleanup;
+  }
+  /* Copy the frequencies because we need to modify them */
+  memcpy(freqs, ctx->freqs, ctx->suffixSize * sizeof(U32));
+  /* Build the dictionary */
+  {
+    const size_t tail = COVER_buildDictionary(ctx, freqs, &activeDmers, dict,
+                                              dictBufferCapacity, parameters);
+    selection = COVER_selectDict(dict + tail, dictBufferCapacity - tail,
+        ctx->samples, ctx->samplesSizes, (unsigned)ctx->nbTrainSamples, ctx->nbTrainSamples, ctx->nbSamples, parameters, ctx->offsets,
+        totalCompressedSize);
+
+    if (COVER_dictSelectionIsError(selection)) {
+      DISPLAYLEVEL(1, "Failed to select dictionary\n");
+      goto _cleanup;
+    }
+  }
+_cleanup:
+  free(dict);
+  COVER_best_finish(data->best, parameters, selection);
+  free(data);
+  COVER_map_destroy(&activeDmers);
+  COVER_dictSelectionFree(selection);
+  if (freqs) {
+    free(freqs);
+  }
+}
+
+ZDICTLIB_API size_t ZDICT_optimizeTrainFromBuffer_cover(
+    void *dictBuffer, size_t dictBufferCapacity, const void *samplesBuffer,
+    const size_t *samplesSizes, unsigned nbSamples,
+    ZDICT_cover_params_t *parameters) {
+  /* constants */
+  const unsigned nbThreads = parameters->nbThreads;
+  const double splitPoint =
+      parameters->splitPoint <= 0.0 ? DEFAULT_SPLITPOINT : parameters->splitPoint;
+  const unsigned kMinD = parameters->d == 0 ? 6 : parameters->d;
+  const unsigned kMaxD = parameters->d == 0 ? 8 : parameters->d;
+  const unsigned kMinK = parameters->k == 0 ? 50 : parameters->k;
+  const unsigned kMaxK = parameters->k == 0 ? 2000 : parameters->k;
+  const unsigned kSteps = parameters->steps == 0 ? 40 : parameters->steps;
+  const unsigned kStepSize = MAX((kMaxK - kMinK) / kSteps, 1);
+  const unsigned kIterations =
+      (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize);
+  const unsigned shrinkDict = 0;
+  /* Local variables */
+  const int displayLevel = parameters->zParams.notificationLevel;
+  unsigned iteration = 1;
+  unsigned d;
+  unsigned k;
+  COVER_best_t best;
+  POOL_ctx *pool = NULL;
+  int warned = 0;
+
+  /* Checks */
+  if (splitPoint <= 0 || splitPoint > 1) {
+    LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect parameters\n");
+    return ERROR(parameter_outOfBound);
+  }
+  if (kMinK < kMaxD || kMaxK < kMinK) {
+    LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect parameters\n");
+    return ERROR(parameter_outOfBound);
+  }
+  if (nbSamples == 0) {
+    DISPLAYLEVEL(1, "Cover must have at least one input file\n");
+    return ERROR(srcSize_wrong);
+  }
+  if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
+    DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n",
+                 ZDICT_DICTSIZE_MIN);
+    return ERROR(dstSize_tooSmall);
+  }
+  if (nbThreads > 1) {
+    pool = POOL_create(nbThreads, 1);
+    if (!pool) {
+      return ERROR(memory_allocation);
+    }
+  }
+  /* Initialization */
+  COVER_best_init(&best);
+  /* Turn down global display level to clean up display at level 2 and below */
+  g_displayLevel = displayLevel == 0 ? 0 : displayLevel - 1;
+  /* Loop through d first because each new value needs a new context */
+  LOCALDISPLAYLEVEL(displayLevel, 2, "Trying %u different sets of parameters\n",
+                    kIterations);
+  for (d = kMinD; d <= kMaxD; d += 2) {
+    /* Initialize the context for this value of d */
+    COVER_ctx_t ctx;
+    LOCALDISPLAYLEVEL(displayLevel, 3, "d=%u\n", d);
+    {
+      const size_t initVal = COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, d, splitPoint);
+      if (ZSTD_isError(initVal)) {
+        LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to initialize context\n");
+        COVER_best_destroy(&best);
+        POOL_free(pool);
+        return initVal;
+      }
+    }
+    if (!warned) {
+      COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.suffixSize, displayLevel);
+      warned = 1;
+    }
+    /* Loop through k reusing the same context */
+    for (k = kMinK; k <= kMaxK; k += kStepSize) {
+      /* Prepare the arguments */
+      COVER_tryParameters_data_t *data = (COVER_tryParameters_data_t *)malloc(
+          sizeof(COVER_tryParameters_data_t));
+      LOCALDISPLAYLEVEL(displayLevel, 3, "k=%u\n", k);
+      if (!data) {
+        LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to allocate parameters\n");
+        COVER_best_destroy(&best);
+        COVER_ctx_destroy(&ctx);
+        POOL_free(pool);
+        return ERROR(memory_allocation);
+      }
+      data->ctx = &ctx;
+      data->best = &best;
+      data->dictBufferCapacity = dictBufferCapacity;
+      data->parameters = *parameters;
+      data->parameters.k = k;
+      data->parameters.d = d;
+      data->parameters.splitPoint = splitPoint;
+      data->parameters.steps = kSteps;
+      data->parameters.shrinkDict = shrinkDict;
+      data->parameters.zParams.notificationLevel = g_displayLevel;
+      /* Check the parameters */
+      if (!COVER_checkParameters(data->parameters, dictBufferCapacity)) {
+        DISPLAYLEVEL(1, "Cover parameters incorrect\n");
+        free(data);
+        continue;
+      }
+      /* Call the function and pass ownership of data to it */
+      COVER_best_start(&best);
+      if (pool) {
+        POOL_add(pool, &COVER_tryParameters, data);
+      } else {
+        COVER_tryParameters(data);
+      }
+      /* Print status */
+      LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%%       ",
+                         (unsigned)((iteration * 100) / kIterations));
+      ++iteration;
+    }
+    COVER_best_wait(&best);
+    COVER_ctx_destroy(&ctx);
+  }
+  LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", "");
+  /* Fill the output buffer and parameters with output of the best parameters */
+  {
+    const size_t dictSize = best.dictSize;
+    if (ZSTD_isError(best.compressedSize)) {
+      const size_t compressedSize = best.compressedSize;
+      COVER_best_destroy(&best);
+      POOL_free(pool);
+      return compressedSize;
+    }
+    *parameters = best.parameters;
+    memcpy(dictBuffer, best.dict, dictSize);
+    COVER_best_destroy(&best);
+    POOL_free(pool);
+    return dictSize;
+  }
+}
diff --git a/src/cover.h b/src/cover.h
new file mode 100644
index 0000000..d9e0636
--- /dev/null
+++ b/src/cover.h
@@ -0,0 +1,147 @@
+#include <stdio.h>  /* fprintf */
+#include <stdlib.h> /* malloc, free, qsort */
+#include <string.h> /* memset */
+#include <time.h>   /* clock */
+#include "mem.h" /* read */
+#include "pool.h"
+#include "threading.h"
+#include "zstd_internal.h" /* includes zstd.h */
+#ifndef ZDICT_STATIC_LINKING_ONLY
+#define ZDICT_STATIC_LINKING_ONLY
+#endif
+#include "zdict.h"
+
+/**
+ * COVER_best_t is used for two purposes:
+ * 1. Synchronizing threads.
+ * 2. Saving the best parameters and dictionary.
+ *
+ * All of the methods except COVER_best_init() are thread safe if zstd is
+ * compiled with multithreaded support.
+ */
+typedef struct COVER_best_s {
+  ZSTD_pthread_mutex_t mutex;
+  ZSTD_pthread_cond_t cond;
+  size_t liveJobs;
+  void *dict;
+  size_t dictSize;
+  ZDICT_cover_params_t parameters;
+  size_t compressedSize;
+} COVER_best_t;
+
+/**
+ * A segment is a range in the source as well as the score of the segment.
+ */
+typedef struct {
+  U32 begin;
+  U32 end;
+  U32 score;
+} COVER_segment_t;
+
+/**
+ *Number of epochs and size of each epoch.
+ */
+typedef struct {
+  U32 num;
+  U32 size;
+} COVER_epoch_info_t;
+
+/**
+ * Struct used for the dictionary selection function.
+ */
+typedef struct COVER_dictSelection {
+  BYTE* dictContent;
+  size_t dictSize;
+  size_t totalCompressedSize;
+} COVER_dictSelection_t;
+
+/**
+ * Computes the number of epochs and the size of each epoch.
+ * We will make sure that each epoch gets at least 10 * k bytes.
+ *
+ * The COVER algorithms divide the data up into epochs of equal size and
+ * select one segment from each epoch.
+ *
+ * @param maxDictSize The maximum allowed dictionary size.
+ * @param nbDmers     The number of dmers we are training on.
+ * @param k           The parameter k (segment size).
+ * @param passes      The target number of passes over the dmer corpus.
+ *                    More passes means a better dictionary.
+ */
+COVER_epoch_info_t COVER_computeEpochs(U32 maxDictSize, U32 nbDmers,
+                                       U32 k, U32 passes);
+
+/**
+ * Warns the user when their corpus is too small.
+ */
+void COVER_warnOnSmallCorpus(size_t maxDictSize, size_t nbDmers, int displayLevel);
+
+/**
+ *  Checks total compressed size of a dictionary
+ */
+size_t COVER_checkTotalCompressedSize(const ZDICT_cover_params_t parameters,
+                                      const size_t *samplesSizes, const BYTE *samples,
+                                      size_t *offsets,
+                                      size_t nbTrainSamples, size_t nbSamples,
+                                      BYTE *const dict, size_t dictBufferCapacity);
+
+/**
+ * Returns the sum of the sample sizes.
+ */
+size_t COVER_sum(const size_t *samplesSizes, unsigned nbSamples) ;
+
+/**
+ * Initialize the `COVER_best_t`.
+ */
+void COVER_best_init(COVER_best_t *best);
+
+/**
+ * Wait until liveJobs == 0.
+ */
+void COVER_best_wait(COVER_best_t *best);
+
+/**
+ * Call COVER_best_wait() and then destroy the COVER_best_t.
+ */
+void COVER_best_destroy(COVER_best_t *best);
+
+/**
+ * Called when a thread is about to be launched.
+ * Increments liveJobs.
+ */
+void COVER_best_start(COVER_best_t *best);
+
+/**
+ * Called when a thread finishes executing, both on error or success.
+ * Decrements liveJobs and signals any waiting threads if liveJobs == 0.
+ * If this dictionary is the best so far save it and its parameters.
+ */
+void COVER_best_finish(COVER_best_t *best, ZDICT_cover_params_t parameters,
+                       COVER_dictSelection_t selection);
+/**
+ * Error function for COVER_selectDict function. Checks if the return
+ * value is an error.
+ */
+unsigned COVER_dictSelectionIsError(COVER_dictSelection_t selection);
+
+ /**
+  * Error function for COVER_selectDict function. Returns a struct where
+  * return.totalCompressedSize is a ZSTD error.
+  */
+COVER_dictSelection_t COVER_dictSelectionError(size_t error);
+
+/**
+ * Always call after selectDict is called to free up used memory from
+ * newly created dictionary.
+ */
+void COVER_dictSelectionFree(COVER_dictSelection_t selection);
+
+/**
+ * Called to finalize the dictionary and select one based on whether or not
+ * the shrink-dict flag was enabled. If enabled the dictionary used is the
+ * smallest dictionary within a specified regression of the compressed size
+ * from the largest dictionary.
+ */
+ COVER_dictSelection_t COVER_selectDict(BYTE* customDictContent,
+                       size_t dictContentSize, const BYTE* samplesBuffer, const size_t* samplesSizes, unsigned nbFinalizeSamples,
+                       size_t nbCheckSamples, size_t nbSamples, ZDICT_cover_params_t params, size_t* offsets, size_t totalCompressedSize);
diff --git a/src/cpu.h b/src/cpu.h
new file mode 100644
index 0000000..5f0923f
--- /dev/null
+++ b/src/cpu.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2018-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_COMMON_CPU_H
+#define ZSTD_COMMON_CPU_H
+
+/**
+ * Implementation taken from folly/CpuId.h
+ * https://github.com/facebook/folly/blob/master/folly/CpuId.h
+ */
+
+#include <string.h>
+
+#include "mem.h"
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+typedef struct {
+    U32 f1c;
+    U32 f1d;
+    U32 f7b;
+    U32 f7c;
+} ZSTD_cpuid_t;
+
+MEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) {
+    U32 f1c = 0;
+    U32 f1d = 0;
+    U32 f7b = 0;
+    U32 f7c = 0;
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
+    int reg[4];
+    __cpuid((int*)reg, 0);
+    {
+        int const n = reg[0];
+        if (n >= 1) {
+            __cpuid((int*)reg, 1);
+            f1c = (U32)reg[2];
+            f1d = (U32)reg[3];
+        }
+        if (n >= 7) {
+            __cpuidex((int*)reg, 7, 0);
+            f7b = (U32)reg[1];
+            f7c = (U32)reg[2];
+        }
+    }
+#elif defined(__i386__) && defined(__PIC__) && !defined(__clang__) && defined(__GNUC__)
+    /* The following block like the normal cpuid branch below, but gcc
+     * reserves ebx for use of its pic register so we must specially
+     * handle the save and restore to avoid clobbering the register
+     */
+    U32 n;
+    __asm__(
+        "pushl %%ebx\n\t"
+        "cpuid\n\t"
+        "popl %%ebx\n\t"
+        : "=a"(n)
+        : "a"(0)
+        : "ecx", "edx");
+    if (n >= 1) {
+      U32 f1a;
+      __asm__(
+          "pushl %%ebx\n\t"
+          "cpuid\n\t"
+          "popl %%ebx\n\t"
+          : "=a"(f1a), "=c"(f1c), "=d"(f1d)
+          : "a"(1));
+    }
+    if (n >= 7) {
+      __asm__(
+          "pushl %%ebx\n\t"
+          "cpuid\n\t"
+          "movl %%ebx, %%eax\n\t"
+          "popl %%ebx"
+          : "=a"(f7b), "=c"(f7c)
+          : "a"(7), "c"(0)
+          : "edx");
+    }
+#elif defined(__x86_64__) || defined(_M_X64) || defined(__i386__)
+    U32 n;
+    __asm__("cpuid" : "=a"(n) : "a"(0) : "ebx", "ecx", "edx");
+    if (n >= 1) {
+      U32 f1a;
+      __asm__("cpuid" : "=a"(f1a), "=c"(f1c), "=d"(f1d) : "a"(1) : "ebx");
+    }
+    if (n >= 7) {
+      U32 f7a;
+      __asm__("cpuid"
+              : "=a"(f7a), "=b"(f7b), "=c"(f7c)
+              : "a"(7), "c"(0)
+              : "edx");
+    }
+#endif
+    {
+        ZSTD_cpuid_t cpuid;
+        cpuid.f1c = f1c;
+        cpuid.f1d = f1d;
+        cpuid.f7b = f7b;
+        cpuid.f7c = f7c;
+        return cpuid;
+    }
+}
+
+#define X(name, r, bit)                                                        \
+  MEM_STATIC int ZSTD_cpuid_##name(ZSTD_cpuid_t const cpuid) {                 \
+    return ((cpuid.r) & (1U << bit)) != 0;                                     \
+  }
+
+/* cpuid(1): Processor Info and Feature Bits. */
+#define C(name, bit) X(name, f1c, bit)
+  C(sse3, 0)
+  C(pclmuldq, 1)
+  C(dtes64, 2)
+  C(monitor, 3)
+  C(dscpl, 4)
+  C(vmx, 5)
+  C(smx, 6)
+  C(eist, 7)
+  C(tm2, 8)
+  C(ssse3, 9)
+  C(cnxtid, 10)
+  C(fma, 12)
+  C(cx16, 13)
+  C(xtpr, 14)
+  C(pdcm, 15)
+  C(pcid, 17)
+  C(dca, 18)
+  C(sse41, 19)
+  C(sse42, 20)
+  C(x2apic, 21)
+  C(movbe, 22)
+  C(popcnt, 23)
+  C(tscdeadline, 24)
+  C(aes, 25)
+  C(xsave, 26)
+  C(osxsave, 27)
+  C(avx, 28)
+  C(f16c, 29)
+  C(rdrand, 30)
+#undef C
+#define D(name, bit) X(name, f1d, bit)
+  D(fpu, 0)
+  D(vme, 1)
+  D(de, 2)
+  D(pse, 3)
+  D(tsc, 4)
+  D(msr, 5)
+  D(pae, 6)
+  D(mce, 7)
+  D(cx8, 8)
+  D(apic, 9)
+  D(sep, 11)
+  D(mtrr, 12)
+  D(pge, 13)
+  D(mca, 14)
+  D(cmov, 15)
+  D(pat, 16)
+  D(pse36, 17)
+  D(psn, 18)
+  D(clfsh, 19)
+  D(ds, 21)
+  D(acpi, 22)
+  D(mmx, 23)
+  D(fxsr, 24)
+  D(sse, 25)
+  D(sse2, 26)
+  D(ss, 27)
+  D(htt, 28)
+  D(tm, 29)
+  D(pbe, 31)
+#undef D
+
+/* cpuid(7): Extended Features. */
+#define B(name, bit) X(name, f7b, bit)
+  B(bmi1, 3)
+  B(hle, 4)
+  B(avx2, 5)
+  B(smep, 7)
+  B(bmi2, 8)
+  B(erms, 9)
+  B(invpcid, 10)
+  B(rtm, 11)
+  B(mpx, 14)
+  B(avx512f, 16)
+  B(avx512dq, 17)
+  B(rdseed, 18)
+  B(adx, 19)
+  B(smap, 20)
+  B(avx512ifma, 21)
+  B(pcommit, 22)
+  B(clflushopt, 23)
+  B(clwb, 24)
+  B(avx512pf, 26)
+  B(avx512er, 27)
+  B(avx512cd, 28)
+  B(sha, 29)
+  B(avx512bw, 30)
+  B(avx512vl, 31)
+#undef B
+#define C(name, bit) X(name, f7c, bit)
+  C(prefetchwt1, 0)
+  C(avx512vbmi, 1)
+#undef C
+
+#undef X
+
+#endif /* ZSTD_COMMON_CPU_H */
diff --git a/src/debug.c b/src/debug.c
new file mode 100644
index 0000000..3ebdd1c
--- /dev/null
+++ b/src/debug.c
@@ -0,0 +1,44 @@
+/* ******************************************************************
+   debug
+   Part of FSE library
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+
+
+/*
+ * This module only hosts one global variable
+ * which can be used to dynamically influence the verbosity of traces,
+ * such as DEBUGLOG and RAWLOG
+ */
+
+#include "debug.h"
+
+int g_debuglevel = DEBUGLEVEL;
diff --git a/src/debug.h b/src/debug.h
new file mode 100644
index 0000000..b4fc89d
--- /dev/null
+++ b/src/debug.h
@@ -0,0 +1,134 @@
+/* ******************************************************************
+   debug
+   Part of FSE library
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+
+
+/*
+ * The purpose of this header is to enable debug functions.
+ * They regroup assert(), DEBUGLOG() and RAWLOG() for run-time,
+ * and DEBUG_STATIC_ASSERT() for compile-time.
+ *
+ * By default, DEBUGLEVEL==0, which means run-time debug is disabled.
+ *
+ * Level 1 enables assert() only.
+ * Starting level 2, traces can be generated and pushed to stderr.
+ * The higher the level, the more verbose the traces.
+ *
+ * It's possible to dynamically adjust level using variable g_debug_level,
+ * which is only declared if DEBUGLEVEL>=2,
+ * and is a global variable, not multi-thread protected (use with care)
+ */
+
+#ifndef DEBUG_H_12987983217
+#define DEBUG_H_12987983217
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* static assert is triggered at compile time, leaving no runtime artefact.
+ * static assert only works with compile-time constants.
+ * Also, this variant can only be used inside a function. */
+#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])
+
+
+/* DEBUGLEVEL is expected to be defined externally,
+ * typically through compiler command line.
+ * Value must be a number. */
+#ifndef DEBUGLEVEL
+#  define DEBUGLEVEL 0
+#endif
+
+
+/* DEBUGFILE can be defined externally,
+ * typically through compiler command line.
+ * note : currently useless.
+ * Value must be stderr or stdout */
+#ifndef DEBUGFILE
+#  define DEBUGFILE stderr
+#endif
+
+
+/* recommended values for DEBUGLEVEL :
+ * 0 : release mode, no debug, all run-time checks disabled
+ * 1 : enables assert() only, no display
+ * 2 : reserved, for currently active debug path
+ * 3 : events once per object lifetime (CCtx, CDict, etc.)
+ * 4 : events once per frame
+ * 5 : events once per block
+ * 6 : events once per sequence (verbose)
+ * 7+: events at every position (*very* verbose)
+ *
+ * It's generally inconvenient to output traces > 5.
+ * In which case, it's possible to selectively trigger high verbosity levels
+ * by modifying g_debug_level.
+ */
+
+#if (DEBUGLEVEL>=1)
+#  include <assert.h>
+#else
+#  ifndef assert   /* assert may be already defined, due to prior #include <assert.h> */
+#    define assert(condition) ((void)0)   /* disable assert (default) */
+#  endif
+#endif
+
+#if (DEBUGLEVEL>=2)
+#  include <stdio.h>
+extern int g_debuglevel; /* the variable is only declared,
+                            it actually lives in debug.c,
+                            and is shared by the whole process.
+                            It's not thread-safe.
+                            It's useful when enabling very verbose levels
+                            on selective conditions (such as position in src) */
+
+#  define RAWLOG(l, ...) {                                      \
+                if (l<=g_debuglevel) {                          \
+                    fprintf(stderr, __VA_ARGS__);               \
+            }   }
+#  define DEBUGLOG(l, ...) {                                    \
+                if (l<=g_debuglevel) {                          \
+                    fprintf(stderr, __FILE__ ": " __VA_ARGS__); \
+                    fprintf(stderr, " \n");                     \
+            }   }
+#else
+#  define RAWLOG(l, ...)      {}    /* disabled */
+#  define DEBUGLOG(l, ...)    {}    /* disabled */
+#endif
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DEBUG_H_12987983217 */
diff --git a/src/divsufsort.c b/src/divsufsort.c
new file mode 100644
index 0000000..ead9220
--- /dev/null
+++ b/src/divsufsort.c
@@ -0,0 +1,1913 @@
+/*
+ * divsufsort.c for libdivsufsort-lite
+ * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*- Compiler specifics -*/
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#endif
+
+#if defined(_MSC_VER)
+#  pragma warning(disable : 4244)
+#  pragma warning(disable : 4127)    /* C4127 : Condition expression is constant */
+#endif
+
+
+/*- Dependencies -*/
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "divsufsort.h"
+
+/*- Constants -*/
+#if defined(INLINE)
+# undef INLINE
+#endif
+#if !defined(INLINE)
+# define INLINE __inline
+#endif
+#if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1)
+# undef ALPHABET_SIZE
+#endif
+#if !defined(ALPHABET_SIZE)
+# define ALPHABET_SIZE (256)
+#endif
+#define BUCKET_A_SIZE (ALPHABET_SIZE)
+#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE)
+#if defined(SS_INSERTIONSORT_THRESHOLD)
+# if SS_INSERTIONSORT_THRESHOLD < 1
+#  undef SS_INSERTIONSORT_THRESHOLD
+#  define SS_INSERTIONSORT_THRESHOLD (1)
+# endif
+#else
+# define SS_INSERTIONSORT_THRESHOLD (8)
+#endif
+#if defined(SS_BLOCKSIZE)
+# if SS_BLOCKSIZE < 0
+#  undef SS_BLOCKSIZE
+#  define SS_BLOCKSIZE (0)
+# elif 32768 <= SS_BLOCKSIZE
+#  undef SS_BLOCKSIZE
+#  define SS_BLOCKSIZE (32767)
+# endif
+#else
+# define SS_BLOCKSIZE (1024)
+#endif
+/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */
+#if SS_BLOCKSIZE == 0
+# define SS_MISORT_STACKSIZE (96)
+#elif SS_BLOCKSIZE <= 4096
+# define SS_MISORT_STACKSIZE (16)
+#else
+# define SS_MISORT_STACKSIZE (24)
+#endif
+#define SS_SMERGE_STACKSIZE (32)
+#define TR_INSERTIONSORT_THRESHOLD (8)
+#define TR_STACKSIZE (64)
+
+
+/*- Macros -*/
+#ifndef SWAP
+# define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0)
+#endif /* SWAP */
+#ifndef MIN
+# define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b))
+#endif /* MIN */
+#ifndef MAX
+# define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b))
+#endif /* MAX */
+#define STACK_PUSH(_a, _b, _c, _d)\
+  do {\
+    assert(ssize < STACK_SIZE);\
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\
+    stack[ssize].c = (_c), stack[ssize++].d = (_d);\
+  } while(0)
+#define STACK_PUSH5(_a, _b, _c, _d, _e)\
+  do {\
+    assert(ssize < STACK_SIZE);\
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\
+    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\
+  } while(0)
+#define STACK_POP(_a, _b, _c, _d)\
+  do {\
+    assert(0 <= ssize);\
+    if(ssize == 0) { return; }\
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d;\
+  } while(0)
+#define STACK_POP5(_a, _b, _c, _d, _e)\
+  do {\
+    assert(0 <= ssize);\
+    if(ssize == 0) { return; }\
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\
+  } while(0)
+#define BUCKET_A(_c0) bucket_A[(_c0)]
+#if ALPHABET_SIZE == 256
+#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)])
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)])
+#else
+#define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)])
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)])
+#endif
+
+
+/*- Private Functions -*/
+
+static const int lg_table[256]= {
+ -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+  5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
+};
+
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
+
+static INLINE
+int
+ss_ilg(int n) {
+#if SS_BLOCKSIZE == 0
+  return (n & 0xffff0000) ?
+          ((n & 0xff000000) ?
+            24 + lg_table[(n >> 24) & 0xff] :
+            16 + lg_table[(n >> 16) & 0xff]) :
+          ((n & 0x0000ff00) ?
+             8 + lg_table[(n >>  8) & 0xff] :
+             0 + lg_table[(n >>  0) & 0xff]);
+#elif SS_BLOCKSIZE < 256
+  return lg_table[n];
+#else
+  return (n & 0xff00) ?
+          8 + lg_table[(n >> 8) & 0xff] :
+          0 + lg_table[(n >> 0) & 0xff];
+#endif
+}
+
+#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
+
+#if SS_BLOCKSIZE != 0
+
+static const int sqq_table[256] = {
+  0,  16,  22,  27,  32,  35,  39,  42,  45,  48,  50,  53,  55,  57,  59,  61,
+ 64,  65,  67,  69,  71,  73,  75,  76,  78,  80,  81,  83,  84,  86,  87,  89,
+ 90,  91,  93,  94,  96,  97,  98,  99, 101, 102, 103, 104, 106, 107, 108, 109,
+110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
+128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
+143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,
+156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168,
+169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180,
+181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191,
+192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201,
+202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211,
+212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221,
+221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230,
+230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238,
+239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247,
+247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255
+};
+
+static INLINE
+int
+ss_isqrt(int x) {
+  int y, e;
+
+  if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; }
+  e = (x & 0xffff0000) ?
+        ((x & 0xff000000) ?
+          24 + lg_table[(x >> 24) & 0xff] :
+          16 + lg_table[(x >> 16) & 0xff]) :
+        ((x & 0x0000ff00) ?
+           8 + lg_table[(x >>  8) & 0xff] :
+           0 + lg_table[(x >>  0) & 0xff]);
+
+  if(e >= 16) {
+    y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7);
+    if(e >= 24) { y = (y + 1 + x / y) >> 1; }
+    y = (y + 1 + x / y) >> 1;
+  } else if(e >= 8) {
+    y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1;
+  } else {
+    return sqq_table[x] >> 4;
+  }
+
+  return (x < (y * y)) ? y - 1 : y;
+}
+
+#endif /* SS_BLOCKSIZE != 0 */
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Compares two suffixes. */
+static INLINE
+int
+ss_compare(const unsigned char *T,
+           const int *p1, const int *p2,
+           int depth) {
+  const unsigned char *U1, *U2, *U1n, *U2n;
+
+  for(U1 = T + depth + *p1,
+      U2 = T + depth + *p2,
+      U1n = T + *(p1 + 1) + 2,
+      U2n = T + *(p2 + 1) + 2;
+      (U1 < U1n) && (U2 < U2n) && (*U1 == *U2);
+      ++U1, ++U2) {
+  }
+
+  return U1 < U1n ?
+        (U2 < U2n ? *U1 - *U2 : 1) :
+        (U2 < U2n ? -1 : 0);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+#if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1)
+
+/* Insertionsort for small size groups */
+static
+void
+ss_insertionsort(const unsigned char *T, const int *PA,
+                 int *first, int *last, int depth) {
+  int *i, *j;
+  int t;
+  int r;
+
+  for(i = last - 2; first <= i; --i) {
+    for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) {
+      do { *(j - 1) = *j; } while((++j < last) && (*j < 0));
+      if(last <= j) { break; }
+    }
+    if(r == 0) { *j = ~*j; }
+    *(j - 1) = t;
+  }
+}
+
+#endif /* (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) */
+
+
+/*---------------------------------------------------------------------------*/
+
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
+
+static INLINE
+void
+ss_fixdown(const unsigned char *Td, const int *PA,
+           int *SA, int i, int size) {
+  int j, k;
+  int v;
+  int c, d, e;
+
+  for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
+    d = Td[PA[SA[k = j++]]];
+    if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; }
+    if(d <= c) { break; }
+  }
+  SA[i] = v;
+}
+
+/* Simple top-down heapsort. */
+static
+void
+ss_heapsort(const unsigned char *Td, const int *PA, int *SA, int size) {
+  int i, m;
+  int t;
+
+  m = size;
+  if((size % 2) == 0) {
+    m--;
+    if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) { SWAP(SA[m], SA[m / 2]); }
+  }
+
+  for(i = m / 2 - 1; 0 <= i; --i) { ss_fixdown(Td, PA, SA, i, m); }
+  if((size % 2) == 0) { SWAP(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); }
+  for(i = m - 1; 0 < i; --i) {
+    t = SA[0], SA[0] = SA[i];
+    ss_fixdown(Td, PA, SA, 0, i);
+    SA[i] = t;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Returns the median of three elements. */
+static INLINE
+int *
+ss_median3(const unsigned char *Td, const int *PA,
+           int *v1, int *v2, int *v3) {
+  int *t;
+  if(Td[PA[*v1]] > Td[PA[*v2]]) { SWAP(v1, v2); }
+  if(Td[PA[*v2]] > Td[PA[*v3]]) {
+    if(Td[PA[*v1]] > Td[PA[*v3]]) { return v1; }
+    else { return v3; }
+  }
+  return v2;
+}
+
+/* Returns the median of five elements. */
+static INLINE
+int *
+ss_median5(const unsigned char *Td, const int *PA,
+           int *v1, int *v2, int *v3, int *v4, int *v5) {
+  int *t;
+  if(Td[PA[*v2]] > Td[PA[*v3]]) { SWAP(v2, v3); }
+  if(Td[PA[*v4]] > Td[PA[*v5]]) { SWAP(v4, v5); }
+  if(Td[PA[*v2]] > Td[PA[*v4]]) { SWAP(v2, v4); SWAP(v3, v5); }
+  if(Td[PA[*v1]] > Td[PA[*v3]]) { SWAP(v1, v3); }
+  if(Td[PA[*v1]] > Td[PA[*v4]]) { SWAP(v1, v4); SWAP(v3, v5); }
+  if(Td[PA[*v3]] > Td[PA[*v4]]) { return v4; }
+  return v3;
+}
+
+/* Returns the pivot element. */
+static INLINE
+int *
+ss_pivot(const unsigned char *Td, const int *PA, int *first, int *last) {
+  int *middle;
+  int t;
+
+  t = last - first;
+  middle = first + t / 2;
+
+  if(t <= 512) {
+    if(t <= 32) {
+      return ss_median3(Td, PA, first, middle, last - 1);
+    } else {
+      t >>= 2;
+      return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1);
+    }
+  }
+  t >>= 3;
+  first  = ss_median3(Td, PA, first, first + t, first + (t << 1));
+  middle = ss_median3(Td, PA, middle - t, middle, middle + t);
+  last   = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1);
+  return ss_median3(Td, PA, first, middle, last);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Binary partition for substrings. */
+static INLINE
+int *
+ss_partition(const int *PA,
+                    int *first, int *last, int depth) {
+  int *a, *b;
+  int t;
+  for(a = first - 1, b = last;;) {
+    for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) { *a = ~*a; }
+    for(; (a < --b) && ((PA[*b] + depth) <  (PA[*b + 1] + 1));) { }
+    if(b <= a) { break; }
+    t = ~*b;
+    *b = *a;
+    *a = t;
+  }
+  if(first < a) { *first = ~*first; }
+  return a;
+}
+
+/* Multikey introsort for medium size groups. */
+static
+void
+ss_mintrosort(const unsigned char *T, const int *PA,
+              int *first, int *last,
+              int depth) {
+#define STACK_SIZE SS_MISORT_STACKSIZE
+  struct { int *a, *b, c; int d; } stack[STACK_SIZE];
+  const unsigned char *Td;
+  int *a, *b, *c, *d, *e, *f;
+  int s, t;
+  int ssize;
+  int limit;
+  int v, x = 0;
+
+  for(ssize = 0, limit = ss_ilg(last - first);;) {
+
+    if((last - first) <= SS_INSERTIONSORT_THRESHOLD) {
+#if 1 < SS_INSERTIONSORT_THRESHOLD
+      if(1 < (last - first)) { ss_insertionsort(T, PA, first, last, depth); }
+#endif
+      STACK_POP(first, last, depth, limit);
+      continue;
+    }
+
+    Td = T + depth;
+    if(limit-- == 0) { ss_heapsort(Td, PA, first, last - first); }
+    if(limit < 0) {
+      for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) {
+        if((x = Td[PA[*a]]) != v) {
+          if(1 < (a - first)) { break; }
+          v = x;
+          first = a;
+        }
+      }
+      if(Td[PA[*first] - 1] < v) {
+        first = ss_partition(PA, first, a, depth);
+      }
+      if((a - first) <= (last - a)) {
+        if(1 < (a - first)) {
+          STACK_PUSH(a, last, depth, -1);
+          last = a, depth += 1, limit = ss_ilg(a - first);
+        } else {
+          first = a, limit = -1;
+        }
+      } else {
+        if(1 < (last - a)) {
+          STACK_PUSH(first, a, depth + 1, ss_ilg(a - first));
+          first = a, limit = -1;
+        } else {
+          last = a, depth += 1, limit = ss_ilg(a - first);
+        }
+      }
+      continue;
+    }
+
+    /* choose pivot */
+    a = ss_pivot(Td, PA, first, last);
+    v = Td[PA[*a]];
+    SWAP(*first, *a);
+
+    /* partition */
+    for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) { }
+    if(((a = b) < last) && (x < v)) {
+      for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) {
+        if(x == v) { SWAP(*b, *a); ++a; }
+      }
+    }
+    for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) { }
+    if((b < (d = c)) && (x > v)) {
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
+        if(x == v) { SWAP(*c, *d); --d; }
+      }
+    }
+    for(; b < c;) {
+      SWAP(*b, *c);
+      for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) {
+        if(x == v) { SWAP(*b, *a); ++a; }
+      }
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
+        if(x == v) { SWAP(*c, *d); --d; }
+      }
+    }
+
+    if(a <= d) {
+      c = b - 1;
+
+      if((s = a - first) > (t = b - a)) { s = t; }
+      for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+      if((s = d - c) > (t = last - d - 1)) { s = t; }
+      for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+
+      a = first + (b - a), c = last - (d - c);
+      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);
+
+      if((a - first) <= (last - c)) {
+        if((last - c) <= (c - b)) {
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          STACK_PUSH(c, last, depth, limit);
+          last = a;
+        } else if((a - first) <= (c - b)) {
+          STACK_PUSH(c, last, depth, limit);
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          last = a;
+        } else {
+          STACK_PUSH(c, last, depth, limit);
+          STACK_PUSH(first, a, depth, limit);
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
+        }
+      } else {
+        if((a - first) <= (c - b)) {
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          STACK_PUSH(first, a, depth, limit);
+          first = c;
+        } else if((last - c) <= (c - b)) {
+          STACK_PUSH(first, a, depth, limit);
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          first = c;
+        } else {
+          STACK_PUSH(first, a, depth, limit);
+          STACK_PUSH(c, last, depth, limit);
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
+        }
+      }
+    } else {
+      limit += 1;
+      if(Td[PA[*first] - 1] < v) {
+        first = ss_partition(PA, first, last, depth);
+        limit = ss_ilg(last - first);
+      }
+      depth += 1;
+    }
+  }
+#undef STACK_SIZE
+}
+
+#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
+
+
+/*---------------------------------------------------------------------------*/
+
+#if SS_BLOCKSIZE != 0
+
+static INLINE
+void
+ss_blockswap(int *a, int *b, int n) {
+  int t;
+  for(; 0 < n; --n, ++a, ++b) {
+    t = *a, *a = *b, *b = t;
+  }
+}
+
+static INLINE
+void
+ss_rotate(int *first, int *middle, int *last) {
+  int *a, *b, t;
+  int l, r;
+  l = middle - first, r = last - middle;
+  for(; (0 < l) && (0 < r);) {
+    if(l == r) { ss_blockswap(first, middle, l); break; }
+    if(l < r) {
+      a = last - 1, b = middle - 1;
+      t = *a;
+      do {
+        *a-- = *b, *b-- = *a;
+        if(b < first) {
+          *a = t;
+          last = a;
+          if((r -= l + 1) <= l) { break; }
+          a -= 1, b = middle - 1;
+          t = *a;
+        }
+      } while(1);
+    } else {
+      a = first, b = middle;
+      t = *a;
+      do {
+        *a++ = *b, *b++ = *a;
+        if(last <= b) {
+          *a = t;
+          first = a + 1;
+          if((l -= r + 1) <= r) { break; }
+          a += 1, b = middle;
+          t = *a;
+        }
+      } while(1);
+    }
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static
+void
+ss_inplacemerge(const unsigned char *T, const int *PA,
+                int *first, int *middle, int *last,
+                int depth) {
+  const int *p;
+  int *a, *b;
+  int len, half;
+  int q, r;
+  int x;
+
+  for(;;) {
+    if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); }
+    else                { x = 0; p = PA +  *(last - 1); }
+    for(a = first, len = middle - first, half = len >> 1, r = -1;
+        0 < len;
+        len = half, half >>= 1) {
+      b = a + half;
+      q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth);
+      if(q < 0) {
+        a = b + 1;
+        half -= (len & 1) ^ 1;
+      } else {
+        r = q;
+      }
+    }
+    if(a < middle) {
+      if(r == 0) { *a = ~*a; }
+      ss_rotate(a, middle, last);
+      last -= middle - a;
+      middle = a;
+      if(first == middle) { break; }
+    }
+    --last;
+    if(x != 0) { while(*--last < 0) { } }
+    if(middle == last) { break; }
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Merge-forward with internal buffer. */
+static
+void
+ss_mergeforward(const unsigned char *T, const int *PA,
+                int *first, int *middle, int *last,
+                int *buf, int depth) {
+  int *a, *b, *c, *bufend;
+  int t;
+  int r;
+
+  bufend = buf + (middle - first) - 1;
+  ss_blockswap(buf, first, middle - first);
+
+  for(t = *(a = first), b = buf, c = middle;;) {
+    r = ss_compare(T, PA + *b, PA + *c, depth);
+    if(r < 0) {
+      do {
+        *a++ = *b;
+        if(bufend <= b) { *bufend = t; return; }
+        *b++ = *a;
+      } while(*b < 0);
+    } else if(r > 0) {
+      do {
+        *a++ = *c, *c++ = *a;
+        if(last <= c) {
+          while(b < bufend) { *a++ = *b, *b++ = *a; }
+          *a = *b, *b = t;
+          return;
+        }
+      } while(*c < 0);
+    } else {
+      *c = ~*c;
+      do {
+        *a++ = *b;
+        if(bufend <= b) { *bufend = t; return; }
+        *b++ = *a;
+      } while(*b < 0);
+
+      do {
+        *a++ = *c, *c++ = *a;
+        if(last <= c) {
+          while(b < bufend) { *a++ = *b, *b++ = *a; }
+          *a = *b, *b = t;
+          return;
+        }
+      } while(*c < 0);
+    }
+  }
+}
+
+/* Merge-backward with internal buffer. */
+static
+void
+ss_mergebackward(const unsigned char *T, const int *PA,
+                 int *first, int *middle, int *last,
+                 int *buf, int depth) {
+  const int *p1, *p2;
+  int *a, *b, *c, *bufend;
+  int t;
+  int r;
+  int x;
+
+  bufend = buf + (last - middle) - 1;
+  ss_blockswap(buf, middle, last - middle);
+
+  x = 0;
+  if(*bufend < 0)       { p1 = PA + ~*bufend; x |= 1; }
+  else                  { p1 = PA +  *bufend; }
+  if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; }
+  else                  { p2 = PA +  *(middle - 1); }
+  for(t = *(a = last - 1), b = bufend, c = middle - 1;;) {
+    r = ss_compare(T, p1, p2, depth);
+    if(0 < r) {
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
+      *a-- = *b;
+      if(b <= buf) { *buf = t; break; }
+      *b-- = *a;
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
+      else       { p1 = PA +  *b; }
+    } else if(r < 0) {
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
+      *a-- = *c, *c-- = *a;
+      if(c < first) {
+        while(buf < b) { *a-- = *b, *b-- = *a; }
+        *a = *b, *b = t;
+        break;
+      }
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
+      else       { p2 = PA +  *c; }
+    } else {
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
+      *a-- = ~*b;
+      if(b <= buf) { *buf = t; break; }
+      *b-- = *a;
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
+      *a-- = *c, *c-- = *a;
+      if(c < first) {
+        while(buf < b) { *a-- = *b, *b-- = *a; }
+        *a = *b, *b = t;
+        break;
+      }
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
+      else       { p1 = PA +  *b; }
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
+      else       { p2 = PA +  *c; }
+    }
+  }
+}
+
+/* D&C based merge. */
+static
+void
+ss_swapmerge(const unsigned char *T, const int *PA,
+             int *first, int *middle, int *last,
+             int *buf, int bufsize, int depth) {
+#define STACK_SIZE SS_SMERGE_STACKSIZE
+#define GETIDX(a) ((0 <= (a)) ? (a) : (~(a)))
+#define MERGE_CHECK(a, b, c)\
+  do {\
+    if(((c) & 1) ||\
+       (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) {\
+      *(a) = ~*(a);\
+    }\
+    if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) {\
+      *(b) = ~*(b);\
+    }\
+  } while(0)
+  struct { int *a, *b, *c; int d; } stack[STACK_SIZE];
+  int *l, *r, *lm, *rm;
+  int m, len, half;
+  int ssize;
+  int check, next;
+
+  for(check = 0, ssize = 0;;) {
+    if((last - middle) <= bufsize) {
+      if((first < middle) && (middle < last)) {
+        ss_mergebackward(T, PA, first, middle, last, buf, depth);
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+      continue;
+    }
+
+    if((middle - first) <= bufsize) {
+      if(first < middle) {
+        ss_mergeforward(T, PA, first, middle, last, buf, depth);
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+      continue;
+    }
+
+    for(m = 0, len = MIN(middle - first, last - middle), half = len >> 1;
+        0 < len;
+        len = half, half >>= 1) {
+      if(ss_compare(T, PA + GETIDX(*(middle + m + half)),
+                       PA + GETIDX(*(middle - m - half - 1)), depth) < 0) {
+        m += half + 1;
+        half -= (len & 1) ^ 1;
+      }
+    }
+
+    if(0 < m) {
+      lm = middle - m, rm = middle + m;
+      ss_blockswap(lm, middle, m);
+      l = r = middle, next = 0;
+      if(rm < last) {
+        if(*rm < 0) {
+          *rm = ~*rm;
+          if(first < lm) { for(; *--l < 0;) { } next |= 4; }
+          next |= 1;
+        } else if(first < lm) {
+          for(; *r < 0; ++r) { }
+          next |= 2;
+        }
+      }
+
+      if((l - first) <= (last - r)) {
+        STACK_PUSH(r, rm, last, (next & 3) | (check & 4));
+        middle = lm, last = l, check = (check & 3) | (next & 4);
+      } else {
+        if((next & 2) && (r == middle)) { next ^= 6; }
+        STACK_PUSH(first, lm, l, (check & 3) | (next & 4));
+        first = r, middle = rm, check = (next & 3) | (check & 4);
+      }
+    } else {
+      if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) {
+        *middle = ~*middle;
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+    }
+  }
+#undef STACK_SIZE
+}
+
+#endif /* SS_BLOCKSIZE != 0 */
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Substring sort */
+static
+void
+sssort(const unsigned char *T, const int *PA,
+       int *first, int *last,
+       int *buf, int bufsize,
+       int depth, int n, int lastsuffix) {
+  int *a;
+#if SS_BLOCKSIZE != 0
+  int *b, *middle, *curbuf;
+  int j, k, curbufsize, limit;
+#endif
+  int i;
+
+  if(lastsuffix != 0) { ++first; }
+
+#if SS_BLOCKSIZE == 0
+  ss_mintrosort(T, PA, first, last, depth);
+#else
+  if((bufsize < SS_BLOCKSIZE) &&
+      (bufsize < (last - first)) &&
+      (bufsize < (limit = ss_isqrt(last - first)))) {
+    if(SS_BLOCKSIZE < limit) { limit = SS_BLOCKSIZE; }
+    buf = middle = last - limit, bufsize = limit;
+  } else {
+    middle = last, limit = 0;
+  }
+  for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) {
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+    ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth);
+#elif 1 < SS_BLOCKSIZE
+    ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth);
+#endif
+    curbufsize = last - (a + SS_BLOCKSIZE);
+    curbuf = a + SS_BLOCKSIZE;
+    if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; }
+    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) {
+      ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth);
+    }
+  }
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+  ss_mintrosort(T, PA, a, middle, depth);
+#elif 1 < SS_BLOCKSIZE
+  ss_insertionsort(T, PA, a, middle, depth);
+#endif
+  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) {
+    if(i & 1) {
+      ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth);
+      a -= k;
+    }
+  }
+  if(limit != 0) {
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+    ss_mintrosort(T, PA, middle, last, depth);
+#elif 1 < SS_BLOCKSIZE
+    ss_insertionsort(T, PA, middle, last, depth);
+#endif
+    ss_inplacemerge(T, PA, first, middle, last, depth);
+  }
+#endif
+
+  if(lastsuffix != 0) {
+    /* Insert last type B* suffix. */
+    int PAi[2]; PAi[0] = PA[*(first - 1)], PAi[1] = n - 2;
+    for(a = first, i = *(first - 1);
+        (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth)));
+        ++a) {
+      *(a - 1) = *a;
+    }
+    *(a - 1) = i;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static INLINE
+int
+tr_ilg(int n) {
+  return (n & 0xffff0000) ?
+          ((n & 0xff000000) ?
+            24 + lg_table[(n >> 24) & 0xff] :
+            16 + lg_table[(n >> 16) & 0xff]) :
+          ((n & 0x0000ff00) ?
+             8 + lg_table[(n >>  8) & 0xff] :
+             0 + lg_table[(n >>  0) & 0xff]);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Simple insertionsort for small size groups. */
+static
+void
+tr_insertionsort(const int *ISAd, int *first, int *last) {
+  int *a, *b;
+  int t, r;
+
+  for(a = first + 1; a < last; ++a) {
+    for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) {
+      do { *(b + 1) = *b; } while((first <= --b) && (*b < 0));
+      if(b < first) { break; }
+    }
+    if(r == 0) { *b = ~*b; }
+    *(b + 1) = t;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static INLINE
+void
+tr_fixdown(const int *ISAd, int *SA, int i, int size) {
+  int j, k;
+  int v;
+  int c, d, e;
+
+  for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
+    d = ISAd[SA[k = j++]];
+    if(d < (e = ISAd[SA[j]])) { k = j; d = e; }
+    if(d <= c) { break; }
+  }
+  SA[i] = v;
+}
+
+/* Simple top-down heapsort. */
+static
+void
+tr_heapsort(const int *ISAd, int *SA, int size) {
+  int i, m;
+  int t;
+
+  m = size;
+  if((size % 2) == 0) {
+    m--;
+    if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { SWAP(SA[m], SA[m / 2]); }
+  }
+
+  for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); }
+  if((size % 2) == 0) { SWAP(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); }
+  for(i = m - 1; 0 < i; --i) {
+    t = SA[0], SA[0] = SA[i];
+    tr_fixdown(ISAd, SA, 0, i);
+    SA[i] = t;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Returns the median of three elements. */
+static INLINE
+int *
+tr_median3(const int *ISAd, int *v1, int *v2, int *v3) {
+  int *t;
+  if(ISAd[*v1] > ISAd[*v2]) { SWAP(v1, v2); }
+  if(ISAd[*v2] > ISAd[*v3]) {
+    if(ISAd[*v1] > ISAd[*v3]) { return v1; }
+    else { return v3; }
+  }
+  return v2;
+}
+
+/* Returns the median of five elements. */
+static INLINE
+int *
+tr_median5(const int *ISAd,
+           int *v1, int *v2, int *v3, int *v4, int *v5) {
+  int *t;
+  if(ISAd[*v2] > ISAd[*v3]) { SWAP(v2, v3); }
+  if(ISAd[*v4] > ISAd[*v5]) { SWAP(v4, v5); }
+  if(ISAd[*v2] > ISAd[*v4]) { SWAP(v2, v4); SWAP(v3, v5); }
+  if(ISAd[*v1] > ISAd[*v3]) { SWAP(v1, v3); }
+  if(ISAd[*v1] > ISAd[*v4]) { SWAP(v1, v4); SWAP(v3, v5); }
+  if(ISAd[*v3] > ISAd[*v4]) { return v4; }
+  return v3;
+}
+
+/* Returns the pivot element. */
+static INLINE
+int *
+tr_pivot(const int *ISAd, int *first, int *last) {
+  int *middle;
+  int t;
+
+  t = last - first;
+  middle = first + t / 2;
+
+  if(t <= 512) {
+    if(t <= 32) {
+      return tr_median3(ISAd, first, middle, last - 1);
+    } else {
+      t >>= 2;
+      return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1);
+    }
+  }
+  t >>= 3;
+  first  = tr_median3(ISAd, first, first + t, first + (t << 1));
+  middle = tr_median3(ISAd, middle - t, middle, middle + t);
+  last   = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1);
+  return tr_median3(ISAd, first, middle, last);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct _trbudget_t trbudget_t;
+struct _trbudget_t {
+  int chance;
+  int remain;
+  int incval;
+  int count;
+};
+
+static INLINE
+void
+trbudget_init(trbudget_t *budget, int chance, int incval) {
+  budget->chance = chance;
+  budget->remain = budget->incval = incval;
+}
+
+static INLINE
+int
+trbudget_check(trbudget_t *budget, int size) {
+  if(size <= budget->remain) { budget->remain -= size; return 1; }
+  if(budget->chance == 0) { budget->count += size; return 0; }
+  budget->remain += budget->incval - size;
+  budget->chance -= 1;
+  return 1;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static INLINE
+void
+tr_partition(const int *ISAd,
+             int *first, int *middle, int *last,
+             int **pa, int **pb, int v) {
+  int *a, *b, *c, *d, *e, *f;
+  int t, s;
+  int x = 0;
+
+  for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v);) { }
+  if(((a = b) < last) && (x < v)) {
+    for(; (++b < last) && ((x = ISAd[*b]) <= v);) {
+      if(x == v) { SWAP(*b, *a); ++a; }
+    }
+  }
+  for(c = last; (b < --c) && ((x = ISAd[*c]) == v);) { }
+  if((b < (d = c)) && (x > v)) {
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
+      if(x == v) { SWAP(*c, *d); --d; }
+    }
+  }
+  for(; b < c;) {
+    SWAP(*b, *c);
+    for(; (++b < c) && ((x = ISAd[*b]) <= v);) {
+      if(x == v) { SWAP(*b, *a); ++a; }
+    }
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
+      if(x == v) { SWAP(*c, *d); --d; }
+    }
+  }
+
+  if(a <= d) {
+    c = b - 1;
+    if((s = a - first) > (t = b - a)) { s = t; }
+    for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+    if((s = d - c) > (t = last - d - 1)) { s = t; }
+    for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+    first += (b - a), last -= (d - c);
+  }
+  *pa = first, *pb = last;
+}
+
+static
+void
+tr_copy(int *ISA, const int *SA,
+        int *first, int *a, int *b, int *last,
+        int depth) {
+  /* sort suffixes of middle partition
+     by using sorted order of suffixes of left and right partition. */
+  int *c, *d, *e;
+  int s, v;
+
+  v = b - SA - 1;
+  for(c = first, d = a - 1; c <= d; ++c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *++d = s;
+      ISA[s] = d - SA;
+    }
+  }
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *--d = s;
+      ISA[s] = d - SA;
+    }
+  }
+}
+
+static
+void
+tr_partialcopy(int *ISA, const int *SA,
+               int *first, int *a, int *b, int *last,
+               int depth) {
+  int *c, *d, *e;
+  int s, v;
+  int rank, lastrank, newrank = -1;
+
+  v = b - SA - 1;
+  lastrank = -1;
+  for(c = first, d = a - 1; c <= d; ++c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *++d = s;
+      rank = ISA[s + depth];
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
+      ISA[s] = newrank;
+    }
+  }
+
+  lastrank = -1;
+  for(e = d; first <= e; --e) {
+    rank = ISA[*e];
+    if(lastrank != rank) { lastrank = rank; newrank = e - SA; }
+    if(newrank != rank) { ISA[*e] = newrank; }
+  }
+
+  lastrank = -1;
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *--d = s;
+      rank = ISA[s + depth];
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
+      ISA[s] = newrank;
+    }
+  }
+}
+
+static
+void
+tr_introsort(int *ISA, const int *ISAd,
+             int *SA, int *first, int *last,
+             trbudget_t *budget) {
+#define STACK_SIZE TR_STACKSIZE
+  struct { const int *a; int *b, *c; int d, e; }stack[STACK_SIZE];
+  int *a, *b, *c;
+  int t;
+  int v, x = 0;
+  int incr = ISAd - ISA;
+  int limit, next;
+  int ssize, trlink = -1;
+
+  for(ssize = 0, limit = tr_ilg(last - first);;) {
+
+    if(limit < 0) {
+      if(limit == -1) {
+        /* tandem repeat partition */
+        tr_partition(ISAd - incr, first, first, last, &a, &b, last - SA - 1);
+
+        /* update ranks */
+        if(a < last) {
+          for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
+        }
+        if(b < last) {
+          for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; }
+        }
+
+        /* push */
+        if(1 < (b - a)) {
+          STACK_PUSH5(NULL, a, b, 0, 0);
+          STACK_PUSH5(ISAd - incr, first, last, -2, trlink);
+          trlink = ssize - 2;
+        }
+        if((a - first) <= (last - b)) {
+          if(1 < (a - first)) {
+            STACK_PUSH5(ISAd, b, last, tr_ilg(last - b), trlink);
+            last = a, limit = tr_ilg(a - first);
+          } else if(1 < (last - b)) {
+            first = b, limit = tr_ilg(last - b);
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        } else {
+          if(1 < (last - b)) {
+            STACK_PUSH5(ISAd, first, a, tr_ilg(a - first), trlink);
+            first = b, limit = tr_ilg(last - b);
+          } else if(1 < (a - first)) {
+            last = a, limit = tr_ilg(a - first);
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        }
+      } else if(limit == -2) {
+        /* tandem repeat copy */
+        a = stack[--ssize].b, b = stack[ssize].c;
+        if(stack[ssize].d == 0) {
+          tr_copy(ISA, SA, first, a, b, last, ISAd - ISA);
+        } else {
+          if(0 <= trlink) { stack[trlink].d = -1; }
+          tr_partialcopy(ISA, SA, first, a, b, last, ISAd - ISA);
+        }
+        STACK_POP5(ISAd, first, last, limit, trlink);
+      } else {
+        /* sorted partition */
+        if(0 <= *first) {
+          a = first;
+          do { ISA[*a] = a - SA; } while((++a < last) && (0 <= *a));
+          first = a;
+        }
+        if(first < last) {
+          a = first; do { *a = ~*a; } while(*++a < 0);
+          next = (ISA[*a] != ISAd[*a]) ? tr_ilg(a - first + 1) : -1;
+          if(++a < last) { for(b = first, v = a - SA - 1; b < a; ++b) { ISA[*b] = v; } }
+
+          /* push */
+          if(trbudget_check(budget, a - first)) {
+            if((a - first) <= (last - a)) {
+              STACK_PUSH5(ISAd, a, last, -3, trlink);
+              ISAd += incr, last = a, limit = next;
+            } else {
+              if(1 < (last - a)) {
+                STACK_PUSH5(ISAd + incr, first, a, next, trlink);
+                first = a, limit = -3;
+              } else {
+                ISAd += incr, last = a, limit = next;
+              }
+            }
+          } else {
+            if(0 <= trlink) { stack[trlink].d = -1; }
+            if(1 < (last - a)) {
+              first = a, limit = -3;
+            } else {
+              STACK_POP5(ISAd, first, last, limit, trlink);
+            }
+          }
+        } else {
+          STACK_POP5(ISAd, first, last, limit, trlink);
+        }
+      }
+      continue;
+    }
+
+    if((last - first) <= TR_INSERTIONSORT_THRESHOLD) {
+      tr_insertionsort(ISAd, first, last);
+      limit = -3;
+      continue;
+    }
+
+    if(limit-- == 0) {
+      tr_heapsort(ISAd, first, last - first);
+      for(a = last - 1; first < a; a = b) {
+        for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; }
+      }
+      limit = -3;
+      continue;
+    }
+
+    /* choose pivot */
+    a = tr_pivot(ISAd, first, last);
+    SWAP(*first, *a);
+    v = ISAd[*first];
+
+    /* partition */
+    tr_partition(ISAd, first, first + 1, last, &a, &b, v);
+    if((last - first) != (b - a)) {
+      next = (ISA[*a] != v) ? tr_ilg(b - a) : -1;
+
+      /* update ranks */
+      for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
+      if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } }
+
+      /* push */
+      if((1 < (b - a)) && (trbudget_check(budget, b - a))) {
+        if((a - first) <= (last - b)) {
+          if((last - b) <= (b - a)) {
+            if(1 < (a - first)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              last = a;
+            } else if(1 < (last - b)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              first = b;
+            } else {
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else if((a - first) <= (b - a)) {
+            if(1 < (a - first)) {
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              last = a;
+            } else {
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else {
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            ISAd += incr, first = a, last = b, limit = next;
+          }
+        } else {
+          if((a - first) <= (b - a)) {
+            if(1 < (last - b)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              first = b;
+            } else if(1 < (a - first)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              last = a;
+            } else {
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else if((last - b) <= (b - a)) {
+            if(1 < (last - b)) {
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              first = b;
+            } else {
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else {
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            ISAd += incr, first = a, last = b, limit = next;
+          }
+        }
+      } else {
+        if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; }
+        if((a - first) <= (last - b)) {
+          if(1 < (a - first)) {
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            last = a;
+          } else if(1 < (last - b)) {
+            first = b;
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        } else {
+          if(1 < (last - b)) {
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            first = b;
+          } else if(1 < (a - first)) {
+            last = a;
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        }
+      }
+    } else {
+      if(trbudget_check(budget, last - first)) {
+        limit = tr_ilg(last - first), ISAd += incr;
+      } else {
+        if(0 <= trlink) { stack[trlink].d = -1; }
+        STACK_POP5(ISAd, first, last, limit, trlink);
+      }
+    }
+  }
+#undef STACK_SIZE
+}
+
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Tandem repeat sort */
+static
+void
+trsort(int *ISA, int *SA, int n, int depth) {
+  int *ISAd;
+  int *first, *last;
+  trbudget_t budget;
+  int t, skip, unsorted;
+
+  trbudget_init(&budget, tr_ilg(n) * 2 / 3, n);
+/*  trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */
+  for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) {
+    first = SA;
+    skip = 0;
+    unsorted = 0;
+    do {
+      if((t = *first) < 0) { first -= t; skip += t; }
+      else {
+        if(skip != 0) { *(first + skip) = skip; skip = 0; }
+        last = SA + ISA[t] + 1;
+        if(1 < (last - first)) {
+          budget.count = 0;
+          tr_introsort(ISA, ISAd, SA, first, last, &budget);
+          if(budget.count != 0) { unsorted += budget.count; }
+          else { skip = first - last; }
+        } else if((last - first) == 1) {
+          skip = -1;
+        }
+        first = last;
+      }
+    } while(first < (SA + n));
+    if(skip != 0) { *(first + skip) = skip; }
+    if(unsorted == 0) { break; }
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Sorts suffixes of type B*. */
+static
+int
+sort_typeBstar(const unsigned char *T, int *SA,
+               int *bucket_A, int *bucket_B,
+               int n, int openMP) {
+  int *PAb, *ISAb, *buf;
+#ifdef LIBBSC_OPENMP
+  int *curbuf;
+  int l;
+#endif
+  int i, j, k, t, m, bufsize;
+  int c0, c1;
+#ifdef LIBBSC_OPENMP
+  int d0, d1;
+#endif
+  (void)openMP;
+
+  /* Initialize bucket arrays. */
+  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; }
+  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; }
+
+  /* Count the number of occurrences of the first one or two characters of each
+     type A, B and B* suffix. Moreover, store the beginning position of all
+     type B* suffixes into the array SA. */
+  for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) {
+    /* type A suffix. */
+    do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1));
+    if(0 <= i) {
+      /* type B* suffix. */
+      ++BUCKET_BSTAR(c0, c1);
+      SA[--m] = i;
+      /* type B suffix. */
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {
+        ++BUCKET_B(c0, c1);
+      }
+    }
+  }
+  m = n - m;
+/*
+note:
+  A type B* suffix is lexicographically smaller than a type B suffix that
+  begins with the same first two characters.
+*/
+
+  /* Calculate the index of start/end point of each bucket. */
+  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) {
+    t = i + BUCKET_A(c0);
+    BUCKET_A(c0) = i + j; /* start point */
+    i = t + BUCKET_B(c0, c0);
+    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) {
+      j += BUCKET_BSTAR(c0, c1);
+      BUCKET_BSTAR(c0, c1) = j; /* end point */
+      i += BUCKET_B(c0, c1);
+    }
+  }
+
+  if(0 < m) {
+    /* Sort the type B* suffixes by their first two characters. */
+    PAb = SA + n - m; ISAb = SA + m;
+    for(i = m - 2; 0 <= i; --i) {
+      t = PAb[i], c0 = T[t], c1 = T[t + 1];
+      SA[--BUCKET_BSTAR(c0, c1)] = i;
+    }
+    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1];
+    SA[--BUCKET_BSTAR(c0, c1)] = m - 1;
+
+    /* Sort the type B* substrings using sssort. */
+#ifdef LIBBSC_OPENMP
+    if (openMP)
+    {
+        buf = SA + m;
+        c0 = ALPHABET_SIZE - 2, c1 = ALPHABET_SIZE - 1, j = m;
+#pragma omp parallel default(shared) private(bufsize, curbuf, k, l, d0, d1)
+        {
+          bufsize = (n - (2 * m)) / omp_get_num_threads();
+          curbuf = buf + omp_get_thread_num() * bufsize;
+          k = 0;
+          for(;;) {
+            #pragma omp critical(sssort_lock)
+            {
+              if(0 < (l = j)) {
+                d0 = c0, d1 = c1;
+                do {
+                  k = BUCKET_BSTAR(d0, d1);
+                  if(--d1 <= d0) {
+                    d1 = ALPHABET_SIZE - 1;
+                    if(--d0 < 0) { break; }
+                  }
+                } while(((l - k) <= 1) && (0 < (l = k)));
+                c0 = d0, c1 = d1, j = k;
+              }
+            }
+            if(l == 0) { break; }
+            sssort(T, PAb, SA + k, SA + l,
+                   curbuf, bufsize, 2, n, *(SA + k) == (m - 1));
+          }
+        }
+    }
+    else
+    {
+        buf = SA + m, bufsize = n - (2 * m);
+        for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
+          for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
+            i = BUCKET_BSTAR(c0, c1);
+            if(1 < (j - i)) {
+              sssort(T, PAb, SA + i, SA + j,
+                     buf, bufsize, 2, n, *(SA + i) == (m - 1));
+            }
+          }
+        }
+    }
+#else
+    buf = SA + m, bufsize = n - (2 * m);
+    for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
+        i = BUCKET_BSTAR(c0, c1);
+        if(1 < (j - i)) {
+          sssort(T, PAb, SA + i, SA + j,
+                 buf, bufsize, 2, n, *(SA + i) == (m - 1));
+        }
+      }
+    }
+#endif
+
+    /* Compute ranks of type B* substrings. */
+    for(i = m - 1; 0 <= i; --i) {
+      if(0 <= SA[i]) {
+        j = i;
+        do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i]));
+        SA[i + 1] = i - j;
+        if(i <= 0) { break; }
+      }
+      j = i;
+      do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0);
+      ISAb[SA[i]] = j;
+    }
+
+    /* Construct the inverse suffix array of type B* suffixes using trsort. */
+    trsort(ISAb, SA, m, 1);
+
+    /* Set the sorted order of tyoe B* suffixes. */
+    for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) {
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) { }
+      if(0 <= i) {
+        t = i;
+        for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { }
+        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t;
+      }
+    }
+
+    /* Calculate the index of start/end point of each bucket. */
+    BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n; /* end point */
+    for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) {
+      i = BUCKET_A(c0 + 1) - 1;
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) {
+        t = i - BUCKET_B(c0, c1);
+        BUCKET_B(c0, c1) = i; /* end point */
+
+        /* Move all type B* suffixes to the correct position. */
+        for(i = t, j = BUCKET_BSTAR(c0, c1);
+            j <= k;
+            --i, --k) { SA[i] = SA[k]; }
+      }
+      BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1; /* start point */
+      BUCKET_B(c0, c0) = i; /* end point */
+    }
+  }
+
+  return m;
+}
+
+/* Constructs the suffix array by using the sorted order of type B* suffixes. */
+static
+void
+construct_SA(const unsigned char *T, int *SA,
+             int *bucket_A, int *bucket_B,
+             int n, int m) {
+  int *i, *j, *k;
+  int s;
+  int c0, c1, c2;
+
+  if(0 < m) {
+    /* Construct the sorted order of type B suffixes by using
+       the sorted order of type B* suffixes. */
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      /* Scan the suffix array from right to left. */
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
+          i <= j;
+          --j) {
+        if(0 < (s = *j)) {
+          assert(T[s] == c1);
+          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
+          assert(T[s - 1] <= T[s]);
+          *j = ~s;
+          c0 = T[--s];
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
+          if(c0 != c2) {
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          assert(k < j); assert(k != NULL);
+          *k-- = s;
+        } else {
+          assert(((s == 0) && (T[s] == c1)) || (s < 0));
+          *j = ~s;
+        }
+      }
+    }
+  }
+
+  /* Construct the suffix array by using
+     the sorted order of type B suffixes. */
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1);
+  /* Scan the suffix array from left to right. */
+  for(i = SA, j = SA + n; i < j; ++i) {
+    if(0 < (s = *i)) {
+      assert(T[s - 1] >= T[s]);
+      c0 = T[--s];
+      if((s == 0) || (T[s - 1] < c0)) { s = ~s; }
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      assert(i < k);
+      *k++ = s;
+    } else {
+      assert(s < 0);
+      *i = ~s;
+    }
+  }
+}
+
+/* Constructs the burrows-wheeler transformed string directly
+   by using the sorted order of type B* suffixes. */
+static
+int
+construct_BWT(const unsigned char *T, int *SA,
+              int *bucket_A, int *bucket_B,
+              int n, int m) {
+  int *i, *j, *k, *orig;
+  int s;
+  int c0, c1, c2;
+
+  if(0 < m) {
+    /* Construct the sorted order of type B suffixes by using
+       the sorted order of type B* suffixes. */
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      /* Scan the suffix array from right to left. */
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
+          i <= j;
+          --j) {
+        if(0 < (s = *j)) {
+          assert(T[s] == c1);
+          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
+          assert(T[s - 1] <= T[s]);
+          c0 = T[--s];
+          *j = ~((int)c0);
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
+          if(c0 != c2) {
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          assert(k < j); assert(k != NULL);
+          *k-- = s;
+        } else if(s != 0) {
+          *j = ~s;
+#ifndef NDEBUG
+        } else {
+          assert(T[s] == c1);
+#endif
+        }
+      }
+    }
+  }
+
+  /* Construct the BWTed string by using
+     the sorted order of type B suffixes. */
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1);
+  /* Scan the suffix array from left to right. */
+  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
+    if(0 < (s = *i)) {
+      assert(T[s - 1] >= T[s]);
+      c0 = T[--s];
+      *i = c0;
+      if((0 < s) && (T[s - 1] < c0)) { s = ~((int)T[s - 1]); }
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      assert(i < k);
+      *k++ = s;
+    } else if(s != 0) {
+      *i = ~s;
+    } else {
+      orig = i;
+    }
+  }
+
+  return orig - SA;
+}
+
+/* Constructs the burrows-wheeler transformed string directly
+   by using the sorted order of type B* suffixes. */
+static
+int
+construct_BWT_indexes(const unsigned char *T, int *SA,
+                      int *bucket_A, int *bucket_B,
+                      int n, int m,
+                      unsigned char * num_indexes, int * indexes) {
+  int *i, *j, *k, *orig;
+  int s;
+  int c0, c1, c2;
+
+  int mod = n / 8;
+  {
+      mod |= mod >> 1;  mod |= mod >> 2;
+      mod |= mod >> 4;  mod |= mod >> 8;
+      mod |= mod >> 16; mod >>= 1;
+
+      *num_indexes = (unsigned char)((n - 1) / (mod + 1));
+  }
+
+  if(0 < m) {
+    /* Construct the sorted order of type B suffixes by using
+       the sorted order of type B* suffixes. */
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      /* Scan the suffix array from right to left. */
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
+          i <= j;
+          --j) {
+        if(0 < (s = *j)) {
+          assert(T[s] == c1);
+          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
+          assert(T[s - 1] <= T[s]);
+
+          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = j - SA;
+
+          c0 = T[--s];
+          *j = ~((int)c0);
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
+          if(c0 != c2) {
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          assert(k < j); assert(k != NULL);
+          *k-- = s;
+        } else if(s != 0) {
+          *j = ~s;
+#ifndef NDEBUG
+        } else {
+          assert(T[s] == c1);
+#endif
+        }
+      }
+    }
+  }
+
+  /* Construct the BWTed string by using
+     the sorted order of type B suffixes. */
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  if (T[n - 2] < c2) {
+    if (((n - 1) & mod) == 0) indexes[(n - 1) / (mod + 1) - 1] = k - SA;
+    *k++ = ~((int)T[n - 2]);
+  }
+  else {
+    *k++ = n - 1;
+  }
+
+  /* Scan the suffix array from left to right. */
+  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
+    if(0 < (s = *i)) {
+      assert(T[s - 1] >= T[s]);
+
+      if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = i - SA;
+
+      c0 = T[--s];
+      *i = c0;
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      assert(i < k);
+      if((0 < s) && (T[s - 1] < c0)) {
+          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = k - SA;
+          *k++ = ~((int)T[s - 1]);
+      } else
+        *k++ = s;
+    } else if(s != 0) {
+      *i = ~s;
+    } else {
+      orig = i;
+    }
+  }
+
+  return orig - SA;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/*- Function -*/
+
+int
+divsufsort(const unsigned char *T, int *SA, int n, int openMP) {
+  int *bucket_A, *bucket_B;
+  int m;
+  int err = 0;
+
+  /* Check arguments. */
+  if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; }
+  else if(n == 0) { return 0; }
+  else if(n == 1) { SA[0] = 0; return 0; }
+  else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; }
+
+  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
+  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
+
+  /* Suffixsort. */
+  if((bucket_A != NULL) && (bucket_B != NULL)) {
+    m = sort_typeBstar(T, SA, bucket_A, bucket_B, n, openMP);
+    construct_SA(T, SA, bucket_A, bucket_B, n, m);
+  } else {
+    err = -2;
+  }
+
+  free(bucket_B);
+  free(bucket_A);
+
+  return err;
+}
+
+int
+divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP) {
+  int *B;
+  int *bucket_A, *bucket_B;
+  int m, pidx, i;
+
+  /* Check arguments. */
+  if((T == NULL) || (U == NULL) || (n < 0)) { return -1; }
+  else if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }
+
+  if((B = A) == NULL) { B = (int *)malloc((size_t)(n + 1) * sizeof(int)); }
+  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
+  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
+
+  /* Burrows-Wheeler Transform. */
+  if((B != NULL) && (bucket_A != NULL) && (bucket_B != NULL)) {
+    m = sort_typeBstar(T, B, bucket_A, bucket_B, n, openMP);
+
+    if (num_indexes == NULL || indexes == NULL) {
+        pidx = construct_BWT(T, B, bucket_A, bucket_B, n, m);
+    } else {
+        pidx = construct_BWT_indexes(T, B, bucket_A, bucket_B, n, m, num_indexes, indexes);
+    }
+
+    /* Copy to output string. */
+    U[0] = T[n - 1];
+    for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)B[i]; }
+    for(i += 1; i < n; ++i) { U[i] = (unsigned char)B[i]; }
+    pidx += 1;
+  } else {
+    pidx = -2;
+  }
+
+  free(bucket_B);
+  free(bucket_A);
+  if(A == NULL) { free(B); }
+
+  return pidx;
+}
diff --git a/src/divsufsort.h b/src/divsufsort.h
new file mode 100644
index 0000000..5440994
--- /dev/null
+++ b/src/divsufsort.h
@@ -0,0 +1,67 @@
+/*
+ * divsufsort.h for libdivsufsort-lite
+ * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _DIVSUFSORT_H
+#define _DIVSUFSORT_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/*- Prototypes -*/
+
+/**
+ * Constructs the suffix array of a given string.
+ * @param T [0..n-1] The input string.
+ * @param SA [0..n-1] The output array of suffixes.
+ * @param n The length of the given string.
+ * @param openMP enables OpenMP optimization.
+ * @return 0 if no error occurred, -1 or -2 otherwise.
+ */
+int
+divsufsort(const unsigned char *T, int *SA, int n, int openMP);
+
+/**
+ * Constructs the burrows-wheeler transformed string of a given string.
+ * @param T [0..n-1] The input string.
+ * @param U [0..n-1] The output string. (can be T)
+ * @param A [0..n-1] The temporary array. (can be NULL)
+ * @param n The length of the given string.
+ * @param num_indexes The length of secondary indexes array. (can be NULL)
+ * @param indexes The secondary indexes array. (can be NULL)
+ * @param openMP enables OpenMP optimization.
+ * @return The primary index if no error occurred, -1 or -2 otherwise.
+ */
+int
+divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* _DIVSUFSORT_H */
diff --git a/src/entropy_common.c b/src/entropy_common.c
new file mode 100644
index 0000000..b12944e
--- /dev/null
+++ b/src/entropy_common.c
@@ -0,0 +1,236 @@
+/*
+   Common functions of New Generation Entropy library
+   Copyright (C) 2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+*************************************************************************** */
+
+/* *************************************
+*  Dependencies
+***************************************/
+#include "mem.h"
+#include "error_private.h"       /* ERR_*, ERROR */
+#define FSE_STATIC_LINKING_ONLY  /* FSE_MIN_TABLELOG */
+#include "fse.h"
+#define HUF_STATIC_LINKING_ONLY  /* HUF_TABLELOG_ABSOLUTEMAX */
+#include "huf.h"
+
+
+/*===   Version   ===*/
+unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; }
+
+
+/*===   Error Management   ===*/
+unsigned FSE_isError(size_t code) { return ERR_isError(code); }
+const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+unsigned HUF_isError(size_t code) { return ERR_isError(code); }
+const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+/*-**************************************************************
+*  FSE NCount encoding-decoding
+****************************************************************/
+size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) {
+        /* This function only works when hbSize >= 4 */
+        char buffer[4];
+        memset(buffer, 0, sizeof(buffer));
+        memcpy(buffer, headerBuffer, hbSize);
+        {   size_t const countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr,
+                                                    buffer, sizeof(buffer));
+            if (FSE_isError(countSize)) return countSize;
+            if (countSize > hbSize) return ERROR(corruption_detected);
+            return countSize;
+    }   }
+    assert(hbSize >= 4);
+
+    /* init */
+    memset(normalizedCounter, 0, (*maxSVPtr+1) * sizeof(normalizedCounter[0]));   /* all symbols not present in NCount have a frequency of 0 */
+    bitStream = MEM_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) & (charnum<=*maxSVPtr)) {
+        if (previous0) {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF) {
+                n0 += 24;
+                if (ip < iend-5) {
+                    ip += 2;
+                    bitStream = MEM_readLE32(ip) >> bitCount;
+                } else {
+                    bitStream >>= 16;
+                    bitCount   += 16;
+            }   }
+            while ((bitStream & 3) == 3) {
+                n0 += 3;
+                bitStream >>= 2;
+                bitCount += 2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                assert((bitCount >> 3) <= 3); /* For first condition to work */
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = MEM_readLE32(ip) >> bitCount;
+            } else {
+                bitStream >>= 2;
+        }   }
+        {   int const max = (2*threshold-1) - remaining;
+            int count;
+
+            if ((bitStream & (threshold-1)) < (U32)max) {
+                count = bitStream & (threshold-1);
+                bitCount += nbBits-1;
+            } else {
+                count = bitStream & (2*threshold-1);
+                if (count >= threshold) count -= max;
+                bitCount += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= count < 0 ? -count : count;   /* -1 means +1 */
+            normalizedCounter[charnum++] = (short)count;
+            previous0 = !count;
+            while (remaining < threshold) {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                ip += bitCount>>3;
+                bitCount &= 7;
+            } else {
+                bitCount -= (int)(8 * (iend - 4 - ip));
+                ip = iend - 4;
+            }
+            bitStream = MEM_readLE32(ip) >> (bitCount & 31);
+    }   }   /* while ((remaining>1) & (charnum<=*maxSVPtr)) */
+    if (remaining != 1) return ERROR(corruption_detected);
+    if (bitCount > 32) return ERROR(corruption_detected);
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    return ip-istart;
+}
+
+
+/*! HUF_readStats() :
+    Read compact Huffman tree, saved by HUF_writeCTable().
+    `huffWeight` is destination buffer.
+    `rankStats` is assumed to be a table of at least HUF_TABLELOG_MAX U32.
+    @return : size read from `src` , or an error Code .
+    Note : Needed by HUF_readCTable() and HUF_readDTableX?() .
+*/
+size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                     U32* nbSymbolsPtr, U32* tableLogPtr,
+                     const void* src, size_t srcSize)
+{
+    U32 weightTotal;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+
+    if (!srcSize) return ERROR(srcSize_wrong);
+    iSize = ip[0];
+    /* memset(huffWeight, 0, hwSize);   *//* is not necessary, even though some analyzer complain ... */
+
+    if (iSize >= 128) {  /* special header */
+        oSize = iSize - 127;
+        iSize = ((oSize+1)/2);
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        if (oSize >= hwSize) return ERROR(corruption_detected);
+        ip += 1;
+        {   U32 n;
+            for (n=0; n<oSize; n+=2) {
+                huffWeight[n]   = ip[n/2] >> 4;
+                huffWeight[n+1] = ip[n/2] & 15;
+    }   }   }
+    else  {   /* header compressed with FSE (normal case) */
+        FSE_DTable fseWorkspace[FSE_DTABLE_SIZE_U32(6)];  /* 6 is max possible tableLog for HUF header (maybe even 5, to be tested) */
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        oSize = FSE_decompress_wksp(huffWeight, hwSize-1, ip+1, iSize, fseWorkspace, 6);   /* max (hwSize-1) values decoded, as last one is implied */
+        if (FSE_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32));
+    weightTotal = 0;
+    {   U32 n; for (n=0; n<oSize; n++) {
+            if (huffWeight[n] >= HUF_TABLELOG_MAX) return ERROR(corruption_detected);
+            rankStats[huffWeight[n]]++;
+            weightTotal += (1 << huffWeight[n]) >> 1;
+    }   }
+    if (weightTotal == 0) return ERROR(corruption_detected);
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    {   U32 const tableLog = BIT_highbit32(weightTotal) + 1;
+        if (tableLog > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
+        *tableLogPtr = tableLog;
+        /* determine last weight */
+        {   U32 const total = 1 << tableLog;
+            U32 const rest = total - weightTotal;
+            U32 const verif = 1 << BIT_highbit32(rest);
+            U32 const lastWeight = BIT_highbit32(rest) + 1;
+            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
+            huffWeight[oSize] = (BYTE)lastWeight;
+            rankStats[lastWeight]++;
+    }   }
+
+    /* check tree construction validity */
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* results */
+    *nbSymbolsPtr = (U32)(oSize+1);
+    return iSize+1;
+}
diff --git a/src/error_private.c b/src/error_private.c
new file mode 100644
index 0000000..7c1bb67
--- /dev/null
+++ b/src/error_private.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* The purpose of this file is to have a single list of error strings embedded in binary */
+
+#include "error_private.h"
+
+const char* ERR_getErrorString(ERR_enum code)
+{
+#ifdef ZSTD_STRIP_ERROR_STRINGS
+    (void)code;
+    return "Error strings stripped";
+#else
+    static const char* const notErrorCode = "Unspecified error code";
+    switch( code )
+    {
+    case PREFIX(no_error): return "No error detected";
+    case PREFIX(GENERIC):  return "Error (generic)";
+    case PREFIX(prefix_unknown): return "Unknown frame descriptor";
+    case PREFIX(version_unsupported): return "Version not supported";
+    case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter";
+    case PREFIX(frameParameter_windowTooLarge): return "Frame requires too much memory for decoding";
+    case PREFIX(corruption_detected): return "Corrupted block detected";
+    case PREFIX(checksum_wrong): return "Restored data doesn't match checksum";
+    case PREFIX(parameter_unsupported): return "Unsupported parameter";
+    case PREFIX(parameter_outOfBound): return "Parameter is out of bound";
+    case PREFIX(init_missing): return "Context should be init first";
+    case PREFIX(memory_allocation): return "Allocation error : not enough memory";
+    case PREFIX(workSpace_tooSmall): return "workSpace buffer is not large enough";
+    case PREFIX(stage_wrong): return "Operation not authorized at current processing stage";
+    case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported";
+    case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large";
+    case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
+    case PREFIX(dictionary_corrupted): return "Dictionary is corrupted";
+    case PREFIX(dictionary_wrong): return "Dictionary mismatch";
+    case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from provided samples";
+    case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
+    case PREFIX(srcSize_wrong): return "Src size is incorrect";
+    case PREFIX(dstBuffer_null): return "Operation on NULL destination buffer";
+        /* following error codes are not stable and may be removed or changed in a future version */
+    case PREFIX(frameIndex_tooLarge): return "Frame index is too large";
+    case PREFIX(seekableIO): return "An I/O error occurred when reading/seeking";
+    case PREFIX(maxCode):
+    default: return notErrorCode;
+    }
+#endif
+}
diff --git a/src/error_private.h b/src/error_private.h
new file mode 100644
index 0000000..0d2fa7e
--- /dev/null
+++ b/src/error_private.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* Note : this module is expected to remain private, do not expose it */
+
+#ifndef ERROR_H_MODULE
+#define ERROR_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* ****************************************
+*  Dependencies
+******************************************/
+#include <stddef.h>        /* size_t */
+#include "zstd_errors.h"  /* enum list */
+
+
+/* ****************************************
+*  Compiler-specific
+******************************************/
+#if defined(__GNUC__)
+#  define ERR_STATIC static __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define ERR_STATIC static inline
+#elif defined(_MSC_VER)
+#  define ERR_STATIC static __inline
+#else
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/*-****************************************
+*  Customization (error_public.h)
+******************************************/
+typedef ZSTD_ErrorCode ERR_enum;
+#define PREFIX(name) ZSTD_error_##name
+
+
+/*-****************************************
+*  Error codes handling
+******************************************/
+#undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */
+#define ERROR(name) ZSTD_ERROR(name)
+#define ZSTD_ERROR(name) ((size_t)-PREFIX(name))
+
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
+
+ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); }
+
+
+/*-****************************************
+*  Error Strings
+******************************************/
+
+const char* ERR_getErrorString(ERR_enum code);   /* error_private.c */
+
+ERR_STATIC const char* ERR_getErrorName(size_t code)
+{
+    return ERR_getErrorString(ERR_getErrorCode(code));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ERROR_H_MODULE */
diff --git a/src/fastcover.c b/src/fastcover.c
new file mode 100644
index 0000000..941bb5a
--- /dev/null
+++ b/src/fastcover.c
@@ -0,0 +1,747 @@
+/*-*************************************
+*  Dependencies
+***************************************/
+#include <stdio.h>  /* fprintf */
+#include <stdlib.h> /* malloc, free, qsort */
+#include <string.h> /* memset */
+#include <time.h>   /* clock */
+
+#include "mem.h" /* read */
+#include "pool.h"
+#include "threading.h"
+#include "cover.h"
+#include "zstd_internal.h" /* includes zstd.h */
+#ifndef ZDICT_STATIC_LINKING_ONLY
+#define ZDICT_STATIC_LINKING_ONLY
+#endif
+#include "zdict.h"
+
+
+/*-*************************************
+*  Constants
+***************************************/
+#define FASTCOVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))
+#define FASTCOVER_MAX_F 31
+#define FASTCOVER_MAX_ACCEL 10
+#define DEFAULT_SPLITPOINT 0.75
+#define DEFAULT_F 20
+#define DEFAULT_ACCEL 1
+
+
+/*-*************************************
+*  Console display
+***************************************/
+static int g_displayLevel = 2;
+#define DISPLAY(...)                                                           \
+  {                                                                            \
+    fprintf(stderr, __VA_ARGS__);                                              \
+    fflush(stderr);                                                            \
+  }
+#define LOCALDISPLAYLEVEL(displayLevel, l, ...)                                \
+  if (displayLevel >= l) {                                                     \
+    DISPLAY(__VA_ARGS__);                                                      \
+  } /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */
+#define DISPLAYLEVEL(l, ...) LOCALDISPLAYLEVEL(g_displayLevel, l, __VA_ARGS__)
+
+#define LOCALDISPLAYUPDATE(displayLevel, l, ...)                               \
+  if (displayLevel >= l) {                                                     \
+    if ((clock() - g_time > refreshRate) || (displayLevel >= 4)) {             \
+      g_time = clock();                                                        \
+      DISPLAY(__VA_ARGS__);                                                    \
+    }                                                                          \
+  }
+#define DISPLAYUPDATE(l, ...) LOCALDISPLAYUPDATE(g_displayLevel, l, __VA_ARGS__)
+static const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;
+static clock_t g_time = 0;
+
+
+/*-*************************************
+* Hash Functions
+***************************************/
+static const U64 prime6bytes = 227718039650203ULL;
+static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; }
+static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); }
+
+static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;
+static size_t ZSTD_hash8(U64 u, U32 h) { return (size_t)(((u) * prime8bytes) >> (64-h)) ; }
+static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); }
+
+
+/**
+ * Hash the d-byte value pointed to by p and mod 2^f
+ */
+static size_t FASTCOVER_hashPtrToIndex(const void* p, U32 h, unsigned d) {
+  if (d == 6) {
+    return ZSTD_hash6Ptr(p, h) & ((1 << h) - 1);
+  }
+  return ZSTD_hash8Ptr(p, h) & ((1 << h) - 1);
+}
+
+
+/*-*************************************
+* Acceleration
+***************************************/
+typedef struct {
+  unsigned finalize;    /* Percentage of training samples used for ZDICT_finalizeDictionary */
+  unsigned skip;        /* Number of dmer skipped between each dmer counted in computeFrequency */
+} FASTCOVER_accel_t;
+
+
+static const FASTCOVER_accel_t FASTCOVER_defaultAccelParameters[FASTCOVER_MAX_ACCEL+1] = {
+  { 100, 0 },   /* accel = 0, should not happen because accel = 0 defaults to accel = 1 */
+  { 100, 0 },   /* accel = 1 */
+  { 50, 1 },   /* accel = 2 */
+  { 34, 2 },   /* accel = 3 */
+  { 25, 3 },   /* accel = 4 */
+  { 20, 4 },   /* accel = 5 */
+  { 17, 5 },   /* accel = 6 */
+  { 14, 6 },   /* accel = 7 */
+  { 13, 7 },   /* accel = 8 */
+  { 11, 8 },   /* accel = 9 */
+  { 10, 9 },   /* accel = 10 */
+};
+
+
+/*-*************************************
+* Context
+***************************************/
+typedef struct {
+  const BYTE *samples;
+  size_t *offsets;
+  const size_t *samplesSizes;
+  size_t nbSamples;
+  size_t nbTrainSamples;
+  size_t nbTestSamples;
+  size_t nbDmers;
+  U32 *freqs;
+  unsigned d;
+  unsigned f;
+  FASTCOVER_accel_t accelParams;
+} FASTCOVER_ctx_t;
+
+
+/*-*************************************
+*  Helper functions
+***************************************/
+/**
+ * Selects the best segment in an epoch.
+ * Segments of are scored according to the function:
+ *
+ * Let F(d) be the frequency of all dmers with hash value d.
+ * Let S_i be hash value of the dmer at position i of segment S which has length k.
+ *
+ *     Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1})
+ *
+ * Once the dmer with hash value d is in the dictionary we set F(d) = 0.
+ */
+static COVER_segment_t FASTCOVER_selectSegment(const FASTCOVER_ctx_t *ctx,
+                                              U32 *freqs, U32 begin, U32 end,
+                                              ZDICT_cover_params_t parameters,
+                                              U16* segmentFreqs) {
+  /* Constants */
+  const U32 k = parameters.k;
+  const U32 d = parameters.d;
+  const U32 f = ctx->f;
+  const U32 dmersInK = k - d + 1;
+
+  /* Try each segment (activeSegment) and save the best (bestSegment) */
+  COVER_segment_t bestSegment = {0, 0, 0};
+  COVER_segment_t activeSegment;
+
+  /* Reset the activeDmers in the segment */
+  /* The activeSegment starts at the beginning of the epoch. */
+  activeSegment.begin = begin;
+  activeSegment.end = begin;
+  activeSegment.score = 0;
+
+  /* Slide the activeSegment through the whole epoch.
+   * Save the best segment in bestSegment.
+   */
+  while (activeSegment.end < end) {
+    /* Get hash value of current dmer */
+    const size_t idx = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.end, f, d);
+
+    /* Add frequency of this index to score if this is the first occurrence of index in active segment */
+    if (segmentFreqs[idx] == 0) {
+      activeSegment.score += freqs[idx];
+    }
+    /* Increment end of segment and segmentFreqs*/
+    activeSegment.end += 1;
+    segmentFreqs[idx] += 1;
+    /* If the window is now too large, drop the first position */
+    if (activeSegment.end - activeSegment.begin == dmersInK + 1) {
+      /* Get hash value of the dmer to be eliminated from active segment */
+      const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d);
+      segmentFreqs[delIndex] -= 1;
+      /* Subtract frequency of this index from score if this is the last occurrence of this index in active segment */
+      if (segmentFreqs[delIndex] == 0) {
+        activeSegment.score -= freqs[delIndex];
+      }
+      /* Increment start of segment */
+      activeSegment.begin += 1;
+    }
+
+    /* If this segment is the best so far save it */
+    if (activeSegment.score > bestSegment.score) {
+      bestSegment = activeSegment;
+    }
+  }
+
+  /* Zero out rest of segmentFreqs array */
+  while (activeSegment.begin < end) {
+    const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d);
+    segmentFreqs[delIndex] -= 1;
+    activeSegment.begin += 1;
+  }
+
+  {
+    /*  Zero the frequency of hash value of each dmer covered by the chosen segment. */
+    U32 pos;
+    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {
+      const size_t i = FASTCOVER_hashPtrToIndex(ctx->samples + pos, f, d);
+      freqs[i] = 0;
+    }
+  }
+
+  return bestSegment;
+}
+
+
+static int FASTCOVER_checkParameters(ZDICT_cover_params_t parameters,
+                                     size_t maxDictSize, unsigned f,
+                                     unsigned accel) {
+  /* k, d, and f are required parameters */
+  if (parameters.d == 0 || parameters.k == 0) {
+    return 0;
+  }
+  /* d has to be 6 or 8 */
+  if (parameters.d != 6 && parameters.d != 8) {
+    return 0;
+  }
+  /* k <= maxDictSize */
+  if (parameters.k > maxDictSize) {
+    return 0;
+  }
+  /* d <= k */
+  if (parameters.d > parameters.k) {
+    return 0;
+  }
+  /* 0 < f <= FASTCOVER_MAX_F*/
+  if (f > FASTCOVER_MAX_F || f == 0) {
+    return 0;
+  }
+  /* 0 < splitPoint <= 1 */
+  if (parameters.splitPoint <= 0 || parameters.splitPoint > 1) {
+    return 0;
+  }
+  /* 0 < accel <= 10 */
+  if (accel > 10 || accel == 0) {
+    return 0;
+  }
+  return 1;
+}
+
+
+/**
+ * Clean up a context initialized with `FASTCOVER_ctx_init()`.
+ */
+static void
+FASTCOVER_ctx_destroy(FASTCOVER_ctx_t* ctx)
+{
+    if (!ctx) return;
+
+    free(ctx->freqs);
+    ctx->freqs = NULL;
+
+    free(ctx->offsets);
+    ctx->offsets = NULL;
+}
+
+
+/**
+ * Calculate for frequency of hash value of each dmer in ctx->samples
+ */
+static void
+FASTCOVER_computeFrequency(U32* freqs, const FASTCOVER_ctx_t* ctx)
+{
+    const unsigned f = ctx->f;
+    const unsigned d = ctx->d;
+    const unsigned skip = ctx->accelParams.skip;
+    const unsigned readLength = MAX(d, 8);
+    size_t i;
+    assert(ctx->nbTrainSamples >= 5);
+    assert(ctx->nbTrainSamples <= ctx->nbSamples);
+    for (i = 0; i < ctx->nbTrainSamples; i++) {
+        size_t start = ctx->offsets[i];  /* start of current dmer */
+        size_t const currSampleEnd = ctx->offsets[i+1];
+        while (start + readLength <= currSampleEnd) {
+            const size_t dmerIndex = FASTCOVER_hashPtrToIndex(ctx->samples + start, f, d);
+            freqs[dmerIndex]++;
+            start = start + skip + 1;
+        }
+    }
+}
+
+
+/**
+ * Prepare a context for dictionary building.
+ * The context is only dependent on the parameter `d` and can used multiple
+ * times.
+ * Returns 0 on success or error code on error.
+ * The context must be destroyed with `FASTCOVER_ctx_destroy()`.
+ */
+static size_t
+FASTCOVER_ctx_init(FASTCOVER_ctx_t* ctx,
+                   const void* samplesBuffer,
+                   const size_t* samplesSizes, unsigned nbSamples,
+                   unsigned d, double splitPoint, unsigned f,
+                   FASTCOVER_accel_t accelParams)
+{
+    const BYTE* const samples = (const BYTE*)samplesBuffer;
+    const size_t totalSamplesSize = COVER_sum(samplesSizes, nbSamples);
+    /* Split samples into testing and training sets */
+    const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples;
+    const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;
+    const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;
+    const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;
+
+    /* Checks */
+    if (totalSamplesSize < MAX(d, sizeof(U64)) ||
+        totalSamplesSize >= (size_t)FASTCOVER_MAX_SAMPLES_SIZE) {
+        DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n",
+                    (unsigned)(totalSamplesSize >> 20), (FASTCOVER_MAX_SAMPLES_SIZE >> 20));
+        return ERROR(srcSize_wrong);
+    }
+
+    /* Check if there are at least 5 training samples */
+    if (nbTrainSamples < 5) {
+        DISPLAYLEVEL(1, "Total number of training samples is %u and is invalid\n", nbTrainSamples);
+        return ERROR(srcSize_wrong);
+    }
+
+    /* Check if there's testing sample */
+    if (nbTestSamples < 1) {
+        DISPLAYLEVEL(1, "Total number of testing samples is %u and is invalid.\n", nbTestSamples);
+        return ERROR(srcSize_wrong);
+    }
+
+    /* Zero the context */
+    memset(ctx, 0, sizeof(*ctx));
+    DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbTrainSamples,
+                    (unsigned)trainingSamplesSize);
+    DISPLAYLEVEL(2, "Testing on %u samples of total size %u\n", nbTestSamples,
+                    (unsigned)testSamplesSize);
+
+    ctx->samples = samples;
+    ctx->samplesSizes = samplesSizes;
+    ctx->nbSamples = nbSamples;
+    ctx->nbTrainSamples = nbTrainSamples;
+    ctx->nbTestSamples = nbTestSamples;
+    ctx->nbDmers = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;
+    ctx->d = d;
+    ctx->f = f;
+    ctx->accelParams = accelParams;
+
+    /* The offsets of each file */
+    ctx->offsets = (size_t*)calloc((nbSamples + 1), sizeof(size_t));
+    if (ctx->offsets == NULL) {
+        DISPLAYLEVEL(1, "Failed to allocate scratch buffers \n");
+        FASTCOVER_ctx_destroy(ctx);
+        return ERROR(memory_allocation);
+    }
+
+    /* Fill offsets from the samplesSizes */
+    {   U32 i;
+        ctx->offsets[0] = 0;
+        assert(nbSamples >= 5);
+        for (i = 1; i <= nbSamples; ++i) {
+            ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1];
+        }
+    }
+
+    /* Initialize frequency array of size 2^f */
+    ctx->freqs = (U32*)calloc(((U64)1 << f), sizeof(U32));
+    if (ctx->freqs == NULL) {
+        DISPLAYLEVEL(1, "Failed to allocate frequency table \n");
+        FASTCOVER_ctx_destroy(ctx);
+        return ERROR(memory_allocation);
+    }
+
+    DISPLAYLEVEL(2, "Computing frequencies\n");
+    FASTCOVER_computeFrequency(ctx->freqs, ctx);
+
+    return 0;
+}
+
+
+/**
+ * Given the prepared context build the dictionary.
+ */
+static size_t
+FASTCOVER_buildDictionary(const FASTCOVER_ctx_t* ctx,
+                          U32* freqs,
+                          void* dictBuffer, size_t dictBufferCapacity,
+                          ZDICT_cover_params_t parameters,
+                          U16* segmentFreqs)
+{
+  BYTE *const dict = (BYTE *)dictBuffer;
+  size_t tail = dictBufferCapacity;
+  /* Divide the data into epochs. We will select one segment from each epoch. */
+  const COVER_epoch_info_t epochs = COVER_computeEpochs(
+      (U32)dictBufferCapacity, (U32)ctx->nbDmers, parameters.k, 1);
+  const size_t maxZeroScoreRun = 10;
+  size_t zeroScoreRun = 0;
+  size_t epoch;
+  DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n",
+                (U32)epochs.num, (U32)epochs.size);
+  /* Loop through the epochs until there are no more segments or the dictionary
+   * is full.
+   */
+  for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs.num) {
+    const U32 epochBegin = (U32)(epoch * epochs.size);
+    const U32 epochEnd = epochBegin + epochs.size;
+    size_t segmentSize;
+    /* Select a segment */
+    COVER_segment_t segment = FASTCOVER_selectSegment(
+        ctx, freqs, epochBegin, epochEnd, parameters, segmentFreqs);
+
+    /* If the segment covers no dmers, then we are out of content.
+     * There may be new content in other epochs, for continue for some time.
+     */
+    if (segment.score == 0) {
+      if (++zeroScoreRun >= maxZeroScoreRun) {
+          break;
+      }
+      continue;
+    }
+    zeroScoreRun = 0;
+
+    /* Trim the segment if necessary and if it is too small then we are done */
+    segmentSize = MIN(segment.end - segment.begin + parameters.d - 1, tail);
+    if (segmentSize < parameters.d) {
+      break;
+    }
+
+    /* We fill the dictionary from the back to allow the best segments to be
+     * referenced with the smallest offsets.
+     */
+    tail -= segmentSize;
+    memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);
+    DISPLAYUPDATE(
+        2, "\r%u%%       ",
+        (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));
+  }
+  DISPLAYLEVEL(2, "\r%79s\r", "");
+  return tail;
+}
+
+/**
+ * Parameters for FASTCOVER_tryParameters().
+ */
+typedef struct FASTCOVER_tryParameters_data_s {
+    const FASTCOVER_ctx_t* ctx;
+    COVER_best_t* best;
+    size_t dictBufferCapacity;
+    ZDICT_cover_params_t parameters;
+} FASTCOVER_tryParameters_data_t;
+
+
+/**
+ * Tries a set of parameters and updates the COVER_best_t with the results.
+ * This function is thread safe if zstd is compiled with multithreaded support.
+ * It takes its parameters as an *OWNING* opaque pointer to support threading.
+ */
+static void FASTCOVER_tryParameters(void *opaque)
+{
+  /* Save parameters as local variables */
+  FASTCOVER_tryParameters_data_t *const data = (FASTCOVER_tryParameters_data_t *)opaque;
+  const FASTCOVER_ctx_t *const ctx = data->ctx;
+  const ZDICT_cover_params_t parameters = data->parameters;
+  size_t dictBufferCapacity = data->dictBufferCapacity;
+  size_t totalCompressedSize = ERROR(GENERIC);
+  /* Initialize array to keep track of frequency of dmer within activeSegment */
+  U16* segmentFreqs = (U16 *)calloc(((U64)1 << ctx->f), sizeof(U16));
+  /* Allocate space for hash table, dict, and freqs */
+  BYTE *const dict = (BYTE * const)malloc(dictBufferCapacity);
+  COVER_dictSelection_t selection = COVER_dictSelectionError(ERROR(GENERIC));
+  U32 *freqs = (U32*) malloc(((U64)1 << ctx->f) * sizeof(U32));
+  if (!segmentFreqs || !dict || !freqs) {
+    DISPLAYLEVEL(1, "Failed to allocate buffers: out of memory\n");
+    goto _cleanup;
+  }
+  /* Copy the frequencies because we need to modify them */
+  memcpy(freqs, ctx->freqs, ((U64)1 << ctx->f) * sizeof(U32));
+  /* Build the dictionary */
+  { const size_t tail = FASTCOVER_buildDictionary(ctx, freqs, dict, dictBufferCapacity,
+                                                    parameters, segmentFreqs);
+
+    const unsigned nbFinalizeSamples = (unsigned)(ctx->nbTrainSamples * ctx->accelParams.finalize / 100);
+    selection = COVER_selectDict(dict + tail, dictBufferCapacity - tail,
+         ctx->samples, ctx->samplesSizes, nbFinalizeSamples, ctx->nbTrainSamples, ctx->nbSamples, parameters, ctx->offsets,
+         totalCompressedSize);
+
+    if (COVER_dictSelectionIsError(selection)) {
+      DISPLAYLEVEL(1, "Failed to select dictionary\n");
+      goto _cleanup;
+    }
+  }
+_cleanup:
+  free(dict);
+  COVER_best_finish(data->best, parameters, selection);
+  free(data);
+  free(segmentFreqs);
+  COVER_dictSelectionFree(selection);
+  free(freqs);
+}
+
+
+static void
+FASTCOVER_convertToCoverParams(ZDICT_fastCover_params_t fastCoverParams,
+                               ZDICT_cover_params_t* coverParams)
+{
+    coverParams->k = fastCoverParams.k;
+    coverParams->d = fastCoverParams.d;
+    coverParams->steps = fastCoverParams.steps;
+    coverParams->nbThreads = fastCoverParams.nbThreads;
+    coverParams->splitPoint = fastCoverParams.splitPoint;
+    coverParams->zParams = fastCoverParams.zParams;
+    coverParams->shrinkDict = fastCoverParams.shrinkDict;
+}
+
+
+static void
+FASTCOVER_convertToFastCoverParams(ZDICT_cover_params_t coverParams,
+                                   ZDICT_fastCover_params_t* fastCoverParams,
+                                   unsigned f, unsigned accel)
+{
+    fastCoverParams->k = coverParams.k;
+    fastCoverParams->d = coverParams.d;
+    fastCoverParams->steps = coverParams.steps;
+    fastCoverParams->nbThreads = coverParams.nbThreads;
+    fastCoverParams->splitPoint = coverParams.splitPoint;
+    fastCoverParams->f = f;
+    fastCoverParams->accel = accel;
+    fastCoverParams->zParams = coverParams.zParams;
+    fastCoverParams->shrinkDict = coverParams.shrinkDict;
+}
+
+
+ZDICTLIB_API size_t
+ZDICT_trainFromBuffer_fastCover(void* dictBuffer, size_t dictBufferCapacity,
+                                const void* samplesBuffer,
+                                const size_t* samplesSizes, unsigned nbSamples,
+                                ZDICT_fastCover_params_t parameters)
+{
+    BYTE* const dict = (BYTE*)dictBuffer;
+    FASTCOVER_ctx_t ctx;
+    ZDICT_cover_params_t coverParams;
+    FASTCOVER_accel_t accelParams;
+    /* Initialize global data */
+    g_displayLevel = parameters.zParams.notificationLevel;
+    /* Assign splitPoint and f if not provided */
+    parameters.splitPoint = 1.0;
+    parameters.f = parameters.f == 0 ? DEFAULT_F : parameters.f;
+    parameters.accel = parameters.accel == 0 ? DEFAULT_ACCEL : parameters.accel;
+    /* Convert to cover parameter */
+    memset(&coverParams, 0 , sizeof(coverParams));
+    FASTCOVER_convertToCoverParams(parameters, &coverParams);
+    /* Checks */
+    if (!FASTCOVER_checkParameters(coverParams, dictBufferCapacity, parameters.f,
+                                   parameters.accel)) {
+      DISPLAYLEVEL(1, "FASTCOVER parameters incorrect\n");
+      return ERROR(parameter_outOfBound);
+    }
+    if (nbSamples == 0) {
+      DISPLAYLEVEL(1, "FASTCOVER must have at least one input file\n");
+      return ERROR(srcSize_wrong);
+    }
+    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
+      DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n",
+                   ZDICT_DICTSIZE_MIN);
+      return ERROR(dstSize_tooSmall);
+    }
+    /* Assign corresponding FASTCOVER_accel_t to accelParams*/
+    accelParams = FASTCOVER_defaultAccelParameters[parameters.accel];
+    /* Initialize context */
+    {
+      size_t const initVal = FASTCOVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples,
+                            coverParams.d, parameters.splitPoint, parameters.f,
+                            accelParams);
+      if (ZSTD_isError(initVal)) {
+        DISPLAYLEVEL(1, "Failed to initialize context\n");
+        return initVal;
+      }
+    }
+    COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, g_displayLevel);
+    /* Build the dictionary */
+    DISPLAYLEVEL(2, "Building dictionary\n");
+    {
+      /* Initialize array to keep track of frequency of dmer within activeSegment */
+      U16* segmentFreqs = (U16 *)calloc(((U64)1 << parameters.f), sizeof(U16));
+      const size_t tail = FASTCOVER_buildDictionary(&ctx, ctx.freqs, dictBuffer,
+                                                dictBufferCapacity, coverParams, segmentFreqs);
+      const unsigned nbFinalizeSamples = (unsigned)(ctx.nbTrainSamples * ctx.accelParams.finalize / 100);
+      const size_t dictionarySize = ZDICT_finalizeDictionary(
+          dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,
+          samplesBuffer, samplesSizes, nbFinalizeSamples, coverParams.zParams);
+      if (!ZSTD_isError(dictionarySize)) {
+          DISPLAYLEVEL(2, "Constructed dictionary of size %u\n",
+                      (unsigned)dictionarySize);
+      }
+      FASTCOVER_ctx_destroy(&ctx);
+      free(segmentFreqs);
+      return dictionarySize;
+    }
+}
+
+
+ZDICTLIB_API size_t
+ZDICT_optimizeTrainFromBuffer_fastCover(
+                    void* dictBuffer, size_t dictBufferCapacity,
+                    const void* samplesBuffer,
+                    const size_t* samplesSizes, unsigned nbSamples,
+                    ZDICT_fastCover_params_t* parameters)
+{
+    ZDICT_cover_params_t coverParams;
+    FASTCOVER_accel_t accelParams;
+    /* constants */
+    const unsigned nbThreads = parameters->nbThreads;
+    const double splitPoint =
+        parameters->splitPoint <= 0.0 ? DEFAULT_SPLITPOINT : parameters->splitPoint;
+    const unsigned kMinD = parameters->d == 0 ? 6 : parameters->d;
+    const unsigned kMaxD = parameters->d == 0 ? 8 : parameters->d;
+    const unsigned kMinK = parameters->k == 0 ? 50 : parameters->k;
+    const unsigned kMaxK = parameters->k == 0 ? 2000 : parameters->k;
+    const unsigned kSteps = parameters->steps == 0 ? 40 : parameters->steps;
+    const unsigned kStepSize = MAX((kMaxK - kMinK) / kSteps, 1);
+    const unsigned kIterations =
+        (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize);
+    const unsigned f = parameters->f == 0 ? DEFAULT_F : parameters->f;
+    const unsigned accel = parameters->accel == 0 ? DEFAULT_ACCEL : parameters->accel;
+    const unsigned shrinkDict = 0;
+    /* Local variables */
+    const int displayLevel = parameters->zParams.notificationLevel;
+    unsigned iteration = 1;
+    unsigned d;
+    unsigned k;
+    COVER_best_t best;
+    POOL_ctx *pool = NULL;
+    int warned = 0;
+    /* Checks */
+    if (splitPoint <= 0 || splitPoint > 1) {
+      LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect splitPoint\n");
+      return ERROR(parameter_outOfBound);
+    }
+    if (accel == 0 || accel > FASTCOVER_MAX_ACCEL) {
+      LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect accel\n");
+      return ERROR(parameter_outOfBound);
+    }
+    if (kMinK < kMaxD || kMaxK < kMinK) {
+      LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect k\n");
+      return ERROR(parameter_outOfBound);
+    }
+    if (nbSamples == 0) {
+      LOCALDISPLAYLEVEL(displayLevel, 1, "FASTCOVER must have at least one input file\n");
+      return ERROR(srcSize_wrong);
+    }
+    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {
+      LOCALDISPLAYLEVEL(displayLevel, 1, "dictBufferCapacity must be at least %u\n",
+                   ZDICT_DICTSIZE_MIN);
+      return ERROR(dstSize_tooSmall);
+    }
+    if (nbThreads > 1) {
+      pool = POOL_create(nbThreads, 1);
+      if (!pool) {
+        return ERROR(memory_allocation);
+      }
+    }
+    /* Initialization */
+    COVER_best_init(&best);
+    memset(&coverParams, 0 , sizeof(coverParams));
+    FASTCOVER_convertToCoverParams(*parameters, &coverParams);
+    accelParams = FASTCOVER_defaultAccelParameters[accel];
+    /* Turn down global display level to clean up display at level 2 and below */
+    g_displayLevel = displayLevel == 0 ? 0 : displayLevel - 1;
+    /* Loop through d first because each new value needs a new context */
+    LOCALDISPLAYLEVEL(displayLevel, 2, "Trying %u different sets of parameters\n",
+                      kIterations);
+    for (d = kMinD; d <= kMaxD; d += 2) {
+      /* Initialize the context for this value of d */
+      FASTCOVER_ctx_t ctx;
+      LOCALDISPLAYLEVEL(displayLevel, 3, "d=%u\n", d);
+      {
+        size_t const initVal = FASTCOVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, d, splitPoint, f, accelParams);
+        if (ZSTD_isError(initVal)) {
+          LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to initialize context\n");
+          COVER_best_destroy(&best);
+          POOL_free(pool);
+          return initVal;
+        }
+      }
+      if (!warned) {
+        COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, displayLevel);
+        warned = 1;
+      }
+      /* Loop through k reusing the same context */
+      for (k = kMinK; k <= kMaxK; k += kStepSize) {
+        /* Prepare the arguments */
+        FASTCOVER_tryParameters_data_t *data = (FASTCOVER_tryParameters_data_t *)malloc(
+            sizeof(FASTCOVER_tryParameters_data_t));
+        LOCALDISPLAYLEVEL(displayLevel, 3, "k=%u\n", k);
+        if (!data) {
+          LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to allocate parameters\n");
+          COVER_best_destroy(&best);
+          FASTCOVER_ctx_destroy(&ctx);
+          POOL_free(pool);
+          return ERROR(memory_allocation);
+        }
+        data->ctx = &ctx;
+        data->best = &best;
+        data->dictBufferCapacity = dictBufferCapacity;
+        data->parameters = coverParams;
+        data->parameters.k = k;
+        data->parameters.d = d;
+        data->parameters.splitPoint = splitPoint;
+        data->parameters.steps = kSteps;
+        data->parameters.shrinkDict = shrinkDict;
+        data->parameters.zParams.notificationLevel = g_displayLevel;
+        /* Check the parameters */
+        if (!FASTCOVER_checkParameters(data->parameters, dictBufferCapacity,
+                                       data->ctx->f, accel)) {
+          DISPLAYLEVEL(1, "FASTCOVER parameters incorrect\n");
+          free(data);
+          continue;
+        }
+        /* Call the function and pass ownership of data to it */
+        COVER_best_start(&best);
+        if (pool) {
+          POOL_add(pool, &FASTCOVER_tryParameters, data);
+        } else {
+          FASTCOVER_tryParameters(data);
+        }
+        /* Print status */
+        LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%%       ",
+                           (unsigned)((iteration * 100) / kIterations));
+        ++iteration;
+      }
+      COVER_best_wait(&best);
+      FASTCOVER_ctx_destroy(&ctx);
+    }
+    LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", "");
+    /* Fill the output buffer and parameters with output of the best parameters */
+    {
+      const size_t dictSize = best.dictSize;
+      if (ZSTD_isError(best.compressedSize)) {
+        const size_t compressedSize = best.compressedSize;
+        COVER_best_destroy(&best);
+        POOL_free(pool);
+        return compressedSize;
+      }
+      FASTCOVER_convertToFastCoverParams(best.parameters, parameters, f, accel);
+      memcpy(dictBuffer, best.dict, dictSize);
+      COVER_best_destroy(&best);
+      POOL_free(pool);
+      return dictSize;
+    }
+
+}
diff --git a/src/fse.h b/src/fse.h
new file mode 100644
index 0000000..811c670
--- /dev/null
+++ b/src/fse.h
@@ -0,0 +1,708 @@
+/* ******************************************************************
+   FSE : Finite State Entropy codec
+   Public Prototypes declaration
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef FSE_H
+#define FSE_H
+
+
+/*-*****************************************
+*  Dependencies
+******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+
+
+/*-*****************************************
+*  FSE_PUBLIC_API : control library symbols visibility
+******************************************/
+#if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
+#  define FSE_PUBLIC_API __attribute__ ((visibility ("default")))
+#elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1)   /* Visual expected */
+#  define FSE_PUBLIC_API __declspec(dllexport)
+#elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
+#  define FSE_PUBLIC_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define FSE_PUBLIC_API
+#endif
+
+/*------   Version   ------*/
+#define FSE_VERSION_MAJOR    0
+#define FSE_VERSION_MINOR    9
+#define FSE_VERSION_RELEASE  0
+
+#define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_VERSION_MINOR.FSE_VERSION_RELEASE
+#define FSE_QUOTE(str) #str
+#define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(str)
+#define FSE_VERSION_STRING FSE_EXPAND_AND_QUOTE(FSE_LIB_VERSION)
+
+#define FSE_VERSION_NUMBER  (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)
+FSE_PUBLIC_API unsigned FSE_versionNumber(void);   /**< library version number; to be used when checking dll version */
+
+
+/*-****************************************
+*  FSE simple functions
+******************************************/
+/*! FSE_compress() :
+    Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'.
+    'dst' buffer must be already allocated. Compression runs faster is dstCapacity >= FSE_compressBound(srcSize).
+    @return : size of compressed data (<= dstCapacity).
+    Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
+                     if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression instead.
+                     if FSE_isError(return), compression failed (more details using FSE_getErrorName())
+*/
+FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity,
+                             const void* src, size_t srcSize);
+
+/*! FSE_decompress():
+    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'dstCapacity'.
+    @return : size of regenerated data (<= maxDstSize),
+              or an error code, which can be tested using FSE_isError() .
+
+    ** Important ** : FSE_decompress() does not decompress non-compressible nor RLE data !!!
+    Why ? : making this distinction requires a header.
+    Header management is intentionally delegated to the user layer, which can better manage special cases.
+*/
+FSE_PUBLIC_API size_t FSE_decompress(void* dst,  size_t dstCapacity,
+                               const void* cSrc, size_t cSrcSize);
+
+
+/*-*****************************************
+*  Tool functions
+******************************************/
+FSE_PUBLIC_API size_t FSE_compressBound(size_t size);       /* maximum compressed size */
+
+/* Error Management */
+FSE_PUBLIC_API unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */
+FSE_PUBLIC_API const char* FSE_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
+
+
+/*-*****************************************
+*  FSE advanced functions
+******************************************/
+/*! FSE_compress2() :
+    Same as FSE_compress(), but allows the selection of 'maxSymbolValue' and 'tableLog'
+    Both parameters can be defined as '0' to mean : use default value
+    @return : size of compressed data
+    Special values : if return == 0, srcData is not compressible => Nothing is stored within cSrc !!!
+                     if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression.
+                     if FSE_isError(return), it's an error code.
+*/
+FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
+
+
+/*-*****************************************
+*  FSE detailed API
+******************************************/
+/*!
+FSE_compress() does the following:
+1. count symbol occurrence from source[] into table count[] (see hist.h)
+2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
+3. save normalized counters to memory buffer using writeNCount()
+4. build encoding table 'CTable' from normalized counters
+5. encode the data stream using encoding table 'CTable'
+
+FSE_decompress() does the following:
+1. read normalized counters with readNCount()
+2. build decoding table 'DTable' from normalized counters
+3. decode the data stream using decoding table 'DTable'
+
+The following API allows targeting specific sub-functions for advanced tasks.
+For example, it's possible to compress several blocks using the same 'CTable',
+or to save and provide normalized distribution using external method.
+*/
+
+/* *** COMPRESSION *** */
+
+/*! FSE_optimalTableLog():
+    dynamically downsize 'tableLog' when conditions are met.
+    It saves CPU time, by using smaller tables, while preserving or even improving compression ratio.
+    @return : recommended tableLog (necessarily <= 'maxTableLog') */
+FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
+
+/*! FSE_normalizeCount():
+    normalize counts so that sum(count[]) == Power_of_2 (2^tableLog)
+    'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1).
+    @return : tableLog,
+              or an errorCode, which can be tested using FSE_isError() */
+FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
+                    const unsigned* count, size_t srcSize, unsigned maxSymbolValue);
+
+/*! FSE_NCountWriteBound():
+    Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'.
+    Typically useful for allocation purpose. */
+FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);
+
+/*! FSE_writeNCount():
+    Compactly save 'normalizedCounter' into 'buffer'.
+    @return : size of the compressed table,
+              or an errorCode, which can be tested using FSE_isError(). */
+FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
+                                 const short* normalizedCounter,
+                                 unsigned maxSymbolValue, unsigned tableLog);
+
+/*! Constructor and Destructor of FSE_CTable.
+    Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */
+typedef unsigned FSE_CTable;   /* don't allocate that. It's only meant to be more restrictive than void* */
+FSE_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog);
+FSE_PUBLIC_API void        FSE_freeCTable (FSE_CTable* ct);
+
+/*! FSE_buildCTable():
+    Builds `ct`, which must be already allocated, using FSE_createCTable().
+    @return : 0, or an errorCode, which can be tested using FSE_isError() */
+FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
+
+/*! FSE_compress_usingCTable():
+    Compress `src` using `ct` into `dst` which must be already allocated.
+    @return : size of compressed data (<= `dstCapacity`),
+              or 0 if compressed data could not fit into `dst`,
+              or an errorCode, which can be tested using FSE_isError() */
+FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);
+
+/*!
+Tutorial :
+----------
+The first step is to count all symbols. FSE_count() does this job very fast.
+Result will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells.
+'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0]
+maxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value)
+FSE_count() will return the number of occurrence of the most frequent symbol.
+This can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility.
+If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
+
+The next step is to normalize the frequencies.
+FSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'.
+It also guarantees a minimum of 1 to any Symbol with frequency >= 1.
+You can use 'tableLog'==0 to mean "use default tableLog value".
+If you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(),
+which will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means "default").
+
+The result of FSE_normalizeCount() will be saved into a table,
+called 'normalizedCounter', which is a table of signed short.
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells.
+The return value is tableLog if everything proceeded as expected.
+It is 0 if there is a single symbol within distribution.
+If there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()).
+
+'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount().
+'buffer' must be already allocated.
+For guaranteed success, buffer size must be at least FSE_headerBound().
+The result of the function is the number of bytes written into 'buffer'.
+If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small).
+
+'normalizedCounter' can then be used to create the compression table 'CTable'.
+The space required by 'CTable' must be already allocated, using FSE_createCTable().
+You can then use FSE_buildCTable() to fill 'CTable'.
+If there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()).
+
+'CTable' can then be used to compress 'src', with FSE_compress_usingCTable().
+Similar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize'
+The function returns the size of compressed data (without header), necessarily <= `dstCapacity`.
+If it returns '0', compressed data could not fit into 'dst'.
+If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
+*/
+
+
+/* *** DECOMPRESSION *** */
+
+/*! FSE_readNCount():
+    Read compactly saved 'normalizedCounter' from 'rBuffer'.
+    @return : size read from 'rBuffer',
+              or an errorCode, which can be tested using FSE_isError().
+              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
+FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
+                           unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
+                           const void* rBuffer, size_t rBuffSize);
+
+/*! Constructor and Destructor of FSE_DTable.
+    Note that its size depends on 'tableLog' */
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+FSE_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog);
+FSE_PUBLIC_API void        FSE_freeDTable(FSE_DTable* dt);
+
+/*! FSE_buildDTable():
+    Builds 'dt', which must be already allocated, using FSE_createDTable().
+    return : 0, or an errorCode, which can be tested using FSE_isError() */
+FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
+
+/*! FSE_decompress_usingDTable():
+    Decompress compressed source `cSrc` of size `cSrcSize` using `dt`
+    into `dst` which must be already allocated.
+    @return : size of regenerated data (necessarily <= `dstCapacity`),
+              or an errorCode, which can be tested using FSE_isError() */
+FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);
+
+/*!
+Tutorial :
+----------
+(Note : these functions only decompress FSE-compressed blocks.
+ If block is uncompressed, use memcpy() instead
+ If block is a single repeated byte, use memset() instead )
+
+The first step is to obtain the normalized frequencies of symbols.
+This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
+In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
+or size the table to handle worst case situations (typically 256).
+FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
+The result of FSE_readNCount() is the number of bytes read from 'rBuffer'.
+Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
+If there is an error, the function will return an error code, which can be tested using FSE_isError().
+
+The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.
+This is performed by the function FSE_buildDTable().
+The space required by 'FSE_DTable' must be already allocated using FSE_createDTable().
+If there is an error, the function will return an error code, which can be tested using FSE_isError().
+
+`FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable().
+`cSrcSize` must be strictly correct, otherwise decompression will fail.
+FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
+*/
+
+#endif  /* FSE_H */
+
+#if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
+#define FSE_H_FSE_STATIC_LINKING_ONLY
+
+/* *** Dependency *** */
+#include "bitstream.h"
+
+
+/* *****************************************
+*  Static allocation
+*******************************************/
+/* FSE buffer bounds */
+#define FSE_NCOUNTBOUND 512
+#define FSE_BLOCKBOUND(size) (size + (size>>7))
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+/* or use the size to malloc() space directly. Pay attention to alignment restrictions though */
+#define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue)   (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
+#define FSE_DTABLE_SIZE(maxTableLog)                   (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))
+
+
+/* *****************************************
+ *  FSE advanced API
+ ***************************************** */
+
+unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
+/**< same as FSE_optimalTableLog(), which used `minus==2` */
+
+/* FSE_compress_wksp() :
+ * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
+ * FSE_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable.
+ */
+#define FSE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue)   ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) )
+size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
+
+size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
+/**< build a fake FSE_CTable, designed for a flat distribution, where each symbol uses nbBits */
+
+size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);
+/**< build a fake FSE_CTable, designed to compress always the same symbolValue */
+
+/* FSE_buildCTable_wksp() :
+ * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
+ * `wkspSize` must be >= `(1<<tableLog)`.
+ */
+size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
+
+size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
+/**< build a fake FSE_DTable, designed to read a flat distribution where each symbol uses nbBits */
+
+size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
+/**< build a fake FSE_DTable, designed to always generate the same symbolValue */
+
+size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog);
+/**< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DTABLE_SIZE_U32(maxLog)` */
+
+typedef enum {
+   FSE_repeat_none,  /**< Cannot use the previous table */
+   FSE_repeat_check, /**< Can use the previous table but it must be checked */
+   FSE_repeat_valid  /**< Can use the previous table and it is assumed to be valid */
+ } FSE_repeat;
+
+/* *****************************************
+*  FSE symbol compression API
+*******************************************/
+/*!
+   This API consists of small unitary functions, which highly benefit from being inlined.
+   Hence their body are included in next section.
+*/
+typedef struct {
+    ptrdiff_t   value;
+    const void* stateTable;
+    const void* symbolTT;
+    unsigned    stateLog;
+} FSE_CState_t;
+
+static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);
+
+static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);
+
+static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);
+
+/**<
+These functions are inner components of FSE_compress_usingCTable().
+They allow the creation of custom streams, mixing multiple tables and bit sources.
+
+A key property to keep in mind is that encoding and decoding are done **in reverse direction**.
+So the first symbol you will encode is the last you will decode, like a LIFO stack.
+
+You will need a few variables to track your CStream. They are :
+
+FSE_CTable    ct;         // Provided by FSE_buildCTable()
+BIT_CStream_t bitStream;  // bitStream tracking structure
+FSE_CState_t  state;      // State tracking structure (can have several)
+
+
+The first thing to do is to init bitStream and state.
+    size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize);
+    FSE_initCState(&state, ct);
+
+Note that BIT_initCStream() can produce an error code, so its result should be tested, using FSE_isError();
+You can then encode your input data, byte after byte.
+FSE_encodeSymbol() outputs a maximum of 'tableLog' bits at a time.
+Remember decoding will be done in reverse direction.
+    FSE_encodeByte(&bitStream, &state, symbol);
+
+At any time, you can also add any bit sequence.
+Note : maximum allowed nbBits is 25, for compatibility with 32-bits decoders
+    BIT_addBits(&bitStream, bitField, nbBits);
+
+The above methods don't commit data to memory, they just store it into local register, for speed.
+Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
+Writing data to memory is a manual operation, performed by the flushBits function.
+    BIT_flushBits(&bitStream);
+
+Your last FSE encoding operation shall be to flush your last state value(s).
+    FSE_flushState(&bitStream, &state);
+
+Finally, you must close the bitStream.
+The function returns the size of CStream in bytes.
+If data couldn't fit into dstBuffer, it will return a 0 ( == not compressible)
+If there is an error, it returns an errorCode (which can be tested using FSE_isError()).
+    size_t size = BIT_closeCStream(&bitStream);
+*/
+
+
+/* *****************************************
+*  FSE symbol decompression API
+*******************************************/
+typedef struct {
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSE_DState_t;
+
+
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
+
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
+
+/**<
+Let's now decompose FSE_decompress_usingDTable() into its unitary components.
+You will decode FSE-encoded symbols from the bitStream,
+and also any other bitFields you put in, **in reverse order**.
+
+You will need a few variables to track your bitStream. They are :
+
+BIT_DStream_t DStream;    // Stream context
+FSE_DState_t  DState;     // State context. Multiple ones are possible
+FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
+
+The first thing to do is to init the bitStream.
+    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
+
+You should then retrieve your initial state(s)
+(in reverse flushing order if you have several ones) :
+    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
+
+You can then decode your data, symbol after symbol.
+For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
+Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
+    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
+
+You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
+Note : maximum allowed nbBits is 25, for 32-bits compatibility
+    size_t bitField = BIT_readBits(&DStream, nbBits);
+
+All above operations only read from local register (which size depends on size_t).
+Refueling the register from memory is manually performed by the reload method.
+    endSignal = FSE_reloadDStream(&DStream);
+
+BIT_reloadDStream() result tells if there is still some more data to read from DStream.
+BIT_DStream_unfinished : there is still some data left into the DStream.
+BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
+BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
+BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
+
+When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
+to properly detect the exact end of stream.
+After each decoded symbol, check if DStream is fully consumed using this simple test :
+    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
+
+When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
+Checking if DStream has reached its end is performed by :
+    BIT_endOfDStream(&DStream);
+Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
+    FSE_endOfDState(&DState);
+*/
+
+
+/* *****************************************
+*  FSE unsafe API
+*******************************************/
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
+
+
+/* *****************************************
+*  Implementation of inlined functions
+*******************************************/
+typedef struct {
+    int deltaFindState;
+    U32 deltaNbBits;
+} FSE_symbolCompressionTransform; /* total 8 bytes */
+
+MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
+{
+    const void* ptr = ct;
+    const U16* u16ptr = (const U16*) ptr;
+    const U32 tableLog = MEM_read16(ptr);
+    statePtr->value = (ptrdiff_t)1<<tableLog;
+    statePtr->stateTable = u16ptr+2;
+    statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
+    statePtr->stateLog = tableLog;
+}
+
+
+/*! FSE_initCState2() :
+*   Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
+*   uses the smallest state value possible, saving the cost of this symbol */
+MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
+{
+    FSE_initCState(statePtr, ct);
+    {   const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
+        const U16* stateTable = (const U16*)(statePtr->stateTable);
+        U32 nbBitsOut  = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
+        statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
+        statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
+    }
+}
+
+MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
+{
+    FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
+    const U16* const stateTable = (const U16*)(statePtr->stateTable);
+    U32 const nbBitsOut  = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
+    BIT_addBits(bitC, statePtr->value, nbBitsOut);
+    statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
+}
+
+MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
+{
+    BIT_addBits(bitC, statePtr->value, statePtr->stateLog);
+    BIT_flushBits(bitC);
+}
+
+
+/* FSE_getMaxNbBits() :
+ * Approximate maximum cost of a symbol, in bits.
+ * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
+ * note 1 : assume symbolValue is valid (<= maxSymbolValue)
+ * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
+MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)
+{
+    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
+    return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;
+}
+
+/* FSE_bitCost() :
+ * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)
+ * note 1 : assume symbolValue is valid (<= maxSymbolValue)
+ * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
+MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
+{
+    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
+    U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
+    U32 const threshold = (minNbBits+1) << 16;
+    assert(tableLog < 16);
+    assert(accuracyLog < 31-tableLog);  /* ensure enough room for renormalization double shift */
+    {   U32 const tableSize = 1 << tableLog;
+        U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);
+        U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog;   /* linear interpolation (very approximate) */
+        U32 const bitMultiplier = 1 << accuracyLog;
+        assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);
+        assert(normalizedDeltaFromThreshold <= bitMultiplier);
+        return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;
+    }
+}
+
+
+/* ======    Decompression    ====== */
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSE_DTableHeader;   /* sizeof U32 */
+
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSE_decode_t;   /* size == U32 */
+
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
+    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
+    BIT_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
+{
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    return DInfo.symbol;
+}
+
+MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    size_t const lowBits = BIT_readBits(bitD, nbBits);
+    DStatePtr->state = DInfo.newState + lowBits;
+}
+
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    BYTE const symbol = DInfo.symbol;
+    size_t const lowBits = BIT_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+/*! FSE_decodeSymbolFast() :
+    unsafe, only works if no symbol has a probability > 50% */
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    BYTE const symbol = DInfo.symbol;
+    size_t const lowBits = BIT_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
+{
+    return DStatePtr->state == 0;
+}
+
+
+
+#ifndef FSE_COMMONDEFS_ONLY
+
+/* **************************************************************
+*  Tuning parameters
+****************************************************************/
+/*!MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#ifndef FSE_MAX_MEMORY_USAGE
+#  define FSE_MAX_MEMORY_USAGE 14
+#endif
+#ifndef FSE_DEFAULT_MEMORY_USAGE
+#  define FSE_DEFAULT_MEMORY_USAGE 13
+#endif
+
+/*!FSE_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#ifndef FSE_MAX_SYMBOL_VALUE
+#  define FSE_MAX_SYMBOL_VALUE 255
+#endif
+
+/* **************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSE_FUNCTION_TYPE BYTE
+#define FSE_FUNCTION_EXTENSION
+#define FSE_DECODE_TYPE FSE_decode_t
+
+
+#endif   /* !FSE_COMMONDEFS_ONLY */
+
+
+/* ***************************************************************
+*  Constants
+*****************************************************************/
+#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
+#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
+#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
+#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
+#define FSE_MIN_TABLELOG 5
+
+#define FSE_TABLELOG_ABSOLUTE_MAX 15
+#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
+#  error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+#define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
+
+
+#endif /* FSE_STATIC_LINKING_ONLY */
+
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/src/fse_compress.c b/src/fse_compress.c
new file mode 100644
index 0000000..68b47e1
--- /dev/null
+++ b/src/fse_compress.c
@@ -0,0 +1,721 @@
+/* ******************************************************************
+   FSE : Finite State Entropy encoder
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/* **************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include "compiler.h"
+#include "mem.h"        /* U32, U16, etc. */
+#include "debug.h"      /* assert, DEBUGLOG */
+#include "hist.h"       /* HIST_count_wksp */
+#include "bitstream.h"
+#define FSE_STATIC_LINKING_ONLY
+#include "fse.h"
+#include "error_private.h"
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define FSE_isError ERR_isError
+
+
+/* **************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSE_FUNCTION_EXTENSION
+#  error "FSE_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSE_FUNCTION_TYPE
+#  error "FSE_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSE_CAT(X,Y) X##Y
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
+
+
+/* Function templates */
+
+/* FSE_buildCTable_wksp() :
+ * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
+ * wkspSize should be sized to handle worst case situation, which is `1<<max_tableLog * sizeof(FSE_FUNCTION_TYPE)`
+ * workSpace must also be properly aligned with FSE_FUNCTION_TYPE requirements
+ */
+size_t FSE_buildCTable_wksp(FSE_CTable* ct,
+                      const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
+                            void* workSpace, size_t wkspSize)
+{
+    U32 const tableSize = 1 << tableLog;
+    U32 const tableMask = tableSize - 1;
+    void* const ptr = ct;
+    U16* const tableU16 = ( (U16*) ptr) + 2;
+    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableLog ? tableSize>>1 : 1) ;
+    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
+    U32 const step = FSE_TABLESTEP(tableSize);
+    U32 cumul[FSE_MAX_SYMBOL_VALUE+2];
+
+    FSE_FUNCTION_TYPE* const tableSymbol = (FSE_FUNCTION_TYPE*)workSpace;
+    U32 highThreshold = tableSize-1;
+
+    /* CTable header */
+    if (((size_t)1 << tableLog) * sizeof(FSE_FUNCTION_TYPE) > wkspSize) return ERROR(tableLog_tooLarge);
+    tableU16[-2] = (U16) tableLog;
+    tableU16[-1] = (U16) maxSymbolValue;
+    assert(tableLog < 16);   /* required for threshold strategy to work */
+
+    /* For explanations on how to distribute symbol values over the table :
+     * http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
+
+     #ifdef __clang_analyzer__
+     memset(tableSymbol, 0, sizeof(*tableSymbol) * tableSize);   /* useless initialization, just to keep scan-build happy */
+     #endif
+
+    /* symbol start positions */
+    {   U32 u;
+        cumul[0] = 0;
+        for (u=1; u <= maxSymbolValue+1; u++) {
+            if (normalizedCounter[u-1]==-1) {  /* Low proba symbol */
+                cumul[u] = cumul[u-1] + 1;
+                tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);
+            } else {
+                cumul[u] = cumul[u-1] + normalizedCounter[u-1];
+        }   }
+        cumul[maxSymbolValue+1] = tableSize+1;
+    }
+
+    /* Spread symbols */
+    {   U32 position = 0;
+        U32 symbol;
+        for (symbol=0; symbol<=maxSymbolValue; symbol++) {
+            int nbOccurrences;
+            int const freq = normalizedCounter[symbol];
+            for (nbOccurrences=0; nbOccurrences<freq; nbOccurrences++) {
+                tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
+                position = (position + step) & tableMask;
+                while (position > highThreshold)
+                    position = (position + step) & tableMask;   /* Low proba area */
+        }   }
+
+        assert(position==0);  /* Must have initialized all positions */
+    }
+
+    /* Build table */
+    {   U32 u; for (u=0; u<tableSize; u++) {
+        FSE_FUNCTION_TYPE s = tableSymbol[u];   /* note : static analyzer may not understand tableSymbol is properly initialized */
+        tableU16[cumul[s]++] = (U16) (tableSize+u);   /* TableU16 : sorted by symbol order; gives next state value */
+    }   }
+
+    /* Build Symbol Transformation Table */
+    {   unsigned total = 0;
+        unsigned s;
+        for (s=0; s<=maxSymbolValue; s++) {
+            switch (normalizedCounter[s])
+            {
+            case  0:
+                /* filling nonetheless, for compatibility with FSE_getMaxNbBits() */
+                symbolTT[s].deltaNbBits = ((tableLog+1) << 16) - (1<<tableLog);
+                break;
+
+            case -1:
+            case  1:
+                symbolTT[s].deltaNbBits = (tableLog << 16) - (1<<tableLog);
+                symbolTT[s].deltaFindState = total - 1;
+                total ++;
+                break;
+            default :
+                {
+                    U32 const maxBitsOut = tableLog - BIT_highbit32 (normalizedCounter[s]-1);
+                    U32 const minStatePlus = normalizedCounter[s] << maxBitsOut;
+                    symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;
+                    symbolTT[s].deltaFindState = total - normalizedCounter[s];
+                    total +=  normalizedCounter[s];
+    }   }   }   }
+
+#if 0  /* debug : symbol costs */
+    DEBUGLOG(5, "\n --- table statistics : ");
+    {   U32 symbol;
+        for (symbol=0; symbol<=maxSymbolValue; symbol++) {
+            DEBUGLOG(5, "%3u: w=%3i,   maxBits=%u, fracBits=%.2f",
+                symbol, normalizedCounter[symbol],
+                FSE_getMaxNbBits(symbolTT, symbol),
+                (double)FSE_bitCost(symbolTT, tableLog, symbol, 8) / 256);
+        }
+    }
+#endif
+
+    return 0;
+}
+
+
+size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    FSE_FUNCTION_TYPE tableSymbol[FSE_MAX_TABLESIZE];   /* memset() is not necessary, even if static analyzer complain about it */
+    return FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog, tableSymbol, sizeof(tableSymbol));
+}
+
+
+
+#ifndef FSE_COMMONDEFS_ONLY
+
+
+/*-**************************************************************
+*  FSE NCount encoding
+****************************************************************/
+size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
+{
+    size_t const maxHeaderSize = (((maxSymbolValue+1) * tableLog) >> 3) + 3;
+    return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */
+}
+
+static size_t
+FSE_writeNCount_generic (void* header, size_t headerBufferSize,
+                   const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
+                         unsigned writeIsSafe)
+{
+    BYTE* const ostart = (BYTE*) header;
+    BYTE* out = ostart;
+    BYTE* const oend = ostart + headerBufferSize;
+    int nbBits;
+    const int tableSize = 1 << tableLog;
+    int remaining;
+    int threshold;
+    U32 bitStream = 0;
+    int bitCount = 0;
+    unsigned symbol = 0;
+    unsigned const alphabetSize = maxSymbolValue + 1;
+    int previousIs0 = 0;
+
+    /* Table Size */
+    bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount;
+    bitCount  += 4;
+
+    /* Init */
+    remaining = tableSize+1;   /* +1 for extra accuracy */
+    threshold = tableSize;
+    nbBits = tableLog+1;
+
+    while ((symbol < alphabetSize) && (remaining>1)) {  /* stops at 1 */
+        if (previousIs0) {
+            unsigned start = symbol;
+            while ((symbol < alphabetSize) && !normalizedCounter[symbol]) symbol++;
+            if (symbol == alphabetSize) break;   /* incorrect distribution */
+            while (symbol >= start+24) {
+                start+=24;
+                bitStream += 0xFFFFU << bitCount;
+                if ((!writeIsSafe) && (out > oend-2))
+                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+                out[0] = (BYTE) bitStream;
+                out[1] = (BYTE)(bitStream>>8);
+                out+=2;
+                bitStream>>=16;
+            }
+            while (symbol >= start+3) {
+                start+=3;
+                bitStream += 3 << bitCount;
+                bitCount += 2;
+            }
+            bitStream += (symbol-start) << bitCount;
+            bitCount += 2;
+            if (bitCount>16) {
+                if ((!writeIsSafe) && (out > oend - 2))
+                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+                out[0] = (BYTE)bitStream;
+                out[1] = (BYTE)(bitStream>>8);
+                out += 2;
+                bitStream >>= 16;
+                bitCount -= 16;
+        }   }
+        {   int count = normalizedCounter[symbol++];
+            int const max = (2*threshold-1) - remaining;
+            remaining -= count < 0 ? -count : count;
+            count++;   /* +1 for extra accuracy */
+            if (count>=threshold)
+                count += max;   /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
+            bitStream += count << bitCount;
+            bitCount  += nbBits;
+            bitCount  -= (count<max);
+            previousIs0  = (count==1);
+            if (remaining<1) return ERROR(GENERIC);
+            while (remaining<threshold) { nbBits--; threshold>>=1; }
+        }
+        if (bitCount>16) {
+            if ((!writeIsSafe) && (out > oend - 2))
+                return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+            out[0] = (BYTE)bitStream;
+            out[1] = (BYTE)(bitStream>>8);
+            out += 2;
+            bitStream >>= 16;
+            bitCount -= 16;
+    }   }
+
+    if (remaining != 1)
+        return ERROR(GENERIC);  /* incorrect normalized distribution */
+    assert(symbol <= alphabetSize);
+
+    /* flush remaining bitStream */
+    if ((!writeIsSafe) && (out > oend - 2))
+        return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+    out[0] = (BYTE)bitStream;
+    out[1] = (BYTE)(bitStream>>8);
+    out+= (bitCount+7) /8;
+
+    return (out-ostart);
+}
+
+
+size_t FSE_writeNCount (void* buffer, size_t bufferSize,
+                  const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported */
+    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */
+
+    if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
+        return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);
+
+    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */);
+}
+
+
+/*-**************************************************************
+*  FSE Compression Code
+****************************************************************/
+
+FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog)
+{
+    size_t size;
+    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
+    size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32);
+    return (FSE_CTable*)malloc(size);
+}
+
+void FSE_freeCTable (FSE_CTable* ct) { free(ct); }
+
+/* provides the minimum logSize to safely represent a distribution */
+static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue)
+{
+    U32 minBitsSrc = BIT_highbit32((U32)(srcSize)) + 1;
+    U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2;
+    U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;
+    assert(srcSize > 1); /* Not supported, RLE should be used instead */
+    return minBits;
+}
+
+unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
+{
+    U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
+    U32 tableLog = maxTableLog;
+    U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
+    assert(srcSize > 1); /* Not supported, RLE should be used instead */
+    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
+    if (maxBitsSrc < tableLog) tableLog = maxBitsSrc;   /* Accuracy can be reduced */
+    if (minBits > tableLog) tableLog = minBits;   /* Need a minimum to safely represent all symbol values */
+    if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG;
+    if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG;
+    return tableLog;
+}
+
+unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
+{
+    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2);
+}
+
+
+/* Secondary normalization method.
+   To be used when primary method fails. */
+
+static size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count, size_t total, U32 maxSymbolValue)
+{
+    short const NOT_YET_ASSIGNED = -2;
+    U32 s;
+    U32 distributed = 0;
+    U32 ToDistribute;
+
+    /* Init */
+    U32 const lowThreshold = (U32)(total >> tableLog);
+    U32 lowOne = (U32)((total * 3) >> (tableLog + 1));
+
+    for (s=0; s<=maxSymbolValue; s++) {
+        if (count[s] == 0) {
+            norm[s]=0;
+            continue;
+        }
+        if (count[s] <= lowThreshold) {
+            norm[s] = -1;
+            distributed++;
+            total -= count[s];
+            continue;
+        }
+        if (count[s] <= lowOne) {
+            norm[s] = 1;
+            distributed++;
+            total -= count[s];
+            continue;
+        }
+
+        norm[s]=NOT_YET_ASSIGNED;
+    }
+    ToDistribute = (1 << tableLog) - distributed;
+
+    if (ToDistribute == 0)
+        return 0;
+
+    if ((total / ToDistribute) > lowOne) {
+        /* risk of rounding to zero */
+        lowOne = (U32)((total * 3) / (ToDistribute * 2));
+        for (s=0; s<=maxSymbolValue; s++) {
+            if ((norm[s] == NOT_YET_ASSIGNED) && (count[s] <= lowOne)) {
+                norm[s] = 1;
+                distributed++;
+                total -= count[s];
+                continue;
+        }   }
+        ToDistribute = (1 << tableLog) - distributed;
+    }
+
+    if (distributed == maxSymbolValue+1) {
+        /* all values are pretty poor;
+           probably incompressible data (should have already been detected);
+           find max, then give all remaining points to max */
+        U32 maxV = 0, maxC = 0;
+        for (s=0; s<=maxSymbolValue; s++)
+            if (count[s] > maxC) { maxV=s; maxC=count[s]; }
+        norm[maxV] += (short)ToDistribute;
+        return 0;
+    }
+
+    if (total == 0) {
+        /* all of the symbols were low enough for the lowOne or lowThreshold */
+        for (s=0; ToDistribute > 0; s = (s+1)%(maxSymbolValue+1))
+            if (norm[s] > 0) { ToDistribute--; norm[s]++; }
+        return 0;
+    }
+
+    {   U64 const vStepLog = 62 - tableLog;
+        U64 const mid = (1ULL << (vStepLog-1)) - 1;
+        U64 const rStep = ((((U64)1<<vStepLog) * ToDistribute) + mid) / total;   /* scale on remaining */
+        U64 tmpTotal = mid;
+        for (s=0; s<=maxSymbolValue; s++) {
+            if (norm[s]==NOT_YET_ASSIGNED) {
+                U64 const end = tmpTotal + (count[s] * rStep);
+                U32 const sStart = (U32)(tmpTotal >> vStepLog);
+                U32 const sEnd = (U32)(end >> vStepLog);
+                U32 const weight = sEnd - sStart;
+                if (weight < 1)
+                    return ERROR(GENERIC);
+                norm[s] = (short)weight;
+                tmpTotal = end;
+    }   }   }
+
+    return 0;
+}
+
+
+size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
+                           const unsigned* count, size_t total,
+                           unsigned maxSymbolValue)
+{
+    /* Sanity checks */
+    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
+    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported size */
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported size */
+    if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC);   /* Too small tableLog, compression potentially impossible */
+
+    {   static U32 const rtbTable[] = {     0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 };
+        U64 const scale = 62 - tableLog;
+        U64 const step = ((U64)1<<62) / total;   /* <== here, one division ! */
+        U64 const vStep = 1ULL<<(scale-20);
+        int stillToDistribute = 1<<tableLog;
+        unsigned s;
+        unsigned largest=0;
+        short largestP=0;
+        U32 lowThreshold = (U32)(total >> tableLog);
+
+        for (s=0; s<=maxSymbolValue; s++) {
+            if (count[s] == total) return 0;   /* rle special case */
+            if (count[s] == 0) { normalizedCounter[s]=0; continue; }
+            if (count[s] <= lowThreshold) {
+                normalizedCounter[s] = -1;
+                stillToDistribute--;
+            } else {
+                short proba = (short)((count[s]*step) >> scale);
+                if (proba<8) {
+                    U64 restToBeat = vStep * rtbTable[proba];
+                    proba += (count[s]*step) - ((U64)proba<<scale) > restToBeat;
+                }
+                if (proba > largestP) { largestP=proba; largest=s; }
+                normalizedCounter[s] = proba;
+                stillToDistribute -= proba;
+        }   }
+        if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) {
+            /* corner case, need another normalization method */
+            size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue);
+            if (FSE_isError(errorCode)) return errorCode;
+        }
+        else normalizedCounter[largest] += (short)stillToDistribute;
+    }
+
+#if 0
+    {   /* Print Table (debug) */
+        U32 s;
+        U32 nTotal = 0;
+        for (s=0; s<=maxSymbolValue; s++)
+            RAWLOG(2, "%3i: %4i \n", s, normalizedCounter[s]);
+        for (s=0; s<=maxSymbolValue; s++)
+            nTotal += abs(normalizedCounter[s]);
+        if (nTotal != (1U<<tableLog))
+            RAWLOG(2, "Warning !!! Total == %u != %u !!!", nTotal, 1U<<tableLog);
+        getchar();
+    }
+#endif
+
+    return tableLog;
+}
+
+
+/* fake FSE_CTable, for raw (uncompressed) input */
+size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits)
+{
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSymbolValue = tableMask;
+    void* const ptr = ct;
+    U16* const tableU16 = ( (U16*) ptr) + 2;
+    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableSize>>1);   /* assumption : tableLog >= 1 */
+    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);             /* min size */
+
+    /* header */
+    tableU16[-2] = (U16) nbBits;
+    tableU16[-1] = (U16) maxSymbolValue;
+
+    /* Build table */
+    for (s=0; s<tableSize; s++)
+        tableU16[s] = (U16)(tableSize + s);
+
+    /* Build Symbol Transformation Table */
+    {   const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
+        for (s=0; s<=maxSymbolValue; s++) {
+            symbolTT[s].deltaNbBits = deltaNbBits;
+            symbolTT[s].deltaFindState = s-1;
+    }   }
+
+    return 0;
+}
+
+/* fake FSE_CTable, for rle input (always same symbol) */
+size_t FSE_buildCTable_rle (FSE_CTable* ct, BYTE symbolValue)
+{
+    void* ptr = ct;
+    U16* tableU16 = ( (U16*) ptr) + 2;
+    void* FSCTptr = (U32*)ptr + 2;
+    FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*) FSCTptr;
+
+    /* header */
+    tableU16[-2] = (U16) 0;
+    tableU16[-1] = (U16) symbolValue;
+
+    /* Build table */
+    tableU16[0] = 0;
+    tableU16[1] = 0;   /* just in case */
+
+    /* Build Symbol Transformation Table */
+    symbolTT[symbolValue].deltaNbBits = 0;
+    symbolTT[symbolValue].deltaFindState = 0;
+
+    return 0;
+}
+
+
+static size_t FSE_compress_usingCTable_generic (void* dst, size_t dstSize,
+                           const void* src, size_t srcSize,
+                           const FSE_CTable* ct, const unsigned fast)
+{
+    const BYTE* const istart = (const BYTE*) src;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* ip=iend;
+
+    BIT_CStream_t bitC;
+    FSE_CState_t CState1, CState2;
+
+    /* init */
+    if (srcSize <= 2) return 0;
+    { size_t const initError = BIT_initCStream(&bitC, dst, dstSize);
+      if (FSE_isError(initError)) return 0; /* not enough space available to write a bitstream */ }
+
+#define FSE_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
+
+    if (srcSize & 1) {
+        FSE_initCState2(&CState1, ct, *--ip);
+        FSE_initCState2(&CState2, ct, *--ip);
+        FSE_encodeSymbol(&bitC, &CState1, *--ip);
+        FSE_FLUSHBITS(&bitC);
+    } else {
+        FSE_initCState2(&CState2, ct, *--ip);
+        FSE_initCState2(&CState1, ct, *--ip);
+    }
+
+    /* join to mod 4 */
+    srcSize -= 2;
+    if ((sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) && (srcSize & 2)) {  /* test bit 2 */
+        FSE_encodeSymbol(&bitC, &CState2, *--ip);
+        FSE_encodeSymbol(&bitC, &CState1, *--ip);
+        FSE_FLUSHBITS(&bitC);
+    }
+
+    /* 2 or 4 encoding per loop */
+    while ( ip>istart ) {
+
+        FSE_encodeSymbol(&bitC, &CState2, *--ip);
+
+        if (sizeof(bitC.bitContainer)*8 < FSE_MAX_TABLELOG*2+7 )   /* this test must be static */
+            FSE_FLUSHBITS(&bitC);
+
+        FSE_encodeSymbol(&bitC, &CState1, *--ip);
+
+        if (sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) {  /* this test must be static */
+            FSE_encodeSymbol(&bitC, &CState2, *--ip);
+            FSE_encodeSymbol(&bitC, &CState1, *--ip);
+        }
+
+        FSE_FLUSHBITS(&bitC);
+    }
+
+    FSE_flushCState(&bitC, &CState2);
+    FSE_flushCState(&bitC, &CState1);
+    return BIT_closeCStream(&bitC);
+}
+
+size_t FSE_compress_usingCTable (void* dst, size_t dstSize,
+                           const void* src, size_t srcSize,
+                           const FSE_CTable* ct)
+{
+    unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize));
+
+    if (fast)
+        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1);
+    else
+        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);
+}
+
+
+size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }
+
+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
+#define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
+
+/* FSE_compress_wksp() :
+ * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
+ * `wkspSize` size must be `(1<<tableLog)`.
+ */
+size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + dstSize;
+
+    unsigned count[FSE_MAX_SYMBOL_VALUE+1];
+    S16   norm[FSE_MAX_SYMBOL_VALUE+1];
+    FSE_CTable* CTable = (FSE_CTable*)workSpace;
+    size_t const CTableSize = FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue);
+    void* scratchBuffer = (void*)(CTable + CTableSize);
+    size_t const scratchBufferSize = wkspSize - (CTableSize * sizeof(FSE_CTable));
+
+    /* init conditions */
+    if (wkspSize < FSE_WKSP_SIZE_U32(tableLog, maxSymbolValue)) return ERROR(tableLog_tooLarge);
+    if (srcSize <= 1) return 0;  /* Not compressible */
+    if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+    if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;
+
+    /* Scan input and build symbol stats */
+    {   CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize, scratchBuffer, scratchBufferSize) );
+        if (maxCount == srcSize) return 1;   /* only a single symbol in src : rle */
+        if (maxCount == 1) return 0;         /* each symbol present maximum once => not compressible */
+        if (maxCount < (srcSize >> 7)) return 0;   /* Heuristic : not compressible enough */
+    }
+
+    tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue);
+    CHECK_F( FSE_normalizeCount(norm, tableLog, count, srcSize, maxSymbolValue) );
+
+    /* Write table description header */
+    {   CHECK_V_F(nc_err, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) );
+        op += nc_err;
+    }
+
+    /* Compress */
+    CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, scratchBufferSize) );
+    {   CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, src, srcSize, CTable) );
+        if (cSize == 0) return 0;   /* not enough space for compressed data */
+        op += cSize;
+    }
+
+    /* check compressibility */
+    if ( (size_t)(op-ostart) >= srcSize-1 ) return 0;
+
+    return op-ostart;
+}
+
+typedef struct {
+    FSE_CTable CTable_max[FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)];
+    BYTE scratchBuffer[1 << FSE_MAX_TABLELOG];
+} fseWkspMax_t;
+
+size_t FSE_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
+{
+    fseWkspMax_t scratchBuffer;
+    DEBUG_STATIC_ASSERT(sizeof(scratchBuffer) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE));   /* compilation failures here means scratchBuffer is not large enough */
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    return FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, &scratchBuffer, sizeof(scratchBuffer));
+}
+
+size_t FSE_compress (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    return FSE_compress2(dst, dstCapacity, src, srcSize, FSE_MAX_SYMBOL_VALUE, FSE_DEFAULT_TABLELOG);
+}
+
+
+#endif   /* FSE_COMMONDEFS_ONLY */
diff --git a/src/fse_decompress.c b/src/fse_decompress.c
new file mode 100644
index 0000000..72bbead
--- /dev/null
+++ b/src/fse_decompress.c
@@ -0,0 +1,309 @@
+/* ******************************************************************
+   FSE : Finite State Entropy decoder
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+
+/* **************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include "bitstream.h"
+#include "compiler.h"
+#define FSE_STATIC_LINKING_ONLY
+#include "fse.h"
+#include "error_private.h"
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define FSE_isError ERR_isError
+#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
+
+/* check and forward error code */
+#define CHECK_F(f) { size_t const e = f; if (FSE_isError(e)) return e; }
+
+
+/* **************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSE_FUNCTION_EXTENSION
+#  error "FSE_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSE_FUNCTION_TYPE
+#  error "FSE_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSE_CAT(X,Y) X##Y
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
+
+
+/* Function templates */
+FSE_DTable* FSE_createDTable (unsigned tableLog)
+{
+    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
+    return (FSE_DTable*)malloc( FSE_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
+}
+
+void FSE_freeDTable (FSE_DTable* dt)
+{
+    free(dt);
+}
+
+size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
+
+    U32 const maxSV1 = maxSymbolValue + 1;
+    U32 const tableSize = 1 << tableLog;
+    U32 highThreshold = tableSize-1;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+
+    /* Init, lay down lowprob symbols */
+    {   FSE_DTableHeader DTableH;
+        DTableH.tableLog = (U16)tableLog;
+        DTableH.fastMode = 1;
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
+            U32 s;
+            for (s=0; s<maxSV1; s++) {
+                if (normalizedCounter[s]==-1) {
+                    tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
+                    symbolNext[s] = 1;
+                } else {
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
+                    symbolNext[s] = normalizedCounter[s];
+        }   }   }
+        memcpy(dt, &DTableH, sizeof(DTableH));
+    }
+
+    /* Spread symbols */
+    {   U32 const tableMask = tableSize-1;
+        U32 const step = FSE_TABLESTEP(tableSize);
+        U32 s, position = 0;
+        for (s=0; s<maxSV1; s++) {
+            int i;
+            for (i=0; i<normalizedCounter[s]; i++) {
+                tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
+                position = (position + step) & tableMask;
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }   }
+        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+    }
+
+    /* Build Decoding table */
+    {   U32 u;
+        for (u=0; u<tableSize; u++) {
+            FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol);
+            U32 const nextState = symbolNext[symbol]++;
+            tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
+    }   }
+
+    return 0;
+}
+
+
+#ifndef FSE_COMMONDEFS_ONLY
+
+/*-*******************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSE_decode_t* const cell = (FSE_decode_t*)dPtr;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSV1 = tableMask+1;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<maxSV1; s++) {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+FORCE_INLINE_TEMPLATE size_t FSE_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSE_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    BIT_DStream_t bitD;
+    FSE_DState_t state1;
+    FSE_DState_t state2;
+
+    /* Init */
+    CHECK_F(BIT_initDStream(&bitD, cSrc, cSrcSize));
+
+    FSE_initDState(&state1, &bitD, dt);
+    FSE_initDState(&state2, &bitD, dt);
+
+#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) & (op<olimit) ; op+=4) {
+        op[0] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[1] = FSE_GETSYMBOL(&state2);
+
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[3] = FSE_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
+    while (1) {
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
+        *op++ = FSE_GETSYMBOL(&state1);
+        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
+            *op++ = FSE_GETSYMBOL(&state2);
+            break;
+        }
+
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
+        *op++ = FSE_GETSYMBOL(&state2);
+        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
+            *op++ = FSE_GETSYMBOL(&state1);
+            break;
+    }   }
+
+    return op-ostart;
+}
+
+
+size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSE_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr;
+    const U32 fastMode = DTableH->fastMode;
+
+    /* select fast mode (static) */
+    if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSE_MAX_SYMBOL_VALUE+1];
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+
+    /* normal FSE decoding mode */
+    size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+    if (FSE_isError(NCountLength)) return NCountLength;
+    //if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size; supposed to be already checked in NCountLength, only remaining case : NCountLength==cSrcSize */
+    if (tableLog > maxLog) return ERROR(tableLog_tooLarge);
+    ip += NCountLength;
+    cSrcSize -= NCountLength;
+
+    CHECK_F( FSE_buildDTable (workSpace, counting, maxSymbolValue, tableLog) );
+
+    return FSE_decompress_usingDTable (dst, dstCapacity, ip, cSrcSize, workSpace);   /* always return, even if it is an error code */
+}
+
+
+typedef FSE_DTable DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
+
+size_t FSE_decompress(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize)
+{
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    return FSE_decompress_wksp(dst, dstCapacity, cSrc, cSrcSize, dt, FSE_MAX_TABLELOG);
+}
+
+
+
+#endif   /* FSE_COMMONDEFS_ONLY */
diff --git a/src/h5io.cpp b/src/h5io.cpp
index 742f0ec..945111d 100644
--- a/src/h5io.cpp
+++ b/src/h5io.cpp
@@ -1,7 +1,9 @@
 #include "EigenH5.h"
 //[[depends(RcppEigen)]]
 //[[Rcpp::plugins(cpp11)]]
+#ifdef USE_BLOSC
 #include <blosc_filter.h>
+#endif
 #include <Rcpp.h>
 
 
@@ -18,6 +20,28 @@ size_t closeFileHandle(const std::string fh){
 
 
 
+//[[Rcpp::export]]
+bool has_blosc(){
+  #ifdef USE_BLOSC
+  return true;
+  #else
+  return false;
+  #endif
+}
+
+//[[Rcpp::export]]
+bool has_lzf(){
+  #ifdef USE_LZF
+  return true;
+  #else
+  return false;
+  #endif
+}
+
+
+
+
+
 // [[Rcpp::interfaces(r,cpp)]]
 //[[Rcpp::export]]
 void start_blosc(){
@@ -30,9 +54,11 @@ void start_blosc(){
   Rcpp::LogicalVector bv(1);
   bv[0]=r==1;
   env["..blosc"]=bv;
+#ifdef USE_LZF
   auto rr = register_lzf();
   bv[0]=rr==1;
    env["..lzf"]=bv;
+#endif
   auto nr = register_zstd();
   bv[0]=nr==1;
   env["..zstd"]=bv;
diff --git a/src/hist.c b/src/hist.c
new file mode 100644
index 0000000..45b7bab
--- /dev/null
+++ b/src/hist.c
@@ -0,0 +1,203 @@
+/* ******************************************************************
+   hist : Histogram functions
+   part of Finite State Entropy project
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/* --- dependencies --- */
+#include "mem.h"             /* U32, BYTE, etc. */
+#include "debug.h"           /* assert, DEBUGLOG */
+#include "error_private.h"   /* ERROR */
+#include "hist.h"
+
+
+/* --- Error management --- */
+unsigned HIST_isError(size_t code) { return ERR_isError(code); }
+
+/*-**************************************************************
+ *  Histogram functions
+ ****************************************************************/
+unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
+                           const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* const end = ip + srcSize;
+    unsigned maxSymbolValue = *maxSymbolValuePtr;
+    unsigned largestCount=0;
+
+    memset(count, 0, (maxSymbolValue+1) * sizeof(*count));
+    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }
+
+    while (ip<end) {
+        assert(*ip <= maxSymbolValue);
+        count[*ip++]++;
+    }
+
+    while (!count[maxSymbolValue]) maxSymbolValue--;
+    *maxSymbolValuePtr = maxSymbolValue;
+
+    {   U32 s;
+        for (s=0; s<=maxSymbolValue; s++)
+            if (count[s] > largestCount) largestCount = count[s];
+    }
+
+    return largestCount;
+}
+
+typedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e;
+
+/* HIST_count_parallel_wksp() :
+ * store histogram into 4 intermediate tables, recombined at the end.
+ * this design makes better use of OoO cpus,
+ * and is noticeably faster when some values are heavily repeated.
+ * But it needs some additional workspace for intermediate tables.
+ * `workSpace` size must be a table of size >= HIST_WKSP_SIZE_U32.
+ * @return : largest histogram frequency,
+ *           or an error code (notably when histogram would be larger than *maxSymbolValuePtr). */
+static size_t HIST_count_parallel_wksp(
+                                unsigned* count, unsigned* maxSymbolValuePtr,
+                                const void* source, size_t sourceSize,
+                                HIST_checkInput_e check,
+                                U32* const workSpace)
+{
+    const BYTE* ip = (const BYTE*)source;
+    const BYTE* const iend = ip+sourceSize;
+    unsigned maxSymbolValue = *maxSymbolValuePtr;
+    unsigned max=0;
+    U32* const Counting1 = workSpace;
+    U32* const Counting2 = Counting1 + 256;
+    U32* const Counting3 = Counting2 + 256;
+    U32* const Counting4 = Counting3 + 256;
+
+    memset(workSpace, 0, 4*256*sizeof(unsigned));
+
+    /* safety checks */
+    if (!sourceSize) {
+        memset(count, 0, maxSymbolValue + 1);
+        *maxSymbolValuePtr = 0;
+        return 0;
+    }
+    if (!maxSymbolValue) maxSymbolValue = 255;            /* 0 == default */
+
+    /* by stripes of 16 bytes */
+    {   U32 cached = MEM_read32(ip); ip += 4;
+        while (ip < iend-15) {
+            U32 c = cached; cached = MEM_read32(ip); ip += 4;
+            Counting1[(BYTE) c     ]++;
+            Counting2[(BYTE)(c>>8) ]++;
+            Counting3[(BYTE)(c>>16)]++;
+            Counting4[       c>>24 ]++;
+            c = cached; cached = MEM_read32(ip); ip += 4;
+            Counting1[(BYTE) c     ]++;
+            Counting2[(BYTE)(c>>8) ]++;
+            Counting3[(BYTE)(c>>16)]++;
+            Counting4[       c>>24 ]++;
+            c = cached; cached = MEM_read32(ip); ip += 4;
+            Counting1[(BYTE) c     ]++;
+            Counting2[(BYTE)(c>>8) ]++;
+            Counting3[(BYTE)(c>>16)]++;
+            Counting4[       c>>24 ]++;
+            c = cached; cached = MEM_read32(ip); ip += 4;
+            Counting1[(BYTE) c     ]++;
+            Counting2[(BYTE)(c>>8) ]++;
+            Counting3[(BYTE)(c>>16)]++;
+            Counting4[       c>>24 ]++;
+        }
+        ip-=4;
+    }
+
+    /* finish last symbols */
+    while (ip<iend) Counting1[*ip++]++;
+
+    if (check) {   /* verify stats will fit into destination table */
+        U32 s; for (s=255; s>maxSymbolValue; s--) {
+            Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
+            if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall);
+    }   }
+
+    {   U32 s;
+        if (maxSymbolValue > 255) maxSymbolValue = 255;
+        for (s=0; s<=maxSymbolValue; s++) {
+            count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s];
+            if (count[s] > max) max = count[s];
+    }   }
+
+    while (!count[maxSymbolValue]) maxSymbolValue--;
+    *maxSymbolValuePtr = maxSymbolValue;
+    return (size_t)max;
+}
+
+/* HIST_countFast_wksp() :
+ * Same as HIST_countFast(), but using an externally provided scratch buffer.
+ * `workSpace` is a writable buffer which must be 4-bytes aligned,
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE
+ */
+size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
+                          const void* source, size_t sourceSize,
+                          void* workSpace, size_t workSpaceSize)
+{
+    if (sourceSize < 1500) /* heuristic threshold */
+        return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);
+    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
+    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
+    return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace);
+}
+
+/* fast variant (unsafe : won't check if src contains values beyond count[] limit) */
+size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
+                     const void* source, size_t sourceSize)
+{
+    unsigned tmpCounters[HIST_WKSP_SIZE_U32];
+    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters, sizeof(tmpCounters));
+}
+
+/* HIST_count_wksp() :
+ * Same as HIST_count(), but using an externally provided scratch buffer.
+ * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
+size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
+                       const void* source, size_t sourceSize,
+                       void* workSpace, size_t workSpaceSize)
+{
+    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
+    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
+    if (*maxSymbolValuePtr < 255)
+        return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace);
+    *maxSymbolValuePtr = 255;
+    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize);
+}
+
+size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
+                 const void* src, size_t srcSize)
+{
+    unsigned tmpCounters[HIST_WKSP_SIZE_U32];
+    return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters, sizeof(tmpCounters));
+}
diff --git a/src/hist.h b/src/hist.h
new file mode 100644
index 0000000..8b38935
--- /dev/null
+++ b/src/hist.h
@@ -0,0 +1,95 @@
+/* ******************************************************************
+   hist : Histogram functions
+   part of Finite State Entropy project
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/* --- dependencies --- */
+#include <stddef.h>   /* size_t */
+
+
+/* --- simple histogram functions --- */
+
+/*! HIST_count():
+ *  Provides the precise count of each byte within a table 'count'.
+ * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
+ *  Updates *maxSymbolValuePtr with actual largest symbol value detected.
+ * @return : count of the most frequent symbol (which isn't identified).
+ *           or an error code, which can be tested using HIST_isError().
+ *           note : if return == srcSize, there is only one symbol.
+ */
+size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
+                  const void* src, size_t srcSize);
+
+unsigned HIST_isError(size_t code);  /**< tells if a return value is an error code */
+
+
+/* --- advanced histogram functions --- */
+
+#define HIST_WKSP_SIZE_U32 1024
+#define HIST_WKSP_SIZE    (HIST_WKSP_SIZE_U32 * sizeof(unsigned))
+/** HIST_count_wksp() :
+ *  Same as HIST_count(), but using an externally provided scratch buffer.
+ *  Benefit is this function will use very little stack space.
+ * `workSpace` is a writable buffer which must be 4-bytes aligned,
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE
+ */
+size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
+                       const void* src, size_t srcSize,
+                       void* workSpace, size_t workSpaceSize);
+
+/** HIST_countFast() :
+ *  same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr.
+ *  This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr`
+ */
+size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
+                      const void* src, size_t srcSize);
+
+/** HIST_countFast_wksp() :
+ *  Same as HIST_countFast(), but using an externally provided scratch buffer.
+ * `workSpace` is a writable buffer which must be 4-bytes aligned,
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE
+ */
+size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
+                           const void* src, size_t srcSize,
+                           void* workSpace, size_t workSpaceSize);
+
+/*! HIST_count_simple() :
+ *  Same as HIST_countFast(), this function is unsafe,
+ *  and will segfault if any value within `src` is `> *maxSymbolValuePtr`.
+ *  It is also a bit slower for large inputs.
+ *  However, it does not need any additional memory (not even on stack).
+ * @return : count of the most frequent symbol.
+ *  Note this function doesn't produce any error (i.e. it must succeed).
+ */
+unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
+                           const void* src, size_t srcSize);
diff --git a/src/huf.h b/src/huf.h
new file mode 100644
index 0000000..6b572c4
--- /dev/null
+++ b/src/huf.h
@@ -0,0 +1,358 @@
+/* ******************************************************************
+   huff0 huffman codec,
+   part of Finite State Entropy library
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef HUF_H_298734234
+#define HUF_H_298734234
+
+/* *** Dependencies *** */
+#include <stddef.h>    /* size_t */
+
+
+/* *** library symbols visibility *** */
+/* Note : when linking with -fvisibility=hidden on gcc, or by default on Visual,
+ *        HUF symbols remain "private" (internal symbols for library only).
+ *        Set macro FSE_DLL_EXPORT to 1 if you want HUF symbols visible on DLL interface */
+#if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)
+#  define HUF_PUBLIC_API __attribute__ ((visibility ("default")))
+#elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1)   /* Visual expected */
+#  define HUF_PUBLIC_API __declspec(dllexport)
+#elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)
+#  define HUF_PUBLIC_API __declspec(dllimport)  /* not required, just to generate faster code (saves a function pointer load from IAT and an indirect jump) */
+#else
+#  define HUF_PUBLIC_API
+#endif
+
+
+/* ========================== */
+/* ***  simple functions  *** */
+/* ========================== */
+
+/** HUF_compress() :
+ *  Compress content from buffer 'src', of size 'srcSize', into buffer 'dst'.
+ * 'dst' buffer must be already allocated.
+ *  Compression runs faster if `dstCapacity` >= HUF_compressBound(srcSize).
+ * `srcSize` must be <= `HUF_BLOCKSIZE_MAX` == 128 KB.
+ * @return : size of compressed data (<= `dstCapacity`).
+ *  Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
+ *                   if HUF_isError(return), compression failed (more details using HUF_getErrorName())
+ */
+HUF_PUBLIC_API size_t HUF_compress(void* dst, size_t dstCapacity,
+                             const void* src, size_t srcSize);
+
+/** HUF_decompress() :
+ *  Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
+ *  into already allocated buffer 'dst', of minimum size 'dstSize'.
+ * `originalSize` : **must** be the ***exact*** size of original (uncompressed) data.
+ *  Note : in contrast with FSE, HUF_decompress can regenerate
+ *         RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
+ *         because it knows size to regenerate (originalSize).
+ * @return : size of regenerated data (== originalSize),
+ *           or an error code, which can be tested using HUF_isError()
+ */
+HUF_PUBLIC_API size_t HUF_decompress(void* dst,  size_t originalSize,
+                               const void* cSrc, size_t cSrcSize);
+
+
+/* ***   Tool functions *** */
+#define HUF_BLOCKSIZE_MAX (128 * 1024)                  /**< maximum input size for a single block compressed with HUF_compress */
+HUF_PUBLIC_API size_t HUF_compressBound(size_t size);   /**< maximum compressed size (worst case) */
+
+/* Error Management */
+HUF_PUBLIC_API unsigned    HUF_isError(size_t code);       /**< tells if a return value is an error code */
+HUF_PUBLIC_API const char* HUF_getErrorName(size_t code);  /**< provides error code string (useful for debugging) */
+
+
+/* ***   Advanced function   *** */
+
+/** HUF_compress2() :
+ *  Same as HUF_compress(), but offers control over `maxSymbolValue` and `tableLog`.
+ * `maxSymbolValue` must be <= HUF_SYMBOLVALUE_MAX .
+ * `tableLog` must be `<= HUF_TABLELOG_MAX` . */
+HUF_PUBLIC_API size_t HUF_compress2 (void* dst, size_t dstCapacity,
+                               const void* src, size_t srcSize,
+                               unsigned maxSymbolValue, unsigned tableLog);
+
+/** HUF_compress4X_wksp() :
+ *  Same as HUF_compress2(), but uses externally allocated `workSpace`.
+ * `workspace` must have minimum alignment of 4, and be at least as large as HUF_WORKSPACE_SIZE */
+#define HUF_WORKSPACE_SIZE (6 << 10)
+#define HUF_WORKSPACE_SIZE_U32 (HUF_WORKSPACE_SIZE / sizeof(U32))
+HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
+                                     const void* src, size_t srcSize,
+                                     unsigned maxSymbolValue, unsigned tableLog,
+                                     void* workSpace, size_t wkspSize);
+
+#endif   /* HUF_H_298734234 */
+
+/* ******************************************************************
+ *  WARNING !!
+ *  The following section contains advanced and experimental definitions
+ *  which shall never be used in the context of a dynamic library,
+ *  because they are not guaranteed to remain stable in the future.
+ *  Only consider them in association with static linking.
+ * *****************************************************************/
+#if defined(HUF_STATIC_LINKING_ONLY) && !defined(HUF_H_HUF_STATIC_LINKING_ONLY)
+#define HUF_H_HUF_STATIC_LINKING_ONLY
+
+/* *** Dependencies *** */
+#include "mem.h"   /* U32 */
+
+
+/* *** Constants *** */
+#define HUF_TABLELOG_MAX      12      /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
+#define HUF_TABLELOG_DEFAULT  11      /* default tableLog value when none specified */
+#define HUF_SYMBOLVALUE_MAX  255
+
+#define HUF_TABLELOG_ABSOLUTEMAX  15  /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
+#if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX)
+#  error "HUF_TABLELOG_MAX is too large !"
+#endif
+
+
+/* ****************************************
+*  Static allocation
+******************************************/
+/* HUF buffer bounds */
+#define HUF_CTABLEBOUND 129
+#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true when incompressible is pre-filtered with fast heuristic */
+#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* static allocation of HUF's Compression Table */
+#define HUF_CTABLE_SIZE_U32(maxSymbolValue)   ((maxSymbolValue)+1)   /* Use tables of U32, for proper alignment */
+#define HUF_CTABLE_SIZE(maxSymbolValue)       (HUF_CTABLE_SIZE_U32(maxSymbolValue) * sizeof(U32))
+#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \
+    U32 name##hb[HUF_CTABLE_SIZE_U32(maxSymbolValue)]; \
+    void* name##hv = &(name##hb); \
+    HUF_CElt* name = (HUF_CElt*)(name##hv)   /* no final ; */
+
+/* static allocation of HUF's DTable */
+typedef U32 HUF_DTable;
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
+#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
+        HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+        HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
+
+
+/* ****************************************
+*  Advanced decompression functions
+******************************************/
+size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
+#ifndef HUF_FORCE_DECOMPRESS_X1
+size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
+#endif
+
+size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< decodes RLE and uncompressed */
+size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
+size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< considers RLE and uncompressed as errors */
+size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
+size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);   /**< single-symbol decoder */
+#ifndef HUF_FORCE_DECOMPRESS_X1
+size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
+size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);   /**< double-symbols decoder */
+#endif
+
+
+/* ****************************************
+ *  HUF detailed API
+ * ****************************************/
+
+/*! HUF_compress() does the following:
+ *  1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h")
+ *  2. (optional) refine tableLog using HUF_optimalTableLog()
+ *  3. build Huffman table from count using HUF_buildCTable()
+ *  4. save Huffman table to memory buffer using HUF_writeCTable()
+ *  5. encode the data stream using HUF_compress4X_usingCTable()
+ *
+ *  The following API allows targeting specific sub-functions for advanced tasks.
+ *  For example, it's possible to compress several blocks using the same 'CTable',
+ *  or to save and regenerate 'CTable' using external methods.
+ */
+unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
+typedef struct HUF_CElt_s HUF_CElt;   /* incomplete type */
+size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits);   /* @return : maxNbBits; CTable and count can overlap. In which case, CTable will overwrite count content */
+size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
+size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
+
+typedef enum {
+   HUF_repeat_none,  /**< Cannot use the previous table */
+   HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */
+   HUF_repeat_valid  /**< Can use the previous table and it is assumed to be valid */
+ } HUF_repeat;
+/** HUF_compress4X_repeat() :
+ *  Same as HUF_compress4X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
+ *  If it uses hufTable it does not modify hufTable or repeat.
+ *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
+ *  If preferRepeat then the old table will always be used if valid. */
+size_t HUF_compress4X_repeat(void* dst, size_t dstSize,
+                       const void* src, size_t srcSize,
+                       unsigned maxSymbolValue, unsigned tableLog,
+                       void* workSpace, size_t wkspSize,    /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
+                       HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2);
+
+/** HUF_buildCTable_wksp() :
+ *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
+ * `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE.
+ */
+#define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1)
+#define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))
+size_t HUF_buildCTable_wksp (HUF_CElt* tree,
+                       const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
+                             void* workSpace, size_t wkspSize);
+
+/*! HUF_readStats() :
+ *  Read compact Huffman tree, saved by HUF_writeCTable().
+ * `huffWeight` is destination buffer.
+ * @return : size read from `src` , or an error Code .
+ *  Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
+size_t HUF_readStats(BYTE* huffWeight, size_t hwSize,
+                     U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,
+                     const void* src, size_t srcSize);
+
+/** HUF_readCTable() :
+ *  Loading a CTable saved with HUF_writeCTable() */
+size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize);
+
+/** HUF_getNbBits() :
+ *  Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX
+ *  Note 1 : is not inlined, as HUF_CElt definition is private
+ *  Note 2 : const void* used, so that it can provide a statically allocated table as argument (which uses type U32) */
+U32 HUF_getNbBits(const void* symbolTable, U32 symbolValue);
+
+/*
+ * HUF_decompress() does the following:
+ * 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics
+ * 2. build Huffman table from save, using HUF_readDTableX?()
+ * 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable()
+ */
+
+/** HUF_selectDecoder() :
+ *  Tells which decoder is likely to decode faster,
+ *  based on a set of pre-computed metrics.
+ * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
+ *  Assumption : 0 < dstSize <= 128 KB */
+U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);
+
+/**
+ *  The minimum workspace size for the `workSpace` used in
+ *  HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp().
+ *
+ *  The space used depends on HUF_TABLELOG_MAX, ranging from ~1500 bytes when
+ *  HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15.
+ *  Buffer overflow errors may potentially occur if code modifications result in
+ *  a required workspace size greater than that specified in the following
+ *  macro.
+ */
+#define HUF_DECOMPRESS_WORKSPACE_SIZE (2 << 10)
+#define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))
+
+#ifndef HUF_FORCE_DECOMPRESS_X2
+size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize);
+size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
+size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
+size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
+#endif
+
+size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+#ifndef HUF_FORCE_DECOMPRESS_X2
+size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
+size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+#endif
+
+
+/* ====================== */
+/* single stream variants */
+/* ====================== */
+
+size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
+size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);  /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
+size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
+/** HUF_compress1X_repeat() :
+ *  Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
+ *  If it uses hufTable it does not modify hufTable or repeat.
+ *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.
+ *  If preferRepeat then the old table will always be used if valid. */
+size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
+                       const void* src, size_t srcSize,
+                       unsigned maxSymbolValue, unsigned tableLog,
+                       void* workSpace, size_t wkspSize,   /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
+                       HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2);
+
+size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+#ifndef HUF_FORCE_DECOMPRESS_X1
+size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
+#endif
+
+size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);
+#ifndef HUF_FORCE_DECOMPRESS_X2
+size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
+size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);   /**< single-symbol decoder */
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
+size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
+size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);   /**< double-symbols decoder */
+#endif
+
+size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);   /**< automatic selection of sing or double symbol decoder, based on DTable */
+#ifndef HUF_FORCE_DECOMPRESS_X2
+size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+#endif
+#ifndef HUF_FORCE_DECOMPRESS_X1
+size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+#endif
+
+/* BMI2 variants.
+ * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
+ */
+size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
+#ifndef HUF_FORCE_DECOMPRESS_X2
+size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);
+#endif
+size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
+size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2);
+
+#endif /* HUF_STATIC_LINKING_ONLY */
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/src/huf_compress.c b/src/huf_compress.c
new file mode 100644
index 0000000..f074f1e
--- /dev/null
+++ b/src/huf_compress.c
@@ -0,0 +1,798 @@
+/* ******************************************************************
+   Huffman encoder, part of New Generation Entropy library
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#endif
+
+
+/* **************************************************************
+*  Includes
+****************************************************************/
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+#include "compiler.h"
+#include "bitstream.h"
+#include "hist.h"
+#define FSE_STATIC_LINKING_ONLY   /* FSE_optimalTableLog_internal */
+#include "fse.h"        /* header compression */
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
+#include "error_private.h"
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define HUF_isError ERR_isError
+#define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
+#define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
+
+
+/* **************************************************************
+*  Utils
+****************************************************************/
+unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
+{
+    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1);
+}
+
+
+/* *******************************************************
+*  HUF : Huffman block compression
+*********************************************************/
+/* HUF_compressWeights() :
+ * Same as FSE_compress(), but dedicated to huff0's weights compression.
+ * The use case needs much less stack memory.
+ * Note : all elements within weightTable are supposed to be <= HUF_TABLELOG_MAX.
+ */
+#define MAX_FSE_TABLELOG_FOR_HUFF_HEADER 6
+static size_t HUF_compressWeights (void* dst, size_t dstSize, const void* weightTable, size_t wtSize)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + dstSize;
+
+    unsigned maxSymbolValue = HUF_TABLELOG_MAX;
+    U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER;
+
+    FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER, HUF_TABLELOG_MAX)];
+    BYTE scratchBuffer[1<<MAX_FSE_TABLELOG_FOR_HUFF_HEADER];
+
+    unsigned count[HUF_TABLELOG_MAX+1];
+    S16 norm[HUF_TABLELOG_MAX+1];
+
+    /* init conditions */
+    if (wtSize <= 1) return 0;  /* Not compressible */
+
+    /* Scan input and build symbol stats */
+    {   unsigned const maxCount = HIST_count_simple(count, &maxSymbolValue, weightTable, wtSize);   /* never fails */
+        if (maxCount == wtSize) return 1;   /* only a single symbol in src : rle */
+        if (maxCount == 1) return 0;        /* each symbol present maximum once => not compressible */
+    }
+
+    tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue);
+    CHECK_F( FSE_normalizeCount(norm, tableLog, count, wtSize, maxSymbolValue) );
+
+    /* Write table description header */
+    {   CHECK_V_F(hSize, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) );
+        op += hSize;
+    }
+
+    /* Compress */
+    CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, sizeof(scratchBuffer)) );
+    {   CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, weightTable, wtSize, CTable) );
+        if (cSize == 0) return 0;   /* not enough space for compressed data */
+        op += cSize;
+    }
+
+    return op-ostart;
+}
+
+
+struct HUF_CElt_s {
+  U16  val;
+  BYTE nbBits;
+};   /* typedef'd to HUF_CElt within "huf.h" */
+
+/*! HUF_writeCTable() :
+    `CTable` : Huffman tree to save, using huf representation.
+    @return : size of saved CTable */
+size_t HUF_writeCTable (void* dst, size_t maxDstSize,
+                        const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog)
+{
+    BYTE bitsToWeight[HUF_TABLELOG_MAX + 1];   /* precomputed conversion table */
+    BYTE huffWeight[HUF_SYMBOLVALUE_MAX];
+    BYTE* op = (BYTE*)dst;
+    U32 n;
+
+     /* check conditions */
+    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
+
+    /* convert to weight */
+    bitsToWeight[0] = 0;
+    for (n=1; n<huffLog+1; n++)
+        bitsToWeight[n] = (BYTE)(huffLog + 1 - n);
+    for (n=0; n<maxSymbolValue; n++)
+        huffWeight[n] = bitsToWeight[CTable[n].nbBits];
+
+    /* attempt weights compression by FSE */
+    {   CHECK_V_F(hSize, HUF_compressWeights(op+1, maxDstSize-1, huffWeight, maxSymbolValue) );
+        if ((hSize>1) & (hSize < maxSymbolValue/2)) {   /* FSE compressed */
+            op[0] = (BYTE)hSize;
+            return hSize+1;
+    }   }
+
+    /* write raw values as 4-bits (max : 15) */
+    if (maxSymbolValue > (256-128)) return ERROR(GENERIC);   /* should not happen : likely means source cannot be compressed */
+    if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */
+    op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1));
+    huffWeight[maxSymbolValue] = 0;   /* to be sure it doesn't cause msan issue in final combination */
+    for (n=0; n<maxSymbolValue; n+=2)
+        op[(n/2)+1] = (BYTE)((huffWeight[n] << 4) + huffWeight[n+1]);
+    return ((maxSymbolValue+1)/2) + 1;
+}
+
+
+size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];   /* init not required, even though some static analyzer may complain */
+    U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */
+    U32 tableLog = 0;
+    U32 nbSymbols = 0;
+
+    /* get symbol weights */
+    CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize));
+
+    /* check result */
+    if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
+    if (nbSymbols > *maxSymbolValuePtr+1) return ERROR(maxSymbolValue_tooSmall);
+
+    /* Prepare base value per rank */
+    {   U32 n, nextRankStart = 0;
+        for (n=1; n<=tableLog; n++) {
+            U32 current = nextRankStart;
+            nextRankStart += (rankVal[n] << (n-1));
+            rankVal[n] = current;
+    }   }
+
+    /* fill nbBits */
+    {   U32 n; for (n=0; n<nbSymbols; n++) {
+            const U32 w = huffWeight[n];
+            CTable[n].nbBits = (BYTE)(tableLog + 1 - w);
+    }   }
+
+    /* fill val */
+    {   U16 nbPerRank[HUF_TABLELOG_MAX+2]  = {0};  /* support w=0=>n=tableLog+1 */
+        U16 valPerRank[HUF_TABLELOG_MAX+2] = {0};
+        { U32 n; for (n=0; n<nbSymbols; n++) nbPerRank[CTable[n].nbBits]++; }
+        /* determine stating value per rank */
+        valPerRank[tableLog+1] = 0;   /* for w==0 */
+        {   U16 min = 0;
+            U32 n; for (n=tableLog; n>0; n--) {  /* start at n=tablelog <-> w=1 */
+                valPerRank[n] = min;     /* get starting value within each rank */
+                min += nbPerRank[n];
+                min >>= 1;
+        }   }
+        /* assign value within rank, symbol order */
+        { U32 n; for (n=0; n<nbSymbols; n++) CTable[n].val = valPerRank[CTable[n].nbBits]++; }
+    }
+
+    *maxSymbolValuePtr = nbSymbols - 1;
+    return readSize;
+}
+
+U32 HUF_getNbBits(const void* symbolTable, U32 symbolValue)
+{
+    const HUF_CElt* table = (const HUF_CElt*)symbolTable;
+    assert(symbolValue <= HUF_SYMBOLVALUE_MAX);
+    return table[symbolValue].nbBits;
+}
+
+
+typedef struct nodeElt_s {
+    U32 count;
+    U16 parent;
+    BYTE byte;
+    BYTE nbBits;
+} nodeElt;
+
+static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 maxNbBits)
+{
+    const U32 largestBits = huffNode[lastNonNull].nbBits;
+    if (largestBits <= maxNbBits) return largestBits;   /* early exit : no elt > maxNbBits */
+
+    /* there are several too large elements (at least >= 2) */
+    {   int totalCost = 0;
+        const U32 baseCost = 1 << (largestBits - maxNbBits);
+        U32 n = lastNonNull;
+
+        while (huffNode[n].nbBits > maxNbBits) {
+            totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits));
+            huffNode[n].nbBits = (BYTE)maxNbBits;
+            n --;
+        }  /* n stops at huffNode[n].nbBits <= maxNbBits */
+        while (huffNode[n].nbBits == maxNbBits) n--;   /* n end at index of smallest symbol using < maxNbBits */
+
+        /* renorm totalCost */
+        totalCost >>= (largestBits - maxNbBits);  /* note : totalCost is necessarily a multiple of baseCost */
+
+        /* repay normalized cost */
+        {   U32 const noSymbol = 0xF0F0F0F0;
+            U32 rankLast[HUF_TABLELOG_MAX+2];
+            int pos;
+
+            /* Get pos of last (smallest) symbol per rank */
+            memset(rankLast, 0xF0, sizeof(rankLast));
+            {   U32 currentNbBits = maxNbBits;
+                for (pos=n ; pos >= 0; pos--) {
+                    if (huffNode[pos].nbBits >= currentNbBits) continue;
+                    currentNbBits = huffNode[pos].nbBits;   /* < maxNbBits */
+                    rankLast[maxNbBits-currentNbBits] = pos;
+            }   }
+
+            while (totalCost > 0) {
+                U32 nBitsToDecrease = BIT_highbit32(totalCost) + 1;
+                for ( ; nBitsToDecrease > 1; nBitsToDecrease--) {
+                    U32 highPos = rankLast[nBitsToDecrease];
+                    U32 lowPos = rankLast[nBitsToDecrease-1];
+                    if (highPos == noSymbol) continue;
+                    if (lowPos == noSymbol) break;
+                    {   U32 const highTotal = huffNode[highPos].count;
+                        U32 const lowTotal = 2 * huffNode[lowPos].count;
+                        if (highTotal <= lowTotal) break;
+                }   }
+                /* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */
+                /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
+                while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))
+                    nBitsToDecrease ++;
+                totalCost -= 1 << (nBitsToDecrease-1);
+                if (rankLast[nBitsToDecrease-1] == noSymbol)
+                    rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease];   /* this rank is no longer empty */
+                huffNode[rankLast[nBitsToDecrease]].nbBits ++;
+                if (rankLast[nBitsToDecrease] == 0)    /* special case, reached largest symbol */
+                    rankLast[nBitsToDecrease] = noSymbol;
+                else {
+                    rankLast[nBitsToDecrease]--;
+                    if (huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits-nBitsToDecrease)
+                        rankLast[nBitsToDecrease] = noSymbol;   /* this rank is now empty */
+            }   }   /* while (totalCost > 0) */
+
+            while (totalCost < 0) {  /* Sometimes, cost correction overshoot */
+                if (rankLast[1] == noSymbol) {  /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */
+                    while (huffNode[n].nbBits == maxNbBits) n--;
+                    huffNode[n+1].nbBits--;
+                    rankLast[1] = n+1;
+                    totalCost++;
+                    continue;
+                }
+                huffNode[ rankLast[1] + 1 ].nbBits--;
+                rankLast[1]++;
+                totalCost ++;
+    }   }   }   /* there are several too large elements (at least >= 2) */
+
+    return maxNbBits;
+}
+
+
+typedef struct {
+    U32 base;
+    U32 current;
+} rankPos;
+
+static void HUF_sort(nodeElt* huffNode, const unsigned* count, U32 maxSymbolValue)
+{
+    rankPos rank[32];
+    U32 n;
+
+    memset(rank, 0, sizeof(rank));
+    for (n=0; n<=maxSymbolValue; n++) {
+        U32 r = BIT_highbit32(count[n] + 1);
+        rank[r].base ++;
+    }
+    for (n=30; n>0; n--) rank[n-1].base += rank[n].base;
+    for (n=0; n<32; n++) rank[n].current = rank[n].base;
+    for (n=0; n<=maxSymbolValue; n++) {
+        U32 const c = count[n];
+        U32 const r = BIT_highbit32(c+1) + 1;
+        U32 pos = rank[r].current++;
+        while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) {
+            huffNode[pos] = huffNode[pos-1];
+            pos--;
+        }
+        huffNode[pos].count = c;
+        huffNode[pos].byte  = (BYTE)n;
+    }
+}
+
+
+/** HUF_buildCTable_wksp() :
+ *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
+ *  `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a table of HUF_CTABLE_WORKSPACE_SIZE_U32 unsigned.
+ */
+#define STARTNODE (HUF_SYMBOLVALUE_MAX+1)
+typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32];
+size_t HUF_buildCTable_wksp (HUF_CElt* tree, const unsigned* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize)
+{
+    nodeElt* const huffNode0 = (nodeElt*)workSpace;
+    nodeElt* const huffNode = huffNode0+1;
+    U32 n, nonNullRank;
+    int lowS, lowN;
+    U16 nodeNb = STARTNODE;
+    U32 nodeRoot;
+
+    /* safety checks */
+    if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
+    if (wkspSize < sizeof(huffNodeTable)) return ERROR(workSpace_tooSmall);
+    if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT;
+    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
+    memset(huffNode0, 0, sizeof(huffNodeTable));
+
+    /* sort, decreasing order */
+    HUF_sort(huffNode, count, maxSymbolValue);
+
+    /* init for parents */
+    nonNullRank = maxSymbolValue;
+    while(huffNode[nonNullRank].count == 0) nonNullRank--;
+    lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb;
+    huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count;
+    huffNode[lowS].parent = huffNode[lowS-1].parent = nodeNb;
+    nodeNb++; lowS-=2;
+    for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);
+    huffNode0[0].count = (U32)(1U<<31);  /* fake entry, strong barrier */
+
+    /* create parents */
+    while (nodeNb <= nodeRoot) {
+        U32 n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
+        U32 n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
+        huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count;
+        huffNode[n1].parent = huffNode[n2].parent = nodeNb;
+        nodeNb++;
+    }
+
+    /* distribute weights (unlimited tree height) */
+    huffNode[nodeRoot].nbBits = 0;
+    for (n=nodeRoot-1; n>=STARTNODE; n--)
+        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
+    for (n=0; n<=nonNullRank; n++)
+        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
+
+    /* enforce maxTableLog */
+    maxNbBits = HUF_setMaxHeight(huffNode, nonNullRank, maxNbBits);
+
+    /* fill result into tree (val, nbBits) */
+    {   U16 nbPerRank[HUF_TABLELOG_MAX+1] = {0};
+        U16 valPerRank[HUF_TABLELOG_MAX+1] = {0};
+        if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC);   /* check fit into table */
+        for (n=0; n<=nonNullRank; n++)
+            nbPerRank[huffNode[n].nbBits]++;
+        /* determine stating value per rank */
+        {   U16 min = 0;
+            for (n=maxNbBits; n>0; n--) {
+                valPerRank[n] = min;      /* get starting value within each rank */
+                min += nbPerRank[n];
+                min >>= 1;
+        }   }
+        for (n=0; n<=maxSymbolValue; n++)
+            tree[huffNode[n].byte].nbBits = huffNode[n].nbBits;   /* push nbBits per symbol, symbol order */
+        for (n=0; n<=maxSymbolValue; n++)
+            tree[n].val = valPerRank[tree[n].nbBits]++;   /* assign value within rank, symbol order */
+    }
+
+    return maxNbBits;
+}
+
+/** HUF_buildCTable() :
+ * @return : maxNbBits
+ *  Note : count is used before tree is written, so they can safely overlap
+ */
+size_t HUF_buildCTable (HUF_CElt* tree, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits)
+{
+    huffNodeTable nodeTable;
+    return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable));
+}
+
+static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
+{
+    size_t nbBits = 0;
+    int s;
+    for (s = 0; s <= (int)maxSymbolValue; ++s) {
+        nbBits += CTable[s].nbBits * count[s];
+    }
+    return nbBits >> 3;
+}
+
+static int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {
+  int bad = 0;
+  int s;
+  for (s = 0; s <= (int)maxSymbolValue; ++s) {
+    bad |= (count[s] != 0) & (CTable[s].nbBits == 0);
+  }
+  return !bad;
+}
+
+size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }
+
+FORCE_INLINE_TEMPLATE void
+HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable)
+{
+    BIT_addBitsFast(bitCPtr, CTable[symbol].val, CTable[symbol].nbBits);
+}
+
+#define HUF_FLUSHBITS(s)  BIT_flushBits(s)
+
+#define HUF_FLUSHBITS_1(stream) \
+    if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*2+7) HUF_FLUSHBITS(stream)
+
+#define HUF_FLUSHBITS_2(stream) \
+    if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*4+7) HUF_FLUSHBITS(stream)
+
+FORCE_INLINE_TEMPLATE size_t
+HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
+                                   const void* src, size_t srcSize,
+                                   const HUF_CElt* CTable)
+{
+    const BYTE* ip = (const BYTE*) src;
+    BYTE* const ostart = (BYTE*)dst;
+    BYTE* const oend = ostart + dstSize;
+    BYTE* op = ostart;
+    size_t n;
+    BIT_CStream_t bitC;
+
+    /* init */
+    if (dstSize < 8) return 0;   /* not enough space to compress */
+    { size_t const initErr = BIT_initCStream(&bitC, op, oend-op);
+      if (HUF_isError(initErr)) return 0; }
+
+    n = srcSize & ~3;  /* join to mod 4 */
+    switch (srcSize & 3)
+    {
+        case 3 : HUF_encodeSymbol(&bitC, ip[n+ 2], CTable);
+                 HUF_FLUSHBITS_2(&bitC);
+		 /* fall-through */
+        case 2 : HUF_encodeSymbol(&bitC, ip[n+ 1], CTable);
+                 HUF_FLUSHBITS_1(&bitC);
+		 /* fall-through */
+        case 1 : HUF_encodeSymbol(&bitC, ip[n+ 0], CTable);
+                 HUF_FLUSHBITS(&bitC);
+		 /* fall-through */
+        case 0 : /* fall-through */
+        default: break;
+    }
+
+    for (; n>0; n-=4) {  /* note : n&3==0 at this stage */
+        HUF_encodeSymbol(&bitC, ip[n- 1], CTable);
+        HUF_FLUSHBITS_1(&bitC);
+        HUF_encodeSymbol(&bitC, ip[n- 2], CTable);
+        HUF_FLUSHBITS_2(&bitC);
+        HUF_encodeSymbol(&bitC, ip[n- 3], CTable);
+        HUF_FLUSHBITS_1(&bitC);
+        HUF_encodeSymbol(&bitC, ip[n- 4], CTable);
+        HUF_FLUSHBITS(&bitC);
+    }
+
+    return BIT_closeCStream(&bitC);
+}
+
+#if DYNAMIC_BMI2
+
+static TARGET_ATTRIBUTE("bmi2") size_t
+HUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize,
+                                   const void* src, size_t srcSize,
+                                   const HUF_CElt* CTable)
+{
+    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
+}
+
+static size_t
+HUF_compress1X_usingCTable_internal_default(void* dst, size_t dstSize,
+                                      const void* src, size_t srcSize,
+                                      const HUF_CElt* CTable)
+{
+    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
+}
+
+static size_t
+HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
+                              const void* src, size_t srcSize,
+                              const HUF_CElt* CTable, const int bmi2)
+{
+    if (bmi2) {
+        return HUF_compress1X_usingCTable_internal_bmi2(dst, dstSize, src, srcSize, CTable);
+    }
+    return HUF_compress1X_usingCTable_internal_default(dst, dstSize, src, srcSize, CTable);
+}
+
+#else
+
+static size_t
+HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,
+                              const void* src, size_t srcSize,
+                              const HUF_CElt* CTable, const int bmi2)
+{
+    (void)bmi2;
+    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
+}
+
+#endif
+
+size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
+{
+    return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
+}
+
+
+static size_t
+HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
+                              const void* src, size_t srcSize,
+                              const HUF_CElt* CTable, int bmi2)
+{
+    size_t const segmentSize = (srcSize+3)/4;   /* first 3 segments */
+    const BYTE* ip = (const BYTE*) src;
+    const BYTE* const iend = ip + srcSize;
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* const oend = ostart + dstSize;
+    BYTE* op = ostart;
+
+    if (dstSize < 6 + 1 + 1 + 1 + 8) return 0;   /* minimum space to compress successfully */
+    if (srcSize < 12) return 0;   /* no saving possible : too small input */
+    op += 6;   /* jumpTable */
+
+    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) );
+        if (cSize==0) return 0;
+        assert(cSize <= 65535);
+        MEM_writeLE16(ostart, (U16)cSize);
+        op += cSize;
+    }
+
+    ip += segmentSize;
+    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) );
+        if (cSize==0) return 0;
+        assert(cSize <= 65535);
+        MEM_writeLE16(ostart+2, (U16)cSize);
+        op += cSize;
+    }
+
+    ip += segmentSize;
+    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) );
+        if (cSize==0) return 0;
+        assert(cSize <= 65535);
+        MEM_writeLE16(ostart+4, (U16)cSize);
+        op += cSize;
+    }
+
+    ip += segmentSize;
+    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, iend-ip, CTable, bmi2) );
+        if (cSize==0) return 0;
+        op += cSize;
+    }
+
+    return op-ostart;
+}
+
+size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
+{
+    return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
+}
+
+typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;
+
+static size_t HUF_compressCTable_internal(
+                BYTE* const ostart, BYTE* op, BYTE* const oend,
+                const void* src, size_t srcSize,
+                HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2)
+{
+    size_t const cSize = (nbStreams==HUF_singleStream) ?
+                         HUF_compress1X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2) :
+                         HUF_compress4X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2);
+    if (HUF_isError(cSize)) { return cSize; }
+    if (cSize==0) { return 0; }   /* uncompressible */
+    op += cSize;
+    /* check compressibility */
+    if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
+    return op-ostart;
+}
+
+typedef struct {
+    unsigned count[HUF_SYMBOLVALUE_MAX + 1];
+    HUF_CElt CTable[HUF_SYMBOLVALUE_MAX + 1];
+    huffNodeTable nodeTable;
+} HUF_compress_tables_t;
+
+/* HUF_compress_internal() :
+ * `workSpace` must a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */
+static size_t
+HUF_compress_internal (void* dst, size_t dstSize,
+                 const void* src, size_t srcSize,
+                       unsigned maxSymbolValue, unsigned huffLog,
+                       HUF_nbStreams_e nbStreams,
+                       void* workSpace, size_t wkspSize,
+                       HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
+                 const int bmi2)
+{
+    HUF_compress_tables_t* const table = (HUF_compress_tables_t*)workSpace;
+    BYTE* const ostart = (BYTE*)dst;
+    BYTE* const oend = ostart + dstSize;
+    BYTE* op = ostart;
+
+    /* checks & inits */
+    if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
+    if (wkspSize < HUF_WORKSPACE_SIZE) return ERROR(workSpace_tooSmall);
+    if (!srcSize) return 0;  /* Uncompressed */
+    if (!dstSize) return 0;  /* cannot fit anything within dst budget */
+    if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);   /* current block size limit */
+    if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
+    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
+    if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;
+    if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;
+
+    /* Heuristic : If old table is valid, use it for small inputs */
+    if (preferRepeat && repeat && *repeat == HUF_repeat_valid) {
+        return HUF_compressCTable_internal(ostart, op, oend,
+                                           src, srcSize,
+                                           nbStreams, oldHufTable, bmi2);
+    }
+
+    /* Scan input and build symbol stats */
+    {   CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, workSpace, wkspSize) );
+        if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }   /* single symbol, rle */
+        if (largest <= (srcSize >> 7)+4) return 0;   /* heuristic : probably not compressible enough */
+    }
+
+    /* Check validity of previous table */
+    if ( repeat
+      && *repeat == HUF_repeat_check
+      && !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) {
+        *repeat = HUF_repeat_none;
+    }
+    /* Heuristic : use existing table for small inputs */
+    if (preferRepeat && repeat && *repeat != HUF_repeat_none) {
+        return HUF_compressCTable_internal(ostart, op, oend,
+                                           src, srcSize,
+                                           nbStreams, oldHufTable, bmi2);
+    }
+
+    /* Build Huffman Tree */
+    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
+    {   size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,
+                                            maxSymbolValue, huffLog,
+                                            table->nodeTable, sizeof(table->nodeTable));
+        CHECK_F(maxBits);
+        huffLog = (U32)maxBits;
+        /* Zero unused symbols in CTable, so we can check it for validity */
+        memset(table->CTable + (maxSymbolValue + 1), 0,
+               sizeof(table->CTable) - ((maxSymbolValue + 1) * sizeof(HUF_CElt)));
+    }
+
+    /* Write table description header */
+    {   CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, table->CTable, maxSymbolValue, huffLog) );
+        /* Check if using previous huffman table is beneficial */
+        if (repeat && *repeat != HUF_repeat_none) {
+            size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue);
+            size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue);
+            if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) {
+                return HUF_compressCTable_internal(ostart, op, oend,
+                                                   src, srcSize,
+                                                   nbStreams, oldHufTable, bmi2);
+        }   }
+
+        /* Use the new huffman table */
+        if (hSize + 12ul >= srcSize) { return 0; }
+        op += hSize;
+        if (repeat) { *repeat = HUF_repeat_none; }
+        if (oldHufTable)
+            memcpy(oldHufTable, table->CTable, sizeof(table->CTable));  /* Save new table */
+    }
+    return HUF_compressCTable_internal(ostart, op, oend,
+                                       src, srcSize,
+                                       nbStreams, table->CTable, bmi2);
+}
+
+
+size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
+                      const void* src, size_t srcSize,
+                      unsigned maxSymbolValue, unsigned huffLog,
+                      void* workSpace, size_t wkspSize)
+{
+    return HUF_compress_internal(dst, dstSize, src, srcSize,
+                                 maxSymbolValue, huffLog, HUF_singleStream,
+                                 workSpace, wkspSize,
+                                 NULL, NULL, 0, 0 /*bmi2*/);
+}
+
+size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
+                      const void* src, size_t srcSize,
+                      unsigned maxSymbolValue, unsigned huffLog,
+                      void* workSpace, size_t wkspSize,
+                      HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
+{
+    return HUF_compress_internal(dst, dstSize, src, srcSize,
+                                 maxSymbolValue, huffLog, HUF_singleStream,
+                                 workSpace, wkspSize, hufTable,
+                                 repeat, preferRepeat, bmi2);
+}
+
+size_t HUF_compress1X (void* dst, size_t dstSize,
+                 const void* src, size_t srcSize,
+                 unsigned maxSymbolValue, unsigned huffLog)
+{
+    unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
+    return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
+}
+
+/* HUF_compress4X_repeat():
+ * compress input using 4 streams.
+ * provide workspace to generate compression tables */
+size_t HUF_compress4X_wksp (void* dst, size_t dstSize,
+                      const void* src, size_t srcSize,
+                      unsigned maxSymbolValue, unsigned huffLog,
+                      void* workSpace, size_t wkspSize)
+{
+    return HUF_compress_internal(dst, dstSize, src, srcSize,
+                                 maxSymbolValue, huffLog, HUF_fourStreams,
+                                 workSpace, wkspSize,
+                                 NULL, NULL, 0, 0 /*bmi2*/);
+}
+
+/* HUF_compress4X_repeat():
+ * compress input using 4 streams.
+ * re-use an existing huffman compression table */
+size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
+                      const void* src, size_t srcSize,
+                      unsigned maxSymbolValue, unsigned huffLog,
+                      void* workSpace, size_t wkspSize,
+                      HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2)
+{
+    return HUF_compress_internal(dst, dstSize, src, srcSize,
+                                 maxSymbolValue, huffLog, HUF_fourStreams,
+                                 workSpace, wkspSize,
+                                 hufTable, repeat, preferRepeat, bmi2);
+}
+
+size_t HUF_compress2 (void* dst, size_t dstSize,
+                const void* src, size_t srcSize,
+                unsigned maxSymbolValue, unsigned huffLog)
+{
+    unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
+    return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
+}
+
+size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return HUF_compress2(dst, maxDstSize, src, srcSize, 255, HUF_TABLELOG_DEFAULT);
+}
diff --git a/src/huf_decompress.c b/src/huf_decompress.c
new file mode 100644
index 0000000..3f8bd29
--- /dev/null
+++ b/src/huf_decompress.c
@@ -0,0 +1,1232 @@
+/* ******************************************************************
+   huff0 huffman decoder,
+   part of Finite State Entropy library
+   Copyright (C) 2013-present, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+
+/* **************************************************************
+*  Dependencies
+****************************************************************/
+#include <string.h>     /* memcpy, memset */
+#include "compiler.h"
+#include "bitstream.h"  /* BIT_* */
+#include "fse.h"        /* to compress headers */
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
+#include "error_private.h"
+
+/* **************************************************************
+*  Macros
+****************************************************************/
+
+/* These two optional macros force the use one way or another of the two
+ * Huffman decompression implementations. You can't force in both directions
+ * at the same time.
+ */
+#if defined(HUF_FORCE_DECOMPRESS_X1) && \
+    defined(HUF_FORCE_DECOMPRESS_X2)
+#error "Cannot force the use of the X1 and X2 decoders at the same time!"
+#endif
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define HUF_isError ERR_isError
+#define CHECK_F(f) { size_t const err_ = (f); if (HUF_isError(err_)) return err_; }
+
+
+/* **************************************************************
+*  Byte alignment for workSpace management
+****************************************************************/
+#define HUF_ALIGN(x, a)         HUF_ALIGN_MASK((x), (a) - 1)
+#define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
+
+
+/* **************************************************************
+*  BMI2 Variant Wrappers
+****************************************************************/
+#if DYNAMIC_BMI2
+
+#define HUF_DGEN(fn)                                                        \
+                                                                            \
+    static size_t fn##_default(                                             \
+                  void* dst,  size_t dstSize,                               \
+            const void* cSrc, size_t cSrcSize,                              \
+            const HUF_DTable* DTable)                                       \
+    {                                                                       \
+        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
+    }                                                                       \
+                                                                            \
+    static TARGET_ATTRIBUTE("bmi2") size_t fn##_bmi2(                       \
+                  void* dst,  size_t dstSize,                               \
+            const void* cSrc, size_t cSrcSize,                              \
+            const HUF_DTable* DTable)                                       \
+    {                                                                       \
+        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
+    }                                                                       \
+                                                                            \
+    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
+                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \
+    {                                                                       \
+        if (bmi2) {                                                         \
+            return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);         \
+        }                                                                   \
+        return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable);          \
+    }
+
+#else
+
+#define HUF_DGEN(fn)                                                        \
+    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
+                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \
+    {                                                                       \
+        (void)bmi2;                                                         \
+        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
+    }
+
+#endif
+
+
+/*-***************************/
+/*  generic DTableDesc       */
+/*-***************************/
+typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
+
+static DTableDesc HUF_getDTableDesc(const HUF_DTable* table)
+{
+    DTableDesc dtd;
+    memcpy(&dtd, table, sizeof(dtd));
+    return dtd;
+}
+
+
+#ifndef HUF_FORCE_DECOMPRESS_X2
+
+/*-***************************/
+/*  single-symbol decoding   */
+/*-***************************/
+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX1;   /* single-symbol decoding */
+
+size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
+{
+    U32 tableLog = 0;
+    U32 nbSymbols = 0;
+    size_t iSize;
+    void* const dtPtr = DTable + 1;
+    HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;
+
+    U32* rankVal;
+    BYTE* huffWeight;
+    size_t spaceUsed32 = 0;
+
+    rankVal = (U32 *)workSpace + spaceUsed32;
+    spaceUsed32 += HUF_TABLELOG_ABSOLUTEMAX + 1;
+    huffWeight = (BYTE *)((U32 *)workSpace + spaceUsed32);
+    spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2;
+
+    if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge);
+
+    DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
+    /* memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* Table header */
+    {   DTableDesc dtd = HUF_getDTableDesc(DTable);
+        if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, Huffman tree cannot fit in */
+        dtd.tableType = 0;
+        dtd.tableLog = (BYTE)tableLog;
+        memcpy(DTable, &dtd, sizeof(dtd));
+    }
+
+    /* Calculate starting value for each rank */
+    {   U32 n, nextRankStart = 0;
+        for (n=1; n<tableLog+1; n++) {
+            U32 const current = nextRankStart;
+            nextRankStart += (rankVal[n] << (n-1));
+            rankVal[n] = current;
+    }   }
+
+    /* fill DTable */
+    {   U32 n;
+        for (n=0; n<nbSymbols; n++) {
+            U32 const w = huffWeight[n];
+            U32 const length = (1 << w) >> 1;
+            U32 u;
+            HUF_DEltX1 D;
+            D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
+            for (u = rankVal[w]; u < rankVal[w] + length; u++)
+                dt[u] = D;
+            rankVal[w] += length;
+    }   }
+
+    return iSize;
+}
+
+size_t HUF_readDTableX1(HUF_DTable* DTable, const void* src, size_t srcSize)
+{
+    U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+    return HUF_readDTableX1_wksp(DTable, src, srcSize,
+                                 workSpace, sizeof(workSpace));
+}
+
+FORCE_INLINE_TEMPLATE BYTE
+HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
+{
+    size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+    BYTE const c = dt[val].byte;
+    BIT_skipBits(Dstream, dt[val].nbBits);
+    return c;
+}
+
+#define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
+    *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)  \
+    if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
+        HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
+
+#define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
+
+HINT_INLINE size_t
+HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 4 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {
+        HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX1_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
+    }
+
+    /* [0-3] symbols remaining */
+    if (MEM_32bits())
+        while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
+            HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
+
+    /* no more data to retrieve from bitstream, no need to reload */
+    while (p < pEnd)
+        HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
+
+    return pEnd-pStart;
+}
+
+FORCE_INLINE_TEMPLATE size_t
+HUF_decompress1X1_usingDTable_internal_body(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + dstSize;
+    const void* dtPtr = DTable + 1;
+    const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
+    BIT_DStream_t bitD;
+    DTableDesc const dtd = HUF_getDTableDesc(DTable);
+    U32 const dtLog = dtd.tableLog;
+
+    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
+
+    HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);
+
+    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    return dstSize;
+}
+
+FORCE_INLINE_TEMPLATE size_t
+HUF_decompress4X1_usingDTable_internal_body(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    /* Check */
+    if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */
+
+    {   const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable + 1;
+        const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        size_t const length1 = MEM_readLE16(istart);
+        size_t const length2 = MEM_readLE16(istart+2);
+        size_t const length3 = MEM_readLE16(istart+4);
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal = BIT_DStream_unfinished;
+        DTableDesc const dtd = HUF_getDTableDesc(DTable);
+        U32 const dtLog = dtd.tableLog;
+
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
+        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
+        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
+        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
+
+        /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        while ( (endSignal==BIT_DStream_unfinished) && (op4<(oend-3)) ) {
+            HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX1_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX1_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX1_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX1_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX1_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX1_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX1_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX1_0(op4, &bitD4);
+            BIT_reloadDStream(&bitD1);
+            BIT_reloadDStream(&bitD2);
+            BIT_reloadDStream(&bitD3);
+            BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        /* note : should not be necessary : op# advance in lock step, and we control op4.
+         *        but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+          if (!endCheck) return ERROR(corruption_detected); }
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+typedef size_t (*HUF_decompress_usingDTable_t)(void *dst, size_t dstSize,
+                                               const void *cSrc,
+                                               size_t cSrcSize,
+                                               const HUF_DTable *DTable);
+
+HUF_DGEN(HUF_decompress1X1_usingDTable_internal)
+HUF_DGEN(HUF_decompress4X1_usingDTable_internal)
+
+
+
+size_t HUF_decompress1X1_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    DTableDesc dtd = HUF_getDTableDesc(DTable);
+    if (dtd.tableType != 0) return ERROR(GENERIC);
+    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+}
+
+size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
+                                   const void* cSrc, size_t cSrcSize,
+                                   void* workSpace, size_t wkspSize)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
+}
+
+
+size_t HUF_decompress1X1_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
+                              const void* cSrc, size_t cSrcSize)
+{
+    U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+    return HUF_decompress1X1_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize,
+                                       workSpace, sizeof(workSpace));
+}
+
+size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
+    return HUF_decompress1X1_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+size_t HUF_decompress4X1_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    DTableDesc dtd = HUF_getDTableDesc(DTable);
+    if (dtd.tableType != 0) return ERROR(GENERIC);
+    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+}
+
+static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
+                                   const void* cSrc, size_t cSrcSize,
+                                   void* workSpace, size_t wkspSize, int bmi2)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUF_readDTableX1_wksp (dctx, cSrc, cSrcSize,
+                                                workSpace, wkspSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
+}
+
+size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
+                                   const void* cSrc, size_t cSrcSize,
+                                   void* workSpace, size_t wkspSize)
+{
+    return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0);
+}
+
+
+size_t HUF_decompress4X1_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+    return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
+                                       workSpace, sizeof(workSpace));
+}
+size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
+    return HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+#endif /* HUF_FORCE_DECOMPRESS_X2 */
+
+
+#ifndef HUF_FORCE_DECOMPRESS_X1
+
+/* *************************/
+/* double-symbols decoding */
+/* *************************/
+
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2;  /* double-symbols decoding */
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
+typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
+typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];
+
+
+/* HUF_fillDTableX2Level2() :
+ * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */
+static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 sizeLog, const U32 consumed,
+                           const U32* rankValOrigin, const int minWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
+                           U32 nbBitsBaseline, U16 baseSeq)
+{
+    HUF_DEltX2 DElt;
+    U32 rankVal[HUF_TABLELOG_MAX + 1];
+
+    /* get pre-calculated rankVal */
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1) {
+        U32 i, skipSize = rankVal[minWeight];
+        MEM_writeLE16(&(DElt.sequence), baseSeq);
+        DElt.nbBits   = (BYTE)(consumed);
+        DElt.length   = 1;
+        for (i = 0; i < skipSize; i++)
+            DTable[i] = DElt;
+    }
+
+    /* fill DTable */
+    {   U32 s; for (s=0; s<sortedListSize; s++) {   /* note : sortedSymbols already skipped */
+            const U32 symbol = sortedSymbols[s].symbol;
+            const U32 weight = sortedSymbols[s].weight;
+            const U32 nbBits = nbBitsBaseline - weight;
+            const U32 length = 1 << (sizeLog-nbBits);
+            const U32 start = rankVal[weight];
+            U32 i = start;
+            const U32 end = start + length;
+
+            MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
+            DElt.nbBits = (BYTE)(nbBits + consumed);
+            DElt.length = 2;
+            do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
+
+            rankVal[weight] += length;
+    }   }
+}
+
+
+static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32 nbBitsBaseline)
+{
+    U32 rankVal[HUF_TABLELOG_MAX + 1];
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
+    const U32 minBits  = nbBitsBaseline - maxWeight;
+    U32 s;
+
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++) {
+        const U16 symbol = sortedList[s].symbol;
+        const U32 weight = sortedList[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 start = rankVal[weight];
+        const U32 length = 1 << (targetLog-nbBits);
+
+        if (targetLog-nbBits >= minBits) {   /* enough room for a second symbol */
+            U32 sortedRank;
+            int minWeight = nbBits + scaleLog;
+            if (minWeight < 1) minWeight = 1;
+            sortedRank = rankStart[minWeight];
+            HUF_fillDTableX2Level2(DTable+start, targetLog-nbBits, nbBits,
+                           rankValOrigin[nbBits], minWeight,
+                           sortedList+sortedRank, sortedListSize-sortedRank,
+                           nbBitsBaseline, symbol);
+        } else {
+            HUF_DEltX2 DElt;
+            MEM_writeLE16(&(DElt.sequence), symbol);
+            DElt.nbBits = (BYTE)(nbBits);
+            DElt.length = 1;
+            {   U32 const end = start + length;
+                U32 u;
+                for (u = start; u < end; u++) DTable[u] = DElt;
+        }   }
+        rankVal[weight] += length;
+    }
+}
+
+size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
+                       const void* src, size_t srcSize,
+                             void* workSpace, size_t wkspSize)
+{
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    DTableDesc dtd = HUF_getDTableDesc(DTable);
+    U32 const maxTableLog = dtd.maxTableLog;
+    size_t iSize;
+    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */
+    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
+    U32 *rankStart;
+
+    rankValCol_t* rankVal;
+    U32* rankStats;
+    U32* rankStart0;
+    sortedSymbol_t* sortedSymbol;
+    BYTE* weightList;
+    size_t spaceUsed32 = 0;
+
+    rankVal = (rankValCol_t *)((U32 *)workSpace + spaceUsed32);
+    spaceUsed32 += (sizeof(rankValCol_t) * HUF_TABLELOG_MAX) >> 2;
+    rankStats = (U32 *)workSpace + spaceUsed32;
+    spaceUsed32 += HUF_TABLELOG_MAX + 1;
+    rankStart0 = (U32 *)workSpace + spaceUsed32;
+    spaceUsed32 += HUF_TABLELOG_MAX + 2;
+    sortedSymbol = (sortedSymbol_t *)workSpace + (spaceUsed32 * sizeof(U32)) / sizeof(sortedSymbol_t);
+    spaceUsed32 += HUF_ALIGN(sizeof(sortedSymbol_t) * (HUF_SYMBOLVALUE_MAX + 1), sizeof(U32)) >> 2;
+    weightList = (BYTE *)((U32 *)workSpace + spaceUsed32);
+    spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2;
+
+    if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge);
+
+    rankStart = rankStart0 + 1;
+    memset(rankStats, 0, sizeof(U32) * (2 * HUF_TABLELOG_MAX + 2 + 1));
+
+    DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable));   /* if compiler fails here, assertion is wrong */
+    if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
+    /* memset(weightList, 0, sizeof(weightList)); */  /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(weightList, HUF_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
+
+    /* Get start index of each weight */
+    {   U32 w, nextRankStart = 0;
+        for (w=1; w<maxW+1; w++) {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {   U32 s;
+        for (s=0; s<nbSymbols; s++) {
+            U32 const w = weightList[s];
+            U32 const r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {   U32* const rankVal0 = rankVal[0];
+        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */
+            U32 nextRankVal = 0;
+            U32 w;
+            for (w=1; w<maxW+1; w++) {
+                U32 current = nextRankVal;
+                nextRankVal += rankStats[w] << (w+rescale);
+                rankVal0[w] = current;
+        }   }
+        {   U32 const minBits = tableLog+1 - maxW;
+            U32 consumed;
+            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
+                U32* const rankValPtr = rankVal[consumed];
+                U32 w;
+                for (w = 1; w < maxW+1; w++) {
+                    rankValPtr[w] = rankVal0[w] >> consumed;
+    }   }   }   }
+
+    HUF_fillDTableX2(dt, maxTableLog,
+                   sortedSymbol, sizeOfSort,
+                   rankStart0, rankVal, maxW,
+                   tableLog+1);
+
+    dtd.tableLog = (BYTE)maxTableLog;
+    dtd.tableType = 1;
+    memcpy(DTable, &dtd, sizeof(dtd));
+    return iSize;
+}
+
+size_t HUF_readDTableX2(HUF_DTable* DTable, const void* src, size_t srcSize)
+{
+  U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+  return HUF_readDTableX2_wksp(DTable, src, srcSize,
+                               workSpace, sizeof(workSpace));
+}
+
+
+FORCE_INLINE_TEMPLATE U32
+HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
+{
+    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 2);
+    BIT_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+FORCE_INLINE_TEMPLATE U32
+HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
+{
+    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 1);
+    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
+    else {
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
+            BIT_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);
+    }   }
+    return 1;
+}
+
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
+        ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
+
+HINT_INLINE size_t
+HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
+                const HUF_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) {
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+    }
+
+    /* closer to end : up to 2 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    while (p <= pEnd-2)
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    if (p < pEnd)
+        p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+FORCE_INLINE_TEMPLATE size_t
+HUF_decompress1X2_usingDTable_internal_body(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    BIT_DStream_t bitD;
+
+    /* Init */
+    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
+
+    /* decode */
+    {   BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */
+        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
+        DTableDesc const dtd = HUF_getDTableDesc(DTable);
+        HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);
+    }
+
+    /* check */
+    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    /* decoded size */
+    return dstSize;
+}
+
+
+FORCE_INLINE_TEMPLATE size_t
+HUF_decompress4X2_usingDTable_internal_body(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {   const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable+1;
+        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        size_t const length1 = MEM_readLE16(istart);
+        size_t const length2 = MEM_readLE16(istart+2);
+        size_t const length3 = MEM_readLE16(istart+4);
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        size_t const segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+        DTableDesc const dtd = HUF_getDTableDesc(DTable);
+        U32 const dtLog = dtd.tableLog;
+
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
+        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
+        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
+        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (endSignal==BIT_DStream_unfinished) & (op4<(oend-(sizeof(bitD4.bitContainer)-1))) ; ) {
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+          if (!endCheck) return ERROR(corruption_detected); }
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+HUF_DGEN(HUF_decompress1X2_usingDTable_internal)
+HUF_DGEN(HUF_decompress4X2_usingDTable_internal)
+
+size_t HUF_decompress1X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    DTableDesc dtd = HUF_getDTableDesc(DTable);
+    if (dtd.tableType != 1) return ERROR(GENERIC);
+    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+}
+
+size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
+                                   const void* cSrc, size_t cSrcSize,
+                                   void* workSpace, size_t wkspSize)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
+                                               workSpace, wkspSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
+}
+
+
+size_t HUF_decompress1X2_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
+                              const void* cSrc, size_t cSrcSize)
+{
+    U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+    return HUF_decompress1X2_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize,
+                                       workSpace, sizeof(workSpace));
+}
+
+size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
+    return HUF_decompress1X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+size_t HUF_decompress4X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    DTableDesc dtd = HUF_getDTableDesc(DTable);
+    if (dtd.tableType != 1) return ERROR(GENERIC);
+    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+}
+
+static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
+                                   const void* cSrc, size_t cSrcSize,
+                                   void* workSpace, size_t wkspSize, int bmi2)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
+                                         workSpace, wkspSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
+}
+
+size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
+                                   const void* cSrc, size_t cSrcSize,
+                                   void* workSpace, size_t wkspSize)
+{
+    return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0);
+}
+
+
+size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
+                              const void* cSrc, size_t cSrcSize)
+{
+    U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+    return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
+                                       workSpace, sizeof(workSpace));
+}
+
+size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
+    return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+#endif /* HUF_FORCE_DECOMPRESS_X1 */
+
+
+/* ***********************************/
+/* Universal decompression selectors */
+/* ***********************************/
+
+size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
+                                    const void* cSrc, size_t cSrcSize,
+                                    const HUF_DTable* DTable)
+{
+    DTableDesc const dtd = HUF_getDTableDesc(DTable);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#else
+    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
+                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#endif
+}
+
+size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
+                                    const void* cSrc, size_t cSrcSize,
+                                    const HUF_DTable* DTable)
+{
+    DTableDesc const dtd = HUF_getDTableDesc(DTable);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#else
+    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
+                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#endif
+}
+
+
+#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
+{
+    /* single, double, quad */
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
+};
+#endif
+
+/** HUF_selectDecoder() :
+ *  Tells which decoder is likely to decode faster,
+ *  based on a set of pre-computed metrics.
+ * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
+ *  Assumption : 0 < dstSize <= 128 KB */
+U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
+{
+    assert(dstSize > 0);
+    assert(dstSize <= 128*1024);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dstSize;
+    (void)cSrcSize;
+    return 0;
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dstSize;
+    (void)cSrcSize;
+    return 1;
+#else
+    /* decoder timing evaluation */
+    {   U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */
+        U32 const D256 = (U32)(dstSize >> 8);
+        U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
+        U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
+        DTime1 += DTime1 >> 3;  /* advantage to algorithm using less memory, to reduce cache eviction */
+        return DTime1 < DTime0;
+    }
+#endif
+}
+
+
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+
+size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
+    static const decompressionAlgo decompress[2] = { HUF_decompress4X1, HUF_decompress4X2 };
+#endif
+
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress4X1(dst, dstSize, cSrc, cSrcSize);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);
+#else
+        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
+#endif
+    }
+}
+
+size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
+#else
+        return algoNb ? HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
+                        HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
+#endif
+    }
+}
+
+size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+    return HUF_decompress4X_hufOnly_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
+                                         workSpace, sizeof(workSpace));
+}
+
+
+size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
+                                     size_t dstSize, const void* cSrc,
+                                     size_t cSrcSize, void* workSpace,
+                                     size_t wkspSize)
+{
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize == 0) return ERROR(corruption_detected);
+
+    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
+#else
+        return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                            cSrcSize, workSpace, wkspSize):
+                        HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
+#endif
+    }
+}
+
+size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
+                                  const void* cSrc, size_t cSrcSize,
+                                  void* workSpace, size_t wkspSize)
+{
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                                cSrcSize, workSpace, wkspSize);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                                cSrcSize, workSpace, wkspSize);
+#else
+        return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                                cSrcSize, workSpace, wkspSize):
+                        HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                                cSrcSize, workSpace, wkspSize);
+#endif
+    }
+}
+
+size_t HUF_decompress1X_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
+                             const void* cSrc, size_t cSrcSize)
+{
+    U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
+    return HUF_decompress1X_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize,
+                                      workSpace, sizeof(workSpace));
+}
+
+
+size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
+{
+    DTableDesc const dtd = HUF_getDTableDesc(DTable);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#else
+    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
+                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#endif
+}
+
+#ifndef HUF_FORCE_DECOMPRESS_X2
+size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
+}
+#endif
+
+size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
+{
+    DTableDesc const dtd = HUF_getDTableDesc(DTable);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#else
+    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
+                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#endif
+}
+
+size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
+{
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize == 0) return ERROR(corruption_detected);
+
+    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
+#else
+        return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) :
+                        HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
+#endif
+    }
+}
diff --git a/src/lzf_filter.cpp b/src/lzf_filter.cpp
index fd2e5fb..46bb1a4 100644
--- a/src/lzf_filter.cpp
+++ b/src/lzf_filter.cpp
@@ -27,7 +27,7 @@
 #include <errno.h>
 #include "hdf5.h"
 #include "lzf/lzf_filter.h"
-
+#include <H5Epubgen.h>
 /* Our own versions of H5Epush_sim, as it changed in 1.8 */
 #if H5_VERS_MAJOR == 1 && H5_VERS_MINOR < 7
 
@@ -97,7 +97,7 @@ int register_lzf(void){
 
     retval = H5Zregister(&filter_class);
     if(retval<0){
-        PUSH_ERR("register_lzf", H5E_CANTREGISTER, "Can't register LZF filter");
+        PUSH_ERR("register_lzf", retval, "Can't register LZF filter");
     }
     return retval;
 }
diff --git a/src/mem.h b/src/mem.h
new file mode 100644
index 0000000..c10d7f6
--- /dev/null
+++ b/src/mem.h
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef MEM_H_MODULE
+#define MEM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*-****************************************
+*  Dependencies
+******************************************/
+#include <stddef.h>     /* size_t, ptrdiff_t */
+#include <string.h>     /* memcpy */
+
+
+/*-****************************************
+*  Compiler specifics
+******************************************/
+#if defined(_MSC_VER)   /* Visual Studio */
+#   include <stdlib.h>  /* _byteswap_ulong */
+#   include <intrin.h>  /* _byteswap_* */
+#endif
+#if defined(__GNUC__)
+#  define MEM_STATIC static __inline __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define MEM_STATIC static inline
+#elif defined(_MSC_VER)
+#  define MEM_STATIC static __inline
+#else
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+#ifndef __has_builtin
+#  define __has_builtin(x) 0  /* compat. with non-clang compilers */
+#endif
+
+/* code only tested on 32 and 64 bits systems */
+#define MEM_STATIC_ASSERT(c)   { enum { MEM_static_assert = 1/(int)(!!(c)) }; }
+MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
+
+
+/*-**************************************************************
+*  Basic Types
+*****************************************************************/
+#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+# include <stdint.h>
+  typedef   uint8_t BYTE;
+  typedef  uint16_t U16;
+  typedef   int16_t S16;
+  typedef  uint32_t U32;
+  typedef   int32_t S32;
+  typedef  uint64_t U64;
+  typedef   int64_t S64;
+#else
+# include <limits.h>
+#if CHAR_BIT != 8
+#  error "this implementation requires char to be exactly 8-bit type"
+#endif
+  typedef unsigned char      BYTE;
+#if USHRT_MAX != 65535
+#  error "this implementation requires short to be exactly 16-bit type"
+#endif
+  typedef unsigned short      U16;
+  typedef   signed short      S16;
+#if UINT_MAX != 4294967295
+#  error "this implementation requires int to be exactly 32-bit type"
+#endif
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+/* note : there are no limits defined for long long type in C90.
+ * limits exist in C99, however, in such case, <stdint.h> is preferred */
+  typedef unsigned long long  U64;
+  typedef   signed long long  S64;
+#endif
+
+
+/*-**************************************************************
+*  Memory I/O
+*****************************************************************/
+/* MEM_FORCE_MEMORY_ACCESS :
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (i.e., not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets depending on alignment.
+ *            In some circumstances, it's the only known way to get the most performance (i.e. GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define MEM_FORCE_MEMORY_ACCESS 2
+#  elif defined(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
+#    define MEM_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
+
+MEM_STATIC unsigned MEM_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
+
+/* violates C standard, by lying on structure alignment.
+Only use if no other choice to achieve best performance on target platform */
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
+MEM_STATIC size_t MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
+
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+#if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(WIN32))
+    __pragma( pack(push, 1) )
+    typedef struct { U16 v; } unalign16;
+    typedef struct { U32 v; } unalign32;
+    typedef struct { U64 v; } unalign64;
+    typedef struct { size_t v; } unalignArch;
+    __pragma( pack(pop) )
+#else
+    typedef struct { U16 v; } __attribute__((packed)) unalign16;
+    typedef struct { U32 v; } __attribute__((packed)) unalign32;
+    typedef struct { U64 v; } __attribute__((packed)) unalign64;
+    typedef struct { size_t v; } __attribute__((packed)) unalignArch;
+#endif
+
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; }
+MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; }
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; }
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; }
+
+#else
+
+/* default method, safe and standard.
+   can sometimes prove slower */
+
+MEM_STATIC U16 MEM_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U32 MEM_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U64 MEM_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC size_t MEM_readST(const void* memPtr)
+{
+    size_t val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+MEM_STATIC void MEM_write32(void* memPtr, U32 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+MEM_STATIC void MEM_write64(void* memPtr, U64 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+#endif /* MEM_FORCE_MEMORY_ACCESS */
+
+MEM_STATIC U32 MEM_swap32(U32 in)
+{
+#if defined(_MSC_VER)     /* Visual Studio */
+    return _byteswap_ulong(in);
+#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
+  || (defined(__clang__) && __has_builtin(__builtin_bswap32))
+    return __builtin_bswap32(in);
+#else
+    return  ((in << 24) & 0xff000000 ) |
+            ((in <<  8) & 0x00ff0000 ) |
+            ((in >>  8) & 0x0000ff00 ) |
+            ((in >> 24) & 0x000000ff );
+#endif
+}
+
+MEM_STATIC U64 MEM_swap64(U64 in)
+{
+#if defined(_MSC_VER)     /* Visual Studio */
+    return _byteswap_uint64(in);
+#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
+  || (defined(__clang__) && __has_builtin(__builtin_bswap64))
+    return __builtin_bswap64(in);
+#else
+    return  ((in << 56) & 0xff00000000000000ULL) |
+            ((in << 40) & 0x00ff000000000000ULL) |
+            ((in << 24) & 0x0000ff0000000000ULL) |
+            ((in << 8)  & 0x000000ff00000000ULL) |
+            ((in >> 8)  & 0x00000000ff000000ULL) |
+            ((in >> 24) & 0x0000000000ff0000ULL) |
+            ((in >> 40) & 0x000000000000ff00ULL) |
+            ((in >> 56) & 0x00000000000000ffULL);
+#endif
+}
+
+MEM_STATIC size_t MEM_swapST(size_t in)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_swap32((U32)in);
+    else
+        return (size_t)MEM_swap64((U64)in);
+}
+
+/*=== Little endian r/w ===*/
+
+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read16(memPtr);
+    else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
+{
+    if (MEM_isLittleEndian()) {
+        MEM_write16(memPtr, val);
+    } else {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE)val;
+        p[1] = (BYTE)(val>>8);
+    }
+}
+
+MEM_STATIC U32 MEM_readLE24(const void* memPtr)
+{
+    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
+}
+
+MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
+{
+    MEM_writeLE16(memPtr, (U16)val);
+    ((BYTE*)memPtr)[2] = (BYTE)(val>>16);
+}
+
+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read32(memPtr);
+    else
+        return MEM_swap32(MEM_read32(memPtr));
+}
+
+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
+{
+    if (MEM_isLittleEndian())
+        MEM_write32(memPtr, val32);
+    else
+        MEM_write32(memPtr, MEM_swap32(val32));
+}
+
+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read64(memPtr);
+    else
+        return MEM_swap64(MEM_read64(memPtr));
+}
+
+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
+{
+    if (MEM_isLittleEndian())
+        MEM_write64(memPtr, val64);
+    else
+        MEM_write64(memPtr, MEM_swap64(val64));
+}
+
+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readLE32(memPtr);
+    else
+        return (size_t)MEM_readLE64(memPtr);
+}
+
+MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
+{
+    if (MEM_32bits())
+        MEM_writeLE32(memPtr, (U32)val);
+    else
+        MEM_writeLE64(memPtr, (U64)val);
+}
+
+/*=== Big endian r/w ===*/
+
+MEM_STATIC U32 MEM_readBE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_swap32(MEM_read32(memPtr));
+    else
+        return MEM_read32(memPtr);
+}
+
+MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
+{
+    if (MEM_isLittleEndian())
+        MEM_write32(memPtr, MEM_swap32(val32));
+    else
+        MEM_write32(memPtr, val32);
+}
+
+MEM_STATIC U64 MEM_readBE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_swap64(MEM_read64(memPtr));
+    else
+        return MEM_read64(memPtr);
+}
+
+MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
+{
+    if (MEM_isLittleEndian())
+        MEM_write64(memPtr, MEM_swap64(val64));
+    else
+        MEM_write64(memPtr, val64);
+}
+
+MEM_STATIC size_t MEM_readBEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readBE32(memPtr);
+    else
+        return (size_t)MEM_readBE64(memPtr);
+}
+
+MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
+{
+    if (MEM_32bits())
+        MEM_writeBE32(memPtr, (U32)val);
+    else
+        MEM_writeBE64(memPtr, (U64)val);
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* MEM_H_MODULE */
diff --git a/src/pool.c b/src/pool.c
new file mode 100644
index 0000000..7a82945
--- /dev/null
+++ b/src/pool.c
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/* ======   Dependencies   ======= */
+#include <stddef.h>    /* size_t */
+#include "debug.h"     /* assert */
+#include "zstd_internal.h"  /* ZSTD_malloc, ZSTD_free */
+#include "pool.h"
+
+/* ======   Compiler specifics   ====== */
+#if defined(_MSC_VER)
+#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */
+#endif
+
+
+#ifdef ZSTD_MULTITHREAD
+
+#include "threading.h"   /* pthread adaptation */
+
+/* A job is a function and an opaque argument */
+typedef struct POOL_job_s {
+    POOL_function function;
+    void *opaque;
+} POOL_job;
+
+struct POOL_ctx_s {
+    ZSTD_customMem customMem;
+    /* Keep track of the threads */
+    ZSTD_pthread_t* threads;
+    size_t threadCapacity;
+    size_t threadLimit;
+
+    /* The queue is a circular buffer */
+    POOL_job *queue;
+    size_t queueHead;
+    size_t queueTail;
+    size_t queueSize;
+
+    /* The number of threads working on jobs */
+    size_t numThreadsBusy;
+    /* Indicates if the queue is empty */
+    int queueEmpty;
+
+    /* The mutex protects the queue */
+    ZSTD_pthread_mutex_t queueMutex;
+    /* Condition variable for pushers to wait on when the queue is full */
+    ZSTD_pthread_cond_t queuePushCond;
+    /* Condition variables for poppers to wait on when the queue is empty */
+    ZSTD_pthread_cond_t queuePopCond;
+    /* Indicates if the queue is shutting down */
+    int shutdown;
+};
+
+/* POOL_thread() :
+ * Work thread for the thread pool.
+ * Waits for jobs and executes them.
+ * @returns : NULL on failure else non-null.
+ */
+static void* POOL_thread(void* opaque) {
+    POOL_ctx* const ctx = (POOL_ctx*)opaque;
+    if (!ctx) { return NULL; }
+    for (;;) {
+        /* Lock the mutex and wait for a non-empty queue or until shutdown */
+        ZSTD_pthread_mutex_lock(&ctx->queueMutex);
+
+        while ( ctx->queueEmpty
+            || (ctx->numThreadsBusy >= ctx->threadLimit) ) {
+            if (ctx->shutdown) {
+                /* even if !queueEmpty, (possible if numThreadsBusy >= threadLimit),
+                 * a few threads will be shutdown while !queueEmpty,
+                 * but enough threads will remain active to finish the queue */
+                ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+                return opaque;
+            }
+            ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex);
+        }
+        /* Pop a job off the queue */
+        {   POOL_job const job = ctx->queue[ctx->queueHead];
+            ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize;
+            ctx->numThreadsBusy++;
+            ctx->queueEmpty = ctx->queueHead == ctx->queueTail;
+            /* Unlock the mutex, signal a pusher, and run the job */
+            ZSTD_pthread_cond_signal(&ctx->queuePushCond);
+            ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+
+            job.function(job.opaque);
+
+            /* If the intended queue size was 0, signal after finishing job */
+            ZSTD_pthread_mutex_lock(&ctx->queueMutex);
+            ctx->numThreadsBusy--;
+            if (ctx->queueSize == 1) {
+                ZSTD_pthread_cond_signal(&ctx->queuePushCond);
+            }
+            ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+        }
+    }  /* for (;;) */
+    assert(0);  /* Unreachable */
+}
+
+POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
+    return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);
+}
+
+POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
+                               ZSTD_customMem customMem) {
+    POOL_ctx* ctx;
+    /* Check parameters */
+    if (!numThreads) { return NULL; }
+    /* Allocate the context and zero initialize */
+    ctx = (POOL_ctx*)ZSTD_calloc(sizeof(POOL_ctx), customMem);
+    if (!ctx) { return NULL; }
+    /* Initialize the job queue.
+     * It needs one extra space since one space is wasted to differentiate
+     * empty and full queues.
+     */
+    ctx->queueSize = queueSize + 1;
+    ctx->queue = (POOL_job*)ZSTD_malloc(ctx->queueSize * sizeof(POOL_job), customMem);
+    ctx->queueHead = 0;
+    ctx->queueTail = 0;
+    ctx->numThreadsBusy = 0;
+    ctx->queueEmpty = 1;
+    (void)ZSTD_pthread_mutex_init(&ctx->queueMutex, NULL);
+    (void)ZSTD_pthread_cond_init(&ctx->queuePushCond, NULL);
+    (void)ZSTD_pthread_cond_init(&ctx->queuePopCond, NULL);
+    ctx->shutdown = 0;
+    /* Allocate space for the thread handles */
+    ctx->threads = (ZSTD_pthread_t*)ZSTD_malloc(numThreads * sizeof(ZSTD_pthread_t), customMem);
+    ctx->threadCapacity = 0;
+    ctx->customMem = customMem;
+    /* Check for errors */
+    if (!ctx->threads || !ctx->queue) { POOL_free(ctx); return NULL; }
+    /* Initialize the threads */
+    {   size_t i;
+        for (i = 0; i < numThreads; ++i) {
+            if (ZSTD_pthread_create(&ctx->threads[i], NULL, &POOL_thread, ctx)) {
+                ctx->threadCapacity = i;
+                POOL_free(ctx);
+                return NULL;
+        }   }
+        ctx->threadCapacity = numThreads;
+        ctx->threadLimit = numThreads;
+    }
+    return ctx;
+}
+
+/*! POOL_join() :
+    Shutdown the queue, wake any sleeping threads, and join all of the threads.
+*/
+static void POOL_join(POOL_ctx* ctx) {
+    /* Shut down the queue */
+    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
+    ctx->shutdown = 1;
+    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+    /* Wake up sleeping threads */
+    ZSTD_pthread_cond_broadcast(&ctx->queuePushCond);
+    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
+    /* Join all of the threads */
+    {   size_t i;
+        for (i = 0; i < ctx->threadCapacity; ++i) {
+            ZSTD_pthread_join(ctx->threads[i], NULL);  /* note : could fail */
+    }   }
+}
+
+void POOL_free(POOL_ctx *ctx) {
+    if (!ctx) { return; }
+    POOL_join(ctx);
+    ZSTD_pthread_mutex_destroy(&ctx->queueMutex);
+    ZSTD_pthread_cond_destroy(&ctx->queuePushCond);
+    ZSTD_pthread_cond_destroy(&ctx->queuePopCond);
+    ZSTD_free(ctx->queue, ctx->customMem);
+    ZSTD_free(ctx->threads, ctx->customMem);
+    ZSTD_free(ctx, ctx->customMem);
+}
+
+
+
+size_t POOL_sizeof(POOL_ctx *ctx) {
+    if (ctx==NULL) return 0;  /* supports sizeof NULL */
+    return sizeof(*ctx)
+        + ctx->queueSize * sizeof(POOL_job)
+        + ctx->threadCapacity * sizeof(ZSTD_pthread_t);
+}
+
+
+/* @return : 0 on success, 1 on error */
+static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)
+{
+    if (numThreads <= ctx->threadCapacity) {
+        if (!numThreads) return 1;
+        ctx->threadLimit = numThreads;
+        return 0;
+    }
+    /* numThreads > threadCapacity */
+    {   ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_malloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem);
+        if (!threadPool) return 1;
+        /* replace existing thread pool */
+        memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(*threadPool));
+        ZSTD_free(ctx->threads, ctx->customMem);
+        ctx->threads = threadPool;
+        /* Initialize additional threads */
+        {   size_t threadId;
+            for (threadId = ctx->threadCapacity; threadId < numThreads; ++threadId) {
+                if (ZSTD_pthread_create(&threadPool[threadId], NULL, &POOL_thread, ctx)) {
+                    ctx->threadCapacity = threadId;
+                    return 1;
+            }   }
+    }   }
+    /* successfully expanded */
+    ctx->threadCapacity = numThreads;
+    ctx->threadLimit = numThreads;
+    return 0;
+}
+
+/* @return : 0 on success, 1 on error */
+int POOL_resize(POOL_ctx* ctx, size_t numThreads)
+{
+    int result;
+    if (ctx==NULL) return 1;
+    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
+    result = POOL_resize_internal(ctx, numThreads);
+    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
+    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+    return result;
+}
+
+/**
+ * Returns 1 if the queue is full and 0 otherwise.
+ *
+ * When queueSize is 1 (pool was created with an intended queueSize of 0),
+ * then a queue is empty if there is a thread free _and_ no job is waiting.
+ */
+static int isQueueFull(POOL_ctx const* ctx) {
+    if (ctx->queueSize > 1) {
+        return ctx->queueHead == ((ctx->queueTail + 1) % ctx->queueSize);
+    } else {
+        return (ctx->numThreadsBusy == ctx->threadLimit) ||
+               !ctx->queueEmpty;
+    }
+}
+
+
+static void POOL_add_internal(POOL_ctx* ctx, POOL_function function, void *opaque)
+{
+    POOL_job const job = {function, opaque};
+    assert(ctx != NULL);
+    if (ctx->shutdown) return;
+
+    ctx->queueEmpty = 0;
+    ctx->queue[ctx->queueTail] = job;
+    ctx->queueTail = (ctx->queueTail + 1) % ctx->queueSize;
+    ZSTD_pthread_cond_signal(&ctx->queuePopCond);
+}
+
+void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque)
+{
+    assert(ctx != NULL);
+    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
+    /* Wait until there is space in the queue for the new job */
+    while (isQueueFull(ctx) && (!ctx->shutdown)) {
+        ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);
+    }
+    POOL_add_internal(ctx, function, opaque);
+    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+}
+
+
+int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque)
+{
+    assert(ctx != NULL);
+    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
+    if (isQueueFull(ctx)) {
+        ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+        return 0;
+    }
+    POOL_add_internal(ctx, function, opaque);
+    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
+    return 1;
+}
+
+
+#else  /* ZSTD_MULTITHREAD  not defined */
+
+/* ========================== */
+/* No multi-threading support */
+/* ========================== */
+
+
+/* We don't need any data, but if it is empty, malloc() might return NULL. */
+struct POOL_ctx_s {
+    int dummy;
+};
+static POOL_ctx g_ctx;
+
+POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
+    return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);
+}
+
+POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customMem customMem) {
+    (void)numThreads;
+    (void)queueSize;
+    (void)customMem;
+    return &g_ctx;
+}
+
+void POOL_free(POOL_ctx* ctx) {
+    assert(!ctx || ctx == &g_ctx);
+    (void)ctx;
+}
+
+int POOL_resize(POOL_ctx* ctx, size_t numThreads) {
+    (void)ctx; (void)numThreads;
+    return 0;
+}
+
+void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) {
+    (void)ctx;
+    function(opaque);
+}
+
+int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque) {
+    (void)ctx;
+    function(opaque);
+    return 1;
+}
+
+size_t POOL_sizeof(POOL_ctx* ctx) {
+    if (ctx==NULL) return 0;  /* supports sizeof NULL */
+    assert(ctx == &g_ctx);
+    return sizeof(*ctx);
+}
+
+#endif  /* ZSTD_MULTITHREAD */
diff --git a/src/pool.h b/src/pool.h
new file mode 100644
index 0000000..458d37f
--- /dev/null
+++ b/src/pool.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef POOL_H
+#define POOL_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+#include <stddef.h>   /* size_t */
+#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_customMem */
+#include "zstd.h"
+
+typedef struct POOL_ctx_s POOL_ctx;
+
+/*! POOL_create() :
+ *  Create a thread pool with at most `numThreads` threads.
+ * `numThreads` must be at least 1.
+ *  The maximum number of queued jobs before blocking is `queueSize`.
+ * @return : POOL_ctx pointer on success, else NULL.
+*/
+POOL_ctx* POOL_create(size_t numThreads, size_t queueSize);
+
+POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
+                               ZSTD_customMem customMem);
+
+/*! POOL_free() :
+ *  Free a thread pool returned by POOL_create().
+ */
+void POOL_free(POOL_ctx* ctx);
+
+/*! POOL_resize() :
+ *  Expands or shrinks pool's number of threads.
+ *  This is more efficient than releasing + creating a new context,
+ *  since it tries to preserve and re-use existing threads.
+ * `numThreads` must be at least 1.
+ * @return : 0 when resize was successful,
+ *           !0 (typically 1) if there is an error.
+ *    note : only numThreads can be resized, queueSize remains unchanged.
+ */
+int POOL_resize(POOL_ctx* ctx, size_t numThreads);
+
+/*! POOL_sizeof() :
+ * @return threadpool memory usage
+ *  note : compatible with NULL (returns 0 in this case)
+ */
+size_t POOL_sizeof(POOL_ctx* ctx);
+
+/*! POOL_function :
+ *  The function type that can be added to a thread pool.
+ */
+typedef void (*POOL_function)(void*);
+
+/*! POOL_add() :
+ *  Add the job `function(opaque)` to the thread pool. `ctx` must be valid.
+ *  Possibly blocks until there is room in the queue.
+ *  Note : The function may be executed asynchronously,
+ *         therefore, `opaque` must live until function has been completed.
+ */
+void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque);
+
+
+/*! POOL_tryAdd() :
+ *  Add the job `function(opaque)` to thread pool _if_ a worker is available.
+ *  Returns immediately even if not (does not block).
+ * @return : 1 if successful, 0 if not.
+ */
+int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque);
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif
diff --git a/src/sexp_io.cpp b/src/sexp_io.cpp
index f62b48e..6c9beb3 100644
--- a/src/sexp_io.cpp
+++ b/src/sexp_io.cpp
@@ -1,4 +1,5 @@
 #include "EigenH5.h"
+#include "highfive/H5DataSet.hpp"
 //[[depends(RcppEigen)]]
 //[[Rcpp::plugins(cpp11)]]
 // [[Rcpp::depends(RcppProgress)]]
@@ -29,31 +30,40 @@ template<> struct r2cpp_t<STRSXP>{
 };
 
 
-SEXPTYPE h2r_T(hid_t htype){
+SEXPTYPE h2r_T(const HighFive::DataType htype){
 
-  Eigen::Triplet<double,typename Eigen::SparseMatrix<double>::StorageIndex > Trip;
-  auto ht = H5Tget_class(htype);
-  if(ht==H5T_INTEGER){
-    //Rcpp::Rcout<<"int"<<std::endl;
+  using namespace HighFive;
+  if(htype.same_class(AtomicType<int>()))
     return(INTSXP);
-  }
-  if(ht==H5T_FLOAT){
-    //Rcpp::Rcout<<"double"<<std::endl;
+  if(htype.same_class(AtomicType<float>()))
     return(REALSXP);
-  }
-  if(ht==H5T_NATIVE_HBOOL){
-    //Rcpp::Rcout<<"BOOL"<<std::endl;
+  if(htype.same_class(AtomicType<bool>()))
     return(LGLSXP);
-  }
-  if(ht==H5T_STRING){
-    //Rcpp::Rcout<<"string"<<std::endl;
+  if(htype.same_class(AtomicType<std::string>()))
     return(STRSXP);
-  }
-  // Rcpp::Rcout<<"NIL"<<std::endl;
 
+  Rcpp::Rcerr<<"Couldn't find matching datatype"<<std::endl;
   return(NILSXP);
 }
 
+
+Rcpp::StringVector h2s_T(const HighFive::DataType htype){
+
+  using namespace HighFive;
+  if(htype.same_class(AtomicType<int>()))
+    return("integer");
+  if(htype.same_class(AtomicType<float>()))
+    return("double");
+  if(htype.same_class(AtomicType<bool>()))
+    return("logical");
+  if(htype.same_class(AtomicType<std::string>()))
+    return("character");
+
+  return(NA_STRING);
+}
+
+
+
 using namespace Rcpp;
 
 
@@ -151,16 +161,58 @@ void write_elem_m_h5(HighFive::Selection &file_sel,
 
 
 
-template <typename Derivate>
-SEXP read_attribute(const Derivate der,const std::string attribute_name){
+
+
+
+SEXP read_attribute(const HighFive::DataSet &der,const std::string attribute_name){
+
+  auto attr = der.getAttribute(attribute_name);
+
+  std::vector<size_t> attr_dims = attr.getSpace().getDimensions();
+  if(attr_dims.size()>1){
+    Rcpp::stop("Can currently only read	vector and scalar attributes");
+  }
+  auto my_t = h2r_T(attr.getDataType());
+  switch(my_t){
+  case INTSXP:{
+    std::vector<int> retv(attr_dims.front());
+    attr.read(retv);
+    return(Rcpp::wrap(retv));
+    break;
+  }
+  case REALSXP: {
+    std::vector<double> retv(attr_dims.front());
+    attr.read(retv);
+    return(Rcpp::wrap(retv));
+    break;
+  }
+  case STRSXP: {
+    std::vector<std::string> retv(attr_dims.front());
+    attr.read(retv);
+    return(Rcpp::wrap(retv));
+    break;
+  }
+  default: {
+    warning(
+	    "Invalid SEXPTYPE %d.\n",
+	    my_t
+	    );
+    Rcpp::Rcerr<<attribute_name<<" has type that can't be read"<<std::endl;
+    Rcpp::stop("Can't read type");
+    return R_NilValue;
+  }
+  }
+}
+
+SEXP read_attribute(const HighFive::Group &der,const std::string attribute_name){
 
   auto attr = der.getAttribute(attribute_name);
-  attr.getDataType().getId();
+
   std::vector<size_t> attr_dims = attr.getSpace().getDimensions();
   if(attr_dims.size()>1){
     Rcpp::stop("Can currently only read	vector and scalar attributes");
   }
-  auto my_t = h2r_T(attr.getDataType().getId());
+  auto my_t = h2r_T(attr.getDataType());
   switch(my_t){
   case INTSXP:{
     std::vector<int> retv(attr_dims.front());
@@ -192,6 +244,12 @@ SEXP read_attribute(const Derivate der,const std::string attribute_name){
   }
 }
 
+
+
+
+
+
+
 template <typename Derivate>
 void write_attribute(Derivate &der,const std::string attribute_name,const Rcpp::RObject data){
   using namespace HighFive;
@@ -267,7 +325,12 @@ void write_elem_v_h5(HighFive::Selection &file_sel,
 }
 
 
-int longest_string_size(Rcpp::StringVector input,const int min_size=255){
+int longest_string_size(Rcpp::StringVector input,int min_size=255){
+
+  #ifdef DEBUG
+  min_size=0;
+  #endif
+
 
   using input_elem = decltype(input.begin());
   int ret_size=0;
@@ -281,11 +344,33 @@ int longest_string_size(Rcpp::StringVector input,const int min_size=255){
   return (std::max(ret_size, min_size)+1);
 }
 
+
+
+int longest_string_size(std::vector<std::string> input,int min_size=255){
+
+  #ifdef DEBUG
+  min_size=0;
+  #endif
+
+
+  int ret_size=0;
+  if(input.begin()!=input.end()){
+    ret_size = std::max_element(input.begin(), input.end(),
+                                [](std::string& a, std::string& b) {
+                                  return a.size() < b.size();
+                                })->size();
+  }
+  return (std::max(ret_size, min_size)+1);
+}
+
+
+
+
 HighFive::DataSet create_dataset(HighFive::Group &group,
 				 const Path &dataname,
 				 const Rcpp::RObject &data,
 				 HighFive::DataSpace &space,
-				 HighFive::Filter &filter){
+				 HighFive::Filter &filter,int min_string_size=255){
   using namespace HighFive;
   auto my_t = data.sexp_type();
   switch (my_t){
@@ -296,7 +381,7 @@ HighFive::DataSet create_dataset(HighFive::Group &group,
     return(group.createDataSet(dataname, space, HighFive::AtomicType<double>(), filter));
   }
   case STRSXP: {
-    int data_size = longest_string_size(Rcpp::as<Rcpp::StringVector>(data));
+    int data_size = longest_string_size(Rcpp::as<Rcpp::StringVector>(data),min_string_size);
     return (group.createDataSet(
         dataname, space, HighFive::AtomicType<std::string>(data_size), filter));
   }
@@ -310,14 +395,18 @@ HighFive::DataSet create_dataset(HighFive::Group &group,
   }
 }
 
-SEXPTYPE typeof_h5_dset(HighFive::DataSet &dset){
+
+
+
+
+SEXPTYPE typeof_h5_dset(const HighFive::DataSet &dset){
   using namespace HighFive;
-  return(h2r_T(dset.getDataType().getId()));
+  return(h2r_T(dset.getDataType()));
 }
 
 SEXPTYPE typeof_h5_attr(HighFive::Attribute &attr){
   using namespace HighFive;
-  return(h2r_T(attr.getDataType().getId()));
+  return(h2r_T(attr.getDataType()));
 }
 
 std::vector<size_t> dataset_dims(std::string filename,
@@ -328,6 +417,28 @@ std::vector<size_t> dataset_dims(std::string filename,
 }
 
 
+// Rcpp::RawVector	read_raw_chunk(std::string filename,
+// 			       std::string datapath,
+// 			       Rcpp::IntegerVector chunk_idx){
+
+//   auto dp=root_path(datapath);
+
+//   HighFive::File file(filename,HighFive::File::ReadOnly);
+//   auto ds=  file.getDataSet(dp);
+//   auto chunk_dims = ds.getFilter().get_chunksizes();
+//   std::vector<hsize_t> mchunk_idx(chunk_dims.size());
+//   for(int i=0; i<chunk_idx.size();i++){
+//     mchunk_idx[i]=chunk_idx*chunk_dims[i];
+//   }
+//   Rcpp::RawVector(
+//   void*	td=
+//   return(.read_raw_chunkmchunk_idx));
+// }
+
+
+
+
+
 
 //[[Rcpp::export]]
 SEXP read_vector(std::string filename,
@@ -348,24 +459,19 @@ SEXP read_vector(std::string filename,
 
   auto file_sel=datasel.makeSelection(dset);
   auto my_t = typeof_h5_dset(dset);
-
+  Rcpp::RObject ret;
   switch (my_t){
   case INTSXP: {
-    auto ret = read_elem_v_h5<INTSXP>(file_sel,datasel);
-
-    return(ret);
+    ret = read_elem_v_h5<INTSXP>(file_sel,datasel);
     break;
   }
   case REALSXP: {
-    auto ret = read_elem_v_h5<REALSXP>(file_sel,datasel);
-
-    return(ret);
+    ret = read_elem_v_h5<REALSXP>(file_sel,datasel);
     break;
   }
   case STRSXP: {
-    auto ret = read_elem_v_h5<STRSXP>(file_sel,datasel);
+    ret = read_elem_v_h5<STRSXP>(file_sel,datasel);
 
-    return(ret);
     break;
   }
   default: {
@@ -379,6 +485,11 @@ SEXP read_vector(std::string filename,
     return R_NilValue;
   }
   }
+  auto attr_v=list_R_attr(dset);
+  for(auto &attr :attr_v){
+    ret.attr(attr.substr(2))=read_attribute(dset,attr);
+  }
+  return ret;
 }
 
 
@@ -482,7 +593,26 @@ bool update_matrix(RObject data,
 
 
 
-
+bool check_string_fits(Rcpp::StringVector input,const HighFive::DataSet dset){
+  auto dt_size = dset.getDataType().n_elem();
+  using input_elem = decltype(input.begin());
+  int ret_size=0;
+  if(input.begin()!=input.end()){
+    auto ret_el = std::max_element(input.begin(), input.end(),
+                                [](input_elem a, input_elem b) {
+                                  return a->size() < b->size();
+                                });
+    auto lss=ret_el->size()+1;
+  if(lss > dt_size){
+    Rcpp::Rcerr<<"longest string in dataset is of size:"<<
+      lss<<"dataset can only fit up to string size: "<<dt_size<<std::endl;
+    auto d_dist = ret_el-input.begin();
+    Rcpp::Rcerr<<"longest string in dataset is at position:"<<d_dist<<" first "<<dt_size<<" chars:"<<Rcpp::as<std::string>(*ret_el).substr(0,dt_size)<<std::endl;
+    return false;
+  }
+  }
+  return true;
+}
 
 
 
@@ -523,6 +653,12 @@ bool update_vector(RObject data,
     }
     case STRSXP: {
       Rcpp::Vector<STRSXP> wvec(data);
+      if(!check_string_fits(wvec,*dset)){
+        Rcpp::Rcerr<<"In file"<<filename<<std::endl;
+        Rcpp::Rcerr<<"In dataset"<<datapath<<std::endl;
+        Rcpp::stop("string will not fit in dataset");
+        
+      };
       write_elem_v_h5<STRSXP>(file_sel,datasel,wvec);
       write_success=true;
       break;
@@ -586,15 +722,6 @@ HighFive::Filter create_filter(std::vector<size_t> data_dimensions,
 
 
 
-
-// void write_S4_h5(const std::string filename, std::string datapath,const RObject data){
-//   auto attribs = data.attributeNames();
-
-//   for(auto &n :attribs){
-//     write_vector_h5(
-
-// }
-
 //[[Rcpp::export]]
 bool write_attribute_h5(const RObject &data,
 			const std::string &filename,
@@ -624,26 +751,50 @@ bool write_attribute_h5(const RObject &data,
   return(true);
 }
 
+//[[Rcpp::export]]
+SEXP read_R_attribute_h5(const std::string &filename,
+		      std::string datapath){
+  using namespace HighFive;
+
+  auto dp= root_path(datapath);
+
+  HighFive::File file(filename,HighFive::File::Create | HighFive::File::ReadWrite);
+
+  if(file.isGroup(dp.parent_path())){
+    auto p_obj = file.getGroup(dp.parent_path());
+    return(read_attribute(p_obj,"R:"+dp.filename()));
+  }else{
+    if(file.isDataSet(dp.parent_path())){
+      auto p_obj = file.getDataSet(dp.parent_path());
+      return(read_attribute(p_obj,"R:"+dp.filename()));
+    }
+    else{
+      Rcpp::Rcerr<<dp.parent_path()<<" Is not a dataset or group"<<std::endl;
+      Rcpp::stop("Attributes can only be read from DataSets or Groups");
+    }
+  }
+}
+
+
+
+
 
 //[[Rcpp::export]]
 SEXP read_attribute_h5(const std::string &filename,
 		      std::string datapath){
   using namespace HighFive;
 
-  // if(datapath[0]!='/'){
-  //   datapath="/"+datapath;
-  // }
   auto dp= root_path(datapath);
-  bool create_success=false;
+
   HighFive::File file(filename,HighFive::File::Create | HighFive::File::ReadWrite);
-  
+
   if(file.isGroup(dp.parent_path())){
     auto p_obj = file.getGroup(dp.parent_path());
-    return(read_attribute<Group>(p_obj,dp.filename()));
+    return(read_attribute(p_obj,dp.filename()));
   }else{
     if(file.isDataSet(dp.parent_path())){
       auto p_obj = file.getDataSet(dp.parent_path());
-      return(read_attribute<DataSet>(p_obj,dp.filename()));
+      return(read_attribute(p_obj,dp.filename()));
     }
     else{
       Rcpp::Rcerr<<dp.parent_path()<<" Is not a dataset or group"<<std::endl;
@@ -668,7 +819,8 @@ bool create_dataset_h5(const std::string &filename,
    auto dp=root_path(datapath);
    bool create_success=false;
    HighFive::File file(filename,HighFive::File::Create | HighFive::File::ReadWrite);
-   const bool store_float= get_list_scalar<bool>(options,"float").value_or(false);
+
+
    
 #ifdef DEBUG
    Rcpp::Rcerr<<"opening/creating group: "<<dp.parent_path()<<std::endl;
@@ -682,19 +834,11 @@ bool create_dataset_h5(const std::string &filename,
    Rcpp::Rcerr<<"opening group: "<<dp.parent_path()<<std::endl;
 #endif
 
+   const bool store_float= get_list_scalar<bool>(options,"float").value_or(false);
 
-   auto data_d = get_list_element<INTSXP>(options,"dim");
-   if(!data_d){
-     data_d =get_list_element<INTSXP>(options,"dims");
-   }
-
-   auto	max_d =	get_list_element<INTSXP>(options,"max_dim");
-   if(!max_d){
-     max_d =get_list_element<INTSXP>(options,"max_dims");
-     //     Rcpp::Rcerr<<"max_dims: "<<*max_d<<std::endl;
-   }else{
-     //     Rcerr<<"no max_dims"<<std::endl;
-   }
+   auto min_string_size = get_list_scalar<int>(options,"min_string_size").value_or(255);
+   auto data_d = get_any_list_element<INTSXP>(options,{"dim","dims"});
+   auto	max_d =	get_any_list_element<INTSXP>(options,{"max_dim","max_dims"});
    std::vector<size_t> max_dvec = Rcpp::as<std::vector<size_t> >(max_d.value_or(Rcpp::IntegerVector::create()));
    if(!max_dvec.empty()){
      for(size_t i=0; i<max_dvec.size();i++){
@@ -708,14 +852,24 @@ bool create_dataset_h5(const std::string &filename,
    auto	filt = create_filter(dimvec,options);
    DataSpace space = DataSpace(dimvec,max_dvec);
    if((data.sexp_type()!=STRSXP) && store_float){
-     
-     group->createDataSet(dp.filename(), space, HighFive::AtomicType<float>(), filt);
+     auto dsr = group->createDataSet(dp.filename(), space, HighFive::AtomicType<float>(), filt);
+     auto attrn = data.attributeNames();
+     for( auto &attr : attrn){
+       if(attr != "dim"){
+         write_attribute(dsr,attr,data);
+       }
+     }
      create_success=true;
    }else{
-   create_dataset(group.value(),dp.filename(),data,space,filt);
+     auto dsr = create_dataset(group.value(),dp.filename(),data,space,filt,min_string_size);
+     auto attrn = data.attributeNames();
+     for( auto &attr : attrn){
+       if(attr != "dim"){
+         write_attribute(dsr,"R:"+attr,data.attr(attr));
+       }
+     }
    }
    create_success=true; 
    file.flush();  
   return(create_success);
- }  
-
+}
diff --git a/src/test-dataqueue.cpp b/src/test-dataqueue.cpp
index d509633..b1eb734 100644
--- a/src/test-dataqueue.cpp
+++ b/src/test-dataqueue.cpp
@@ -1,6 +1,7 @@
 
 #include <stdlib.h>
 #include "EigenH5.h"
+#include "eigenh5/indexers.hpp"
 #include <stdio.h>
 #include <testthat.h>
 #include <R.h>
@@ -171,7 +172,38 @@ context("We can read and write matrices using the DataQueue"){
 
 
     }
+}
 
-
+context("Subsetting works"){
+
+  constexpr SubInterval inter(0,100);
+  static_assert(inter.get_offset()==0,"offset works");
+  static_assert(inter.get_size()==100,"size works");
+  static_assert(inter.num_chunks(10)==10,"chunking works");
+  static_assert(inter.num_chunks(11)==10,"ceiling division works");
+  static_assert(inter.chunk_i(0,10)==SubInterval(0,10),"first chunk is first chunk");
+  static_assert(inter.chunk_i(1,10)==SubInterval(10,10),"second chunk is second chunk");
+  static_assert(inter.chunk_i(3,10)==SubInterval(30,10),"third chunk is third chunk");
+  static_assert(inter.chunk_i(1,10).sub_chunk(SubInterval(0,20))==SubInterval(0,10));
+  static_assert(inter.chunk_i(3,10).sub_chunk(SubInterval(0,35))==SubInterval(0,5));
+  static_assert(inter.chunk_selection(SubInterval(3,10),10).get_offset()==0);
+  static_assert(inter.chunk_selection(SubInterval(3,10),10).get_size()==20);
+  static_assert(inter.chunk_selection(SubInterval(0,10),10).get_size()==10);
+  static_assert(inter.chunk_selection(SubInterval(11,10),10).get_size()==20);
+  static_assert(inter.chunk_selection(SubInterval(11,10),10).get_offset()==10);
+
+
+  const ChunkParser cp(100,11,{3,10},false);
+  int i=0;
+  auto ip = cp.begin();
+  expect_true(ip->chunk_size()==8);
+  expect_true(ip->chunk_offset()==3);
+  expect_true(ip->disk_offset()==0);
+  expect_true(ip->disk_size()==11);
+  ip++;
+  expect_true(ip->chunk_size()==2);
+  expect_true(ip->chunk_offset()==0);
+  expect_true(ip->disk_offset()==11);
+  expect_true(ip->disk_size()==11);
 
 }
diff --git a/src/threading.c b/src/threading.c
new file mode 100644
index 0000000..f3d4fa8
--- /dev/null
+++ b/src/threading.c
@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2016 Tino Reichardt
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ *
+ * You can contact the author at:
+ * - zstdmt source repository: https://github.com/mcmilk/zstdmt
+ */
+
+/**
+ * This file will hold wrapper for systems, which do not support pthreads
+ */
+
+/* create fake symbol to avoid empty translation unit warning */
+int g_ZSTD_threading_useless_symbol;
+
+#if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
+
+/**
+ * Windows minimalist Pthread Wrapper, based on :
+ * http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
+ */
+
+
+/* ===  Dependencies  === */
+#include <process.h>
+#include <errno.h>
+#include "threading.h"
+
+
+/* ===  Implementation  === */
+
+static unsigned __stdcall worker(void *arg)
+{
+    ZSTD_pthread_t* const thread = (ZSTD_pthread_t*) arg;
+    thread->arg = thread->start_routine(thread->arg);
+    return 0;
+}
+
+int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
+            void* (*start_routine) (void*), void* arg)
+{
+    (void)unused;
+    thread->arg = arg;
+    thread->start_routine = start_routine;
+    thread->handle = (HANDLE) _beginthreadex(NULL, 0, worker, thread, 0, NULL);
+
+    if (!thread->handle)
+        return errno;
+    else
+        return 0;
+}
+
+int ZSTD_pthread_join(ZSTD_pthread_t thread, void **value_ptr)
+{
+    DWORD result;
+
+    if (!thread.handle) return 0;
+
+    result = WaitForSingleObject(thread.handle, INFINITE);
+    switch (result) {
+    case WAIT_OBJECT_0:
+        if (value_ptr) *value_ptr = thread.arg;
+        return 0;
+    case WAIT_ABANDONED:
+        return EINVAL;
+    default:
+        return GetLastError();
+    }
+}
+
+#endif   /* ZSTD_MULTITHREAD */
diff --git a/src/threading.h b/src/threading.h
new file mode 100644
index 0000000..d806c89
--- /dev/null
+++ b/src/threading.h
@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2016 Tino Reichardt
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ *
+ * You can contact the author at:
+ * - zstdmt source repository: https://github.com/mcmilk/zstdmt
+ */
+
+#ifndef THREADING_H_938743
+#define THREADING_H_938743
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
+
+/**
+ * Windows minimalist Pthread Wrapper, based on :
+ * http://www.cse.wustl.edu/~schmidt/win32-cv-1.html
+ */
+#ifdef WINVER
+#  undef WINVER
+#endif
+#define WINVER       0x0600
+
+#ifdef _WIN32_WINNT
+#  undef _WIN32_WINNT
+#endif
+#define _WIN32_WINNT 0x0600
+
+#ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */
+#include <windows.h>
+#undef ERROR
+#define ERROR(name) ZSTD_ERROR(name)
+
+
+/* mutex */
+#define ZSTD_pthread_mutex_t           CRITICAL_SECTION
+#define ZSTD_pthread_mutex_init(a, b)  ((void)(b), InitializeCriticalSection((a)), 0)
+#define ZSTD_pthread_mutex_destroy(a)  DeleteCriticalSection((a))
+#define ZSTD_pthread_mutex_lock(a)     EnterCriticalSection((a))
+#define ZSTD_pthread_mutex_unlock(a)   LeaveCriticalSection((a))
+
+/* condition variable */
+#define ZSTD_pthread_cond_t             CONDITION_VARIABLE
+#define ZSTD_pthread_cond_init(a, b)    ((void)(b), InitializeConditionVariable((a)), 0)
+#define ZSTD_pthread_cond_destroy(a)    ((void)(a))
+#define ZSTD_pthread_cond_wait(a, b)    SleepConditionVariableCS((a), (b), INFINITE)
+#define ZSTD_pthread_cond_signal(a)     WakeConditionVariable((a))
+#define ZSTD_pthread_cond_broadcast(a)  WakeAllConditionVariable((a))
+
+/* ZSTD_pthread_create() and ZSTD_pthread_join() */
+typedef struct {
+    HANDLE handle;
+    void* (*start_routine)(void*);
+    void* arg;
+} ZSTD_pthread_t;
+
+int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
+                   void* (*start_routine) (void*), void* arg);
+
+int ZSTD_pthread_join(ZSTD_pthread_t thread, void** value_ptr);
+
+/**
+ * add here more wrappers as required
+ */
+
+
+#elif defined(ZSTD_MULTITHREAD)   /* posix assumed ; need a better detection method */
+/* ===   POSIX Systems   === */
+#  include <pthread.h>
+
+#define ZSTD_pthread_mutex_t            pthread_mutex_t
+#define ZSTD_pthread_mutex_init(a, b)   pthread_mutex_init((a), (b))
+#define ZSTD_pthread_mutex_destroy(a)   pthread_mutex_destroy((a))
+#define ZSTD_pthread_mutex_lock(a)      pthread_mutex_lock((a))
+#define ZSTD_pthread_mutex_unlock(a)    pthread_mutex_unlock((a))
+
+#define ZSTD_pthread_cond_t             pthread_cond_t
+#define ZSTD_pthread_cond_init(a, b)    pthread_cond_init((a), (b))
+#define ZSTD_pthread_cond_destroy(a)    pthread_cond_destroy((a))
+#define ZSTD_pthread_cond_wait(a, b)    pthread_cond_wait((a), (b))
+#define ZSTD_pthread_cond_signal(a)     pthread_cond_signal((a))
+#define ZSTD_pthread_cond_broadcast(a)  pthread_cond_broadcast((a))
+
+#define ZSTD_pthread_t                  pthread_t
+#define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))
+#define ZSTD_pthread_join(a, b)         pthread_join((a),(b))
+
+#else  /* ZSTD_MULTITHREAD not defined */
+/* No multithreading support */
+
+typedef int ZSTD_pthread_mutex_t;
+#define ZSTD_pthread_mutex_init(a, b)   ((void)(a), (void)(b), 0)
+#define ZSTD_pthread_mutex_destroy(a)   ((void)(a))
+#define ZSTD_pthread_mutex_lock(a)      ((void)(a))
+#define ZSTD_pthread_mutex_unlock(a)    ((void)(a))
+
+typedef int ZSTD_pthread_cond_t;
+#define ZSTD_pthread_cond_init(a, b)    ((void)(a), (void)(b), 0)
+#define ZSTD_pthread_cond_destroy(a)    ((void)(a))
+#define ZSTD_pthread_cond_wait(a, b)    ((void)(a), (void)(b))
+#define ZSTD_pthread_cond_signal(a)     ((void)(a))
+#define ZSTD_pthread_cond_broadcast(a)  ((void)(a))
+
+/* do not use ZSTD_pthread_t */
+
+#endif /* ZSTD_MULTITHREAD */
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* THREADING_H_938743 */
diff --git a/src/utils.cpp b/src/utils.cpp
index a285a8c..eef9640 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -1,9 +1,91 @@
 #include "EigenH5.h"
 //[[depends(RcppEigen)]]
-//[[Rcpp::plugins(cpp11)]]
+//[[depends(RcppParallel)]]
+//[[Rcpp::plugins(cpp17)]]
 #include <array>
-
 // [[Rcpp::interfaces(r, cpp)]]
+#include "rutils/rutils.hpp"
+#if __has_include(<charconv>)
+#include <charconv>
+#else
+#include <cstdio>
+#endif
+#include <set>
+#include <iostream>
+#include <algorithm>
+#include <cstdint>
+
+
+
+
+//[[Rcpp::export]]
+Rcpp::IntegerVector fast_str2int(Rcpp::StringVector input,const int offset=0,const int na_val=NA_INTEGER){
+
+  SEXP str_sxp(input);
+  const size_t p =input.size();
+  Rcpp::IntegerVector ret(p);
+  auto pp = get_string_ptr(str_sxp);
+  int tresult;
+  std::transform(pp,pp+p,ret.begin(),[&](SEXP x){
+                                       if(x==R_NaString)
+                                         return na_val;
+                                       const size_t strl=LENGTH(x);
+                                       const char* chp = CHAR(x);
+                                       const char* beg=chp+offset;
+                                       const char* end=chp+LENGTH( x );
+                                       if(offset>=strl){
+                                         // Rcpp::Rcerr<<"For string"<<CHAR(x)<<std::endl;
+                                         // Rcpp::Rcerr<<"LEN(x): "<<LENGTH(x)<<std::endl;
+                                         // Rcpp::Rcerr<<"string offset greater than string length"<<std::endl;
+                                         return na_val;
+                                       }
+
+#if __has_include(<charconv>)
+                                       if(auto [p, ec] = std::from_chars(beg, end, tresult);
+                                          ec == std::errc())
+                                         return tresult;
+#else
+                                       if(sscanf (beg,"%d",&tresult)>0)
+                                         return(tresult);
+#endif
+                                       return (na_val);
+
+
+                                     });
+  return(ret);
+}
+
+
+
+//[[Rcpp::export]]
+Rcpp::IntegerVector fast_str2ascii(Rcpp::StringVector input,int offset=0){
+
+  SEXP str_sxp(input);
+  const size_t p =input.size();
+  Rcpp::IntegerVector ret(p);
+  auto pp = get_string_ptr(str_sxp);
+  std::transform(pp,pp+p,ret.begin(),[&](SEXP x){
+                                       if(x==R_NaString)
+                                         return NA_INTEGER;
+                                       const size_t strl=LENGTH(x);
+                                       const char* chp = CHAR(x);
+                                       const char* beg=chp+offset;
+                                       const char* end=chp+LENGTH( x );
+                                       if(offset>=strl){
+                                         // Rcpp::Rcerr<<"For string"<<CHAR(x)<<"\n";
+                                         // Rcpp::Rcerr<<"LEN(x): "<<LENGTH(x)<<std::endl;
+                                         // Rcpp::Rcerr<<"string offset greater than string length";
+                                         return(NA_INTEGER);
+                                       }
+
+                                       return static_cast<int>(*beg);
+                                     });
+  return(ret);
+}
+
+
+
+
 
 
 
@@ -43,7 +125,6 @@ void create_file_h5(const std::string filename){
 Rcpp::IntegerVector dataset_chunks(const std::string filename,
 				   const std::string datapath){
   using namespace HighFive;
-  bool ret = false;
   HighFive::File file(filename,HighFive::File::ReadOnly);
   return(Rcpp::wrap(file.getDataSet(Path(datapath)).getFilter().get_chunksizes()));
 }
@@ -78,8 +159,9 @@ Rcpp::List get_datset_filter(const std::string filename, const std::string datap
   HighFive::File file(filename,HighFive::File::ReadOnly);
   auto filt_pair = file.getDataSet(Path(datapath)).getFilter().get_filter_info();
   using namespace Rcpp;
-  return(List::create(_["name"]=wrap(filt_pair.first),
-		      _["options"]=wrap(filt_pair.second)));
+  return wrap_pair(filt_pair,"name","options");
+  // return(List::create(_["name"]=wrap(filt_pair.first),
+  //       	      _["options"]=wrap(filt_pair.second)));
 }
 
 
@@ -116,6 +198,15 @@ bool isObject(const std::string filename, std::string dataname) {
   return (ret);
 }
 
+
+//[[Rcpp::export]]
+int ArrayTypeSize(const std::string filename, std::string dataname) {
+
+  auto ret = HighFive::File(filename,HighFive::File::ReadOnly).getGroup(Path("/")).getDataSet(Path("/" + dataname)).getDataType().n_elem();
+  return (ret);
+}
+
+
 //[[Rcpp::export]]
 bool isDataSet(const std::string filename, std::string dataname){
 
@@ -152,6 +243,8 @@ bool isGroup(const std::string filename, std::string dataname){
   return(ret);
 }
 
+
+
 //[[Rcpp::export("ls_h5_exp")]]
 Rcpp::StringVector ls_h5(const std::string filename,Rcpp::CharacterVector groupname = Rcpp::CharacterVector::create("/"),
                          bool full_names=false){
@@ -180,9 +273,14 @@ Rcpp::StringVector ls_h5(const std::string filename,Rcpp::CharacterVector groupn
 
   return (retvec);
 }
+
+
+
+
+
 //[[Rcpp::export]]
-Rcpp::StringVector typeof_h5(const std::string &filename,
-                   const std::string &datapath){
+Rcpp::StringVector typeof_h5(const std::string filename,
+                   const std::string datapath){
 
 
   using namespace HighFive;
@@ -192,68 +290,52 @@ Rcpp::StringVector typeof_h5(const std::string &filename,
   }
   HighFive::File file(filename,HighFive::File::ReadOnly);
   auto arg = file.getDataSet(Path(datapath));
-  SEXPTYPE h2t = h2r_T(arg.getDataType().getId());
-  Rcpp::StringVector ret;
-  if (h2t == REALSXP){
-    ret = Rcpp::StringVector::create("double");
-  }else{
-    if (h2t == INTSXP){
-      ret = Rcpp::StringVector::create("integer");
+  return(h2s_T(arg.getDataType()));
+}
+
+
+
+//[[Rcpp::export]]
+Rcpp::List info_h5(const Rcpp::StringVector filename, Rcpp::StringVector datapaths){
+  using namespace Rcpp;
+  const auto file = HighFive::File(as<std::string>(filename[0]),HighFive::File::ReadOnly);
+
+  const size_t num_datasets = datapaths.size();
+  std::vector<HighFive::DataSet> dsets;
+
+  List dim_l(num_datasets);
+  StringVector types(num_datasets);
+  IntegerVector disk_size(num_datasets);
+  List filter_l(num_datasets);
+
+  //  std::unordered_set<size_t> ds_sizes;
+  for(int i=0; i<num_datasets;i++){
+    auto obj_v = file.getObject(as<std::string>(datapaths(i)));
+    if(auto dset = std::get_if<HighFive::DataSet>(&obj_v)){
+      auto dsd = dset->getSpace().getDimensions();
+      IntegerVector tr(dsd.begin(),dsd.end());
+      dim_l[i]=tr;
+      types[i]=h2s_T(dset->getDataType())[0];
+      disk_size[i] = static_cast<int>(dset->getStorageSize());
+      filter_l[i]=wrap_pair(dset->getFilter().get_filter_info(),"name","options");
     }else{
-      if(h2t == STRSXP){
-	ret = Rcpp::StringVector::create("character");
-      }else{
-	ret = Rcpp::StringVector::create("NULL");
-      }
+      dim_l[i]=IntegerVector::create(NA_INTEGER);
+      types[i]="group";
+      disk_size[i]=NA_INTEGER;
+      filter_l[i]=NA_INTEGER;
     }
   }
-
-  return(ret);
+  auto m_ret_l = List::create(_["name"]=datapaths,
+                          _["type"]=types,
+                          _["storage_size"]=disk_size,
+                          _["dims"]=dim_l,
+                          _["filter"]=filter_l);
+  m_ret_l.attr("class") = StringVector::create("tbl_df","tbl","data.frame");
+  m_ret_l.attr("row.names") = seq(1, num_datasets);
+  return m_ret_l;
 }
 
 
-// 
-// Rcpp::IntegerVector subset_h5(const std::string	filename, Rcpp::DataFrame check,const std::string path_prefix="/",const int chunksize=5000){
-// 
-//   using namespace HighFive;
-// 
-// 
-//   HighFive::File file(filename,HighFive::File::ReadOnly);
-// 
-//   auto group=file.getGroup(path_prefix);
-//   auto test_names = df.attr("names");
-//   std::map<std::string,DataSet> ds;
-//   size_t op=0;
-//   for(auto it : test_names){
-//     if( auto dsn = group.openDataSet(it)){
-//       auto p_d = dsn->getDataDimensions();
-//       if(p_d.size()!=1){
-// 	if(p_d.[1]!=1){
-// 	  Rcpp::Rcerr<<"In datapath"<<path_prefix<<"/"<<it<<std::endl;
-// 	  Rcpp::Rcerr<<"dataset is of dimensions:";
-// 	  for( auto ip : p_d){
-// 	    Rcpp::Rcerr<<ip<<"\n";
-// 	  }
-// 
-// 	  Rcpp::stop("Dataset must be vector or one column matrix");
-// 	}
-//       }
-//       if(op=0){
-// 	op=p_d[0];
-//       }
-//       if(p_d[0]!=op){
-// 	Rcpp::Rcerr<<"In datapath"<<path_prefix<<"/"<<it<<std::endl;
-// 	Rcpp::Rcerr<<"data is of length "<<p_d[0]<<std::endl;
-// 	Rcpp::stop("datasets must all be of the same dimension!");
-//       }
-//       ds.insert(it,*dsn);
-//     }
-//   }
-// 
-// 
-// }
-
-
 inline bool exists_file (const std::string& name) {
     std::ifstream f(name.c_str());
     return f.good();
@@ -299,7 +381,6 @@ Rcpp::DataFrame file_acc_ct(const std::string filename){
 }
 
 
-
 //[[Rcpp::export]]
 Rcpp::IntegerVector dim_h5(const std::string &filename,const std::string datapath){
 
@@ -359,6 +440,3 @@ void concat_mats(const std::string newfile, const std::string newpath, Rcpp::Lis
   H5Dclose(dset);
 
 }
-
-
-
diff --git a/src/xxhash.c b/src/xxhash.c
new file mode 100644
index 0000000..99d2459
--- /dev/null
+++ b/src/xxhash.c
@@ -0,0 +1,882 @@
+/*
+*  xxHash - Fast Hash algorithm
+*  Copyright (C) 2012-2016, Yann Collet
+*
+*  BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions are
+*  met:
+*
+*  * Redistributions of source code must retain the above copyright
+*  notice, this list of conditions and the following disclaimer.
+*  * Redistributions in binary form must reproduce the above
+*  copyright notice, this list of conditions and the following disclaimer
+*  in the documentation and/or other materials provided with the
+*  distribution.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*  You can contact the author at :
+*  - xxHash homepage: http://www.xxhash.com
+*  - xxHash source repository : https://github.com/Cyan4973/xxHash
+*/
+
+
+/* *************************************
+*  Tuning parameters
+***************************************/
+/*!XXH_FORCE_MEMORY_ACCESS :
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
+ *            It can generate buggy code on targets which do not support unaligned memory accesses.
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://stackoverflow.com/a/32095106/646947 for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define XXH_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) )) || \
+  defined(__ICCARM__)
+#    define XXH_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+/*!XXH_ACCEPT_NULL_INPUT_POINTER :
+ * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
+ * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
+ * By default, this option is disabled. To enable it, uncomment below define :
+ */
+/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */
+
+/*!XXH_FORCE_NATIVE_FORMAT :
+ * By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
+ * Results are therefore identical for little-endian and big-endian CPU.
+ * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
+ * Should endian-independence be of no importance for your application, you may set the #define below to 1,
+ * to improve speed for Big-endian CPU.
+ * This option has no impact on Little_Endian CPU.
+ */
+#ifndef XXH_FORCE_NATIVE_FORMAT   /* can be defined externally */
+#  define XXH_FORCE_NATIVE_FORMAT 0
+#endif
+
+/*!XXH_FORCE_ALIGN_CHECK :
+ * This is a minor performance trick, only useful with lots of very small keys.
+ * It means : check for aligned/unaligned input.
+ * The check costs one initial branch per hash; set to 0 when the input data
+ * is guaranteed to be aligned.
+ */
+#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
+#  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
+#    define XXH_FORCE_ALIGN_CHECK 0
+#  else
+#    define XXH_FORCE_ALIGN_CHECK 1
+#  endif
+#endif
+
+
+/* *************************************
+*  Includes & Memory related functions
+***************************************/
+/* Modify the local functions below should you wish to use some other memory routines */
+/* for malloc(), free() */
+#include <stdlib.h>
+#include <stddef.h>     /* size_t */
+static void* XXH_malloc(size_t s) { return malloc(s); }
+static void  XXH_free  (void* p)  { free(p); }
+/* for memcpy() */
+#include <string.h>
+static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
+
+#ifndef XXH_STATIC_LINKING_ONLY
+#  define XXH_STATIC_LINKING_ONLY
+#endif
+#include "xxhash.h"
+
+
+/* *************************************
+*  Compiler Specific Options
+***************************************/
+#if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#  define INLINE_KEYWORD inline
+#else
+#  define INLINE_KEYWORD
+#endif
+
+#if defined(__GNUC__) || defined(__ICCARM__)
+#  define FORCE_INLINE_ATTR __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#  define FORCE_INLINE_ATTR __forceinline
+#else
+#  define FORCE_INLINE_ATTR
+#endif
+
+#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
+
+
+#ifdef _MSC_VER
+#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
+#endif
+
+
+/* *************************************
+*  Basic Types
+***************************************/
+#ifndef MEM_MODULE
+# define MEM_MODULE
+# if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+    typedef uint8_t  BYTE;
+    typedef uint16_t U16;
+    typedef uint32_t U32;
+    typedef  int32_t S32;
+    typedef uint64_t U64;
+#  else
+    typedef unsigned char      BYTE;
+    typedef unsigned short     U16;
+    typedef unsigned int       U32;
+    typedef   signed int       S32;
+    typedef unsigned long long U64;   /* if your compiler doesn't support unsigned long long, replace by another 64-bit type here. Note that xxhash.h will also need to be updated. */
+#  endif
+#endif
+
+
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
+
+/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
+static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; }
+static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign;
+
+static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+static U64 XXH_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+#else
+
+/* portable and safe solution. Generally efficient.
+ * see : http://stackoverflow.com/a/32095106/646947
+ */
+
+static U32 XXH_read32(const void* memPtr)
+{
+    U32 val;
+    memcpy(&val, memPtr, sizeof(val));
+    return val;
+}
+
+static U64 XXH_read64(const void* memPtr)
+{
+    U64 val;
+    memcpy(&val, memPtr, sizeof(val));
+    return val;
+}
+
+#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
+
+
+/* ****************************************
+*  Compiler-specific Functions and Macros
+******************************************/
+#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+
+/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
+#if defined(_MSC_VER)
+#  define XXH_rotl32(x,r) _rotl(x,r)
+#  define XXH_rotl64(x,r) _rotl64(x,r)
+#else
+#if defined(__ICCARM__)
+#  include <intrinsics.h>
+#  define XXH_rotl32(x,r) __ROR(x,(32 - r))
+#else
+#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
+#endif
+#  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r)))
+#endif
+
+#if defined(_MSC_VER)     /* Visual Studio */
+#  define XXH_swap32 _byteswap_ulong
+#  define XXH_swap64 _byteswap_uint64
+#elif GCC_VERSION >= 403
+#  define XXH_swap32 __builtin_bswap32
+#  define XXH_swap64 __builtin_bswap64
+#else
+static U32 XXH_swap32 (U32 x)
+{
+    return  ((x << 24) & 0xff000000 ) |
+            ((x <<  8) & 0x00ff0000 ) |
+            ((x >>  8) & 0x0000ff00 ) |
+            ((x >> 24) & 0x000000ff );
+}
+static U64 XXH_swap64 (U64 x)
+{
+    return  ((x << 56) & 0xff00000000000000ULL) |
+            ((x << 40) & 0x00ff000000000000ULL) |
+            ((x << 24) & 0x0000ff0000000000ULL) |
+            ((x << 8)  & 0x000000ff00000000ULL) |
+            ((x >> 8)  & 0x00000000ff000000ULL) |
+            ((x >> 24) & 0x0000000000ff0000ULL) |
+            ((x >> 40) & 0x000000000000ff00ULL) |
+            ((x >> 56) & 0x00000000000000ffULL);
+}
+#endif
+
+
+/* *************************************
+*  Architecture Macros
+***************************************/
+typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
+
+/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
+#ifndef XXH_CPU_LITTLE_ENDIAN
+    static const int g_one = 1;
+#   define XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one))
+#endif
+
+
+/* ***************************
+*  Memory reads
+*****************************/
+typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
+
+FORCE_INLINE_TEMPLATE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
+{
+    if (align==XXH_unaligned)
+        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
+    else
+        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
+}
+
+FORCE_INLINE_TEMPLATE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
+{
+    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
+}
+
+static U32 XXH_readBE32(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
+}
+
+FORCE_INLINE_TEMPLATE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
+{
+    if (align==XXH_unaligned)
+        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
+    else
+        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
+}
+
+FORCE_INLINE_TEMPLATE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
+{
+    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
+}
+
+static U64 XXH_readBE64(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
+}
+
+
+/* *************************************
+*  Macros
+***************************************/
+#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; }    /* use only *after* variable declarations */
+
+
+/* *************************************
+*  Constants
+***************************************/
+static const U32 PRIME32_1 = 2654435761U;
+static const U32 PRIME32_2 = 2246822519U;
+static const U32 PRIME32_3 = 3266489917U;
+static const U32 PRIME32_4 =  668265263U;
+static const U32 PRIME32_5 =  374761393U;
+
+static const U64 PRIME64_1 = 11400714785074694791ULL;
+static const U64 PRIME64_2 = 14029467366897019727ULL;
+static const U64 PRIME64_3 =  1609587929392839161ULL;
+static const U64 PRIME64_4 =  9650029242287828579ULL;
+static const U64 PRIME64_5 =  2870177450012600261ULL;
+
+XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
+
+
+/* **************************
+*  Utils
+****************************/
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* restrict dstState, const XXH32_state_t* restrict srcState)
+{
+    memcpy(dstState, srcState, sizeof(*dstState));
+}
+
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* restrict dstState, const XXH64_state_t* restrict srcState)
+{
+    memcpy(dstState, srcState, sizeof(*dstState));
+}
+
+
+/* ***************************
+*  Simple Hash Functions
+*****************************/
+
+static U32 XXH32_round(U32 seed, U32 input)
+{
+    seed += input * PRIME32_2;
+    seed  = XXH_rotl32(seed, 13);
+    seed *= PRIME32_1;
+    return seed;
+}
+
+FORCE_INLINE_TEMPLATE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
+{
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* bEnd = p + len;
+    U32 h32;
+#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
+
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+    if (p==NULL) {
+        len=0;
+        bEnd=p=(const BYTE*)(size_t)16;
+    }
+#endif
+
+    if (len>=16) {
+        const BYTE* const limit = bEnd - 16;
+        U32 v1 = seed + PRIME32_1 + PRIME32_2;
+        U32 v2 = seed + PRIME32_2;
+        U32 v3 = seed + 0;
+        U32 v4 = seed - PRIME32_1;
+
+        do {
+            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
+            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
+            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
+            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
+        } while (p<=limit);
+
+        h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
+    } else {
+        h32  = seed + PRIME32_5;
+    }
+
+    h32 += (U32) len;
+
+    while (p+4<=bEnd) {
+        h32 += XXH_get32bits(p) * PRIME32_3;
+        h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
+        p+=4;
+    }
+
+    while (p<bEnd) {
+        h32 += (*p) * PRIME32_5;
+        h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
+        p++;
+    }
+
+    h32 ^= h32 >> 15;
+    h32 *= PRIME32_2;
+    h32 ^= h32 >> 13;
+    h32 *= PRIME32_3;
+    h32 ^= h32 >> 16;
+
+    return h32;
+}
+
+
+XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
+{
+#if 0
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
+    XXH32_CREATESTATE_STATIC(state);
+    XXH32_reset(state, seed);
+    XXH32_update(state, input, len);
+    return XXH32_digest(state);
+#else
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if (XXH_FORCE_ALIGN_CHECK) {
+        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
+            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
+            else
+                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
+    }   }
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
+    else
+        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
+#endif
+}
+
+
+static U64 XXH64_round(U64 acc, U64 input)
+{
+    acc += input * PRIME64_2;
+    acc  = XXH_rotl64(acc, 31);
+    acc *= PRIME64_1;
+    return acc;
+}
+
+static U64 XXH64_mergeRound(U64 acc, U64 val)
+{
+    val  = XXH64_round(0, val);
+    acc ^= val;
+    acc  = acc * PRIME64_1 + PRIME64_4;
+    return acc;
+}
+
+FORCE_INLINE_TEMPLATE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
+{
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* const bEnd = p + len;
+    U64 h64;
+#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
+
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+    if (p==NULL) {
+        len=0;
+        bEnd=p=(const BYTE*)(size_t)32;
+    }
+#endif
+
+    if (len>=32) {
+        const BYTE* const limit = bEnd - 32;
+        U64 v1 = seed + PRIME64_1 + PRIME64_2;
+        U64 v2 = seed + PRIME64_2;
+        U64 v3 = seed + 0;
+        U64 v4 = seed - PRIME64_1;
+
+        do {
+            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
+            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
+            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
+            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
+        } while (p<=limit);
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+        h64 = XXH64_mergeRound(h64, v1);
+        h64 = XXH64_mergeRound(h64, v2);
+        h64 = XXH64_mergeRound(h64, v3);
+        h64 = XXH64_mergeRound(h64, v4);
+
+    } else {
+        h64  = seed + PRIME64_5;
+    }
+
+    h64 += (U64) len;
+
+    while (p+8<=bEnd) {
+        U64 const k1 = XXH64_round(0, XXH_get64bits(p));
+        h64 ^= k1;
+        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
+        p+=8;
+    }
+
+    if (p+4<=bEnd) {
+        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
+        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
+        p+=4;
+    }
+
+    while (p<bEnd) {
+        h64 ^= (*p) * PRIME64_5;
+        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
+        p++;
+    }
+
+    h64 ^= h64 >> 33;
+    h64 *= PRIME64_2;
+    h64 ^= h64 >> 29;
+    h64 *= PRIME64_3;
+    h64 ^= h64 >> 32;
+
+    return h64;
+}
+
+
+XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
+{
+#if 0
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
+    XXH64_CREATESTATE_STATIC(state);
+    XXH64_reset(state, seed);
+    XXH64_update(state, input, len);
+    return XXH64_digest(state);
+#else
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if (XXH_FORCE_ALIGN_CHECK) {
+        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
+            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
+            else
+                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
+    }   }
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
+    else
+        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
+#endif
+}
+
+
+/* **************************************************
+*  Advanced Hash Functions
+****************************************************/
+
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
+{
+    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
+}
+XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
+{
+    XXH_free(statePtr);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
+{
+    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
+}
+XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
+{
+    XXH_free(statePtr);
+    return XXH_OK;
+}
+
+
+/*** Hash feed ***/
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
+{
+    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state)-4);   /* do not write into reserved, for future removal */
+    state.v1 = seed + PRIME32_1 + PRIME32_2;
+    state.v2 = seed + PRIME32_2;
+    state.v3 = seed + 0;
+    state.v4 = seed - PRIME32_1;
+    memcpy(statePtr, &state, sizeof(state));
+    return XXH_OK;
+}
+
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
+{
+    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state)-8);   /* do not write into reserved, for future removal */
+    state.v1 = seed + PRIME64_1 + PRIME64_2;
+    state.v2 = seed + PRIME64_2;
+    state.v3 = seed + 0;
+    state.v4 = seed - PRIME64_1;
+    memcpy(statePtr, &state, sizeof(state));
+    return XXH_OK;
+}
+
+
+FORCE_INLINE_TEMPLATE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
+{
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* const bEnd = p + len;
+
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+    if (input==NULL) return XXH_ERROR;
+#endif
+
+    state->total_len_32 += (unsigned)len;
+    state->large_len |= (len>=16) | (state->total_len_32>=16);
+
+    if (state->memsize + len < 16)  {   /* fill in tmp buffer */
+        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
+        state->memsize += (unsigned)len;
+        return XXH_OK;
+    }
+
+    if (state->memsize) {   /* some data left from previous update */
+        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
+        {   const U32* p32 = state->mem32;
+            state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
+            state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
+            state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
+            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); p32++;
+        }
+        p += 16-state->memsize;
+        state->memsize = 0;
+    }
+
+    if (p <= bEnd-16) {
+        const BYTE* const limit = bEnd - 16;
+        U32 v1 = state->v1;
+        U32 v2 = state->v2;
+        U32 v3 = state->v3;
+        U32 v4 = state->v4;
+
+        do {
+            v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
+            v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
+            v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
+            v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
+        } while (p<=limit);
+
+        state->v1 = v1;
+        state->v2 = v2;
+        state->v3 = v3;
+        state->v4 = v4;
+    }
+
+    if (p < bEnd) {
+        XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
+        state->memsize = (unsigned)(bEnd-p);
+    }
+
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
+    else
+        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
+}
+
+
+
+FORCE_INLINE_TEMPLATE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
+{
+    const BYTE * p = (const BYTE*)state->mem32;
+    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
+    U32 h32;
+
+    if (state->large_len) {
+        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
+    } else {
+        h32 = state->v3 /* == seed */ + PRIME32_5;
+    }
+
+    h32 += state->total_len_32;
+
+    while (p+4<=bEnd) {
+        h32 += XXH_readLE32(p, endian) * PRIME32_3;
+        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
+        p+=4;
+    }
+
+    while (p<bEnd) {
+        h32 += (*p) * PRIME32_5;
+        h32  = XXH_rotl32(h32, 11) * PRIME32_1;
+        p++;
+    }
+
+    h32 ^= h32 >> 15;
+    h32 *= PRIME32_2;
+    h32 ^= h32 >> 13;
+    h32 *= PRIME32_3;
+    h32 ^= h32 >> 16;
+
+    return h32;
+}
+
+
+XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_digest_endian(state_in, XXH_littleEndian);
+    else
+        return XXH32_digest_endian(state_in, XXH_bigEndian);
+}
+
+
+
+/* **** XXH64 **** */
+
+FORCE_INLINE_TEMPLATE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
+{
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* const bEnd = p + len;
+
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+    if (input==NULL) return XXH_ERROR;
+#endif
+
+    state->total_len += len;
+
+    if (state->memsize + len < 32) {  /* fill in tmp buffer */
+        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
+        state->memsize += (U32)len;
+        return XXH_OK;
+    }
+
+    if (state->memsize) {   /* tmp buffer is full */
+        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
+        state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
+        state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
+        state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
+        state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
+        p += 32-state->memsize;
+        state->memsize = 0;
+    }
+
+    if (p+32 <= bEnd) {
+        const BYTE* const limit = bEnd - 32;
+        U64 v1 = state->v1;
+        U64 v2 = state->v2;
+        U64 v3 = state->v3;
+        U64 v4 = state->v4;
+
+        do {
+            v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
+            v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
+            v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
+            v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
+        } while (p<=limit);
+
+        state->v1 = v1;
+        state->v2 = v2;
+        state->v3 = v3;
+        state->v4 = v4;
+    }
+
+    if (p < bEnd) {
+        XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
+        state->memsize = (unsigned)(bEnd-p);
+    }
+
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
+    else
+        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
+}
+
+
+
+FORCE_INLINE_TEMPLATE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
+{
+    const BYTE * p = (const BYTE*)state->mem64;
+    const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize;
+    U64 h64;
+
+    if (state->total_len >= 32) {
+        U64 const v1 = state->v1;
+        U64 const v2 = state->v2;
+        U64 const v3 = state->v3;
+        U64 const v4 = state->v4;
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+        h64 = XXH64_mergeRound(h64, v1);
+        h64 = XXH64_mergeRound(h64, v2);
+        h64 = XXH64_mergeRound(h64, v3);
+        h64 = XXH64_mergeRound(h64, v4);
+    } else {
+        h64  = state->v3 + PRIME64_5;
+    }
+
+    h64 += (U64) state->total_len;
+
+    while (p+8<=bEnd) {
+        U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian));
+        h64 ^= k1;
+        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
+        p+=8;
+    }
+
+    if (p+4<=bEnd) {
+        h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1;
+        h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
+        p+=4;
+    }
+
+    while (p<bEnd) {
+        h64 ^= (*p) * PRIME64_5;
+        h64  = XXH_rotl64(h64, 11) * PRIME64_1;
+        p++;
+    }
+
+    h64 ^= h64 >> 33;
+    h64 *= PRIME64_2;
+    h64 ^= h64 >> 29;
+    h64 *= PRIME64_3;
+    h64 ^= h64 >> 32;
+
+    return h64;
+}
+
+
+XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH64_digest_endian(state_in, XXH_littleEndian);
+    else
+        return XXH64_digest_endian(state_in, XXH_bigEndian);
+}
+
+
+/* **************************
+*  Canonical representation
+****************************/
+
+/*! Default XXH result types are basic unsigned 32 and 64 bits.
+*   The canonical representation follows human-readable write convention, aka big-endian (large digits first).
+*   These functions allow transformation of hash result into and from its canonical format.
+*   This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs.
+*/
+
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
+{
+    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
+    memcpy(dst, &hash, sizeof(*dst));
+}
+
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
+{
+    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
+    memcpy(dst, &hash, sizeof(*dst));
+}
+
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
+{
+    return XXH_readBE32(src);
+}
+
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
+{
+    return XXH_readBE64(src);
+}
diff --git a/src/xxhash.h b/src/xxhash.h
new file mode 100644
index 0000000..9bad1f5
--- /dev/null
+++ b/src/xxhash.h
@@ -0,0 +1,305 @@
+/*
+   xxHash - Extremely Fast Hash algorithm
+   Header File
+   Copyright (C) 2012-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - xxHash source repository : https://github.com/Cyan4973/xxHash
+*/
+
+/* Notice extracted from xxHash homepage :
+
+xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
+It also successfully passes all tests from the SMHasher suite.
+
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
+
+Name            Speed       Q.Score   Author
+xxHash          5.4 GB/s     10
+CrapWow         3.2 GB/s      2       Andrew
+MumurHash 3a    2.7 GB/s     10       Austin Appleby
+SpookyHash      2.0 GB/s     10       Bob Jenkins
+SBox            1.4 GB/s      9       Bret Mulvey
+Lookup3         1.2 GB/s      9       Bob Jenkins
+SuperFastHash   1.2 GB/s      1       Paul Hsieh
+CityHash64      1.05 GB/s    10       Pike & Alakuijala
+FNV             0.55 GB/s     5       Fowler, Noll, Vo
+CRC32           0.43 GB/s     9
+MD5-32          0.33 GB/s    10       Ronald L. Rivest
+SHA1-32         0.28 GB/s    10
+
+Q.Score is a measure of quality of the hash function.
+It depends on successfully passing SMHasher test set.
+10 is a perfect score.
+
+A 64-bits version, named XXH64, is available since r35.
+It offers much better speed, but for 64-bits applications only.
+Name     Speed on 64 bits    Speed on 32 bits
+XXH64       13.8 GB/s            1.9 GB/s
+XXH32        6.8 GB/s            6.0 GB/s
+*/
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef XXHASH_H_5627135585666179
+#define XXHASH_H_5627135585666179 1
+
+
+/* ****************************
+*  Definitions
+******************************/
+#include <stddef.h>   /* size_t */
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+
+
+/* ****************************
+*  API modifier
+******************************/
+/** XXH_PRIVATE_API
+*   This is useful if you want to include xxhash functions in `static` mode
+*   in order to inline them, and remove their symbol from the public list.
+*   Methodology :
+*     #define XXH_PRIVATE_API
+*     #include "xxhash.h"
+*   `xxhash.c` is automatically included.
+*   It's not useful to compile and link it as a separate module anymore.
+*/
+#ifdef XXH_PRIVATE_API
+#  ifndef XXH_STATIC_LINKING_ONLY
+#    define XXH_STATIC_LINKING_ONLY
+#  endif
+#  if defined(__GNUC__)
+#    define XXH_PUBLIC_API static __inline __attribute__((unused))
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#    define XXH_PUBLIC_API static inline
+#  elif defined(_MSC_VER)
+#    define XXH_PUBLIC_API static __inline
+#  else
+#    define XXH_PUBLIC_API static   /* this version may generate warnings for unused static functions; disable the relevant warning */
+#  endif
+#else
+#  define XXH_PUBLIC_API   /* do nothing */
+#endif /* XXH_PRIVATE_API */
+
+/*!XXH_NAMESPACE, aka Namespace Emulation :
+
+If you want to include _and expose_ xxHash functions from within your own library,
+but also want to avoid symbol collisions with another library which also includes xxHash,
+
+you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
+with the value of XXH_NAMESPACE (so avoid to keep it NULL and avoid numeric values).
+
+Note that no change is required within the calling program as long as it includes `xxhash.h` :
+regular symbol name will be automatically translated by this header.
+*/
+#ifdef XXH_NAMESPACE
+#  define XXH_CAT(A,B) A##B
+#  define XXH_NAME2(A,B) XXH_CAT(A,B)
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
+#endif
+
+
+/* *************************************
+*  Version
+***************************************/
+#define XXH_VERSION_MAJOR    0
+#define XXH_VERSION_MINOR    6
+#define XXH_VERSION_RELEASE  2
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+
+
+/* ****************************
+*  Simple Hash Functions
+******************************/
+typedef unsigned int       XXH32_hash_t;
+typedef unsigned long long XXH64_hash_t;
+
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
+
+/*!
+XXH32() :
+    Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
+    The memory between input & input+length must be valid (allocated and read-accessible).
+    "seed" can be used to alter the result predictably.
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
+XXH64() :
+    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
+    "seed" can be used to alter the result predictably.
+    This function runs 2x faster on 64-bits systems, but slower on 32-bits systems (see benchmark).
+*/
+
+
+/* ****************************
+*  Streaming Hash Functions
+******************************/
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
+
+/*! State allocation, compatible with dynamic libraries */
+
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
+
+
+/* hash streaming */
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
+
+/*
+These functions generate the xxHash of an input provided in multiple segments.
+Note that, for small input, they are slower than single-call functions, due to state management.
+For small input, prefer `XXH32()` and `XXH64()` .
+
+XXH state must first be allocated, using XXH*_createState() .
+
+Start a new hash by initializing state with a seed, using XXH*_reset().
+
+Then, feed the hash state by calling XXH*_update() as many times as necessary.
+Obviously, input must be allocated and read accessible.
+The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
+
+Finally, a hash value can be produced anytime, by using XXH*_digest().
+This function returns the nn-bits hash as an int or long long.
+
+It's still possible to continue inserting input into the hash state after a digest,
+and generate some new hashes later on, by calling again XXH*_digest().
+
+When done, free XXH state space if it was allocated dynamically.
+*/
+
+
+/* **************************
+*  Utils
+****************************/
+#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))   /* ! C99 */
+#  define restrict   /* disable restrict */
+#endif
+
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* restrict dst_state, const XXH32_state_t* restrict src_state);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* restrict dst_state, const XXH64_state_t* restrict src_state);
+
+
+/* **************************
+*  Canonical representation
+****************************/
+/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
+*  The canonical representation uses human-readable write convention, aka big-endian (large digits first).
+*  These functions allow transformation of hash result into and from its canonical format.
+*  This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
+*/
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
+
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+
+#endif /* XXHASH_H_5627135585666179 */
+
+
+
+/* ================================================================================================
+   This section contains definitions which are not guaranteed to remain stable.
+   They may change in future versions, becoming incompatible with a different version of the library.
+   They shall only be used with static linking.
+   Never use these definitions in association with dynamic linking !
+=================================================================================================== */
+#if defined(XXH_STATIC_LINKING_ONLY) && !defined(XXH_STATIC_H_3543687687345)
+#define XXH_STATIC_H_3543687687345
+
+/* These definitions are only meant to allow allocation of XXH state
+   statically, on stack, or in a struct for example.
+   Do not use members directly. */
+
+   struct XXH32_state_s {
+       unsigned total_len_32;
+       unsigned large_len;
+       unsigned v1;
+       unsigned v2;
+       unsigned v3;
+       unsigned v4;
+       unsigned mem32[4];   /* buffer defined as U32 for alignment */
+       unsigned memsize;
+       unsigned reserved;   /* never read nor write, will be removed in a future version */
+   };   /* typedef'd to XXH32_state_t */
+
+   struct XXH64_state_s {
+       unsigned long long total_len;
+       unsigned long long v1;
+       unsigned long long v2;
+       unsigned long long v3;
+       unsigned long long v4;
+       unsigned long long mem64[4];   /* buffer defined as U64 for alignment */
+       unsigned memsize;
+       unsigned reserved[2];          /* never read nor write, will be removed in a future version */
+   };   /* typedef'd to XXH64_state_t */
+
+
+#  ifdef XXH_PRIVATE_API
+#    include "xxhash.c"   /* include xxhash functions as `static`, for inlining */
+#  endif
+
+#endif /* XXH_STATIC_LINKING_ONLY && XXH_STATIC_H_3543687687345 */
+
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/src/zbuff.h b/src/zbuff.h
new file mode 100644
index 0000000..a93115d
--- /dev/null
+++ b/src/zbuff.h
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* ***************************************************************
+*  NOTES/WARNINGS
+******************************************************************/
+/* The streaming API defined here is deprecated.
+ * Consider migrating towards ZSTD_compressStream() API in `zstd.h`
+ * See 'lib/README.md'.
+ *****************************************************************/
+
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef ZSTD_BUFFERED_H_23987
+#define ZSTD_BUFFERED_H_23987
+
+/* *************************************
+*  Dependencies
+***************************************/
+#include <stddef.h>      /* size_t */
+#include "zstd.h"        /* ZSTD_CStream, ZSTD_DStream, ZSTDLIB_API */
+
+
+/* ***************************************************************
+*  Compiler specifics
+*****************************************************************/
+/* Deprecation warnings */
+/* Should these warnings be a problem,
+   it is generally possible to disable them,
+   typically with -Wno-deprecated-declarations for gcc
+   or _CRT_SECURE_NO_WARNINGS in Visual.
+   Otherwise, it's also possible to define ZBUFF_DISABLE_DEPRECATE_WARNINGS */
+#ifdef ZBUFF_DISABLE_DEPRECATE_WARNINGS
+#  define ZBUFF_DEPRECATED(message) ZSTDLIB_API  /* disable deprecation warnings */
+#else
+#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
+#    define ZBUFF_DEPRECATED(message) [[deprecated(message)]] ZSTDLIB_API
+#  elif (defined(__GNUC__) && (__GNUC__ >= 5)) || defined(__clang__)
+#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated(message)))
+#  elif defined(__GNUC__) && (__GNUC__ >= 3)
+#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated))
+#  elif defined(_MSC_VER)
+#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __declspec(deprecated(message))
+#  else
+#    pragma message("WARNING: You need to implement ZBUFF_DEPRECATED for this compiler")
+#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API
+#  endif
+#endif /* ZBUFF_DISABLE_DEPRECATE_WARNINGS */
+
+
+/* *************************************
+*  Streaming functions
+***************************************/
+/* This is the easier "buffered" streaming API,
+*  using an internal buffer to lift all restrictions on user-provided buffers
+*  which can be any size, any place, for both input and output.
+*  ZBUFF and ZSTD are 100% interoperable,
+*  frames created by one can be decoded by the other one */
+
+typedef ZSTD_CStream ZBUFF_CCtx;
+ZBUFF_DEPRECATED("use ZSTD_createCStream") ZBUFF_CCtx* ZBUFF_createCCtx(void);
+ZBUFF_DEPRECATED("use ZSTD_freeCStream")   size_t      ZBUFF_freeCCtx(ZBUFF_CCtx* cctx);
+
+ZBUFF_DEPRECATED("use ZSTD_initCStream")           size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel);
+ZBUFF_DEPRECATED("use ZSTD_initCStream_usingDict") size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
+
+ZBUFF_DEPRECATED("use ZSTD_compressStream") size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr);
+ZBUFF_DEPRECATED("use ZSTD_flushStream")    size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);
+ZBUFF_DEPRECATED("use ZSTD_endStream")      size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);
+
+/*-*************************************************
+*  Streaming compression - howto
+*
+*  A ZBUFF_CCtx object is required to track streaming operation.
+*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.
+*  ZBUFF_CCtx objects can be reused multiple times.
+*
+*  Start by initializing ZBUF_CCtx.
+*  Use ZBUFF_compressInit() to start a new compression operation.
+*  Use ZBUFF_compressInitDictionary() for a compression which requires a dictionary.
+*
+*  Use ZBUFF_compressContinue() repetitively to consume input stream.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written within *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present again remaining data.
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst .
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's just a hint, to improve latency)
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  At any moment, it's possible to flush whatever data remains within buffer, using ZBUFF_compressFlush().
+*  The nb of bytes written into `dst` will be reported into *dstCapacityPtr.
+*  Note that the function cannot output more than *dstCapacityPtr,
+*  therefore, some content might still be left into internal buffer if *dstCapacityPtr is too small.
+*  @return : nb of bytes still present into internal buffer (0 if it's empty)
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  ZBUFF_compressEnd() instructs to finish a frame.
+*  It will perform a flush and write frame epilogue.
+*  The epilogue is required for decoders to consider a frame completed.
+*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.
+*  In which case, call again ZBUFF_compressFlush() to complete the flush.
+*  @return : nb of bytes still present into internal buffer (0 if it's empty)
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  Hint : _recommended buffer_ sizes (not compulsory) : ZBUFF_recommendedCInSize() / ZBUFF_recommendedCOutSize()
+*  input : ZBUFF_recommendedCInSize==128 KB block size is the internal unit, use this value to reduce intermediate stages (better latency)
+*  output : ZBUFF_recommendedCOutSize==ZSTD_compressBound(128 KB) + 3 + 3 : ensures it's always possible to write/flush/end a full block. Skip some buffering.
+*  By using both, it ensures that input will be entirely consumed, and output will always contain the result, reducing intermediate buffering.
+* **************************************************/
+
+
+typedef ZSTD_DStream ZBUFF_DCtx;
+ZBUFF_DEPRECATED("use ZSTD_createDStream") ZBUFF_DCtx* ZBUFF_createDCtx(void);
+ZBUFF_DEPRECATED("use ZSTD_freeDStream")   size_t      ZBUFF_freeDCtx(ZBUFF_DCtx* dctx);
+
+ZBUFF_DEPRECATED("use ZSTD_initDStream")           size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx);
+ZBUFF_DEPRECATED("use ZSTD_initDStream_usingDict") size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* dctx, const void* dict, size_t dictSize);
+
+ZBUFF_DEPRECATED("use ZSTD_decompressStream") size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx,
+                                            void* dst, size_t* dstCapacityPtr,
+                                      const void* src, size_t* srcSizePtr);
+
+/*-***************************************************************************
+*  Streaming decompression howto
+*
+*  A ZBUFF_DCtx object is required to track streaming operations.
+*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
+*  Use ZBUFF_decompressInit() to start a new decompression operation,
+*   or ZBUFF_decompressInitDictionary() if decompression requires a dictionary.
+*  Note that ZBUFF_DCtx objects can be re-init multiple times.
+*
+*  Use ZBUFF_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
+*  @return : 0 when a frame is completely decoded and fully flushed,
+*            1 when there is still some data left within internal buffer to flush,
+*            >1 when more data is expected, with value being a suggested next input size (it's just a hint, which helps latency),
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize() and ZBUFF_recommendedDOutSize()
+*  output : ZBUFF_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
+*  input  : ZBUFF_recommendedDInSize == 128KB + 3;
+*           just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* *******************************************************************************/
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+ZBUFF_DEPRECATED("use ZSTD_isError")      unsigned ZBUFF_isError(size_t errorCode);
+ZBUFF_DEPRECATED("use ZSTD_getErrorName") const char* ZBUFF_getErrorName(size_t errorCode);
+
+/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
+*   These sizes are just hints, they tend to offer better latency */
+ZBUFF_DEPRECATED("use ZSTD_CStreamInSize")  size_t ZBUFF_recommendedCInSize(void);
+ZBUFF_DEPRECATED("use ZSTD_CStreamOutSize") size_t ZBUFF_recommendedCOutSize(void);
+ZBUFF_DEPRECATED("use ZSTD_DStreamInSize")  size_t ZBUFF_recommendedDInSize(void);
+ZBUFF_DEPRECATED("use ZSTD_DStreamOutSize") size_t ZBUFF_recommendedDOutSize(void);
+
+#endif  /* ZSTD_BUFFERED_H_23987 */
+
+
+#ifdef ZBUFF_STATIC_LINKING_ONLY
+#ifndef ZBUFF_STATIC_H_30298098432
+#define ZBUFF_STATIC_H_30298098432
+
+/* ====================================================================================
+ * The definitions in this section are considered experimental.
+ * They should never be used in association with a dynamic library, as they may change in the future.
+ * They are provided for advanced usages.
+ * Use them only in association with static linking.
+ * ==================================================================================== */
+
+/*--- Dependency ---*/
+#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_parameters, ZSTD_customMem */
+#include "zstd.h"
+
+
+/*--- Custom memory allocator ---*/
+/*! ZBUFF_createCCtx_advanced() :
+ *  Create a ZBUFF compression context using external alloc and free functions */
+ZBUFF_DEPRECATED("use ZSTD_createCStream_advanced") ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem);
+
+/*! ZBUFF_createDCtx_advanced() :
+ *  Create a ZBUFF decompression context using external alloc and free functions */
+ZBUFF_DEPRECATED("use ZSTD_createDStream_advanced") ZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem);
+
+
+/*--- Advanced Streaming Initialization ---*/
+ZBUFF_DEPRECATED("use ZSTD_initDStream_usingDict") size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
+                                               const void* dict, size_t dictSize,
+                                               ZSTD_parameters params, unsigned long long pledgedSrcSize);
+
+
+#endif    /* ZBUFF_STATIC_H_30298098432 */
+#endif    /* ZBUFF_STATIC_LINKING_ONLY */
+
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/src/zbuff_common.c b/src/zbuff_common.c
new file mode 100644
index 0000000..661b9b0
--- /dev/null
+++ b/src/zbuff_common.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include "error_private.h"
+#include "zbuff.h"
+
+/*-****************************************
+*  ZBUFF Error Management  (deprecated)
+******************************************/
+
+/*! ZBUFF_isError() :
+*   tells if a return value is an error code */
+unsigned ZBUFF_isError(size_t errorCode) { return ERR_isError(errorCode); }
+/*! ZBUFF_getErrorName() :
+*   provides error code string from function result (useful for debugging) */
+const char* ZBUFF_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
diff --git a/src/zbuff_compress.c b/src/zbuff_compress.c
new file mode 100644
index 0000000..f39c60d
--- /dev/null
+++ b/src/zbuff_compress.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+
+/* *************************************
+*  Dependencies
+***************************************/
+#define ZBUFF_STATIC_LINKING_ONLY
+#include "zbuff.h"
+
+
+/*-***********************************************************
+*  Streaming compression
+*
+*  A ZBUFF_CCtx object is required to track streaming operation.
+*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.
+*  Use ZBUFF_compressInit() to start a new compression operation.
+*  ZBUFF_CCtx objects can be reused multiple times.
+*
+*  Use ZBUFF_compressContinue() repetitively to consume your input.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.
+*  The content of dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change dst .
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer.
+*  Note that it will not output more than *dstCapacityPtr.
+*  Therefore, some content might still be left into its internal buffer if dst buffer is too small.
+*  @return : nb of bytes still present into internal buffer (0 if it's empty)
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  ZBUFF_compressEnd() instructs to finish a frame.
+*  It will perform a flush and write frame epilogue.
+*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.
+*  @return : nb of bytes still present into internal buffer (0 if it's empty)
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory)
+*  input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value.
+*  output : ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize : ensures it's always possible to write/flush/end a full block at best speed.
+* ***********************************************************/
+
+ZBUFF_CCtx* ZBUFF_createCCtx(void)
+{
+    return ZSTD_createCStream();
+}
+
+ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem)
+{
+    return ZSTD_createCStream_advanced(customMem);
+}
+
+size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc)
+{
+    return ZSTD_freeCStream(zbc);
+}
+
+
+/* ======   Initialization   ====== */
+
+size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
+                                   const void* dict, size_t dictSize,
+                                   ZSTD_parameters params, unsigned long long pledgedSrcSize)
+{
+    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* preserve "0 == unknown" behavior */
+    return ZSTD_initCStream_advanced(zbc, dict, dictSize, params, pledgedSrcSize);
+}
+
+
+size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel)
+{
+    return ZSTD_initCStream_usingDict(zbc, dict, dictSize, compressionLevel);
+}
+
+size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)
+{
+    return ZSTD_initCStream(zbc, compressionLevel);
+}
+
+/* ======   Compression   ====== */
+
+
+size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc,
+                              void* dst, size_t* dstCapacityPtr,
+                        const void* src, size_t* srcSizePtr)
+{
+    size_t result;
+    ZSTD_outBuffer outBuff;
+    ZSTD_inBuffer inBuff;
+    outBuff.dst = dst;
+    outBuff.pos = 0;
+    outBuff.size = *dstCapacityPtr;
+    inBuff.src = src;
+    inBuff.pos = 0;
+    inBuff.size = *srcSizePtr;
+    result = ZSTD_compressStream(zbc, &outBuff, &inBuff);
+    *dstCapacityPtr = outBuff.pos;
+    *srcSizePtr = inBuff.pos;
+    return result;
+}
+
+
+
+/* ======   Finalize   ====== */
+
+size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
+{
+    size_t result;
+    ZSTD_outBuffer outBuff;
+    outBuff.dst = dst;
+    outBuff.pos = 0;
+    outBuff.size = *dstCapacityPtr;
+    result = ZSTD_flushStream(zbc, &outBuff);
+    *dstCapacityPtr = outBuff.pos;
+    return result;
+}
+
+
+size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
+{
+    size_t result;
+    ZSTD_outBuffer outBuff;
+    outBuff.dst = dst;
+    outBuff.pos = 0;
+    outBuff.size = *dstCapacityPtr;
+    result = ZSTD_endStream(zbc, &outBuff);
+    *dstCapacityPtr = outBuff.pos;
+    return result;
+}
+
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+size_t ZBUFF_recommendedCInSize(void)  { return ZSTD_CStreamInSize(); }
+size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); }
diff --git a/src/zbuff_decompress.c b/src/zbuff_decompress.c
new file mode 100644
index 0000000..923c22b
--- /dev/null
+++ b/src/zbuff_decompress.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+
+/* *************************************
+*  Dependencies
+***************************************/
+#define ZBUFF_STATIC_LINKING_ONLY
+#include "zbuff.h"
+
+
+ZBUFF_DCtx* ZBUFF_createDCtx(void)
+{
+    return ZSTD_createDStream();
+}
+
+ZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem)
+{
+    return ZSTD_createDStream_advanced(customMem);
+}
+
+size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbd)
+{
+    return ZSTD_freeDStream(zbd);
+}
+
+
+/* *** Initialization *** */
+
+size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* zbd, const void* dict, size_t dictSize)
+{
+    return ZSTD_initDStream_usingDict(zbd, dict, dictSize);
+}
+
+size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbd)
+{
+    return ZSTD_initDStream(zbd);
+}
+
+
+/* *** Decompression *** */
+
+size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbd,
+                                void* dst, size_t* dstCapacityPtr,
+                          const void* src, size_t* srcSizePtr)
+{
+    ZSTD_outBuffer outBuff;
+    ZSTD_inBuffer inBuff;
+    size_t result;
+    outBuff.dst  = dst;
+    outBuff.pos  = 0;
+    outBuff.size = *dstCapacityPtr;
+    inBuff.src  = src;
+    inBuff.pos  = 0;
+    inBuff.size = *srcSizePtr;
+    result = ZSTD_decompressStream(zbd, &outBuff, &inBuff);
+    *dstCapacityPtr = outBuff.pos;
+    *srcSizePtr = inBuff.pos;
+    return result;
+}
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+size_t ZBUFF_recommendedDInSize(void)  { return ZSTD_DStreamInSize(); }
+size_t ZBUFF_recommendedDOutSize(void) { return ZSTD_DStreamOutSize(); }
diff --git a/src/zdict.c b/src/zdict.c
new file mode 100644
index 0000000..ee21ee1
--- /dev/null
+++ b/src/zdict.c
@@ -0,0 +1,1111 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/*-**************************************
+*  Tuning parameters
+****************************************/
+#define MINRATIO 4   /* minimum nb of apparition to be selected in dictionary */
+#define ZDICT_MAX_SAMPLES_SIZE (2000U << 20)
+#define ZDICT_MIN_SAMPLES_SIZE (ZDICT_CONTENTSIZE_MIN * MINRATIO)
+
+
+/*-**************************************
+*  Compiler Options
+****************************************/
+/* Unix Large Files support (>4GB) */
+#define _FILE_OFFSET_BITS 64
+#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */
+#  define _LARGEFILE_SOURCE
+#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */
+#  define _LARGEFILE64_SOURCE
+#endif
+
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include <stdlib.h>        /* malloc, free */
+#include <string.h>        /* memset */
+#include <stdio.h>         /* fprintf, fopen, ftello64 */
+#include <time.h>          /* clock */
+
+#include "mem.h"           /* read */
+#include "fse.h"           /* FSE_normalizeCount, FSE_writeNCount */
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"           /* HUF_buildCTable, HUF_writeCTable */
+#include "zstd_internal.h" /* includes zstd.h */
+#include "xxhash.h"        /* XXH64 */
+#include "divsufsort.h"
+#ifndef ZDICT_STATIC_LINKING_ONLY
+#  define ZDICT_STATIC_LINKING_ONLY
+#endif
+#include "zdict.h"
+
+
+/*-*************************************
+*  Constants
+***************************************/
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define DICTLISTSIZE_DEFAULT 10000
+
+#define NOISELENGTH 32
+
+static const int g_compressionLevel_default = 3;
+static const U32 g_selectivity_default = 9;
+
+
+/*-*************************************
+*  Console display
+***************************************/
+#define DISPLAY(...)         { fprintf(stderr, __VA_ARGS__); fflush( stderr ); }
+#define DISPLAYLEVEL(l, ...) if (notificationLevel>=l) { DISPLAY(__VA_ARGS__); }    /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */
+
+static clock_t ZDICT_clockSpan(clock_t nPrevious) { return clock() - nPrevious; }
+
+static void ZDICT_printHex(const void* ptr, size_t length)
+{
+    const BYTE* const b = (const BYTE*)ptr;
+    size_t u;
+    for (u=0; u<length; u++) {
+        BYTE c = b[u];
+        if (c<32 || c>126) c = '.';   /* non-printable char */
+        DISPLAY("%c", c);
+    }
+}
+
+
+/*-********************************************************
+*  Helper functions
+**********************************************************/
+unsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); }
+
+const char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
+
+unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize)
+{
+    if (dictSize < 8) return 0;
+    if (MEM_readLE32(dictBuffer) != ZSTD_MAGIC_DICTIONARY) return 0;
+    return MEM_readLE32((const char*)dictBuffer + 4);
+}
+
+
+/*-********************************************************
+*  Dictionary training functions
+**********************************************************/
+static unsigned ZDICT_NbCommonBytes (size_t val)
+{
+    if (MEM_isLittleEndian()) {
+        if (MEM_64bits()) {
+#       if defined(_MSC_VER) && defined(_WIN64)
+            unsigned long r = 0;
+            _BitScanForward64( &r, (U64)val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_ctzll((U64)val) >> 3);
+#       else
+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
+#       endif
+        } else { /* 32 bits */
+#       if defined(_MSC_VER)
+            unsigned long r=0;
+            _BitScanForward( &r, (U32)val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_ctz((U32)val) >> 3);
+#       else
+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
+#       endif
+        }
+    } else {  /* Big Endian CPU */
+        if (MEM_64bits()) {
+#       if defined(_MSC_VER) && defined(_WIN64)
+            unsigned long r = 0;
+            _BitScanReverse64( &r, val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_clzll(val) >> 3);
+#       else
+            unsigned r;
+            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
+            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
+            r += (!val);
+            return r;
+#       endif
+        } else { /* 32 bits */
+#       if defined(_MSC_VER)
+            unsigned long r = 0;
+            _BitScanReverse( &r, (unsigned long)val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_clz((U32)val) >> 3);
+#       else
+            unsigned r;
+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
+            r += (!val);
+            return r;
+#       endif
+    }   }
+}
+
+
+/*! ZDICT_count() :
+    Count the nb of common bytes between 2 pointers.
+    Note : this function presumes end of buffer followed by noisy guard band.
+*/
+static size_t ZDICT_count(const void* pIn, const void* pMatch)
+{
+    const char* const pStart = (const char*)pIn;
+    for (;;) {
+        size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
+        if (!diff) {
+            pIn = (const char*)pIn+sizeof(size_t);
+            pMatch = (const char*)pMatch+sizeof(size_t);
+            continue;
+        }
+        pIn = (const char*)pIn+ZDICT_NbCommonBytes(diff);
+        return (size_t)((const char*)pIn - pStart);
+    }
+}
+
+
+typedef struct {
+    U32 pos;
+    U32 length;
+    U32 savings;
+} dictItem;
+
+static void ZDICT_initDictItem(dictItem* d)
+{
+    d->pos = 1;
+    d->length = 0;
+    d->savings = (U32)(-1);
+}
+
+
+#define LLIMIT 64          /* heuristic determined experimentally */
+#define MINMATCHLENGTH 7   /* heuristic determined experimentally */
+static dictItem ZDICT_analyzePos(
+                       BYTE* doneMarks,
+                       const int* suffix, U32 start,
+                       const void* buffer, U32 minRatio, U32 notificationLevel)
+{
+    U32 lengthList[LLIMIT] = {0};
+    U32 cumulLength[LLIMIT] = {0};
+    U32 savings[LLIMIT] = {0};
+    const BYTE* b = (const BYTE*)buffer;
+    size_t maxLength = LLIMIT;
+    size_t pos = suffix[start];
+    U32 end = start;
+    dictItem solution;
+
+    /* init */
+    memset(&solution, 0, sizeof(solution));
+    doneMarks[pos] = 1;
+
+    /* trivial repetition cases */
+    if ( (MEM_read16(b+pos+0) == MEM_read16(b+pos+2))
+       ||(MEM_read16(b+pos+1) == MEM_read16(b+pos+3))
+       ||(MEM_read16(b+pos+2) == MEM_read16(b+pos+4)) ) {
+        /* skip and mark segment */
+        U16 const pattern16 = MEM_read16(b+pos+4);
+        U32 u, patternEnd = 6;
+        while (MEM_read16(b+pos+patternEnd) == pattern16) patternEnd+=2 ;
+        if (b[pos+patternEnd] == b[pos+patternEnd-1]) patternEnd++;
+        for (u=1; u<patternEnd; u++)
+            doneMarks[pos+u] = 1;
+        return solution;
+    }
+
+    /* look forward */
+    {   size_t length;
+        do {
+            end++;
+            length = ZDICT_count(b + pos, b + suffix[end]);
+        } while (length >= MINMATCHLENGTH);
+    }
+
+    /* look backward */
+    {   size_t length;
+        do {
+            length = ZDICT_count(b + pos, b + *(suffix+start-1));
+            if (length >=MINMATCHLENGTH) start--;
+        } while(length >= MINMATCHLENGTH);
+    }
+
+    /* exit if not found a minimum nb of repetitions */
+    if (end-start < minRatio) {
+        U32 idx;
+        for(idx=start; idx<end; idx++)
+            doneMarks[suffix[idx]] = 1;
+        return solution;
+    }
+
+    {   int i;
+        U32 mml;
+        U32 refinedStart = start;
+        U32 refinedEnd = end;
+
+        DISPLAYLEVEL(4, "\n");
+        DISPLAYLEVEL(4, "found %3u matches of length >= %i at pos %7u  ", (unsigned)(end-start), MINMATCHLENGTH, (unsigned)pos);
+        DISPLAYLEVEL(4, "\n");
+
+        for (mml = MINMATCHLENGTH ; ; mml++) {
+            BYTE currentChar = 0;
+            U32 currentCount = 0;
+            U32 currentID = refinedStart;
+            U32 id;
+            U32 selectedCount = 0;
+            U32 selectedID = currentID;
+            for (id =refinedStart; id < refinedEnd; id++) {
+                if (b[suffix[id] + mml] != currentChar) {
+                    if (currentCount > selectedCount) {
+                        selectedCount = currentCount;
+                        selectedID = currentID;
+                    }
+                    currentID = id;
+                    currentChar = b[ suffix[id] + mml];
+                    currentCount = 0;
+                }
+                currentCount ++;
+            }
+            if (currentCount > selectedCount) {  /* for last */
+                selectedCount = currentCount;
+                selectedID = currentID;
+            }
+
+            if (selectedCount < minRatio)
+                break;
+            refinedStart = selectedID;
+            refinedEnd = refinedStart + selectedCount;
+        }
+
+        /* evaluate gain based on new dict */
+        start = refinedStart;
+        pos = suffix[refinedStart];
+        end = start;
+        memset(lengthList, 0, sizeof(lengthList));
+
+        /* look forward */
+        {   size_t length;
+            do {
+                end++;
+                length = ZDICT_count(b + pos, b + suffix[end]);
+                if (length >= LLIMIT) length = LLIMIT-1;
+                lengthList[length]++;
+            } while (length >=MINMATCHLENGTH);
+        }
+
+        /* look backward */
+        {   size_t length = MINMATCHLENGTH;
+            while ((length >= MINMATCHLENGTH) & (start > 0)) {
+                length = ZDICT_count(b + pos, b + suffix[start - 1]);
+                if (length >= LLIMIT) length = LLIMIT - 1;
+                lengthList[length]++;
+                if (length >= MINMATCHLENGTH) start--;
+            }
+        }
+
+        /* largest useful length */
+        memset(cumulLength, 0, sizeof(cumulLength));
+        cumulLength[maxLength-1] = lengthList[maxLength-1];
+        for (i=(int)(maxLength-2); i>=0; i--)
+            cumulLength[i] = cumulLength[i+1] + lengthList[i];
+
+        for (i=LLIMIT-1; i>=MINMATCHLENGTH; i--) if (cumulLength[i]>=minRatio) break;
+        maxLength = i;
+
+        /* reduce maxLength in case of final into repetitive data */
+        {   U32 l = (U32)maxLength;
+            BYTE const c = b[pos + maxLength-1];
+            while (b[pos+l-2]==c) l--;
+            maxLength = l;
+        }
+        if (maxLength < MINMATCHLENGTH) return solution;   /* skip : no long-enough solution */
+
+        /* calculate savings */
+        savings[5] = 0;
+        for (i=MINMATCHLENGTH; i<=(int)maxLength; i++)
+            savings[i] = savings[i-1] + (lengthList[i] * (i-3));
+
+        DISPLAYLEVEL(4, "Selected dict at position %u, of length %u : saves %u (ratio: %.2f)  \n",
+                     (unsigned)pos, (unsigned)maxLength, (unsigned)savings[maxLength], (double)savings[maxLength] / maxLength);
+
+        solution.pos = (U32)pos;
+        solution.length = (U32)maxLength;
+        solution.savings = savings[maxLength];
+
+        /* mark positions done */
+        {   U32 id;
+            for (id=start; id<end; id++) {
+                U32 p, pEnd, length;
+                U32 const testedPos = suffix[id];
+                if (testedPos == pos)
+                    length = solution.length;
+                else {
+                    length = (U32)ZDICT_count(b+pos, b+testedPos);
+                    if (length > solution.length) length = solution.length;
+                }
+                pEnd = (U32)(testedPos + length);
+                for (p=testedPos; p<pEnd; p++)
+                    doneMarks[p] = 1;
+    }   }   }
+
+    return solution;
+}
+
+
+static int isIncluded(const void* in, const void* container, size_t length)
+{
+    const char* const ip = (const char*) in;
+    const char* const into = (const char*) container;
+    size_t u;
+
+    for (u=0; u<length; u++) {  /* works because end of buffer is a noisy guard band */
+        if (ip[u] != into[u]) break;
+    }
+
+    return u==length;
+}
+
+/*! ZDICT_tryMerge() :
+    check if dictItem can be merged, do it if possible
+    @return : id of destination elt, 0 if not merged
+*/
+static U32 ZDICT_tryMerge(dictItem* table, dictItem elt, U32 eltNbToSkip, const void* buffer)
+{
+    const U32 tableSize = table->pos;
+    const U32 eltEnd = elt.pos + elt.length;
+    const char* const buf = (const char*) buffer;
+
+    /* tail overlap */
+    U32 u; for (u=1; u<tableSize; u++) {
+        if (u==eltNbToSkip) continue;
+        if ((table[u].pos > elt.pos) && (table[u].pos <= eltEnd)) {  /* overlap, existing > new */
+            /* append */
+            U32 const addedLength = table[u].pos - elt.pos;
+            table[u].length += addedLength;
+            table[u].pos = elt.pos;
+            table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
+            table[u].savings += elt.length / 8;    /* rough approx bonus */
+            elt = table[u];
+            /* sort : improve rank */
+            while ((u>1) && (table[u-1].savings < elt.savings))
+            table[u] = table[u-1], u--;
+            table[u] = elt;
+            return u;
+    }   }
+
+    /* front overlap */
+    for (u=1; u<tableSize; u++) {
+        if (u==eltNbToSkip) continue;
+
+        if ((table[u].pos + table[u].length >= elt.pos) && (table[u].pos < elt.pos)) {  /* overlap, existing < new */
+            /* append */
+            int const addedLength = (int)eltEnd - (table[u].pos + table[u].length);
+            table[u].savings += elt.length / 8;    /* rough approx bonus */
+            if (addedLength > 0) {   /* otherwise, elt fully included into existing */
+                table[u].length += addedLength;
+                table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
+            }
+            /* sort : improve rank */
+            elt = table[u];
+            while ((u>1) && (table[u-1].savings < elt.savings))
+                table[u] = table[u-1], u--;
+            table[u] = elt;
+            return u;
+        }
+
+        if (MEM_read64(buf + table[u].pos) == MEM_read64(buf + elt.pos + 1)) {
+            if (isIncluded(buf + table[u].pos, buf + elt.pos + 1, table[u].length)) {
+                size_t const addedLength = MAX( (int)elt.length - (int)table[u].length , 1 );
+                table[u].pos = elt.pos;
+                table[u].savings += (U32)(elt.savings * addedLength / elt.length);
+                table[u].length = MIN(elt.length, table[u].length + 1);
+                return u;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+static void ZDICT_removeDictItem(dictItem* table, U32 id)
+{
+    /* convention : table[0].pos stores nb of elts */
+    U32 const max = table[0].pos;
+    U32 u;
+    if (!id) return;   /* protection, should never happen */
+    for (u=id; u<max-1; u++)
+        table[u] = table[u+1];
+    table->pos--;
+}
+
+
+static void ZDICT_insertDictItem(dictItem* table, U32 maxSize, dictItem elt, const void* buffer)
+{
+    /* merge if possible */
+    U32 mergeId = ZDICT_tryMerge(table, elt, 0, buffer);
+    if (mergeId) {
+        U32 newMerge = 1;
+        while (newMerge) {
+            newMerge = ZDICT_tryMerge(table, table[mergeId], mergeId, buffer);
+            if (newMerge) ZDICT_removeDictItem(table, mergeId);
+            mergeId = newMerge;
+        }
+        return;
+    }
+
+    /* insert */
+    {   U32 current;
+        U32 nextElt = table->pos;
+        if (nextElt >= maxSize) nextElt = maxSize-1;
+        current = nextElt-1;
+        while (table[current].savings < elt.savings) {
+            table[current+1] = table[current];
+            current--;
+        }
+        table[current+1] = elt;
+        table->pos = nextElt+1;
+    }
+}
+
+
+static U32 ZDICT_dictSize(const dictItem* dictList)
+{
+    U32 u, dictSize = 0;
+    for (u=1; u<dictList[0].pos; u++)
+        dictSize += dictList[u].length;
+    return dictSize;
+}
+
+
+static size_t ZDICT_trainBuffer_legacy(dictItem* dictList, U32 dictListSize,
+                            const void* const buffer, size_t bufferSize,   /* buffer must end with noisy guard band */
+                            const size_t* fileSizes, unsigned nbFiles,
+                            unsigned minRatio, U32 notificationLevel)
+{
+    int* const suffix0 = (int*)malloc((bufferSize+2)*sizeof(*suffix0));
+    int* const suffix = suffix0+1;
+    U32* reverseSuffix = (U32*)malloc((bufferSize)*sizeof(*reverseSuffix));
+    BYTE* doneMarks = (BYTE*)malloc((bufferSize+16)*sizeof(*doneMarks));   /* +16 for overflow security */
+    U32* filePos = (U32*)malloc(nbFiles * sizeof(*filePos));
+    size_t result = 0;
+    clock_t displayClock = 0;
+    clock_t const refreshRate = CLOCKS_PER_SEC * 3 / 10;
+
+#   define DISPLAYUPDATE(l, ...) if (notificationLevel>=l) { \
+            if (ZDICT_clockSpan(displayClock) > refreshRate)  \
+            { displayClock = clock(); DISPLAY(__VA_ARGS__); \
+            if (notificationLevel>=4) fflush(stderr); } }
+
+    /* init */
+    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
+    if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) {
+        result = ERROR(memory_allocation);
+        goto _cleanup;
+    }
+    if (minRatio < MINRATIO) minRatio = MINRATIO;
+    memset(doneMarks, 0, bufferSize+16);
+
+    /* limit sample set size (divsufsort limitation)*/
+    if (bufferSize > ZDICT_MAX_SAMPLES_SIZE) DISPLAYLEVEL(3, "sample set too large : reduced to %u MB ...\n", (unsigned)(ZDICT_MAX_SAMPLES_SIZE>>20));
+    while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles];
+
+    /* sort */
+    DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (unsigned)(bufferSize>>20));
+    {   int const divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0);
+        if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; }
+    }
+    suffix[bufferSize] = (int)bufferSize;   /* leads into noise */
+    suffix0[0] = (int)bufferSize;           /* leads into noise */
+    /* build reverse suffix sort */
+    {   size_t pos;
+        for (pos=0; pos < bufferSize; pos++)
+            reverseSuffix[suffix[pos]] = (U32)pos;
+        /* note filePos tracks borders between samples.
+           It's not used at this stage, but planned to become useful in a later update */
+        filePos[0] = 0;
+        for (pos=1; pos<nbFiles; pos++)
+            filePos[pos] = (U32)(filePos[pos-1] + fileSizes[pos-1]);
+    }
+
+    DISPLAYLEVEL(2, "finding patterns ... \n");
+    DISPLAYLEVEL(3, "minimum ratio : %u \n", minRatio);
+
+    {   U32 cursor; for (cursor=0; cursor < bufferSize; ) {
+            dictItem solution;
+            if (doneMarks[cursor]) { cursor++; continue; }
+            solution = ZDICT_analyzePos(doneMarks, suffix, reverseSuffix[cursor], buffer, minRatio, notificationLevel);
+            if (solution.length==0) { cursor++; continue; }
+            ZDICT_insertDictItem(dictList, dictListSize, solution, buffer);
+            cursor += solution.length;
+            DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / bufferSize * 100);
+    }   }
+
+_cleanup:
+    free(suffix0);
+    free(reverseSuffix);
+    free(doneMarks);
+    free(filePos);
+    return result;
+}
+
+
+static void ZDICT_fillNoise(void* buffer, size_t length)
+{
+    unsigned const prime1 = 2654435761U;
+    unsigned const prime2 = 2246822519U;
+    unsigned acc = prime1;
+    size_t p=0;;
+    for (p=0; p<length; p++) {
+        acc *= prime2;
+        ((unsigned char*)buffer)[p] = (unsigned char)(acc >> 21);
+    }
+}
+
+
+typedef struct
+{
+    ZSTD_CDict* dict;    /* dictionary */
+    ZSTD_CCtx* zc;     /* working context */
+    void* workPlace;   /* must be ZSTD_BLOCKSIZE_MAX allocated */
+} EStats_ress_t;
+
+#define MAXREPOFFSET 1024
+
+static void ZDICT_countEStats(EStats_ress_t esr, ZSTD_parameters params,
+                              unsigned* countLit, unsigned* offsetcodeCount, unsigned* matchlengthCount, unsigned* litlengthCount, U32* repOffsets,
+                              const void* src, size_t srcSize,
+                              U32 notificationLevel)
+{
+    size_t const blockSizeMax = MIN (ZSTD_BLOCKSIZE_MAX, 1 << params.cParams.windowLog);
+    size_t cSize;
+
+    if (srcSize > blockSizeMax) srcSize = blockSizeMax;   /* protection vs large samples */
+    {   size_t const errorCode = ZSTD_compressBegin_usingCDict(esr.zc, esr.dict);
+        if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, "warning : ZSTD_compressBegin_usingCDict failed \n"); return; }
+
+    }
+    cSize = ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);
+    if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, "warning : could not compress sample size %u \n", (unsigned)srcSize); return; }
+
+    if (cSize) {  /* if == 0; block is not compressible */
+        const seqStore_t* const seqStorePtr = ZSTD_getSeqStore(esr.zc);
+
+        /* literals stats */
+        {   const BYTE* bytePtr;
+            for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++)
+                countLit[*bytePtr]++;
+        }
+
+        /* seqStats */
+        {   U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
+            ZSTD_seqToCodes(seqStorePtr);
+
+            {   const BYTE* codePtr = seqStorePtr->ofCode;
+                U32 u;
+                for (u=0; u<nbSeq; u++) offsetcodeCount[codePtr[u]]++;
+            }
+
+            {   const BYTE* codePtr = seqStorePtr->mlCode;
+                U32 u;
+                for (u=0; u<nbSeq; u++) matchlengthCount[codePtr[u]]++;
+            }
+
+            {   const BYTE* codePtr = seqStorePtr->llCode;
+                U32 u;
+                for (u=0; u<nbSeq; u++) litlengthCount[codePtr[u]]++;
+            }
+
+            if (nbSeq >= 2) { /* rep offsets */
+                const seqDef* const seq = seqStorePtr->sequencesStart;
+                U32 offset1 = seq[0].offset - 3;
+                U32 offset2 = seq[1].offset - 3;
+                if (offset1 >= MAXREPOFFSET) offset1 = 0;
+                if (offset2 >= MAXREPOFFSET) offset2 = 0;
+                repOffsets[offset1] += 3;
+                repOffsets[offset2] += 1;
+    }   }   }
+}
+
+static size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles)
+{
+    size_t total=0;
+    unsigned u;
+    for (u=0; u<nbFiles; u++) total += fileSizes[u];
+    return total;
+}
+
+typedef struct { U32 offset; U32 count; } offsetCount_t;
+
+static void ZDICT_insertSortCount(offsetCount_t table[ZSTD_REP_NUM+1], U32 val, U32 count)
+{
+    U32 u;
+    table[ZSTD_REP_NUM].offset = val;
+    table[ZSTD_REP_NUM].count = count;
+    for (u=ZSTD_REP_NUM; u>0; u--) {
+        offsetCount_t tmp;
+        if (table[u-1].count >= table[u].count) break;
+        tmp = table[u-1];
+        table[u-1] = table[u];
+        table[u] = tmp;
+    }
+}
+
+/* ZDICT_flatLit() :
+ * rewrite `countLit` to contain a mostly flat but still compressible distribution of literals.
+ * necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode.
+ */
+static void ZDICT_flatLit(unsigned* countLit)
+{
+    int u;
+    for (u=1; u<256; u++) countLit[u] = 2;
+    countLit[0]   = 4;
+    countLit[253] = 1;
+    countLit[254] = 1;
+}
+
+#define OFFCODE_MAX 30  /* only applicable to first block */
+static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,
+                                   unsigned compressionLevel,
+                             const void*  srcBuffer, const size_t* fileSizes, unsigned nbFiles,
+                             const void* dictBuffer, size_t  dictBufferSize,
+                                   unsigned notificationLevel)
+{
+    unsigned countLit[256];
+    HUF_CREATE_STATIC_CTABLE(hufTable, 255);
+    unsigned offcodeCount[OFFCODE_MAX+1];
+    short offcodeNCount[OFFCODE_MAX+1];
+    U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB));
+    unsigned matchLengthCount[MaxML+1];
+    short matchLengthNCount[MaxML+1];
+    unsigned litLengthCount[MaxLL+1];
+    short litLengthNCount[MaxLL+1];
+    U32 repOffset[MAXREPOFFSET];
+    offsetCount_t bestRepOffset[ZSTD_REP_NUM+1];
+    EStats_ress_t esr = { NULL, NULL, NULL };
+    ZSTD_parameters params;
+    U32 u, huffLog = 11, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total;
+    size_t pos = 0, errorCode;
+    size_t eSize = 0;
+    size_t const totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles);
+    size_t const averageSampleSize = totalSrcSize / (nbFiles + !nbFiles);
+    BYTE* dstPtr = (BYTE*)dstBuffer;
+
+    /* init */
+    DEBUGLOG(4, "ZDICT_analyzeEntropy");
+    if (offcodeMax>OFFCODE_MAX) { eSize = ERROR(dictionaryCreation_failed); goto _cleanup; }   /* too large dictionary */
+    for (u=0; u<256; u++) countLit[u] = 1;   /* any character must be described */
+    for (u=0; u<=offcodeMax; u++) offcodeCount[u] = 1;
+    for (u=0; u<=MaxML; u++) matchLengthCount[u] = 1;
+    for (u=0; u<=MaxLL; u++) litLengthCount[u] = 1;
+    memset(repOffset, 0, sizeof(repOffset));
+    repOffset[1] = repOffset[4] = repOffset[8] = 1;
+    memset(bestRepOffset, 0, sizeof(bestRepOffset));
+    if (compressionLevel==0) compressionLevel = g_compressionLevel_default;
+    params = ZSTD_getParams(compressionLevel, averageSampleSize, dictBufferSize);
+
+    esr.dict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, ZSTD_dlm_byRef, ZSTD_dct_rawContent, params.cParams, ZSTD_defaultCMem);
+    esr.zc = ZSTD_createCCtx();
+    esr.workPlace = malloc(ZSTD_BLOCKSIZE_MAX);
+    if (!esr.dict || !esr.zc || !esr.workPlace) {
+        eSize = ERROR(memory_allocation);
+        DISPLAYLEVEL(1, "Not enough memory \n");
+        goto _cleanup;
+    }
+
+    /* collect stats on all samples */
+    for (u=0; u<nbFiles; u++) {
+        ZDICT_countEStats(esr, params,
+                          countLit, offcodeCount, matchLengthCount, litLengthCount, repOffset,
+                         (const char*)srcBuffer + pos, fileSizes[u],
+                          notificationLevel);
+        pos += fileSizes[u];
+    }
+
+    /* analyze, build stats, starting with literals */
+    {   size_t maxNbBits = HUF_buildCTable (hufTable, countLit, 255, huffLog);
+        if (HUF_isError(maxNbBits)) {
+            eSize = maxNbBits;
+            DISPLAYLEVEL(1, " HUF_buildCTable error \n");
+            goto _cleanup;
+        }
+        if (maxNbBits==8) {  /* not compressible : will fail on HUF_writeCTable() */
+            DISPLAYLEVEL(2, "warning : pathological dataset : literals are not compressible : samples are noisy or too regular \n");
+            ZDICT_flatLit(countLit);  /* replace distribution by a fake "mostly flat but still compressible" distribution, that HUF_writeCTable() can encode */
+            maxNbBits = HUF_buildCTable (hufTable, countLit, 255, huffLog);
+            assert(maxNbBits==9);
+        }
+        huffLog = (U32)maxNbBits;
+    }
+
+    /* looking for most common first offsets */
+    {   U32 offset;
+        for (offset=1; offset<MAXREPOFFSET; offset++)
+            ZDICT_insertSortCount(bestRepOffset, offset, repOffset[offset]);
+    }
+    /* note : the result of this phase should be used to better appreciate the impact on statistics */
+
+    total=0; for (u=0; u<=offcodeMax; u++) total+=offcodeCount[u];
+    errorCode = FSE_normalizeCount(offcodeNCount, Offlog, offcodeCount, total, offcodeMax);
+    if (FSE_isError(errorCode)) {
+        eSize = errorCode;
+        DISPLAYLEVEL(1, "FSE_normalizeCount error with offcodeCount \n");
+        goto _cleanup;
+    }
+    Offlog = (U32)errorCode;
+
+    total=0; for (u=0; u<=MaxML; u++) total+=matchLengthCount[u];
+    errorCode = FSE_normalizeCount(matchLengthNCount, mlLog, matchLengthCount, total, MaxML);
+    if (FSE_isError(errorCode)) {
+        eSize = errorCode;
+        DISPLAYLEVEL(1, "FSE_normalizeCount error with matchLengthCount \n");
+        goto _cleanup;
+    }
+    mlLog = (U32)errorCode;
+
+    total=0; for (u=0; u<=MaxLL; u++) total+=litLengthCount[u];
+    errorCode = FSE_normalizeCount(litLengthNCount, llLog, litLengthCount, total, MaxLL);
+    if (FSE_isError(errorCode)) {
+        eSize = errorCode;
+        DISPLAYLEVEL(1, "FSE_normalizeCount error with litLengthCount \n");
+        goto _cleanup;
+    }
+    llLog = (U32)errorCode;
+
+    /* write result to buffer */
+    {   size_t const hhSize = HUF_writeCTable(dstPtr, maxDstSize, hufTable, 255, huffLog);
+        if (HUF_isError(hhSize)) {
+            eSize = hhSize;
+            DISPLAYLEVEL(1, "HUF_writeCTable error \n");
+            goto _cleanup;
+        }
+        dstPtr += hhSize;
+        maxDstSize -= hhSize;
+        eSize += hhSize;
+    }
+
+    {   size_t const ohSize = FSE_writeNCount(dstPtr, maxDstSize, offcodeNCount, OFFCODE_MAX, Offlog);
+        if (FSE_isError(ohSize)) {
+            eSize = ohSize;
+            DISPLAYLEVEL(1, "FSE_writeNCount error with offcodeNCount \n");
+            goto _cleanup;
+        }
+        dstPtr += ohSize;
+        maxDstSize -= ohSize;
+        eSize += ohSize;
+    }
+
+    {   size_t const mhSize = FSE_writeNCount(dstPtr, maxDstSize, matchLengthNCount, MaxML, mlLog);
+        if (FSE_isError(mhSize)) {
+            eSize = mhSize;
+            DISPLAYLEVEL(1, "FSE_writeNCount error with matchLengthNCount \n");
+            goto _cleanup;
+        }
+        dstPtr += mhSize;
+        maxDstSize -= mhSize;
+        eSize += mhSize;
+    }
+
+    {   size_t const lhSize = FSE_writeNCount(dstPtr, maxDstSize, litLengthNCount, MaxLL, llLog);
+        if (FSE_isError(lhSize)) {
+            eSize = lhSize;
+            DISPLAYLEVEL(1, "FSE_writeNCount error with litlengthNCount \n");
+            goto _cleanup;
+        }
+        dstPtr += lhSize;
+        maxDstSize -= lhSize;
+        eSize += lhSize;
+    }
+
+    if (maxDstSize<12) {
+        eSize = ERROR(dstSize_tooSmall);
+        DISPLAYLEVEL(1, "not enough space to write RepOffsets \n");
+        goto _cleanup;
+    }
+# if 0
+    MEM_writeLE32(dstPtr+0, bestRepOffset[0].offset);
+    MEM_writeLE32(dstPtr+4, bestRepOffset[1].offset);
+    MEM_writeLE32(dstPtr+8, bestRepOffset[2].offset);
+#else
+    /* at this stage, we don't use the result of "most common first offset",
+       as the impact of statistics is not properly evaluated */
+    MEM_writeLE32(dstPtr+0, repStartValue[0]);
+    MEM_writeLE32(dstPtr+4, repStartValue[1]);
+    MEM_writeLE32(dstPtr+8, repStartValue[2]);
+#endif
+    eSize += 12;
+
+_cleanup:
+    ZSTD_freeCDict(esr.dict);
+    ZSTD_freeCCtx(esr.zc);
+    free(esr.workPlace);
+
+    return eSize;
+}
+
+
+
+size_t ZDICT_finalizeDictionary(void* dictBuffer, size_t dictBufferCapacity,
+                          const void* customDictContent, size_t dictContentSize,
+                          const void* samplesBuffer, const size_t* samplesSizes,
+                          unsigned nbSamples, ZDICT_params_t params)
+{
+    size_t hSize;
+#define HBUFFSIZE 256   /* should prove large enough for all entropy headers */
+    BYTE header[HBUFFSIZE];
+    int const compressionLevel = (params.compressionLevel == 0) ? g_compressionLevel_default : params.compressionLevel;
+    U32 const notificationLevel = params.notificationLevel;
+
+    /* check conditions */
+    DEBUGLOG(4, "ZDICT_finalizeDictionary");
+    if (dictBufferCapacity < dictContentSize) return ERROR(dstSize_tooSmall);
+    if (dictContentSize < ZDICT_CONTENTSIZE_MIN) return ERROR(srcSize_wrong);
+    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) return ERROR(dstSize_tooSmall);
+
+    /* dictionary header */
+    MEM_writeLE32(header, ZSTD_MAGIC_DICTIONARY);
+    {   U64 const randomID = XXH64(customDictContent, dictContentSize, 0);
+        U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768;
+        U32 const dictID = params.dictID ? params.dictID : compliantID;
+        MEM_writeLE32(header+4, dictID);
+    }
+    hSize = 8;
+
+    /* entropy tables */
+    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
+    DISPLAYLEVEL(2, "statistics ... \n");
+    {   size_t const eSize = ZDICT_analyzeEntropy(header+hSize, HBUFFSIZE-hSize,
+                                  compressionLevel,
+                                  samplesBuffer, samplesSizes, nbSamples,
+                                  customDictContent, dictContentSize,
+                                  notificationLevel);
+        if (ZDICT_isError(eSize)) return eSize;
+        hSize += eSize;
+    }
+
+    /* copy elements in final buffer ; note : src and dst buffer can overlap */
+    if (hSize + dictContentSize > dictBufferCapacity) dictContentSize = dictBufferCapacity - hSize;
+    {   size_t const dictSize = hSize + dictContentSize;
+        char* dictEnd = (char*)dictBuffer + dictSize;
+        memmove(dictEnd - dictContentSize, customDictContent, dictContentSize);
+        memcpy(dictBuffer, header, hSize);
+        return dictSize;
+    }
+}
+
+
+static size_t ZDICT_addEntropyTablesFromBuffer_advanced(
+        void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
+        const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+        ZDICT_params_t params)
+{
+    int const compressionLevel = (params.compressionLevel == 0) ? g_compressionLevel_default : params.compressionLevel;
+    U32 const notificationLevel = params.notificationLevel;
+    size_t hSize = 8;
+
+    /* calculate entropy tables */
+    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
+    DISPLAYLEVEL(2, "statistics ... \n");
+    {   size_t const eSize = ZDICT_analyzeEntropy((char*)dictBuffer+hSize, dictBufferCapacity-hSize,
+                                  compressionLevel,
+                                  samplesBuffer, samplesSizes, nbSamples,
+                                  (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize,
+                                  notificationLevel);
+        if (ZDICT_isError(eSize)) return eSize;
+        hSize += eSize;
+    }
+
+    /* add dictionary header (after entropy tables) */
+    MEM_writeLE32(dictBuffer, ZSTD_MAGIC_DICTIONARY);
+    {   U64 const randomID = XXH64((char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize, 0);
+        U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768;
+        U32 const dictID = params.dictID ? params.dictID : compliantID;
+        MEM_writeLE32((char*)dictBuffer+4, dictID);
+    }
+
+    if (hSize + dictContentSize < dictBufferCapacity)
+        memmove((char*)dictBuffer + hSize, (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize);
+    return MIN(dictBufferCapacity, hSize+dictContentSize);
+}
+
+/* Hidden declaration for dbio.c */
+size_t ZDICT_trainFromBuffer_unsafe_legacy(
+                            void* dictBuffer, size_t maxDictSize,
+                            const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+                            ZDICT_legacy_params_t params);
+/*! ZDICT_trainFromBuffer_unsafe_legacy() :
+*   Warning : `samplesBuffer` must be followed by noisy guard band.
+*   @return : size of dictionary, or an error code which can be tested with ZDICT_isError()
+*/
+size_t ZDICT_trainFromBuffer_unsafe_legacy(
+                            void* dictBuffer, size_t maxDictSize,
+                            const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+                            ZDICT_legacy_params_t params)
+{
+    U32 const dictListSize = MAX(MAX(DICTLISTSIZE_DEFAULT, nbSamples), (U32)(maxDictSize/16));
+    dictItem* const dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList));
+    unsigned const selectivity = params.selectivityLevel == 0 ? g_selectivity_default : params.selectivityLevel;
+    unsigned const minRep = (selectivity > 30) ? MINRATIO : nbSamples >> selectivity;
+    size_t const targetDictSize = maxDictSize;
+    size_t const samplesBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);
+    size_t dictSize = 0;
+    U32 const notificationLevel = params.zParams.notificationLevel;
+
+    /* checks */
+    if (!dictList) return ERROR(memory_allocation);
+    if (maxDictSize < ZDICT_DICTSIZE_MIN) { free(dictList); return ERROR(dstSize_tooSmall); }   /* requested dictionary size is too small */
+    if (samplesBuffSize < ZDICT_MIN_SAMPLES_SIZE) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* not enough source to create dictionary */
+
+    /* init */
+    ZDICT_initDictItem(dictList);
+
+    /* build dictionary */
+    ZDICT_trainBuffer_legacy(dictList, dictListSize,
+                       samplesBuffer, samplesBuffSize,
+                       samplesSizes, nbSamples,
+                       minRep, notificationLevel);
+
+    /* display best matches */
+    if (params.zParams.notificationLevel>= 3) {
+        unsigned const nb = MIN(25, dictList[0].pos);
+        unsigned const dictContentSize = ZDICT_dictSize(dictList);
+        unsigned u;
+        DISPLAYLEVEL(3, "\n %u segments found, of total size %u \n", (unsigned)dictList[0].pos-1, dictContentSize);
+        DISPLAYLEVEL(3, "list %u best segments \n", nb-1);
+        for (u=1; u<nb; u++) {
+            unsigned const pos = dictList[u].pos;
+            unsigned const length = dictList[u].length;
+            U32 const printedLength = MIN(40, length);
+            if ((pos > samplesBuffSize) || ((pos + length) > samplesBuffSize)) {
+                free(dictList);
+                return ERROR(GENERIC);   /* should never happen */
+            }
+            DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |",
+                         u, length, pos, (unsigned)dictList[u].savings);
+            ZDICT_printHex((const char*)samplesBuffer+pos, printedLength);
+            DISPLAYLEVEL(3, "| \n");
+    }   }
+
+
+    /* create dictionary */
+    {   unsigned dictContentSize = ZDICT_dictSize(dictList);
+        if (dictContentSize < ZDICT_CONTENTSIZE_MIN) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* dictionary content too small */
+        if (dictContentSize < targetDictSize/4) {
+            DISPLAYLEVEL(2, "!  warning : selected content significantly smaller than requested (%u < %u) \n", dictContentSize, (unsigned)maxDictSize);
+            if (samplesBuffSize < 10 * targetDictSize)
+                DISPLAYLEVEL(2, "!  consider increasing the number of samples (total size : %u MB)\n", (unsigned)(samplesBuffSize>>20));
+            if (minRep > MINRATIO) {
+                DISPLAYLEVEL(2, "!  consider increasing selectivity to produce larger dictionary (-s%u) \n", selectivity+1);
+                DISPLAYLEVEL(2, "!  note : larger dictionaries are not necessarily better, test its efficiency on samples \n");
+            }
+        }
+
+        if ((dictContentSize > targetDictSize*3) && (nbSamples > 2*MINRATIO) && (selectivity>1)) {
+            unsigned proposedSelectivity = selectivity-1;
+            while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; }
+            DISPLAYLEVEL(2, "!  note : calculated dictionary significantly larger than requested (%u > %u) \n", dictContentSize, (unsigned)maxDictSize);
+            DISPLAYLEVEL(2, "!  consider increasing dictionary size, or produce denser dictionary (-s%u) \n", proposedSelectivity);
+            DISPLAYLEVEL(2, "!  always test dictionary efficiency on real samples \n");
+        }
+
+        /* limit dictionary size */
+        {   U32 const max = dictList->pos;   /* convention : nb of useful elts within dictList */
+            U32 currentSize = 0;
+            U32 n; for (n=1; n<max; n++) {
+                currentSize += dictList[n].length;
+                if (currentSize > targetDictSize) { currentSize -= dictList[n].length; break; }
+            }
+            dictList->pos = n;
+            dictContentSize = currentSize;
+        }
+
+        /* build dict content */
+        {   U32 u;
+            BYTE* ptr = (BYTE*)dictBuffer + maxDictSize;
+            for (u=1; u<dictList->pos; u++) {
+                U32 l = dictList[u].length;
+                ptr -= l;
+                if (ptr<(BYTE*)dictBuffer) { free(dictList); return ERROR(GENERIC); }   /* should not happen */
+                memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l);
+        }   }
+
+        dictSize = ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, maxDictSize,
+                                                             samplesBuffer, samplesSizes, nbSamples,
+                                                             params.zParams);
+    }
+
+    /* clean up */
+    free(dictList);
+    return dictSize;
+}
+
+
+/* ZDICT_trainFromBuffer_legacy() :
+ * issue : samplesBuffer need to be followed by a noisy guard band.
+ * work around : duplicate the buffer, and add the noise */
+size_t ZDICT_trainFromBuffer_legacy(void* dictBuffer, size_t dictBufferCapacity,
+                              const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+                              ZDICT_legacy_params_t params)
+{
+    size_t result;
+    void* newBuff;
+    size_t const sBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);
+    if (sBuffSize < ZDICT_MIN_SAMPLES_SIZE) return 0;   /* not enough content => no dictionary */
+
+    newBuff = malloc(sBuffSize + NOISELENGTH);
+    if (!newBuff) return ERROR(memory_allocation);
+
+    memcpy(newBuff, samplesBuffer, sBuffSize);
+    ZDICT_fillNoise((char*)newBuff + sBuffSize, NOISELENGTH);   /* guard band, for end of buffer condition */
+
+    result =
+        ZDICT_trainFromBuffer_unsafe_legacy(dictBuffer, dictBufferCapacity, newBuff,
+                                            samplesSizes, nbSamples, params);
+    free(newBuff);
+    return result;
+}
+
+
+size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
+                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)
+{
+    ZDICT_fastCover_params_t params;
+    DEBUGLOG(3, "ZDICT_trainFromBuffer");
+    memset(&params, 0, sizeof(params));
+    params.d = 8;
+    params.steps = 4;
+    /* Default to level 6 since no compression level information is available */
+    params.zParams.compressionLevel = 3;
+#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=1)
+    params.zParams.notificationLevel = DEBUGLEVEL;
+#endif
+    return ZDICT_optimizeTrainFromBuffer_fastCover(dictBuffer, dictBufferCapacity,
+                                               samplesBuffer, samplesSizes, nbSamples,
+                                               &params);
+}
+
+size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
+                                  const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)
+{
+    ZDICT_params_t params;
+    memset(&params, 0, sizeof(params));
+    return ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, dictBufferCapacity,
+                                                     samplesBuffer, samplesSizes, nbSamples,
+                                                     params);
+}
diff --git a/src/zdict.h b/src/zdict.h
new file mode 100644
index 0000000..37978ec
--- /dev/null
+++ b/src/zdict.h
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef DICTBUILDER_H_001
+#define DICTBUILDER_H_001
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*======  Dependencies  ======*/
+#include <stddef.h>  /* size_t */
+
+
+/* =====   ZDICTLIB_API : control library symbols visibility   ===== */
+#ifndef ZDICTLIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define ZDICTLIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define ZDICTLIB_VISIBILITY
+#  endif
+#endif
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZDICTLIB_API __declspec(dllexport) ZDICTLIB_VISIBILITY
+#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
+#  define ZDICTLIB_API __declspec(dllimport) ZDICTLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define ZDICTLIB_API ZDICTLIB_VISIBILITY
+#endif
+
+
+/*! ZDICT_trainFromBuffer():
+ *  Train a dictionary from an array of samples.
+ *  Redirect towards ZDICT_optimizeTrainFromBuffer_fastCover() single-threaded, with d=8, steps=4,
+ *  f=20, and accel=1.
+ *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
+ *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
+ *  The resulting dictionary will be saved into `dictBuffer`.
+ * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
+ *          or an error code, which can be tested with ZDICT_isError().
+ *  Note:  Dictionary training will fail if there are not enough samples to construct a
+ *         dictionary, or if most of the samples are too small (< 8 bytes being the lower limit).
+ *         If dictionary training fails, you should use zstd without a dictionary, as the dictionary
+ *         would've been ineffective anyways. If you believe your samples would benefit from a dictionary
+ *         please open an issue with details, and we can look into it.
+ *  Note: ZDICT_trainFromBuffer()'s memory usage is about 6 MB.
+ *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
+ *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
+ *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
+ *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
+ */
+ZDICTLIB_API size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
+                                    const void* samplesBuffer,
+                                    const size_t* samplesSizes, unsigned nbSamples);
+
+
+/*======   Helper functions   ======*/
+ZDICTLIB_API unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize);  /**< extracts dictID; @return zero if error (not a valid dictionary) */
+ZDICTLIB_API unsigned ZDICT_isError(size_t errorCode);
+ZDICTLIB_API const char* ZDICT_getErrorName(size_t errorCode);
+
+
+
+#ifdef ZDICT_STATIC_LINKING_ONLY
+
+/* ====================================================================================
+ * The definitions in this section are considered experimental.
+ * They should never be used with a dynamic library, as they may change in the future.
+ * They are provided for advanced usages.
+ * Use them only in association with static linking.
+ * ==================================================================================== */
+
+typedef struct {
+    int      compressionLevel;   /* optimize for a specific zstd compression level; 0 means default */
+    unsigned notificationLevel;  /* Write log to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; */
+    unsigned dictID;             /* force dictID value; 0 means auto mode (32-bits random value) */
+} ZDICT_params_t;
+
+/*! ZDICT_cover_params_t:
+ *  k and d are the only required parameters.
+ *  For others, value 0 means default.
+ */
+typedef struct {
+    unsigned k;                  /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */
+    unsigned d;                  /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */
+    unsigned steps;              /* Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked */
+    unsigned nbThreads;          /* Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined */
+    double splitPoint;           /* Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (1.0), 1.0 when all samples are used for both training and testing */
+    unsigned shrinkDict;         /* Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking  */
+    unsigned shrinkDictMaxRegression; /* Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. */
+    ZDICT_params_t zParams;
+} ZDICT_cover_params_t;
+
+typedef struct {
+    unsigned k;                  /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */
+    unsigned d;                  /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */
+    unsigned f;                  /* log of size of frequency array : constraint: 0 < f <= 31 : 1 means default(20)*/
+    unsigned steps;              /* Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked */
+    unsigned nbThreads;          /* Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined */
+    double splitPoint;           /* Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (0.75), 1.0 when all samples are used for both training and testing */
+    unsigned accel;              /* Acceleration level: constraint: 0 < accel <= 10, higher means faster and less accurate, 0 means default(1) */
+    unsigned shrinkDict;         /* Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking  */
+    unsigned shrinkDictMaxRegression; /* Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. */
+
+    ZDICT_params_t zParams;
+} ZDICT_fastCover_params_t;
+
+/*! ZDICT_trainFromBuffer_cover():
+ *  Train a dictionary from an array of samples using the COVER algorithm.
+ *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
+ *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
+ *  The resulting dictionary will be saved into `dictBuffer`.
+ * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
+ *          or an error code, which can be tested with ZDICT_isError().
+ *          See ZDICT_trainFromBuffer() for details on failure modes.
+ *  Note: ZDICT_trainFromBuffer_cover() requires about 9 bytes of memory for each input byte.
+ *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
+ *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
+ *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
+ *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
+ */
+ZDICTLIB_API size_t ZDICT_trainFromBuffer_cover(
+          void *dictBuffer, size_t dictBufferCapacity,
+    const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples,
+          ZDICT_cover_params_t parameters);
+
+/*! ZDICT_optimizeTrainFromBuffer_cover():
+ * The same requirements as above hold for all the parameters except `parameters`.
+ * This function tries many parameter combinations and picks the best parameters.
+ * `*parameters` is filled with the best parameters found,
+ * dictionary constructed with those parameters is stored in `dictBuffer`.
+ *
+ * All of the parameters d, k, steps are optional.
+ * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}.
+ * if steps is zero it defaults to its default value.
+ * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000].
+ *
+ * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
+ *          or an error code, which can be tested with ZDICT_isError().
+ *          On success `*parameters` contains the parameters selected.
+ *          See ZDICT_trainFromBuffer() for details on failure modes.
+ * Note: ZDICT_optimizeTrainFromBuffer_cover() requires about 8 bytes of memory for each input byte and additionally another 5 bytes of memory for each byte of memory for each thread.
+ */
+ZDICTLIB_API size_t ZDICT_optimizeTrainFromBuffer_cover(
+          void* dictBuffer, size_t dictBufferCapacity,
+    const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+          ZDICT_cover_params_t* parameters);
+
+/*! ZDICT_trainFromBuffer_fastCover():
+ *  Train a dictionary from an array of samples using a modified version of COVER algorithm.
+ *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
+ *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
+ *  d and k are required.
+ *  All other parameters are optional, will use default values if not provided
+ *  The resulting dictionary will be saved into `dictBuffer`.
+ * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
+ *          or an error code, which can be tested with ZDICT_isError().
+ *          See ZDICT_trainFromBuffer() for details on failure modes.
+ *  Note: ZDICT_trainFromBuffer_fastCover() requires 6 * 2^f bytes of memory.
+ *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
+ *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
+ *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
+ *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
+ */
+ZDICTLIB_API size_t ZDICT_trainFromBuffer_fastCover(void *dictBuffer,
+                    size_t dictBufferCapacity, const void *samplesBuffer,
+                    const size_t *samplesSizes, unsigned nbSamples,
+                    ZDICT_fastCover_params_t parameters);
+
+/*! ZDICT_optimizeTrainFromBuffer_fastCover():
+ * The same requirements as above hold for all the parameters except `parameters`.
+ * This function tries many parameter combinations (specifically, k and d combinations)
+ * and picks the best parameters. `*parameters` is filled with the best parameters found,
+ * dictionary constructed with those parameters is stored in `dictBuffer`.
+ * All of the parameters d, k, steps, f, and accel are optional.
+ * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}.
+ * if steps is zero it defaults to its default value.
+ * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000].
+ * If f is zero, default value of 20 is used.
+ * If accel is zero, default value of 1 is used.
+ *
+ * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
+ *          or an error code, which can be tested with ZDICT_isError().
+ *          On success `*parameters` contains the parameters selected.
+ *          See ZDICT_trainFromBuffer() for details on failure modes.
+ * Note: ZDICT_optimizeTrainFromBuffer_fastCover() requires about 6 * 2^f bytes of memory for each thread.
+ */
+ZDICTLIB_API size_t ZDICT_optimizeTrainFromBuffer_fastCover(void* dictBuffer,
+                    size_t dictBufferCapacity, const void* samplesBuffer,
+                    const size_t* samplesSizes, unsigned nbSamples,
+                    ZDICT_fastCover_params_t* parameters);
+
+/*! ZDICT_finalizeDictionary():
+ * Given a custom content as a basis for dictionary, and a set of samples,
+ * finalize dictionary by adding headers and statistics.
+ *
+ * Samples must be stored concatenated in a flat buffer `samplesBuffer`,
+ * supplied with an array of sizes `samplesSizes`, providing the size of each sample in order.
+ *
+ * dictContentSize must be >= ZDICT_CONTENTSIZE_MIN bytes.
+ * maxDictSize must be >= dictContentSize, and must be >= ZDICT_DICTSIZE_MIN bytes.
+ *
+ * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`),
+ *          or an error code, which can be tested by ZDICT_isError().
+ * Note: ZDICT_finalizeDictionary() will push notifications into stderr if instructed to, using notificationLevel>0.
+ * Note 2: dictBuffer and dictContent can overlap
+ */
+#define ZDICT_CONTENTSIZE_MIN 128
+#define ZDICT_DICTSIZE_MIN    256
+ZDICTLIB_API size_t ZDICT_finalizeDictionary(void* dictBuffer, size_t dictBufferCapacity,
+                                const void* dictContent, size_t dictContentSize,
+                                const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+                                ZDICT_params_t parameters);
+
+typedef struct {
+    unsigned selectivityLevel;   /* 0 means default; larger => select more => larger dictionary */
+    ZDICT_params_t zParams;
+} ZDICT_legacy_params_t;
+
+/*! ZDICT_trainFromBuffer_legacy():
+ *  Train a dictionary from an array of samples.
+ *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
+ *  supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
+ *  The resulting dictionary will be saved into `dictBuffer`.
+ * `parameters` is optional and can be provided with values set to 0 to mean "default".
+ * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
+ *          or an error code, which can be tested with ZDICT_isError().
+ *          See ZDICT_trainFromBuffer() for details on failure modes.
+ *  Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
+ *        It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
+ *        In general, it's recommended to provide a few thousands samples, though this can vary a lot.
+ *        It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
+ *  Note: ZDICT_trainFromBuffer_legacy() will send notifications into stderr if instructed to, using notificationLevel>0.
+ */
+ZDICTLIB_API size_t ZDICT_trainFromBuffer_legacy(
+    void *dictBuffer, size_t dictBufferCapacity,
+    const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples,
+    ZDICT_legacy_params_t parameters);
+
+/* Deprecation warnings */
+/* It is generally possible to disable deprecation warnings from compiler,
+   for example with -Wno-deprecated-declarations for gcc
+   or _CRT_SECURE_NO_WARNINGS in Visual.
+   Otherwise, it's also possible to manually define ZDICT_DISABLE_DEPRECATE_WARNINGS */
+#ifdef ZDICT_DISABLE_DEPRECATE_WARNINGS
+#  define ZDICT_DEPRECATED(message) ZDICTLIB_API   /* disable deprecation warnings */
+#else
+#  define ZDICT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
+#    define ZDICT_DEPRECATED(message) [[deprecated(message)]] ZDICTLIB_API
+#  elif (ZDICT_GCC_VERSION >= 405) || defined(__clang__)
+#    define ZDICT_DEPRECATED(message) ZDICTLIB_API __attribute__((deprecated(message)))
+#  elif (ZDICT_GCC_VERSION >= 301)
+#    define ZDICT_DEPRECATED(message) ZDICTLIB_API __attribute__((deprecated))
+#  elif defined(_MSC_VER)
+#    define ZDICT_DEPRECATED(message) ZDICTLIB_API __declspec(deprecated(message))
+#  else
+#    pragma message("WARNING: You need to implement ZDICT_DEPRECATED for this compiler")
+#    define ZDICT_DEPRECATED(message) ZDICTLIB_API
+#  endif
+#endif /* ZDICT_DISABLE_DEPRECATE_WARNINGS */
+
+ZDICT_DEPRECATED("use ZDICT_finalizeDictionary() instead")
+size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
+                                  const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples);
+
+
+#endif   /* ZDICT_STATIC_LINKING_ONLY */
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* DICTBUILDER_H_001 */
diff --git a/src/zstd.h b/src/zstd.h
new file mode 100644
index 0000000..f8e95f2
--- /dev/null
+++ b/src/zstd.h
@@ -0,0 +1,1947 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef ZSTD_H_235446
+#define ZSTD_H_235446
+
+/* ======   Dependency   ======*/
+#include <stddef.h>   /* size_t */
+
+
+/* =====   ZSTDLIB_API : control library symbols visibility   ===== */
+#ifndef ZSTDLIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define ZSTDLIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define ZSTDLIB_VISIBILITY
+#  endif
+#endif
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBILITY
+#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
+#  define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define ZSTDLIB_API ZSTDLIB_VISIBILITY
+#endif
+
+
+/*******************************************************************************
+  Introduction
+
+  zstd, short for Zstandard, is a fast lossless compression algorithm, targeting
+  real-time compression scenarios at zlib-level and better compression ratios.
+  The zstd compression library provides in-memory compression and decompression
+  functions.
+
+  The library supports regular compression levels from 1 up to ZSTD_maxCLevel(),
+  which is currently 22. Levels >= 20, labeled `--ultra`, should be used with
+  caution, as they require more memory. The library also offers negative
+  compression levels, which extend the range of speed vs. ratio preferences.
+  The lower the level, the faster the speed (at the cost of compression).
+
+  Compression can be done in:
+    - a single step (described as Simple API)
+    - a single step, reusing a context (described as Explicit context)
+    - unbounded multiple steps (described as Streaming compression)
+
+  The compression ratio achievable on small data can be highly improved using
+  a dictionary. Dictionary compression can be performed in:
+    - a single step (described as Simple dictionary API)
+    - a single step, reusing a dictionary (described as Bulk-processing
+      dictionary API)
+
+  Advanced experimental functions can be accessed using
+  `#define ZSTD_STATIC_LINKING_ONLY` before including zstd.h.
+
+  Advanced experimental APIs should never be used with a dynamically-linked
+  library. They are not "stable"; their definitions or signatures may change in
+  the future. Only static linking is allowed.
+*******************************************************************************/
+
+/*------   Version   ------*/
+#define ZSTD_VERSION_MAJOR    1
+#define ZSTD_VERSION_MINOR    4
+#define ZSTD_VERSION_RELEASE  3
+
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
+ZSTDLIB_API unsigned ZSTD_versionNumber(void);   /**< to check runtime library version */
+
+#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE
+#define ZSTD_QUOTE(str) #str
+#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)
+#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)
+ZSTDLIB_API const char* ZSTD_versionString(void);   /* requires v1.3.0+ */
+
+/* *************************************
+ *  Default constant
+ ***************************************/
+#ifndef ZSTD_CLEVEL_DEFAULT
+#  define ZSTD_CLEVEL_DEFAULT 3
+#endif
+
+/* *************************************
+ *  Constants
+ ***************************************/
+
+/* All magic numbers are supposed read/written to/from files/memory using little-endian convention */
+#define ZSTD_MAGICNUMBER            0xFD2FB528    /* valid since v0.8.0 */
+#define ZSTD_MAGIC_DICTIONARY       0xEC30A437    /* valid since v0.7.0 */
+#define ZSTD_MAGIC_SKIPPABLE_START  0x184D2A50    /* all 16 values, from 0x184D2A50 to 0x184D2A5F, signal the beginning of a skippable frame */
+#define ZSTD_MAGIC_SKIPPABLE_MASK   0xFFFFFFF0
+
+#define ZSTD_BLOCKSIZELOG_MAX  17
+#define ZSTD_BLOCKSIZE_MAX     (1<<ZSTD_BLOCKSIZELOG_MAX)
+
+
+
+/***************************************
+*  Simple API
+***************************************/
+/*! ZSTD_compress() :
+ *  Compresses `src` content as a single zstd compressed frame into already allocated `dst`.
+ *  Hint : compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`.
+ *  @return : compressed size written into `dst` (<= `dstCapacity),
+ *            or an error code if it fails (which can be tested using ZSTD_isError()). */
+ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity,
+                            const void* src, size_t srcSize,
+                                  int compressionLevel);
+
+/*! ZSTD_decompress() :
+ *  `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.
+ *  `dstCapacity` is an upper bound of originalSize to regenerate.
+ *  If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data.
+ *  @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
+ *            or an errorCode if it fails (which can be tested using ZSTD_isError()). */
+ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,
+                              const void* src, size_t compressedSize);
+
+/*! ZSTD_getFrameContentSize() : requires v1.3.0+
+ *  `src` should point to the start of a ZSTD encoded frame.
+ *  `srcSize` must be at least as large as the frame header.
+ *            hint : any size >= `ZSTD_frameHeaderSize_max` is large enough.
+ *  @return : - decompressed size of `src` frame content, if known
+ *            - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
+ *            - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)
+ *   note 1 : a 0 return value means the frame is valid but "empty".
+ *   note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode.
+ *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
+ *            In which case, it's necessary to use streaming mode to decompress data.
+ *            Optionally, application can rely on some implicit limit,
+ *            as ZSTD_decompress() only needs an upper bound of decompressed size.
+ *            (For example, data could be necessarily cut into blocks <= 16 KB).
+ *   note 3 : decompressed size is always present when compression is completed using single-pass functions,
+ *            such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict().
+ *   note 4 : decompressed size can be very large (64-bits value),
+ *            potentially larger than what local system can handle as a single memory segment.
+ *            In which case, it's necessary to use streaming mode to decompress data.
+ *   note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified.
+ *            Always ensure return value fits within application's authorized limits.
+ *            Each application can set its own limits.
+ *   note 6 : This function replaces ZSTD_getDecompressedSize() */
+#define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);
+
+/*! ZSTD_getDecompressedSize() :
+ *  NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize().
+ *  Both functions work the same way, but ZSTD_getDecompressedSize() blends
+ *  "empty", "unknown" and "error" results to the same return value (0),
+ *  while ZSTD_getFrameContentSize() gives them separate return values.
+ * @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. */
+ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize);
+
+/*! ZSTD_findFrameCompressedSize() :
+ * `src` should point to the start of a ZSTD frame or skippable frame.
+ * `srcSize` must be >= first frame size
+ * @return : the compressed size of the first frame starting at `src`,
+ *           suitable to pass as `srcSize` to `ZSTD_decompress` or similar,
+ *        or an error code if input is invalid */
+ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);
+
+
+/*======  Helper functions  ======*/
+#define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */
+ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */
+ZSTDLIB_API unsigned    ZSTD_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
+ZSTDLIB_API const char* ZSTD_getErrorName(size_t code);     /*!< provides readable string from an error code */
+ZSTDLIB_API int         ZSTD_minCLevel(void);               /*!< minimum negative compression level allowed */
+ZSTDLIB_API int         ZSTD_maxCLevel(void);               /*!< maximum compression level available */
+
+
+/***************************************
+*  Explicit context
+***************************************/
+/*= Compression context
+ *  When compressing many times,
+ *  it is recommended to allocate a context just once,
+ *  and re-use it for each successive compression operation.
+ *  This will make workload friendlier for system's memory.
+ *  Note : re-using context is just a speed / resource optimization.
+ *         It doesn't change the compression ratio, which remains identical.
+ *  Note 2 : In multi-threaded environments,
+ *         use one different context per thread for parallel execution.
+ */
+typedef struct ZSTD_CCtx_s ZSTD_CCtx;
+ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);
+ZSTDLIB_API size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);
+
+/*! ZSTD_compressCCtx() :
+ *  Same as ZSTD_compress(), using an explicit ZSTD_CCtx
+ *  The function will compress at requested compression level,
+ *  ignoring any other parameter */
+ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
+                                     void* dst, size_t dstCapacity,
+                               const void* src, size_t srcSize,
+                                     int compressionLevel);
+
+/*= Decompression context
+ *  When decompressing many times,
+ *  it is recommended to allocate a context only once,
+ *  and re-use it for each successive compression operation.
+ *  This will make workload friendlier for system's memory.
+ *  Use one context per thread for parallel execution. */
+typedef struct ZSTD_DCtx_s ZSTD_DCtx;
+ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
+ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);
+
+/*! ZSTD_decompressDCtx() :
+ *  Same as ZSTD_decompress(),
+ *  requires an allocated ZSTD_DCtx.
+ *  Compatible with sticky parameters.
+ */
+ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,
+                                       void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize);
+
+
+/***************************************
+*  Advanced compression API
+***************************************/
+
+/* API design :
+ *   Parameters are pushed one by one into an existing context,
+ *   using ZSTD_CCtx_set*() functions.
+ *   Pushed parameters are sticky : they are valid for next compressed frame, and any subsequent frame.
+ *   "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
+ *   They do not apply to "simple" one-shot variants such as ZSTD_compressCCtx()
+ *
+ *   It's possible to reset all parameters to "default" using ZSTD_CCtx_reset().
+ *
+ *   This API supercedes all other "advanced" API entry points in the experimental section.
+ *   In the future, we expect to remove from experimental API entry points which are redundant with this API.
+ */
+
+
+/* Compression strategies, listed from fastest to strongest */
+typedef enum { ZSTD_fast=1,
+               ZSTD_dfast=2,
+               ZSTD_greedy=3,
+               ZSTD_lazy=4,
+               ZSTD_lazy2=5,
+               ZSTD_btlazy2=6,
+               ZSTD_btopt=7,
+               ZSTD_btultra=8,
+               ZSTD_btultra2=9
+               /* note : new strategies _might_ be added in the future.
+                         Only the order (from fast to strong) is guaranteed */
+} ZSTD_strategy;
+
+
+typedef enum {
+
+    /* compression parameters
+     * Note: When compressing with a ZSTD_CDict these parameters are superseded
+     * by the parameters used to construct the ZSTD_CDict. See ZSTD_CCtx_refCDict()
+     * for more info (superseded-by-cdict). */
+    ZSTD_c_compressionLevel=100, /* Update all compression parameters according to pre-defined cLevel table
+                              * Default level is ZSTD_CLEVEL_DEFAULT==3.
+                              * Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT.
+                              * Note 1 : it's possible to pass a negative compression level.
+                              * Note 2 : setting a level sets all default values of other compression parameters */
+    ZSTD_c_windowLog=101,    /* Maximum allowed back-reference distance, expressed as power of 2.
+                              * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX.
+                              * Special: value 0 means "use default windowLog".
+                              * Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT
+                              *       requires explicitly allowing such window size at decompression stage if using streaming. */
+    ZSTD_c_hashLog=102,      /* Size of the initial probe table, as a power of 2.
+                              * Resulting memory usage is (1 << (hashLog+2)).
+                              * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX.
+                              * Larger tables improve compression ratio of strategies <= dFast,
+                              * and improve speed of strategies > dFast.
+                              * Special: value 0 means "use default hashLog". */
+    ZSTD_c_chainLog=103,     /* Size of the multi-probe search table, as a power of 2.
+                              * Resulting memory usage is (1 << (chainLog+2)).
+                              * Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX.
+                              * Larger tables result in better and slower compression.
+                              * This parameter is useless when using "fast" strategy.
+                              * It's still useful when using "dfast" strategy,
+                              * in which case it defines a secondary probe table.
+                              * Special: value 0 means "use default chainLog". */
+    ZSTD_c_searchLog=104,    /* Number of search attempts, as a power of 2.
+                              * More attempts result in better and slower compression.
+                              * This parameter is useless when using "fast" and "dFast" strategies.
+                              * Special: value 0 means "use default searchLog". */
+    ZSTD_c_minMatch=105,     /* Minimum size of searched matches.
+                              * Note that Zstandard can still find matches of smaller size,
+                              * it just tweaks its search algorithm to look for this size and larger.
+                              * Larger values increase compression and decompression speed, but decrease ratio.
+                              * Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX.
+                              * Note that currently, for all strategies < btopt, effective minimum is 4.
+                              *                    , for all strategies > fast, effective maximum is 6.
+                              * Special: value 0 means "use default minMatchLength". */
+    ZSTD_c_targetLength=106, /* Impact of this field depends on strategy.
+                              * For strategies btopt, btultra & btultra2:
+                              *     Length of Match considered "good enough" to stop search.
+                              *     Larger values make compression stronger, and slower.
+                              * For strategy fast:
+                              *     Distance between match sampling.
+                              *     Larger values make compression faster, and weaker.
+                              * Special: value 0 means "use default targetLength". */
+    ZSTD_c_strategy=107,     /* See ZSTD_strategy enum definition.
+                              * The higher the value of selected strategy, the more complex it is,
+                              * resulting in stronger and slower compression.
+                              * Special: value 0 means "use default strategy". */
+
+    /* LDM mode parameters */
+    ZSTD_c_enableLongDistanceMatching=160, /* Enable long distance matching.
+                                     * This parameter is designed to improve compression ratio
+                                     * for large inputs, by finding large matches at long distance.
+                                     * It increases memory usage and window size.
+                                     * Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB
+                                     * except when expressly set to a different value. */
+    ZSTD_c_ldmHashLog=161,   /* Size of the table for long distance matching, as a power of 2.
+                              * Larger values increase memory usage and compression ratio,
+                              * but decrease compression speed.
+                              * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX
+                              * default: windowlog - 7.
+                              * Special: value 0 means "automatically determine hashlog". */
+    ZSTD_c_ldmMinMatch=162,  /* Minimum match size for long distance matcher.
+                              * Larger/too small values usually decrease compression ratio.
+                              * Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX.
+                              * Special: value 0 means "use default value" (default: 64). */
+    ZSTD_c_ldmBucketSizeLog=163, /* Log size of each bucket in the LDM hash table for collision resolution.
+                              * Larger values improve collision resolution but decrease compression speed.
+                              * The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX.
+                              * Special: value 0 means "use default value" (default: 3). */
+    ZSTD_c_ldmHashRateLog=164, /* Frequency of inserting/looking up entries into the LDM hash table.
+                              * Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN).
+                              * Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage.
+                              * Larger values improve compression speed.
+                              * Deviating far from default value will likely result in a compression ratio decrease.
+                              * Special: value 0 means "automatically determine hashRateLog". */
+
+    /* frame parameters */
+    ZSTD_c_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1)
+                              * Content size must be known at the beginning of compression.
+                              * This is automatically the case when using ZSTD_compress2(),
+                              * For streaming variants, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() */
+    ZSTD_c_checksumFlag=201, /* A 32-bits checksum of content is written at end of frame (default:0) */
+    ZSTD_c_dictIDFlag=202,   /* When applicable, dictionary's ID is written into frame header (default:1) */
+
+    /* multi-threading parameters */
+    /* These parameters are only useful if multi-threading is enabled (compiled with build macro ZSTD_MULTITHREAD).
+     * They return an error otherwise. */
+    ZSTD_c_nbWorkers=400,    /* Select how many threads will be spawned to compress in parallel.
+                              * When nbWorkers >= 1, triggers asynchronous mode when used with ZSTD_compressStream*() :
+                              * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
+                              * while compression work is performed in parallel, within worker threads.
+                              * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
+                              *  in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
+                              * More workers improve speed, but also increase memory usage.
+                              * Default value is `0`, aka "single-threaded mode" : no worker is spawned, compression is performed inside Caller's thread, all invocations are blocking */
+    ZSTD_c_jobSize=401,      /* Size of a compression job. This value is enforced only when nbWorkers >= 1.
+                              * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads.
+                              * 0 means default, which is dynamically determined based on compression parameters.
+                              * Job size must be a minimum of overlap size, or 1 MB, whichever is largest.
+                              * The minimum size is automatically and transparently enforced */
+    ZSTD_c_overlapLog=402,   /* Control the overlap size, as a fraction of window size.
+                              * The overlap size is an amount of data reloaded from previous job at the beginning of a new job.
+                              * It helps preserve compression ratio, while each job is compressed in parallel.
+                              * This value is enforced only when nbWorkers >= 1.
+                              * Larger values increase compression ratio, but decrease speed.
+                              * Possible values range from 0 to 9 :
+                              * - 0 means "default" : value will be determined by the library, depending on strategy
+                              * - 1 means "no overlap"
+                              * - 9 means "full overlap", using a full window size.
+                              * Each intermediate rank increases/decreases load size by a factor 2 :
+                              * 9: full window;  8: w/2;  7: w/4;  6: w/8;  5:w/16;  4: w/32;  3:w/64;  2:w/128;  1:no overlap;  0:default
+                              * default value varies between 6 and 9, depending on strategy */
+
+    /* note : additional experimental parameters are also available
+     * within the experimental section of the API.
+     * At the time of this writing, they include :
+     * ZSTD_c_rsyncable
+     * ZSTD_c_format
+     * ZSTD_c_forceMaxWindow
+     * ZSTD_c_forceAttachDict
+     * ZSTD_c_literalCompressionMode
+     * ZSTD_c_targetCBlockSize
+     * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
+     * note : never ever use experimentalParam? names directly;
+     *        also, the enums values themselves are unstable and can still change.
+     */
+     ZSTD_c_experimentalParam1=500,
+     ZSTD_c_experimentalParam2=10,
+     ZSTD_c_experimentalParam3=1000,
+     ZSTD_c_experimentalParam4=1001,
+     ZSTD_c_experimentalParam5=1002,
+     ZSTD_c_experimentalParam6=1003,
+} ZSTD_cParameter;
+
+typedef struct {
+    size_t error;
+    int lowerBound;
+    int upperBound;
+} ZSTD_bounds;
+
+/*! ZSTD_cParam_getBounds() :
+ *  All parameters must belong to an interval with lower and upper bounds,
+ *  otherwise they will either trigger an error or be automatically clamped.
+ * @return : a structure, ZSTD_bounds, which contains
+ *         - an error status field, which must be tested using ZSTD_isError()
+ *         - lower and upper bounds, both inclusive
+ */
+ZSTDLIB_API ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam);
+
+/*! ZSTD_CCtx_setParameter() :
+ *  Set one compression parameter, selected by enum ZSTD_cParameter.
+ *  All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds().
+ *  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
+ *  Setting a parameter is generally only possible during frame initialization (before starting compression).
+ *  Exception : when using multi-threading mode (nbWorkers >= 1),
+ *              the following parameters can be updated _during_ compression (within same frame):
+ *              => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy.
+ *              new parameters will be active for next job only (after a flush()).
+ * @return : an error code (which can be tested using ZSTD_isError()).
+ */
+ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);
+
+/*! ZSTD_CCtx_setPledgedSrcSize() :
+ *  Total input data size to be compressed as a single frame.
+ *  Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag.
+ *  This value will also be controlled at end of frame, and trigger an error if not respected.
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ *  Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame.
+ *           In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN.
+ *           ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame.
+ *  Note 2 : pledgedSrcSize is only valid once, for the next frame.
+ *           It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN.
+ *  Note 3 : Whenever all input data is provided and consumed in a single round,
+ *           for example with ZSTD_compress2(),
+ *           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
+ *           this value is automatically overridden by srcSize instead.
+ */
+ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);
+
+typedef enum {
+    ZSTD_reset_session_only = 1,
+    ZSTD_reset_parameters = 2,
+    ZSTD_reset_session_and_parameters = 3
+} ZSTD_ResetDirective;
+
+/*! ZSTD_CCtx_reset() :
+ *  There are 2 different things that can be reset, independently or jointly :
+ *  - The session : will stop compressing current frame, and make CCtx ready to start a new one.
+ *                  Useful after an error, or to interrupt any ongoing compression.
+ *                  Any internal data not yet flushed is cancelled.
+ *                  Compression parameters and dictionary remain unchanged.
+ *                  They will be used to compress next frame.
+ *                  Resetting session never fails.
+ *  - The parameters : changes all parameters back to "default".
+ *                  This removes any reference to any dictionary too.
+ *                  Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)
+ *                  otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())
+ *  - Both : similar to resetting the session, followed by resetting parameters.
+ */
+ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);
+
+/*! ZSTD_compress2() :
+ *  Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API.
+ *  ZSTD_compress2() always starts a new frame.
+ *  Should cctx hold data from a previously unfinished frame, everything about it is forgotten.
+ *  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
+ *  - The function is always blocking, returns when compression is completed.
+ *  Hint : compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`.
+ * @return : compressed size written into `dst` (<= `dstCapacity),
+ *           or an error code if it fails (which can be tested using ZSTD_isError()).
+ */
+ZSTDLIB_API size_t ZSTD_compress2( ZSTD_CCtx* cctx,
+                                   void* dst, size_t dstCapacity,
+                             const void* src, size_t srcSize);
+
+
+/***************************************
+*  Advanced decompression API
+***************************************/
+
+/* The advanced API pushes parameters one by one into an existing DCtx context.
+ * Parameters are sticky, and remain valid for all following frames
+ * using the same DCtx context.
+ * It's possible to reset parameters to default values using ZSTD_DCtx_reset().
+ * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
+ *        Therefore, no new decompression function is necessary.
+ */
+
+typedef enum {
+
+    ZSTD_d_windowLogMax=100, /* Select a size limit (in power of 2) beyond which
+                              * the streaming API will refuse to allocate memory buffer
+                              * in order to protect the host from unreasonable memory requirements.
+                              * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
+                              * By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT).
+                              * Special: value 0 means "use default maximum windowLog". */
+
+    /* note : additional experimental parameters are also available
+     * within the experimental section of the API.
+     * At the time of this writing, they include :
+     * ZSTD_c_format
+     * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.
+     * note : never ever use experimentalParam? names directly
+     */
+     ZSTD_d_experimentalParam1=1000
+
+} ZSTD_dParameter;
+
+/*! ZSTD_dParam_getBounds() :
+ *  All parameters must belong to an interval with lower and upper bounds,
+ *  otherwise they will either trigger an error or be automatically clamped.
+ * @return : a structure, ZSTD_bounds, which contains
+ *         - an error status field, which must be tested using ZSTD_isError()
+ *         - both lower and upper bounds, inclusive
+ */
+ZSTDLIB_API ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam);
+
+/*! ZSTD_DCtx_setParameter() :
+ *  Set one compression parameter, selected by enum ZSTD_dParameter.
+ *  All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds().
+ *  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).
+ *  Setting a parameter is only possible during frame initialization (before starting decompression).
+ * @return : 0, or an error code (which can be tested using ZSTD_isError()).
+ */
+ZSTDLIB_API size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int value);
+
+/*! ZSTD_DCtx_reset() :
+ *  Return a DCtx to clean state.
+ *  Session and parameters can be reset jointly or separately.
+ *  Parameters can only be reset when no active frame is being decompressed.
+ * @return : 0, or an error code, which can be tested with ZSTD_isError()
+ */
+ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);
+
+
+/****************************
+*  Streaming
+****************************/
+
+typedef struct ZSTD_inBuffer_s {
+  const void* src;    /**< start of input buffer */
+  size_t size;        /**< size of input buffer */
+  size_t pos;         /**< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size */
+} ZSTD_inBuffer;
+
+typedef struct ZSTD_outBuffer_s {
+  void*  dst;         /**< start of output buffer */
+  size_t size;        /**< size of output buffer */
+  size_t pos;         /**< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size */
+} ZSTD_outBuffer;
+
+
+
+/*-***********************************************************************
+*  Streaming compression - HowTo
+*
+*  A ZSTD_CStream object is required to track streaming operation.
+*  Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
+*  ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
+*  It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
+*
+*  For parallel execution, use one separate ZSTD_CStream per thread.
+*
+*  note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
+*
+*  Parameters are sticky : when starting a new compression on the same context,
+*  it will re-use the same sticky parameters as previous compression session.
+*  When in doubt, it's recommended to fully initialize the context before usage.
+*  Use ZSTD_CCtx_reset() to reset the context and ZSTD_CCtx_setParameter(),
+*  ZSTD_CCtx_setPledgedSrcSize(), or ZSTD_CCtx_loadDictionary() and friends to
+*  set more specific parameters, the pledged source size, or load a dictionary.
+*
+*  Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to
+*  consume input stream. The function will automatically update both `pos`
+*  fields within `input` and `output`.
+*  Note that the function may not consume the entire input, for example, because
+*  the output buffer is already full, in which case `input.pos < input.size`.
+*  The caller must check if input has been entirely consumed.
+*  If not, the caller must make some room to receive more compressed data,
+*  and then present again remaining input data.
+*  note: ZSTD_e_continue is guaranteed to make some forward progress when called,
+*        but doesn't guarantee maximal forward progress. This is especially relevant
+*        when compressing with multiple threads. The call won't block if it can
+*        consume some input, but if it can't it will wait for some, but not all,
+*        output to be flushed.
+* @return : provides a minimum amount of data remaining to be flushed from internal buffers
+*           or an error code, which can be tested using ZSTD_isError().
+*
+*  At any moment, it's possible to flush whatever data might remain stuck within internal buffer,
+*  using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.
+*  Note that, if `output->size` is too small, a single invocation with ZSTD_e_flush might not be enough (return code > 0).
+*  In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.
+*  You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the
+*  operation.
+*  note: ZSTD_e_flush will flush as much output as possible, meaning when compressing with multiple threads, it will
+*        block until the flush is complete or the output buffer is full.
+*  @return : 0 if internal buffers are entirely flushed,
+*            >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
+*            or an error code, which can be tested using ZSTD_isError().
+*
+*  Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.
+*  It will perform a flush and write frame epilogue.
+*  The epilogue is required for decoders to consider a frame completed.
+*  flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.
+*  You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to
+*  start a new frame.
+*  note: ZSTD_e_end will flush as much output as possible, meaning when compressing with multiple threads, it will
+*        block until the flush is complete or the output buffer is full.
+*  @return : 0 if frame fully completed and fully flushed,
+*            >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),
+*            or an error code, which can be tested using ZSTD_isError().
+*
+* *******************************************************************/
+
+typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */
+                                 /* Continue to distinguish them for compatibility with older versions <= v1.2.0 */
+/*===== ZSTD_CStream management functions =====*/
+ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
+ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);
+
+/*===== Streaming compression functions =====*/
+typedef enum {
+    ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal compression ratio */
+    ZSTD_e_flush=1,    /* flush any data provided so far,
+                        * it creates (at least) one new block, that can be decoded immediately on reception;
+                        * frame will continue: any future data can still reference previously compressed data, improving compression.
+                        * note : multithreaded compression will block to flush as much output as possible. */
+    ZSTD_e_end=2       /* flush any remaining data _and_ close current frame.
+                        * note that frame is only closed after compressed data is fully flushed (return value == 0).
+                        * After that point, any additional data starts a new frame.
+                        * note : each frame is independent (does not reference any content from previous frame).
+                        : note : multithreaded compression will block to flush as much output as possible. */
+} ZSTD_EndDirective;
+
+/*! ZSTD_compressStream2() :
+ *  Behaves about the same as ZSTD_compressStream, with additional control on end directive.
+ *  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
+ *  - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)
+ *  - output->pos must be <= dstCapacity, input->pos must be <= srcSize
+ *  - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
+ *  - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.
+ *  - When nbWorkers>=1, function is non-blocking : it just acquires a copy of input, and distributes jobs to internal worker threads, flush whatever is available,
+ *                                                  and then immediately returns, just indicating that there is some data remaining to be flushed.
+ *                                                  The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
+ *  - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.
+ *  - @return provides a minimum amount of data remaining to be flushed from internal buffers
+ *            or an error code, which can be tested using ZSTD_isError().
+ *            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
+ *            This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers.
+ *            For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed.
+ *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
+ *            only ZSTD_e_end or ZSTD_e_flush operations are allowed.
+ *            Before starting a new compression job, or changing compression parameters,
+ *            it is required to fully flush internal buffers.
+ */
+ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
+                                         ZSTD_outBuffer* output,
+                                         ZSTD_inBuffer* input,
+                                         ZSTD_EndDirective endOp);
+
+
+/* These buffer sizes are softly recommended.
+ * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
+ * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),
+ * reducing the amount of memory shuffling and buffering, resulting in minor performance savings.
+ *
+ * However, note that these recommendations are from the perspective of a C caller program.
+ * If the streaming interface is invoked from some other language,
+ * especially managed ones such as Java or Go, through a foreign function interface such as jni or cgo,
+ * a major performance rule is to reduce crossing such interface to an absolute minimum.
+ * It's not rare that performance ends being spent more into the interface, rather than compression itself.
+ * In which cases, prefer using large buffers, as large as practical,
+ * for both input and output, to reduce the nb of roundtrips.
+ */
+ZSTDLIB_API size_t ZSTD_CStreamInSize(void);    /**< recommended size for input buffer */
+ZSTDLIB_API size_t ZSTD_CStreamOutSize(void);   /**< recommended size for output buffer. Guarantee to successfully flush at least one complete compressed block. */
+
+
+/* *****************************************************************************
+ * This following is a legacy streaming API.
+ * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().
+ * It is redundant, but remains fully supported.
+ * Advanced parameters and dictionary compression can only be used through the
+ * new API.
+ ******************************************************************************/
+
+/*!
+ * Equivalent to:
+ *
+ *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+ *     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)
+ *     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
+ */
+ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
+/*!
+ * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
+ * NOTE: The return value is different. ZSTD_compressStream() returns a hint for
+ * the next read size (if non-zero and not an error). ZSTD_compressStream2()
+ * returns the minimum nb of bytes left to flush (if non-zero and not an error).
+ */
+ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
+/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */
+ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
+/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */
+ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
+
+
+/*-***************************************************************************
+*  Streaming decompression - HowTo
+*
+*  A ZSTD_DStream object is required to track streaming operations.
+*  Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
+*  ZSTD_DStream objects can be re-used multiple times.
+*
+*  Use ZSTD_initDStream() to start a new decompression operation.
+* @return : recommended first input size
+*  Alternatively, use advanced API to set specific properties.
+*
+*  Use ZSTD_decompressStream() repetitively to consume your input.
+*  The function will update both `pos` fields.
+*  If `input.pos < input.size`, some input has not been consumed.
+*  It's up to the caller to present again remaining data.
+*  The function tries to flush all data decoded immediately, respecting output buffer size.
+*  If `output.pos < output.size`, decoder has flushed everything it could.
+*  But if `output.pos == output.size`, there might be some data left within internal buffers.,
+*  In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
+*  Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX.
+* @return : 0 when a frame is completely decoded and fully flushed,
+*        or an error code, which can be tested using ZSTD_isError(),
+*        or any other value > 0, which means there is still some decoding or flushing to do to complete current frame :
+*                                the return value is a suggested next input size (just a hint for better latency)
+*                                that will never request more than the remaining frame size.
+* *******************************************************************************/
+
+typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
+                                 /* For compatibility with versions <= v1.2.0, prefer differentiating them. */
+/*===== ZSTD_DStream management functions =====*/
+ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
+ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);
+
+/*===== Streaming decompression functions =====*/
+
+/* This function is redundant with the advanced API and equivalent to:
+ *
+ *     ZSTD_DCtx_reset(zds);
+ *     ZSTD_DCtx_refDDict(zds, NULL);
+ */
+ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
+
+ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
+
+ZSTDLIB_API size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */
+ZSTDLIB_API size_t ZSTD_DStreamOutSize(void);   /*!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. */
+
+
+/**************************
+*  Simple dictionary API
+***************************/
+/*! ZSTD_compress_usingDict() :
+ *  Compression at an explicit compression level using a Dictionary.
+ *  A dictionary can be any arbitrary data segment (also called a prefix),
+ *  or a buffer with specified information (see dictBuilder/zdict.h).
+ *  Note : This function loads the dictionary, resulting in significant startup delay.
+ *         It's intended for a dictionary used only once.
+ *  Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used. */
+ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,
+                                           void* dst, size_t dstCapacity,
+                                     const void* src, size_t srcSize,
+                                     const void* dict,size_t dictSize,
+                                           int compressionLevel);
+
+/*! ZSTD_decompress_usingDict() :
+ *  Decompression using a known Dictionary.
+ *  Dictionary must be identical to the one used during compression.
+ *  Note : This function loads the dictionary, resulting in significant startup delay.
+ *         It's intended for a dictionary used only once.
+ *  Note : When `dict == NULL || dictSize < 8` no dictionary is used. */
+ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
+                                             void* dst, size_t dstCapacity,
+                                       const void* src, size_t srcSize,
+                                       const void* dict,size_t dictSize);
+
+
+/***********************************
+ *  Bulk processing dictionary API
+ **********************************/
+typedef struct ZSTD_CDict_s ZSTD_CDict;
+
+/*! ZSTD_createCDict() :
+ *  When compressing multiple messages / blocks using the same dictionary, it's recommended to load it only once.
+ *  ZSTD_createCDict() will create a digested dictionary, ready to start future compression operations without startup cost.
+ *  ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.
+ * `dictBuffer` can be released after ZSTD_CDict creation, because its content is copied within CDict.
+ *  Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate `dictBuffer` content.
+ *  Note : A ZSTD_CDict can be created from an empty dictBuffer, but it is inefficient when used to compress small data. */
+ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize,
+                                         int compressionLevel);
+
+/*! ZSTD_freeCDict() :
+ *  Function frees memory allocated by ZSTD_createCDict(). */
+ZSTDLIB_API size_t      ZSTD_freeCDict(ZSTD_CDict* CDict);
+
+/*! ZSTD_compress_usingCDict() :
+ *  Compression using a digested Dictionary.
+ *  Recommended when same dictionary is used multiple times.
+ *  Note : compression level is _decided at dictionary creation time_,
+ *     and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) */
+ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
+                                            void* dst, size_t dstCapacity,
+                                      const void* src, size_t srcSize,
+                                      const ZSTD_CDict* cdict);
+
+
+typedef struct ZSTD_DDict_s ZSTD_DDict;
+
+/*! ZSTD_createDDict() :
+ *  Create a digested dictionary, ready to start decompression operation without startup delay.
+ *  dictBuffer can be released after DDict creation, as its content is copied inside DDict. */
+ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize);
+
+/*! ZSTD_freeDDict() :
+ *  Function frees memory allocated with ZSTD_createDDict() */
+ZSTDLIB_API size_t      ZSTD_freeDDict(ZSTD_DDict* ddict);
+
+/*! ZSTD_decompress_usingDDict() :
+ *  Decompression using a digested Dictionary.
+ *  Recommended when same dictionary is used multiple times. */
+ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
+                                              void* dst, size_t dstCapacity,
+                                        const void* src, size_t srcSize,
+                                        const ZSTD_DDict* ddict);
+
+
+/********************************
+ *  Dictionary helper functions
+ *******************************/
+
+/*! ZSTD_getDictID_fromDict() :
+ *  Provides the dictID stored within dictionary.
+ *  if @return == 0, the dictionary is not conformant with Zstandard specification.
+ *  It can still be loaded, but as a content-only dictionary. */
+ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize);
+
+/*! ZSTD_getDictID_fromDDict() :
+ *  Provides the dictID of the dictionary loaded into `ddict`.
+ *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
+ *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
+ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict);
+
+/*! ZSTD_getDictID_fromFrame() :
+ *  Provides the dictID required to decompressed the frame stored within `src`.
+ *  If @return == 0, the dictID could not be decoded.
+ *  This could for one of the following reasons :
+ *  - The frame does not require a dictionary to be decoded (most common case).
+ *  - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden information.
+ *    Note : this use case also happens when using a non-conformant dictionary.
+ *  - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`).
+ *  - This is not a Zstandard frame.
+ *  When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. */
+ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
+
+
+/*******************************************************************************
+ * Advanced dictionary and prefix API
+ *
+ * This API allows dictionaries to be used with ZSTD_compress2(),
+ * ZSTD_compressStream2(), and ZSTD_decompress(). Dictionaries are sticky, and
+ * only reset with the context is reset with ZSTD_reset_parameters or
+ * ZSTD_reset_session_and_parameters. Prefixes are single-use.
+ ******************************************************************************/
+
+
+/*! ZSTD_CCtx_loadDictionary() :
+ *  Create an internal CDict from `dict` buffer.
+ *  Decompression will have to use same dictionary.
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ *  Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,
+ *           meaning "return to no-dictionary mode".
+ *  Note 1 : Dictionary is sticky, it will be used for all future compressed frames.
+ *           To return to "no-dictionary" situation, load a NULL dictionary (or reset parameters).
+ *  Note 2 : Loading a dictionary involves building tables.
+ *           It's also a CPU consuming operation, with non-negligible impact on latency.
+ *           Tables are dependent on compression parameters, and for this reason,
+ *           compression parameters can no longer be changed after loading a dictionary.
+ *  Note 3 :`dict` content will be copied internally.
+ *           Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead.
+ *           In such a case, dictionary buffer must outlive its users.
+ *  Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()
+ *           to precisely select how dictionary content must be interpreted. */
+ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
+
+/*! ZSTD_CCtx_refCDict() :
+ *  Reference a prepared dictionary, to be used for all next compressed frames.
+ *  Note that compression parameters are enforced from within CDict,
+ *  and supersede any compression parameter previously set within CCtx.
+ *  The parameters ignored are labled as "superseded-by-cdict" in the ZSTD_cParameter enum docs.
+ *  The ignored parameters will be used again if the CCtx is returned to no-dictionary mode.
+ *  The dictionary will remain valid for future compressed frames using same CCtx.
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ *  Special : Referencing a NULL CDict means "return to no-dictionary mode".
+ *  Note 1 : Currently, only one dictionary can be managed.
+ *           Referencing a new dictionary effectively "discards" any previous one.
+ *  Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. */
+ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
+
+/*! ZSTD_CCtx_refPrefix() :
+ *  Reference a prefix (single-usage dictionary) for next compressed frame.
+ *  A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end).
+ *  Decompression will need same prefix to properly regenerate data.
+ *  Compressing with a prefix is similar in outcome as performing a diff and compressing it,
+ *  but performs much faster, especially during decompression (compression speed is tunable with compression level).
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ *  Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary
+ *  Note 1 : Prefix buffer is referenced. It **must** outlive compression.
+ *           Its content must remain unmodified during compression.
+ *  Note 2 : If the intention is to diff some large src data blob with some prior version of itself,
+ *           ensure that the window size is large enough to contain the entire source.
+ *           See ZSTD_c_windowLog.
+ *  Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters.
+ *           It's a CPU consuming operation, with non-negligible impact on latency.
+ *           If there is a need to use the same prefix multiple times, consider loadDictionary instead.
+ *  Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dm_rawContent).
+ *           Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. */
+ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx,
+                                 const void* prefix, size_t prefixSize);
+
+/*! ZSTD_DCtx_loadDictionary() :
+ *  Create an internal DDict from dict buffer,
+ *  to be used to decompress next frames.
+ *  The dictionary remains valid for all future frames, until explicitly invalidated.
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ *  Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,
+ *            meaning "return to no-dictionary mode".
+ *  Note 1 : Loading a dictionary involves building tables,
+ *           which has a non-negligible impact on CPU usage and latency.
+ *           It's recommended to "load once, use many times", to amortize the cost
+ *  Note 2 :`dict` content will be copied internally, so `dict` can be released after loading.
+ *           Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead.
+ *  Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of
+ *           how dictionary content is loaded and interpreted.
+ */
+ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
+
+/*! ZSTD_DCtx_refDDict() :
+ *  Reference a prepared dictionary, to be used to decompress next frames.
+ *  The dictionary remains active for decompression of future frames using same DCtx.
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ *  Note 1 : Currently, only one dictionary can be managed.
+ *           Referencing a new dictionary effectively "discards" any previous one.
+ *  Special: referencing a NULL DDict means "return to no-dictionary mode".
+ *  Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx.
+ */
+ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
+
+/*! ZSTD_DCtx_refPrefix() :
+ *  Reference a prefix (single-usage dictionary) to decompress next frame.
+ *  This is the reverse operation of ZSTD_CCtx_refPrefix(),
+ *  and must use the same prefix as the one used during compression.
+ *  Prefix is **only used once**. Reference is discarded at end of frame.
+ *  End of frame is reached when ZSTD_decompressStream() returns 0.
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ *  Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary
+ *  Note 2 : Prefix buffer is referenced. It **must** outlive decompression.
+ *           Prefix buffer must remain unmodified up to the end of frame,
+ *           reached when ZSTD_decompressStream() returns 0.
+ *  Note 3 : By default, the prefix is treated as raw content (ZSTD_dm_rawContent).
+ *           Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)
+ *  Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost.
+ *           A full dictionary is more costly, as it requires building tables.
+ */
+ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx,
+                                 const void* prefix, size_t prefixSize);
+
+/* ===   Memory management   === */
+
+/*! ZSTD_sizeof_*() :
+ *  These functions give the _current_ memory usage of selected object.
+ *  Note that object memory usage can evolve (increase or decrease) over time. */
+ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx);
+ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx);
+ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
+ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
+ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict);
+ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
+
+#endif  /* ZSTD_H_235446 */
+
+
+/* **************************************************************************************
+ *   ADVANCED AND EXPERIMENTAL FUNCTIONS
+ ****************************************************************************************
+ * The definitions in the following section are considered experimental.
+ * They are provided for advanced scenarios.
+ * They should never be used with a dynamic library, as prototypes may change in the future.
+ * Use them only in association with static linking.
+ * ***************************************************************************************/
+
+#if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)
+#define ZSTD_H_ZSTD_STATIC_LINKING_ONLY
+
+/****************************************************************************************
+ *   experimental API (static linking only)
+ ****************************************************************************************
+ * The following symbols and constants
+ * are not planned to join "stable API" status in the near future.
+ * They can still change in future versions.
+ * Some of them are planned to remain in the static_only section indefinitely.
+ * Some of them might be removed in the future (especially when redundant with existing stable functions)
+ * ***************************************************************************************/
+
+#define ZSTD_FRAMEHEADERSIZE_PREFIX 5   /* minimum input size required to query frame header size */
+#define ZSTD_FRAMEHEADERSIZE_MIN    6
+#define ZSTD_FRAMEHEADERSIZE_MAX   18   /* can be useful for static allocation */
+#define ZSTD_SKIPPABLEHEADERSIZE    8
+
+/* compression parameter bounds */
+#define ZSTD_WINDOWLOG_MAX_32    30
+#define ZSTD_WINDOWLOG_MAX_64    31
+#define ZSTD_WINDOWLOG_MAX     ((int)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64))
+#define ZSTD_WINDOWLOG_MIN       10
+#define ZSTD_HASHLOG_MAX       ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30)
+#define ZSTD_HASHLOG_MIN          6
+#define ZSTD_CHAINLOG_MAX_32     29
+#define ZSTD_CHAINLOG_MAX_64     30
+#define ZSTD_CHAINLOG_MAX      ((int)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64))
+#define ZSTD_CHAINLOG_MIN        ZSTD_HASHLOG_MIN
+#define ZSTD_SEARCHLOG_MAX      (ZSTD_WINDOWLOG_MAX-1)
+#define ZSTD_SEARCHLOG_MIN        1
+#define ZSTD_MINMATCH_MAX         7   /* only for ZSTD_fast, other strategies are limited to 6 */
+#define ZSTD_MINMATCH_MIN         3   /* only for ZSTD_btopt+, faster strategies are limited to 4 */
+#define ZSTD_TARGETLENGTH_MAX    ZSTD_BLOCKSIZE_MAX
+#define ZSTD_TARGETLENGTH_MIN     0   /* note : comparing this constant to an unsigned results in a tautological test */
+#define ZSTD_STRATEGY_MIN        ZSTD_fast
+#define ZSTD_STRATEGY_MAX        ZSTD_btultra2
+
+
+#define ZSTD_OVERLAPLOG_MIN       0
+#define ZSTD_OVERLAPLOG_MAX       9
+
+#define ZSTD_WINDOWLOG_LIMIT_DEFAULT 27   /* by default, the streaming decoder will refuse any frame
+                                           * requiring larger than (1<<ZSTD_WINDOWLOG_LIMIT_DEFAULT) window size,
+                                           * to preserve host's memory from unreasonable requirements.
+                                           * This limit can be overridden using ZSTD_DCtx_setParameter(,ZSTD_d_windowLogMax,).
+                                           * The limit does not apply for one-pass decoders (such as ZSTD_decompress()), since no additional memory is allocated */
+
+
+/* LDM parameter bounds */
+#define ZSTD_LDM_HASHLOG_MIN      ZSTD_HASHLOG_MIN
+#define ZSTD_LDM_HASHLOG_MAX      ZSTD_HASHLOG_MAX
+#define ZSTD_LDM_MINMATCH_MIN        4
+#define ZSTD_LDM_MINMATCH_MAX     4096
+#define ZSTD_LDM_BUCKETSIZELOG_MIN   1
+#define ZSTD_LDM_BUCKETSIZELOG_MAX   8
+#define ZSTD_LDM_HASHRATELOG_MIN     0
+#define ZSTD_LDM_HASHRATELOG_MAX (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)
+
+/* Advanced parameter bounds */
+#define ZSTD_TARGETCBLOCKSIZE_MIN   64
+#define ZSTD_TARGETCBLOCKSIZE_MAX   ZSTD_BLOCKSIZE_MAX
+
+/* internal */
+#define ZSTD_HASHLOG3_MAX           17
+
+
+/* ---  Advanced types  --- */
+
+typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params;
+
+typedef struct {
+    unsigned windowLog;       /**< largest match distance : larger == more compression, more memory needed during decompression */
+    unsigned chainLog;        /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */
+    unsigned hashLog;         /**< dispatch table : larger == faster, more memory */
+    unsigned searchLog;       /**< nb of searches : larger == more compression, slower */
+    unsigned minMatch;        /**< match length searched : larger == faster decompression, sometimes less compression */
+    unsigned targetLength;    /**< acceptable match size for optimal parser (only) : larger == more compression, slower */
+    ZSTD_strategy strategy;   /**< see ZSTD_strategy definition above */
+} ZSTD_compressionParameters;
+
+typedef struct {
+    int contentSizeFlag; /**< 1: content size will be in frame header (when known) */
+    int checksumFlag;    /**< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection */
+    int noDictIDFlag;    /**< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) */
+} ZSTD_frameParameters;
+
+typedef struct {
+    ZSTD_compressionParameters cParams;
+    ZSTD_frameParameters fParams;
+} ZSTD_parameters;
+
+typedef enum {
+    ZSTD_dct_auto = 0,       /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */
+    ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */
+    ZSTD_dct_fullDict = 2    /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */
+} ZSTD_dictContentType_e;
+
+typedef enum {
+    ZSTD_dlm_byCopy = 0,  /**< Copy dictionary content internally */
+    ZSTD_dlm_byRef = 1,   /**< Reference dictionary content -- the dictionary buffer must outlive its users. */
+} ZSTD_dictLoadMethod_e;
+
+typedef enum {
+    /* Opened question : should we have a format ZSTD_f_auto ?
+     * Today, it would mean exactly the same as ZSTD_f_zstd1.
+     * But, in the future, should several formats become supported,
+     * on the compression side, it would mean "default format".
+     * On the decompression side, it would mean "automatic format detection",
+     * so that ZSTD_f_zstd1 would mean "accept *only* zstd frames".
+     * Since meaning is a little different, another option could be to define different enums for compression and decompression.
+     * This question could be kept for later, when there are actually multiple formats to support,
+     * but there is also the question of pinning enum values, and pinning value `0` is especially important */
+    ZSTD_f_zstd1 = 0,           /* zstd frame format, specified in zstd_compression_format.md (default) */
+    ZSTD_f_zstd1_magicless = 1, /* Variant of zstd frame format, without initial 4-bytes magic number.
+                                 * Useful to save 4 bytes per generated frame.
+                                 * Decoder cannot recognise automatically this format, requiring this instruction. */
+} ZSTD_format_e;
+
+typedef enum {
+    /* Note: this enum and the behavior it controls are effectively internal
+     * implementation details of the compressor. They are expected to continue
+     * to evolve and should be considered only in the context of extremely
+     * advanced performance tuning.
+     *
+     * Zstd currently supports the use of a CDict in two ways:
+     *
+     * - The contents of the CDict can be copied into the working context. This
+     *   means that the compression can search both the dictionary and input
+     *   while operating on a single set of internal tables. This makes
+     *   the compression faster per-byte of input. However, the initial copy of
+     *   the CDict's tables incurs a fixed cost at the beginning of the
+     *   compression. For small compressions (< 8 KB), that copy can dominate
+     *   the cost of the compression.
+     *
+     * - The CDict's tables can be used in-place. In this model, compression is
+     *   slower per input byte, because the compressor has to search two sets of
+     *   tables. However, this model incurs no start-up cost (as long as the
+     *   working context's tables can be reused). For small inputs, this can be
+     *   faster than copying the CDict's tables.
+     *
+     * Zstd has a simple internal heuristic that selects which strategy to use
+     * at the beginning of a compression. However, if experimentation shows that
+     * Zstd is making poor choices, it is possible to override that choice with
+     * this enum.
+     */
+    ZSTD_dictDefaultAttach = 0, /* Use the default heuristic. */
+    ZSTD_dictForceAttach   = 1, /* Never copy the dictionary. */
+    ZSTD_dictForceCopy     = 2, /* Always copy the dictionary. */
+} ZSTD_dictAttachPref_e;
+
+typedef enum {
+  ZSTD_lcm_auto = 0,          /**< Automatically determine the compression mode based on the compression level.
+                               *   Negative compression levels will be uncompressed, and positive compression
+                               *   levels will be compressed. */
+  ZSTD_lcm_huffman = 1,       /**< Always attempt Huffman compression. Uncompressed literals will still be
+                               *   emitted if Huffman compression is not profitable. */
+  ZSTD_lcm_uncompressed = 2,  /**< Always emit uncompressed literals. */
+} ZSTD_literalCompressionMode_e;
+
+
+/***************************************
+*  Frame size functions
+***************************************/
+
+/*! ZSTD_findDecompressedSize() :
+ *  `src` should point to the start of a series of ZSTD encoded and/or skippable frames
+ *  `srcSize` must be the _exact_ size of this series
+ *       (i.e. there should be a frame boundary at `src + srcSize`)
+ *  @return : - decompressed size of all data in all successive frames
+ *            - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN
+ *            - if an error occurred: ZSTD_CONTENTSIZE_ERROR
+ *
+ *   note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.
+ *            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.
+ *            In which case, it's necessary to use streaming mode to decompress data.
+ *   note 2 : decompressed size is always present when compression is done with ZSTD_compress()
+ *   note 3 : decompressed size can be very large (64-bits value),
+ *            potentially larger than what local system can handle as a single memory segment.
+ *            In which case, it's necessary to use streaming mode to decompress data.
+ *   note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.
+ *            Always ensure result fits within application's authorized limits.
+ *            Each application can set its own limits.
+ *   note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to
+ *            read each contained frame header.  This is fast as most of the data is skipped,
+ *            however it does mean that all frame data must be present and valid. */
+ZSTDLIB_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);
+
+/*! ZSTD_decompressBound() :
+ *  `src` should point to the start of a series of ZSTD encoded and/or skippable frames
+ *  `srcSize` must be the _exact_ size of this series
+ *       (i.e. there should be a frame boundary at `src + srcSize`)
+ *  @return : - upper-bound for the decompressed size of all data in all successive frames
+ *            - if an error occured: ZSTD_CONTENTSIZE_ERROR
+ *
+ *  note 1  : an error can occur if `src` contains an invalid or incorrectly formatted frame.
+ *  note 2  : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`.
+ *            in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value.
+ *  note 3  : when the decompressed size field isn't available, the upper-bound for that frame is calculated by:
+ *              upper-bound = # blocks * min(128 KB, Window_Size)
+ */
+ZSTDLIB_API unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize);
+
+/*! ZSTD_frameHeaderSize() :
+ *  srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX.
+ * @return : size of the Frame Header,
+ *           or an error code (if srcSize is too small) */
+ZSTDLIB_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);
+
+
+/***************************************
+*  Memory management
+***************************************/
+
+/*! ZSTD_estimate*() :
+ *  These functions make it possible to estimate memory usage
+ *  of a future {D,C}Ctx, before its creation.
+ *  ZSTD_estimateCCtxSize() will provide a budget large enough for any compression level up to selected one.
+ *  It will also consider src size to be arbitrarily "large", which is worst case.
+ *  If srcSize is known to always be small, ZSTD_estimateCCtxSize_usingCParams() can provide a tighter estimation.
+ *  ZSTD_estimateCCtxSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
+ *  ZSTD_estimateCCtxSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.
+ *  Note : CCtx size estimation is only correct for single-threaded compression. */
+ZSTDLIB_API size_t ZSTD_estimateCCtxSize(int compressionLevel);
+ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);
+ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);
+ZSTDLIB_API size_t ZSTD_estimateDCtxSize(void);
+
+/*! ZSTD_estimateCStreamSize() :
+ *  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
+ *  It will also consider src size to be arbitrarily "large", which is worst case.
+ *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
+ *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.
+ *  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.
+ *  Note : CStream size estimation is only correct for single-threaded compression.
+ *  ZSTD_DStream memory budget depends on window Size.
+ *  This information can be passed manually, using ZSTD_estimateDStreamSize,
+ *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
+ *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
+ *         an internal ?Dict will be created, which additional size is not estimated here.
+ *         In this case, get total size by adding ZSTD_estimate?DictSize */
+ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
+ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
+ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
+ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
+ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
+
+/*! ZSTD_estimate?DictSize() :
+ *  ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict().
+ *  ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced().
+ *  Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller.
+ */
+ZSTDLIB_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);
+ZSTDLIB_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);
+ZSTDLIB_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);
+
+/*! ZSTD_initStatic*() :
+ *  Initialize an object using a pre-allocated fixed-size buffer.
+ *  workspace: The memory area to emplace the object into.
+ *             Provided pointer *must be 8-bytes aligned*.
+ *             Buffer must outlive object.
+ *  workspaceSize: Use ZSTD_estimate*Size() to determine
+ *                 how large workspace must be to support target scenario.
+ * @return : pointer to object (same address as workspace, just different type),
+ *           or NULL if error (size too small, incorrect alignment, etc.)
+ *  Note : zstd will never resize nor malloc() when using a static buffer.
+ *         If the object requires more memory than available,
+ *         zstd will just error out (typically ZSTD_error_memory_allocation).
+ *  Note 2 : there is no corresponding "free" function.
+ *           Since workspace is allocated externally, it must be freed externally too.
+ *  Note 3 : cParams : use ZSTD_getCParams() to convert a compression level
+ *           into its associated cParams.
+ *  Limitation 1 : currently not compatible with internal dictionary creation, triggered by
+ *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
+ *  Limitation 2 : static cctx currently not compatible with multi-threading.
+ *  Limitation 3 : static dctx is incompatible with legacy support.
+ */
+ZSTDLIB_API ZSTD_CCtx*    ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);
+ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
+
+ZSTDLIB_API ZSTD_DCtx*    ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize);
+ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */
+
+ZSTDLIB_API const ZSTD_CDict* ZSTD_initStaticCDict(
+                                        void* workspace, size_t workspaceSize,
+                                        const void* dict, size_t dictSize,
+                                        ZSTD_dictLoadMethod_e dictLoadMethod,
+                                        ZSTD_dictContentType_e dictContentType,
+                                        ZSTD_compressionParameters cParams);
+
+ZSTDLIB_API const ZSTD_DDict* ZSTD_initStaticDDict(
+                                        void* workspace, size_t workspaceSize,
+                                        const void* dict, size_t dictSize,
+                                        ZSTD_dictLoadMethod_e dictLoadMethod,
+                                        ZSTD_dictContentType_e dictContentType);
+
+
+/*! Custom memory allocation :
+ *  These prototypes make it possible to pass your own allocation/free functions.
+ *  ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below.
+ *  All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones.
+ */
+typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);
+typedef void  (*ZSTD_freeFunction) (void* opaque, void* address);
+typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
+static ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL };  /**< this constant defers to stdlib's functions */
+
+ZSTDLIB_API ZSTD_CCtx*    ZSTD_createCCtx_advanced(ZSTD_customMem customMem);
+ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
+ZSTDLIB_API ZSTD_DCtx*    ZSTD_createDCtx_advanced(ZSTD_customMem customMem);
+ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
+
+ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize,
+                                                  ZSTD_dictLoadMethod_e dictLoadMethod,
+                                                  ZSTD_dictContentType_e dictContentType,
+                                                  ZSTD_compressionParameters cParams,
+                                                  ZSTD_customMem customMem);
+
+ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
+                                                  ZSTD_dictLoadMethod_e dictLoadMethod,
+                                                  ZSTD_dictContentType_e dictContentType,
+                                                  ZSTD_customMem customMem);
+
+
+
+/***************************************
+*  Advanced compression functions
+***************************************/
+
+/*! ZSTD_createCDict_byReference() :
+ *  Create a digested dictionary for compression
+ *  Dictionary content is just referenced, not duplicated.
+ *  As a consequence, `dictBuffer` **must** outlive CDict,
+ *  and its content must remain unmodified throughout the lifetime of CDict. */
+ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel);
+
+/*! ZSTD_getCParams() :
+ * @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize.
+ * `estimatedSrcSize` value is optional, select 0 if not known */
+ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
+
+/*! ZSTD_getParams() :
+ *  same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.
+ *  All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */
+ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
+
+/*! ZSTD_checkCParams() :
+ *  Ensure param values remain within authorized range.
+ * @return 0 on success, or an error code (can be checked with ZSTD_isError()) */
+ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
+
+/*! ZSTD_adjustCParams() :
+ *  optimize params for a given `srcSize` and `dictSize`.
+ * `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN.
+ * `dictSize` must be `0` when there is no dictionary.
+ *  cPar can be invalid : all parameters will be clamped within valid range in the @return struct.
+ *  This function never fails (wide contract) */
+ZSTDLIB_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);
+
+/*! ZSTD_compress_advanced() :
+ *  Same as ZSTD_compress_usingDict(), with fine-tune control over compression parameters (by structure) */
+ZSTDLIB_API size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,
+                                          void* dst, size_t dstCapacity,
+                                    const void* src, size_t srcSize,
+                                    const void* dict,size_t dictSize,
+                                          ZSTD_parameters params);
+
+/*! ZSTD_compress_usingCDict_advanced() :
+ *  Same as ZSTD_compress_usingCDict(), with fine-tune control over frame parameters */
+ZSTDLIB_API size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
+                                              void* dst, size_t dstCapacity,
+                                        const void* src, size_t srcSize,
+                                        const ZSTD_CDict* cdict,
+                                              ZSTD_frameParameters fParams);
+
+
+/*! ZSTD_CCtx_loadDictionary_byReference() :
+ *  Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.
+ *  It saves some memory, but also requires that `dict` outlives its usage within `cctx` */
+ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
+
+/*! ZSTD_CCtx_loadDictionary_advanced() :
+ *  Same as ZSTD_CCtx_loadDictionary(), but gives finer control over
+ *  how to load the dictionary (by copy ? by reference ?)
+ *  and how to interpret it (automatic ? force raw mode ? full mode only ?) */
+ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);
+
+/*! ZSTD_CCtx_refPrefix_advanced() :
+ *  Same as ZSTD_CCtx_refPrefix(), but gives finer control over
+ *  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
+ZSTDLIB_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);
+
+/* ===   experimental parameters   === */
+/* these parameters can be used with ZSTD_setParameter()
+ * they are not guaranteed to remain supported in the future */
+
+ /* Enables rsyncable mode,
+  * which makes compressed files more rsync friendly
+  * by adding periodic synchronization points to the compressed data.
+  * The target average block size is ZSTD_c_jobSize / 2.
+  * It's possible to modify the job size to increase or decrease
+  * the granularity of the synchronization point.
+  * Once the jobSize is smaller than the window size,
+  * it will result in compression ratio degradation.
+  * NOTE 1: rsyncable mode only works when multithreading is enabled.
+  * NOTE 2: rsyncable performs poorly in combination with long range mode,
+  * since it will decrease the effectiveness of synchronization points,
+  * though mileage may vary.
+  * NOTE 3: Rsyncable mode limits maximum compression speed to ~400 MB/s.
+  * If the selected compression level is already running significantly slower,
+  * the overall speed won't be significantly impacted.
+  */
+ #define ZSTD_c_rsyncable ZSTD_c_experimentalParam1
+
+/* Select a compression format.
+ * The value must be of type ZSTD_format_e.
+ * See ZSTD_format_e enum definition for details */
+#define ZSTD_c_format ZSTD_c_experimentalParam2
+
+/* Force back-reference distances to remain < windowSize,
+ * even when referencing into Dictionary content (default:0) */
+#define ZSTD_c_forceMaxWindow ZSTD_c_experimentalParam3
+
+/* Controls whether the contents of a CDict
+ * are used in place, or copied into the working context.
+ * Accepts values from the ZSTD_dictAttachPref_e enum.
+ * See the comments on that enum for an explanation of the feature. */
+#define ZSTD_c_forceAttachDict ZSTD_c_experimentalParam4
+
+/* Controls how the literals are compressed (default is auto).
+ * The value must be of type ZSTD_literalCompressionMode_e.
+ * See ZSTD_literalCompressionMode_t enum definition for details.
+ */
+#define ZSTD_c_literalCompressionMode ZSTD_c_experimentalParam5
+
+/* Tries to fit compressed block size to be around targetCBlockSize.
+ * No target when targetCBlockSize == 0.
+ * There is no guarantee on compressed block size (default:0) */
+#define ZSTD_c_targetCBlockSize ZSTD_c_experimentalParam6
+
+/*! ZSTD_CCtx_getParameter() :
+ *  Get the requested compression parameter value, selected by enum ZSTD_cParameter,
+ *  and store it into int* value.
+ * @return : 0, or an error code (which can be tested with ZSTD_isError()).
+ */
+ZSTDLIB_API size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value);
+
+
+/*! ZSTD_CCtx_params :
+ *  Quick howto :
+ *  - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure
+ *  - ZSTD_CCtxParams_setParameter() : Push parameters one by one into
+ *                                     an existing ZSTD_CCtx_params structure.
+ *                                     This is similar to
+ *                                     ZSTD_CCtx_setParameter().
+ *  - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to
+ *                                    an existing CCtx.
+ *                                    These parameters will be applied to
+ *                                    all subsequent frames.
+ *  - ZSTD_compressStream2() : Do compression using the CCtx.
+ *  - ZSTD_freeCCtxParams() : Free the memory.
+ *
+ *  This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()
+ *  for static allocation of CCtx for single-threaded compression.
+ */
+ZSTDLIB_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void);
+ZSTDLIB_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params);
+
+/*! ZSTD_CCtxParams_reset() :
+ *  Reset params to default values.
+ */
+ZSTDLIB_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params);
+
+/*! ZSTD_CCtxParams_init() :
+ *  Initializes the compression parameters of cctxParams according to
+ *  compression level. All other parameters are reset to their default values.
+ */
+ZSTDLIB_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel);
+
+/*! ZSTD_CCtxParams_init_advanced() :
+ *  Initializes the compression and frame parameters of cctxParams according to
+ *  params. All other parameters are reset to their default values.
+ */
+ZSTDLIB_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params);
+
+/*! ZSTD_CCtxParams_setParameter() :
+ *  Similar to ZSTD_CCtx_setParameter.
+ *  Set one compression parameter, selected by enum ZSTD_cParameter.
+ *  Parameters must be applied to a ZSTD_CCtx using ZSTD_CCtx_setParametersUsingCCtxParams().
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ */
+ZSTDLIB_API size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);
+
+/*! ZSTD_CCtxParams_getParameter() :
+ * Similar to ZSTD_CCtx_getParameter.
+ * Get the requested value of one compression parameter, selected by enum ZSTD_cParameter.
+ * @result : 0, or an error code (which can be tested with ZSTD_isError()).
+ */
+ZSTDLIB_API size_t ZSTD_CCtxParams_getParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int* value);
+
+/*! ZSTD_CCtx_setParametersUsingCCtxParams() :
+ *  Apply a set of ZSTD_CCtx_params to the compression context.
+ *  This can be done even after compression is started,
+ *    if nbWorkers==0, this will have no impact until a new compression is started.
+ *    if nbWorkers>=1, new parameters will be picked up at next job,
+ *       with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated).
+ */
+ZSTDLIB_API size_t ZSTD_CCtx_setParametersUsingCCtxParams(
+        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params);
+
+/*! ZSTD_compressStream2_simpleArgs() :
+ *  Same as ZSTD_compressStream2(),
+ *  but using only integral types as arguments.
+ *  This variant might be helpful for binders from dynamic languages
+ *  which have troubles handling structures containing memory pointers.
+ */
+ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs (
+                            ZSTD_CCtx* cctx,
+                            void* dst, size_t dstCapacity, size_t* dstPos,
+                      const void* src, size_t srcSize, size_t* srcPos,
+                            ZSTD_EndDirective endOp);
+
+
+/***************************************
+*  Advanced decompression functions
+***************************************/
+
+/*! ZSTD_isFrame() :
+ *  Tells if the content of `buffer` starts with a valid Frame Identifier.
+ *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
+ *  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
+ *  Note 3 : Skippable Frame Identifiers are considered valid. */
+ZSTDLIB_API unsigned ZSTD_isFrame(const void* buffer, size_t size);
+
+/*! ZSTD_createDDict_byReference() :
+ *  Create a digested dictionary, ready to start decompression operation without startup delay.
+ *  Dictionary content is referenced, and therefore stays in dictBuffer.
+ *  It is important that dictBuffer outlives DDict,
+ *  it must remain read accessible throughout the lifetime of DDict */
+ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);
+
+/*! ZSTD_DCtx_loadDictionary_byReference() :
+ *  Same as ZSTD_DCtx_loadDictionary(),
+ *  but references `dict` content instead of copying it into `dctx`.
+ *  This saves memory if `dict` remains around.,
+ *  However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. */
+ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
+
+/*! ZSTD_DCtx_loadDictionary_advanced() :
+ *  Same as ZSTD_DCtx_loadDictionary(),
+ *  but gives direct control over
+ *  how to load the dictionary (by copy ? by reference ?)
+ *  and how to interpret it (automatic ? force raw mode ? full mode only ?). */
+ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);
+
+/*! ZSTD_DCtx_refPrefix_advanced() :
+ *  Same as ZSTD_DCtx_refPrefix(), but gives finer control over
+ *  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) */
+ZSTDLIB_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);
+
+/*! ZSTD_DCtx_setMaxWindowSize() :
+ *  Refuses allocating internal buffers for frames requiring a window size larger than provided limit.
+ *  This protects a decoder context from reserving too much memory for itself (potential attack scenario).
+ *  This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.
+ *  By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)
+ * @return : 0, or an error code (which can be tested using ZSTD_isError()).
+ */
+ZSTDLIB_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize);
+
+/* ZSTD_d_format
+ * experimental parameter,
+ * allowing selection between ZSTD_format_e input compression formats
+ */
+#define ZSTD_d_format ZSTD_d_experimentalParam1
+
+/*! ZSTD_DCtx_setFormat() :
+ *  Instruct the decoder context about what kind of data to decode next.
+ *  This instruction is mandatory to decode data without a fully-formed header,
+ *  such ZSTD_f_zstd1_magicless for example.
+ * @return : 0, or an error code (which can be tested using ZSTD_isError()). */
+ZSTDLIB_API size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format);
+
+/*! ZSTD_decompressStream_simpleArgs() :
+ *  Same as ZSTD_decompressStream(),
+ *  but using only integral types as arguments.
+ *  This can be helpful for binders from dynamic languages
+ *  which have troubles handling structures containing memory pointers.
+ */
+ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs (
+                            ZSTD_DCtx* dctx,
+                            void* dst, size_t dstCapacity, size_t* dstPos,
+                      const void* src, size_t srcSize, size_t* srcPos);
+
+
+/********************************************************************
+*  Advanced streaming functions
+*  Warning : most of these functions are now redundant with the Advanced API.
+*  Once Advanced API reaches "stable" status,
+*  redundant functions will be deprecated, and then at some point removed.
+********************************************************************/
+
+/*=====   Advanced Streaming compression functions  =====*/
+/**! ZSTD_initCStream_srcSize() :
+ * This function is deprecated, and equivalent to:
+ *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+ *     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)
+ *     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
+ *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
+ *
+ * pledgedSrcSize must be correct. If it is not known at init time, use
+ * ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs,
+ * "0" also disables frame content size field. It may be enabled in the future.
+ */
+ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);
+/**! ZSTD_initCStream_usingDict() :
+ * This function is deprecated, and is equivalent to:
+ *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+ *     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
+ *     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
+ *
+ * Creates of an internal CDict (incompatible with static CCtx), except if
+ * dict == NULL or dictSize < 8, in which case no dict is used.
+ * Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if
+ * it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.
+ */
+ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel);
+/**! ZSTD_initCStream_advanced() :
+ * This function is deprecated, and is approximately equivalent to:
+ *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+ *     ZSTD_CCtx_setZstdParams(zcs, params); // Set the zstd params and leave the rest as-is
+ *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
+ *     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
+ *
+ * pledgedSrcSize must be correct. If srcSize is not known at init time, use
+ * value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy.
+ */
+ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);
+/**! ZSTD_initCStream_usingCDict() :
+ * This function is deprecated, and equivalent to:
+ *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+ *     ZSTD_CCtx_refCDict(zcs, cdict);
+ *
+ * note : cdict will just be referenced, and must outlive compression session
+ */
+ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);
+/**! ZSTD_initCStream_usingCDict_advanced() :
+ * This function is deprecated, and is approximately equivalent to:
+ *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+ *     ZSTD_CCtx_setZstdFrameParams(zcs, fParams); // Set the zstd frame params and leave the rest as-is
+ *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
+ *     ZSTD_CCtx_refCDict(zcs, cdict);
+ *
+ * same as ZSTD_initCStream_usingCDict(), with control over frame parameters.
+ * pledgedSrcSize must be correct. If srcSize is not known at init time, use
+ * value ZSTD_CONTENTSIZE_UNKNOWN.
+ */
+ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);
+
+/*! ZSTD_resetCStream() :
+ * This function is deprecated, and is equivalent to:
+ *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+ *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
+ *
+ *  start a new frame, using same parameters from previous frame.
+ *  This is typically useful to skip dictionary loading stage, since it will re-use it in-place.
+ *  Note that zcs must be init at least once before using ZSTD_resetCStream().
+ *  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.
+ *  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
+ *  For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs,
+ *  but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.
+ * @return : 0, or an error code (which can be tested using ZSTD_isError())
+ */
+ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
+
+
+typedef struct {
+    unsigned long long ingested;   /* nb input bytes read and buffered */
+    unsigned long long consumed;   /* nb input bytes actually compressed */
+    unsigned long long produced;   /* nb of compressed bytes generated and buffered */
+    unsigned long long flushed;    /* nb of compressed bytes flushed : not provided; can be tracked from caller side */
+    unsigned currentJobID;         /* MT only : latest started job nb */
+    unsigned nbActiveWorkers;      /* MT only : nb of workers actively compressing at probe time */
+} ZSTD_frameProgression;
+
+/* ZSTD_getFrameProgression() :
+ * tells how much data has been ingested (read from input)
+ * consumed (input actually compressed) and produced (output) for current frame.
+ * Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed.
+ * Aggregates progression inside active worker threads.
+ */
+ZSTDLIB_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx);
+
+/*! ZSTD_toFlushNow() :
+ *  Tell how many bytes are ready to be flushed immediately.
+ *  Useful for multithreading scenarios (nbWorkers >= 1).
+ *  Probe the oldest active job, defined as oldest job not yet entirely flushed,
+ *  and check its output buffer.
+ * @return : amount of data stored in oldest job and ready to be flushed immediately.
+ *  if @return == 0, it means either :
+ *  + there is no active job (could be checked with ZSTD_frameProgression()), or
+ *  + oldest job is still actively compressing data,
+ *    but everything it has produced has also been flushed so far,
+ *    therefore flush speed is limited by production speed of oldest job
+ *    irrespective of the speed of concurrent (and newer) jobs.
+ */
+ZSTDLIB_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx);
+
+
+/*=====   Advanced Streaming decompression functions  =====*/
+/**
+ * This function is deprecated, and is equivalent to:
+ *
+ *     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
+ *     ZSTD_DCtx_loadDictionary(zds, dict, dictSize);
+ *
+ * note: no dictionary will be used if dict == NULL or dictSize < 8
+ */
+ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
+/**
+ * This function is deprecated, and is equivalent to:
+ *
+ *     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
+ *     ZSTD_DCtx_refDDict(zds, ddict);
+ *
+ * note : ddict is referenced, it must outlive decompression session
+ */
+ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);
+/**
+ * This function is deprecated, and is equivalent to:
+ *
+ *     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);
+ *
+ * re-use decompression parameters from previous init; saves dictionary loading
+ */
+ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
+
+
+/*********************************************************************
+*  Buffer-less and synchronous inner streaming functions
+*
+*  This is an advanced API, giving full control over buffer management, for users which need direct control over memory.
+*  But it's also a complex one, with several restrictions, documented below.
+*  Prefer normal streaming API for an easier experience.
+********************************************************************* */
+
+/**
+  Buffer-less streaming compression (synchronous mode)
+
+  A ZSTD_CCtx object is required to track streaming operations.
+  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.
+  ZSTD_CCtx object can be re-used multiple times within successive compression operations.
+
+  Start by initializing a context.
+  Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression,
+  or ZSTD_compressBegin_advanced(), for finer parameter control.
+  It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()
+
+  Then, consume your input using ZSTD_compressContinue().
+  There are some important considerations to keep in mind when using this advanced function :
+  - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.
+  - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.
+  - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.
+    Worst case evaluation is provided by ZSTD_compressBound().
+    ZSTD_compressContinue() doesn't guarantee recover after a failed compression.
+  - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).
+    It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)
+  - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.
+    In which case, it will "discard" the relevant memory section from its history.
+
+  Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.
+  It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.
+  Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.
+
+  `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again.
+*/
+
+/*=====   Buffer-less streaming compression functions  =====*/
+ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
+ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
+ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */
+ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */
+ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */
+ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */
+
+ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+/*-
+  Buffer-less streaming decompression (synchronous mode)
+
+  A ZSTD_DCtx object is required to track streaming operations.
+  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
+  A ZSTD_DCtx object can be re-used multiple times.
+
+  First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().
+  Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.
+  Data fragment must be large enough to ensure successful decoding.
+ `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.
+  @result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.
+           >0 : `srcSize` is too small, please provide at least @result bytes on next attempt.
+           errorCode, which can be tested using ZSTD_isError().
+
+  It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,
+  such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).
+  Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.
+  As a consequence, check that values remain within valid application range.
+  For example, do not allocate memory blindly, check that `windowSize` is within expectation.
+  Each application can set its own limits, depending on local restrictions.
+  For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.
+
+  ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.
+  ZSTD_decompressContinue() is very sensitive to contiguity,
+  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
+  or that previous contiguous segment is large enough to properly handle maximum back-reference distance.
+  There are multiple ways to guarantee this condition.
+
+  The most memory efficient way is to use a round buffer of sufficient size.
+  Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),
+  which can @return an error code if required value is too large for current system (in 32-bits mode).
+  In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,
+  up to the moment there is not enough room left in the buffer to guarantee decoding another full block,
+  which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.
+  At which point, decoding can resume from the beginning of the buffer.
+  Note that already decoded data stored in the buffer should be flushed before being overwritten.
+
+  There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.
+
+  Finally, if you control the compression process, you can also ignore all buffer size rules,
+  as long as the encoder and decoder progress in "lock-step",
+  aka use exactly the same buffer sizes, break contiguity at the same place, etc.
+
+  Once buffers are setup, start decompression, with ZSTD_decompressBegin().
+  If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().
+
+  Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.
+
+ @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
+  It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.
+  It can also be an error code, which can be tested with ZSTD_isError().
+
+  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
+  Context can then be reset to start a new decompression.
+
+  Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().
+  This information is not required to properly decode a frame.
+
+  == Special case : skippable frames ==
+
+  Skippable frames allow integration of user-defined data into a flow of concatenated frames.
+  Skippable frames will be ignored (skipped) by decompressor.
+  The format of skippable frames is as follows :
+  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
+  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
+  c) Frame Content - any content (User Data) of length equal to Frame Size
+  For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.
+  For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.
+*/
+
+/*=====   Buffer-less streaming decompression functions  =====*/
+typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
+typedef struct {
+    unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */
+    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */
+    unsigned blockSizeMax;
+    ZSTD_frameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
+    unsigned headerSize;
+    unsigned dictID;
+    unsigned checksumFlag;
+} ZSTD_frameHeader;
+
+/*! ZSTD_getFrameHeader() :
+ *  decode Frame Header, or requires larger `srcSize`.
+ * @return : 0, `zfhPtr` is correctly filled,
+ *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
+ *           or an error code, which can be tested using ZSTD_isError() */
+ZSTDLIB_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
+/*! ZSTD_getFrameHeader_advanced() :
+ *  same as ZSTD_getFrameHeader(),
+ *  with added capability to select a format (like ZSTD_f_zstd1_magicless) */
+ZSTDLIB_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);
+ZSTDLIB_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize);  /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */
+
+ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
+ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
+ZSTDLIB_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
+
+ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
+ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+/* misc */
+ZSTDLIB_API void   ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);
+typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;
+ZSTDLIB_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
+
+
+
+
+/* ============================ */
+/**       Block level API       */
+/* ============================ */
+
+/*!
+    Block functions produce and decode raw zstd blocks, without frame metadata.
+    Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes).
+    But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.
+
+    A few rules to respect :
+    - Compressing and decompressing require a context structure
+      + Use ZSTD_createCCtx() and ZSTD_createDCtx()
+    - It is necessary to init context before starting
+      + compression : any ZSTD_compressBegin*() variant, including with dictionary
+      + decompression : any ZSTD_decompressBegin*() variant, including with dictionary
+      + copyCCtx() and copyDCtx() can be used too
+    - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB
+      + If input is larger than a block size, it's necessary to split input data into multiple blocks
+      + For inputs larger than a single block, consider using regular ZSTD_compress() instead.
+        Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block.
+    - When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !
+      ===> In which case, nothing is produced into `dst` !
+      + User __must__ test for such outcome and deal directly with uncompressed data
+      + A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0.
+        Doing so would mess up with statistics history, leading to potential data corruption.
+      + ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!
+      + In case of multiple successive blocks, should some of them be uncompressed,
+        decoder must be informed of their existence in order to follow proper history.
+        Use ZSTD_insertBlock() for such a case.
+*/
+
+/*=====   Raw zstd block functions  =====*/
+ZSTDLIB_API size_t ZSTD_getBlockSize   (const ZSTD_CCtx* cctx);
+ZSTDLIB_API size_t ZSTD_compressBlock  (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZSTD_insertBlock    (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize);  /**< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. */
+
+
+#endif   /* ZSTD_H_ZSTD_STATIC_LINKING_ONLY */
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/src/zstd_common.c b/src/zstd_common.c
new file mode 100644
index 0000000..667f4a2
--- /dev/null
+++ b/src/zstd_common.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include <stdlib.h>      /* malloc, calloc, free */
+#include <string.h>      /* memset */
+#include "error_private.h"
+#include "zstd_internal.h"
+
+
+/*-****************************************
+*  Version
+******************************************/
+unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; }
+
+const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }
+
+
+/*-****************************************
+*  ZSTD Error Management
+******************************************/
+#undef ZSTD_isError   /* defined within zstd_internal.h */
+/*! ZSTD_isError() :
+ *  tells if a return value is an error code
+ *  symbol is required for external callers */
+unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
+
+/*! ZSTD_getErrorName() :
+ *  provides error code string from function result (useful for debugging) */
+const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+/*! ZSTD_getError() :
+ *  convert a `size_t` function result into a proper ZSTD_errorCode enum */
+ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }
+
+/*! ZSTD_getErrorString() :
+ *  provides error code string from enum */
+const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); }
+
+
+
+/*=**************************************************************
+*  Custom allocator
+****************************************************************/
+void* ZSTD_malloc(size_t size, ZSTD_customMem customMem)
+{
+    if (customMem.customAlloc)
+        return customMem.customAlloc(customMem.opaque, size);
+    return malloc(size);
+}
+
+void* ZSTD_calloc(size_t size, ZSTD_customMem customMem)
+{
+    if (customMem.customAlloc) {
+        /* calloc implemented as malloc+memset;
+         * not as efficient as calloc, but next best guess for custom malloc */
+        void* const ptr = customMem.customAlloc(customMem.opaque, size);
+        memset(ptr, 0, size);
+        return ptr;
+    }
+    return calloc(1, size);
+}
+
+void ZSTD_free(void* ptr, ZSTD_customMem customMem)
+{
+    if (ptr!=NULL) {
+        if (customMem.customFree)
+            customMem.customFree(customMem.opaque, ptr);
+        else
+            free(ptr);
+    }
+}
diff --git a/src/zstd_compress.c b/src/zstd_compress.c
new file mode 100644
index 0000000..cd73db1
--- /dev/null
+++ b/src/zstd_compress.c
@@ -0,0 +1,3906 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include <limits.h>         /* INT_MAX */
+#include <string.h>         /* memset */
+#include "cpu.h"
+#include "mem.h"
+#include "hist.h"           /* HIST_countFast_wksp */
+#define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */
+#include "fse.h"
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
+#include "zstd_compress_internal.h"
+#include "zstd_compress_sequences.h"
+#include "zstd_compress_literals.h"
+#include "zstd_fast.h"
+#include "zstd_double_fast.h"
+#include "zstd_lazy.h"
+#include "zstd_opt.h"
+#include "zstd_ldm.h"
+
+
+/*-*************************************
+*  Helper functions
+***************************************/
+size_t ZSTD_compressBound(size_t srcSize) {
+    return ZSTD_COMPRESSBOUND(srcSize);
+}
+
+
+/*-*************************************
+*  Context memory management
+***************************************/
+struct ZSTD_CDict_s {
+    void* dictBuffer;
+    const void* dictContent;
+    size_t dictContentSize;
+    void* workspace;
+    size_t workspaceSize;
+    ZSTD_matchState_t matchState;
+    ZSTD_compressedBlockState_t cBlockState;
+    ZSTD_customMem customMem;
+    U32 dictID;
+};  /* typedef'd to ZSTD_CDict within "zstd.h" */
+
+ZSTD_CCtx* ZSTD_createCCtx(void)
+{
+    return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);
+}
+
+static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)
+{
+    assert(cctx != NULL);
+    memset(cctx, 0, sizeof(*cctx));
+    cctx->customMem = memManager;
+    cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
+    {   size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);
+        assert(!ZSTD_isError(err));
+        (void)err;
+    }
+}
+
+ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
+{
+    ZSTD_STATIC_ASSERT(zcss_init==0);
+    ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));
+    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
+    {   ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_malloc(sizeof(ZSTD_CCtx), customMem);
+        if (!cctx) return NULL;
+        ZSTD_initCCtx(cctx, customMem);
+        return cctx;
+    }
+}
+
+ZSTD_CCtx* ZSTD_initStaticCCtx(void *workspace, size_t workspaceSize)
+{
+    ZSTD_CCtx* const cctx = (ZSTD_CCtx*) workspace;
+    if (workspaceSize <= sizeof(ZSTD_CCtx)) return NULL;  /* minimum size */
+    if ((size_t)workspace & 7) return NULL;  /* must be 8-aligned */
+    memset(workspace, 0, workspaceSize);   /* may be a bit generous, could memset be smaller ? */
+    cctx->staticSize = workspaceSize;
+    cctx->workSpace = (void*)(cctx+1);
+    cctx->workSpaceSize = workspaceSize - sizeof(ZSTD_CCtx);
+
+    /* statically sized space. entropyWorkspace never moves (but prev/next block swap places) */
+    if (cctx->workSpaceSize < HUF_WORKSPACE_SIZE + 2 * sizeof(ZSTD_compressedBlockState_t)) return NULL;
+    assert(((size_t)cctx->workSpace & (sizeof(void*)-1)) == 0);   /* ensure correct alignment */
+    cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)cctx->workSpace;
+    cctx->blockState.nextCBlock = cctx->blockState.prevCBlock + 1;
+    {
+        void* const ptr = cctx->blockState.nextCBlock + 1;
+        cctx->entropyWorkspace = (U32*)ptr;
+    }
+    cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
+    return cctx;
+}
+
+/**
+ * Clears and frees all of the dictionaries in the CCtx.
+ */
+static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)
+{
+    ZSTD_free(cctx->localDict.dictBuffer, cctx->customMem);
+    ZSTD_freeCDict(cctx->localDict.cdict);
+    memset(&cctx->localDict, 0, sizeof(cctx->localDict));
+    memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
+    cctx->cdict = NULL;
+}
+
+static size_t ZSTD_sizeof_localDict(ZSTD_localDict dict)
+{
+    size_t const bufferSize = dict.dictBuffer != NULL ? dict.dictSize : 0;
+    size_t const cdictSize = ZSTD_sizeof_CDict(dict.cdict);
+    return bufferSize + cdictSize;
+}
+
+static void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx)
+{
+    assert(cctx != NULL);
+    assert(cctx->staticSize == 0);
+    ZSTD_free(cctx->workSpace, cctx->customMem); cctx->workSpace = NULL;
+    ZSTD_clearAllDicts(cctx);
+#ifdef ZSTD_MULTITHREAD
+    ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL;
+#endif
+}
+
+size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
+{
+    if (cctx==NULL) return 0;   /* support free on NULL */
+    RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
+                    "not compatible with static CCtx");
+    ZSTD_freeCCtxContent(cctx);
+    ZSTD_free(cctx, cctx->customMem);
+    return 0;
+}
+
+
+static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)
+{
+#ifdef ZSTD_MULTITHREAD
+    return ZSTDMT_sizeof_CCtx(cctx->mtctx);
+#else
+    (void)cctx;
+    return 0;
+#endif
+}
+
+
+size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)
+{
+    if (cctx==NULL) return 0;   /* support sizeof on NULL */
+    return sizeof(*cctx) + cctx->workSpaceSize
+           + ZSTD_sizeof_localDict(cctx->localDict)
+           + ZSTD_sizeof_mtctx(cctx);
+}
+
+size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
+{
+    return ZSTD_sizeof_CCtx(zcs);  /* same object */
+}
+
+/* private API call, for dictBuilder only */
+const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStore); }
+
+static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(
+        ZSTD_compressionParameters cParams)
+{
+    ZSTD_CCtx_params cctxParams;
+    memset(&cctxParams, 0, sizeof(cctxParams));
+    cctxParams.cParams = cParams;
+    cctxParams.compressionLevel = ZSTD_CLEVEL_DEFAULT;  /* should not matter, as all cParams are presumed properly defined */
+    assert(!ZSTD_checkCParams(cParams));
+    cctxParams.fParams.contentSizeFlag = 1;
+    return cctxParams;
+}
+
+static ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced(
+        ZSTD_customMem customMem)
+{
+    ZSTD_CCtx_params* params;
+    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
+    params = (ZSTD_CCtx_params*)ZSTD_calloc(
+            sizeof(ZSTD_CCtx_params), customMem);
+    if (!params) { return NULL; }
+    params->customMem = customMem;
+    params->compressionLevel = ZSTD_CLEVEL_DEFAULT;
+    params->fParams.contentSizeFlag = 1;
+    return params;
+}
+
+ZSTD_CCtx_params* ZSTD_createCCtxParams(void)
+{
+    return ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem);
+}
+
+size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params)
+{
+    if (params == NULL) { return 0; }
+    ZSTD_free(params, params->customMem);
+    return 0;
+}
+
+size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params)
+{
+    return ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);
+}
+
+size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel) {
+    RETURN_ERROR_IF(!cctxParams, GENERIC);
+    memset(cctxParams, 0, sizeof(*cctxParams));
+    cctxParams->compressionLevel = compressionLevel;
+    cctxParams->fParams.contentSizeFlag = 1;
+    return 0;
+}
+
+size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params)
+{
+    RETURN_ERROR_IF(!cctxParams, GENERIC);
+    FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) );
+    memset(cctxParams, 0, sizeof(*cctxParams));
+    cctxParams->cParams = params.cParams;
+    cctxParams->fParams = params.fParams;
+    cctxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT;   /* should not matter, as all cParams are presumed properly defined */
+    assert(!ZSTD_checkCParams(params.cParams));
+    return 0;
+}
+
+/* ZSTD_assignParamsToCCtxParams() :
+ * params is presumed valid at this stage */
+static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(
+        ZSTD_CCtx_params cctxParams, ZSTD_parameters params)
+{
+    ZSTD_CCtx_params ret = cctxParams;
+    ret.cParams = params.cParams;
+    ret.fParams = params.fParams;
+    ret.compressionLevel = ZSTD_CLEVEL_DEFAULT;   /* should not matter, as all cParams are presumed properly defined */
+    assert(!ZSTD_checkCParams(params.cParams));
+    return ret;
+}
+
+ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
+{
+    ZSTD_bounds bounds = { 0, 0, 0 };
+
+    switch(param)
+    {
+    case ZSTD_c_compressionLevel:
+        bounds.lowerBound = ZSTD_minCLevel();
+        bounds.upperBound = ZSTD_maxCLevel();
+        return bounds;
+
+    case ZSTD_c_windowLog:
+        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
+        bounds.upperBound = ZSTD_WINDOWLOG_MAX;
+        return bounds;
+
+    case ZSTD_c_hashLog:
+        bounds.lowerBound = ZSTD_HASHLOG_MIN;
+        bounds.upperBound = ZSTD_HASHLOG_MAX;
+        return bounds;
+
+    case ZSTD_c_chainLog:
+        bounds.lowerBound = ZSTD_CHAINLOG_MIN;
+        bounds.upperBound = ZSTD_CHAINLOG_MAX;
+        return bounds;
+
+    case ZSTD_c_searchLog:
+        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
+        bounds.upperBound = ZSTD_SEARCHLOG_MAX;
+        return bounds;
+
+    case ZSTD_c_minMatch:
+        bounds.lowerBound = ZSTD_MINMATCH_MIN;
+        bounds.upperBound = ZSTD_MINMATCH_MAX;
+        return bounds;
+
+    case ZSTD_c_targetLength:
+        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
+        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
+        return bounds;
+
+    case ZSTD_c_strategy:
+        bounds.lowerBound = ZSTD_STRATEGY_MIN;
+        bounds.upperBound = ZSTD_STRATEGY_MAX;
+        return bounds;
+
+    case ZSTD_c_contentSizeFlag:
+        bounds.lowerBound = 0;
+        bounds.upperBound = 1;
+        return bounds;
+
+    case ZSTD_c_checksumFlag:
+        bounds.lowerBound = 0;
+        bounds.upperBound = 1;
+        return bounds;
+
+    case ZSTD_c_dictIDFlag:
+        bounds.lowerBound = 0;
+        bounds.upperBound = 1;
+        return bounds;
+
+    case ZSTD_c_nbWorkers:
+        bounds.lowerBound = 0;
+#ifdef ZSTD_MULTITHREAD
+        bounds.upperBound = ZSTDMT_NBWORKERS_MAX;
+#else
+        bounds.upperBound = 0;
+#endif
+        return bounds;
+
+    case ZSTD_c_jobSize:
+        bounds.lowerBound = 0;
+#ifdef ZSTD_MULTITHREAD
+        bounds.upperBound = ZSTDMT_JOBSIZE_MAX;
+#else
+        bounds.upperBound = 0;
+#endif
+        return bounds;
+
+    case ZSTD_c_overlapLog:
+        bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;
+        bounds.upperBound = ZSTD_OVERLAPLOG_MAX;
+        return bounds;
+
+    case ZSTD_c_enableLongDistanceMatching:
+        bounds.lowerBound = 0;
+        bounds.upperBound = 1;
+        return bounds;
+
+    case ZSTD_c_ldmHashLog:
+        bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;
+        bounds.upperBound = ZSTD_LDM_HASHLOG_MAX;
+        return bounds;
+
+    case ZSTD_c_ldmMinMatch:
+        bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;
+        bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;
+        return bounds;
+
+    case ZSTD_c_ldmBucketSizeLog:
+        bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;
+        bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;
+        return bounds;
+
+    case ZSTD_c_ldmHashRateLog:
+        bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;
+        bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX;
+        return bounds;
+
+    /* experimental parameters */
+    case ZSTD_c_rsyncable:
+        bounds.lowerBound = 0;
+        bounds.upperBound = 1;
+        return bounds;
+
+    case ZSTD_c_forceMaxWindow :
+        bounds.lowerBound = 0;
+        bounds.upperBound = 1;
+        return bounds;
+
+    case ZSTD_c_format:
+        ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
+        bounds.lowerBound = ZSTD_f_zstd1;
+        bounds.upperBound = ZSTD_f_zstd1_magicless;   /* note : how to ensure at compile time that this is the highest value enum ? */
+        return bounds;
+
+    case ZSTD_c_forceAttachDict:
+        ZSTD_STATIC_ASSERT(ZSTD_dictDefaultAttach < ZSTD_dictForceCopy);
+        bounds.lowerBound = ZSTD_dictDefaultAttach;
+        bounds.upperBound = ZSTD_dictForceCopy;       /* note : how to ensure at compile time that this is the highest value enum ? */
+        return bounds;
+
+    case ZSTD_c_literalCompressionMode:
+        ZSTD_STATIC_ASSERT(ZSTD_lcm_auto < ZSTD_lcm_huffman && ZSTD_lcm_huffman < ZSTD_lcm_uncompressed);
+        bounds.lowerBound = ZSTD_lcm_auto;
+        bounds.upperBound = ZSTD_lcm_uncompressed;
+        return bounds;
+
+    case ZSTD_c_targetCBlockSize:
+        bounds.lowerBound = ZSTD_TARGETCBLOCKSIZE_MIN;
+        bounds.upperBound = ZSTD_TARGETCBLOCKSIZE_MAX;
+        return bounds;
+
+    default:
+        {   ZSTD_bounds const boundError = { ERROR(parameter_unsupported), 0, 0 };
+            return boundError;
+        }
+    }
+}
+
+/* ZSTD_cParam_clampBounds:
+ * Clamps the value into the bounded range.
+ */
+static size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value)
+{
+    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
+    if (ZSTD_isError(bounds.error)) return bounds.error;
+    if (*value < bounds.lowerBound) *value = bounds.lowerBound;
+    if (*value > bounds.upperBound) *value = bounds.upperBound;
+    return 0;
+}
+
+#define BOUNDCHECK(cParam, val) { \
+    RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val), \
+                    parameter_outOfBound); \
+}
+
+
+static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
+{
+    switch(param)
+    {
+    case ZSTD_c_compressionLevel:
+    case ZSTD_c_hashLog:
+    case ZSTD_c_chainLog:
+    case ZSTD_c_searchLog:
+    case ZSTD_c_minMatch:
+    case ZSTD_c_targetLength:
+    case ZSTD_c_strategy:
+        return 1;
+
+    case ZSTD_c_format:
+    case ZSTD_c_windowLog:
+    case ZSTD_c_contentSizeFlag:
+    case ZSTD_c_checksumFlag:
+    case ZSTD_c_dictIDFlag:
+    case ZSTD_c_forceMaxWindow :
+    case ZSTD_c_nbWorkers:
+    case ZSTD_c_jobSize:
+    case ZSTD_c_overlapLog:
+    case ZSTD_c_rsyncable:
+    case ZSTD_c_enableLongDistanceMatching:
+    case ZSTD_c_ldmHashLog:
+    case ZSTD_c_ldmMinMatch:
+    case ZSTD_c_ldmBucketSizeLog:
+    case ZSTD_c_ldmHashRateLog:
+    case ZSTD_c_forceAttachDict:
+    case ZSTD_c_literalCompressionMode:
+    case ZSTD_c_targetCBlockSize:
+    default:
+        return 0;
+    }
+}
+
+size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
+{
+    DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
+    if (cctx->streamStage != zcss_init) {
+        if (ZSTD_isUpdateAuthorized(param)) {
+            cctx->cParamsChanged = 1;
+        } else {
+            RETURN_ERROR(stage_wrong);
+    }   }
+
+    switch(param)
+    {
+    case ZSTD_c_nbWorkers:
+        RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,
+                        "MT not compatible with static alloc");
+        break;
+
+    case ZSTD_c_compressionLevel:
+    case ZSTD_c_windowLog:
+    case ZSTD_c_hashLog:
+    case ZSTD_c_chainLog:
+    case ZSTD_c_searchLog:
+    case ZSTD_c_minMatch:
+    case ZSTD_c_targetLength:
+    case ZSTD_c_strategy:
+    case ZSTD_c_ldmHashRateLog:
+    case ZSTD_c_format:
+    case ZSTD_c_contentSizeFlag:
+    case ZSTD_c_checksumFlag:
+    case ZSTD_c_dictIDFlag:
+    case ZSTD_c_forceMaxWindow:
+    case ZSTD_c_forceAttachDict:
+    case ZSTD_c_literalCompressionMode:
+    case ZSTD_c_jobSize:
+    case ZSTD_c_overlapLog:
+    case ZSTD_c_rsyncable:
+    case ZSTD_c_enableLongDistanceMatching:
+    case ZSTD_c_ldmHashLog:
+    case ZSTD_c_ldmMinMatch:
+    case ZSTD_c_ldmBucketSizeLog:
+    case ZSTD_c_targetCBlockSize:
+        break;
+
+    default: RETURN_ERROR(parameter_unsupported);
+    }
+    return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value);
+}
+
+size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams,
+                                    ZSTD_cParameter param, int value)
+{
+    DEBUGLOG(4, "ZSTD_CCtxParams_setParameter (%i, %i)", (int)param, value);
+    switch(param)
+    {
+    case ZSTD_c_format :
+        BOUNDCHECK(ZSTD_c_format, value);
+        CCtxParams->format = (ZSTD_format_e)value;
+        return (size_t)CCtxParams->format;
+
+    case ZSTD_c_compressionLevel : {
+        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value));
+        if (value) {  /* 0 : does not change current level */
+            CCtxParams->compressionLevel = value;
+        }
+        if (CCtxParams->compressionLevel >= 0) return CCtxParams->compressionLevel;
+        return 0;  /* return type (size_t) cannot represent negative values */
+    }
+
+    case ZSTD_c_windowLog :
+        if (value!=0)   /* 0 => use default */
+            BOUNDCHECK(ZSTD_c_windowLog, value);
+        CCtxParams->cParams.windowLog = value;
+        return CCtxParams->cParams.windowLog;
+
+    case ZSTD_c_hashLog :
+        if (value!=0)   /* 0 => use default */
+            BOUNDCHECK(ZSTD_c_hashLog, value);
+        CCtxParams->cParams.hashLog = value;
+        return CCtxParams->cParams.hashLog;
+
+    case ZSTD_c_chainLog :
+        if (value!=0)   /* 0 => use default */
+            BOUNDCHECK(ZSTD_c_chainLog, value);
+        CCtxParams->cParams.chainLog = value;
+        return CCtxParams->cParams.chainLog;
+
+    case ZSTD_c_searchLog :
+        if (value!=0)   /* 0 => use default */
+            BOUNDCHECK(ZSTD_c_searchLog, value);
+        CCtxParams->cParams.searchLog = value;
+        return value;
+
+    case ZSTD_c_minMatch :
+        if (value!=0)   /* 0 => use default */
+            BOUNDCHECK(ZSTD_c_minMatch, value);
+        CCtxParams->cParams.minMatch = value;
+        return CCtxParams->cParams.minMatch;
+
+    case ZSTD_c_targetLength :
+        BOUNDCHECK(ZSTD_c_targetLength, value);
+        CCtxParams->cParams.targetLength = value;
+        return CCtxParams->cParams.targetLength;
+
+    case ZSTD_c_strategy :
+        if (value!=0)   /* 0 => use default */
+            BOUNDCHECK(ZSTD_c_strategy, value);
+        CCtxParams->cParams.strategy = (ZSTD_strategy)value;
+        return (size_t)CCtxParams->cParams.strategy;
+
+    case ZSTD_c_contentSizeFlag :
+        /* Content size written in frame header _when known_ (default:1) */
+        DEBUGLOG(4, "set content size flag = %u", (value!=0));
+        CCtxParams->fParams.contentSizeFlag = value != 0;
+        return CCtxParams->fParams.contentSizeFlag;
+
+    case ZSTD_c_checksumFlag :
+        /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */
+        CCtxParams->fParams.checksumFlag = value != 0;
+        return CCtxParams->fParams.checksumFlag;
+
+    case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
+        DEBUGLOG(4, "set dictIDFlag = %u", (value!=0));
+        CCtxParams->fParams.noDictIDFlag = !value;
+        return !CCtxParams->fParams.noDictIDFlag;
+
+    case ZSTD_c_forceMaxWindow :
+        CCtxParams->forceWindow = (value != 0);
+        return CCtxParams->forceWindow;
+
+    case ZSTD_c_forceAttachDict : {
+        const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value;
+        BOUNDCHECK(ZSTD_c_forceAttachDict, pref);
+        CCtxParams->attachDictPref = pref;
+        return CCtxParams->attachDictPref;
+    }
+
+    case ZSTD_c_literalCompressionMode : {
+        const ZSTD_literalCompressionMode_e lcm = (ZSTD_literalCompressionMode_e)value;
+        BOUNDCHECK(ZSTD_c_literalCompressionMode, lcm);
+        CCtxParams->literalCompressionMode = lcm;
+        return CCtxParams->literalCompressionMode;
+    }
+
+    case ZSTD_c_nbWorkers :
+#ifndef ZSTD_MULTITHREAD
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+        return 0;
+#else
+        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value));
+        CCtxParams->nbWorkers = value;
+        return CCtxParams->nbWorkers;
+#endif
+
+    case ZSTD_c_jobSize :
+#ifndef ZSTD_MULTITHREAD
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+        return 0;
+#else
+        /* Adjust to the minimum non-default value. */
+        if (value != 0 && value < ZSTDMT_JOBSIZE_MIN)
+            value = ZSTDMT_JOBSIZE_MIN;
+        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value));
+        assert(value >= 0);
+        CCtxParams->jobSize = value;
+        return CCtxParams->jobSize;
+#endif
+
+    case ZSTD_c_overlapLog :
+#ifndef ZSTD_MULTITHREAD
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+        return 0;
+#else
+        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value));
+        CCtxParams->overlapLog = value;
+        return CCtxParams->overlapLog;
+#endif
+
+    case ZSTD_c_rsyncable :
+#ifndef ZSTD_MULTITHREAD
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+        return 0;
+#else
+        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value));
+        CCtxParams->rsyncable = value;
+        return CCtxParams->rsyncable;
+#endif
+
+    case ZSTD_c_enableLongDistanceMatching :
+        CCtxParams->ldmParams.enableLdm = (value!=0);
+        return CCtxParams->ldmParams.enableLdm;
+
+    case ZSTD_c_ldmHashLog :
+        if (value!=0)   /* 0 ==> auto */
+            BOUNDCHECK(ZSTD_c_ldmHashLog, value);
+        CCtxParams->ldmParams.hashLog = value;
+        return CCtxParams->ldmParams.hashLog;
+
+    case ZSTD_c_ldmMinMatch :
+        if (value!=0)   /* 0 ==> default */
+            BOUNDCHECK(ZSTD_c_ldmMinMatch, value);
+        CCtxParams->ldmParams.minMatchLength = value;
+        return CCtxParams->ldmParams.minMatchLength;
+
+    case ZSTD_c_ldmBucketSizeLog :
+        if (value!=0)   /* 0 ==> default */
+            BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value);
+        CCtxParams->ldmParams.bucketSizeLog = value;
+        return CCtxParams->ldmParams.bucketSizeLog;
+
+    case ZSTD_c_ldmHashRateLog :
+        RETURN_ERROR_IF(value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN,
+                        parameter_outOfBound);
+        CCtxParams->ldmParams.hashRateLog = value;
+        return CCtxParams->ldmParams.hashRateLog;
+
+    case ZSTD_c_targetCBlockSize :
+        if (value!=0)   /* 0 ==> default */
+            BOUNDCHECK(ZSTD_c_targetCBlockSize, value);
+        CCtxParams->targetCBlockSize = value;
+        return CCtxParams->targetCBlockSize;
+
+    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
+    }
+}
+
+size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value)
+{
+    return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value);
+}
+
+size_t ZSTD_CCtxParams_getParameter(
+        ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, int* value)
+{
+    switch(param)
+    {
+    case ZSTD_c_format :
+        *value = CCtxParams->format;
+        break;
+    case ZSTD_c_compressionLevel :
+        *value = CCtxParams->compressionLevel;
+        break;
+    case ZSTD_c_windowLog :
+        *value = (int)CCtxParams->cParams.windowLog;
+        break;
+    case ZSTD_c_hashLog :
+        *value = (int)CCtxParams->cParams.hashLog;
+        break;
+    case ZSTD_c_chainLog :
+        *value = (int)CCtxParams->cParams.chainLog;
+        break;
+    case ZSTD_c_searchLog :
+        *value = CCtxParams->cParams.searchLog;
+        break;
+    case ZSTD_c_minMatch :
+        *value = CCtxParams->cParams.minMatch;
+        break;
+    case ZSTD_c_targetLength :
+        *value = CCtxParams->cParams.targetLength;
+        break;
+    case ZSTD_c_strategy :
+        *value = (unsigned)CCtxParams->cParams.strategy;
+        break;
+    case ZSTD_c_contentSizeFlag :
+        *value = CCtxParams->fParams.contentSizeFlag;
+        break;
+    case ZSTD_c_checksumFlag :
+        *value = CCtxParams->fParams.checksumFlag;
+        break;
+    case ZSTD_c_dictIDFlag :
+        *value = !CCtxParams->fParams.noDictIDFlag;
+        break;
+    case ZSTD_c_forceMaxWindow :
+        *value = CCtxParams->forceWindow;
+        break;
+    case ZSTD_c_forceAttachDict :
+        *value = CCtxParams->attachDictPref;
+        break;
+    case ZSTD_c_literalCompressionMode :
+        *value = CCtxParams->literalCompressionMode;
+        break;
+    case ZSTD_c_nbWorkers :
+#ifndef ZSTD_MULTITHREAD
+        assert(CCtxParams->nbWorkers == 0);
+#endif
+        *value = CCtxParams->nbWorkers;
+        break;
+    case ZSTD_c_jobSize :
+#ifndef ZSTD_MULTITHREAD
+        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
+#else
+        assert(CCtxParams->jobSize <= INT_MAX);
+        *value = (int)CCtxParams->jobSize;
+        break;
+#endif
+    case ZSTD_c_overlapLog :
+#ifndef ZSTD_MULTITHREAD
+        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
+#else
+        *value = CCtxParams->overlapLog;
+        break;
+#endif
+    case ZSTD_c_rsyncable :
+#ifndef ZSTD_MULTITHREAD
+        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
+#else
+        *value = CCtxParams->rsyncable;
+        break;
+#endif
+    case ZSTD_c_enableLongDistanceMatching :
+        *value = CCtxParams->ldmParams.enableLdm;
+        break;
+    case ZSTD_c_ldmHashLog :
+        *value = CCtxParams->ldmParams.hashLog;
+        break;
+    case ZSTD_c_ldmMinMatch :
+        *value = CCtxParams->ldmParams.minMatchLength;
+        break;
+    case ZSTD_c_ldmBucketSizeLog :
+        *value = CCtxParams->ldmParams.bucketSizeLog;
+        break;
+    case ZSTD_c_ldmHashRateLog :
+        *value = CCtxParams->ldmParams.hashRateLog;
+        break;
+    case ZSTD_c_targetCBlockSize :
+        *value = (int)CCtxParams->targetCBlockSize;
+        break;
+    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
+    }
+    return 0;
+}
+
+/** ZSTD_CCtx_setParametersUsingCCtxParams() :
+ *  just applies `params` into `cctx`
+ *  no action is performed, parameters are merely stored.
+ *  If ZSTDMT is enabled, parameters are pushed to cctx->mtctx.
+ *    This is possible even if a compression is ongoing.
+ *    In which case, new parameters will be applied on the fly, starting with next compression job.
+ */
+size_t ZSTD_CCtx_setParametersUsingCCtxParams(
+        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
+{
+    DEBUGLOG(4, "ZSTD_CCtx_setParametersUsingCCtxParams");
+    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
+    RETURN_ERROR_IF(cctx->cdict, stage_wrong);
+
+    cctx->requestedParams = *params;
+    return 0;
+}
+
+ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize);
+    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
+    cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
+    return 0;
+}
+
+/**
+ * Initializes the local dict using the requested parameters.
+ * NOTE: This does not use the pledged src size, because it may be used for more
+ * than one compression.
+ */
+static size_t ZSTD_initLocalDict(ZSTD_CCtx* cctx)
+{
+    ZSTD_localDict* const dl = &cctx->localDict;
+    ZSTD_compressionParameters const cParams = ZSTD_getCParamsFromCCtxParams(
+            &cctx->requestedParams, 0, dl->dictSize);
+    if (dl->dict == NULL) {
+        /* No local dictionary. */
+        assert(dl->dictBuffer == NULL);
+        assert(dl->cdict == NULL);
+        assert(dl->dictSize == 0);
+        return 0;
+    }
+    if (dl->cdict != NULL) {
+        assert(cctx->cdict == dl->cdict);
+        /* Local dictionary already initialized. */
+        return 0;
+    }
+    assert(dl->dictSize > 0);
+    assert(cctx->cdict == NULL);
+    assert(cctx->prefixDict.dict == NULL);
+
+    dl->cdict = ZSTD_createCDict_advanced(
+            dl->dict,
+            dl->dictSize,
+            ZSTD_dlm_byRef,
+            dl->dictContentType,
+            cParams,
+            cctx->customMem);
+    RETURN_ERROR_IF(!dl->cdict, memory_allocation);
+    cctx->cdict = dl->cdict;
+    return 0;
+}
+
+size_t ZSTD_CCtx_loadDictionary_advanced(
+        ZSTD_CCtx* cctx, const void* dict, size_t dictSize,
+        ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
+{
+    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
+    RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
+                    "no malloc for static CCtx");
+    DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
+    ZSTD_clearAllDicts(cctx);  /* in case one already exists */
+    if (dict == NULL || dictSize == 0)  /* no dictionary mode */
+        return 0;
+    if (dictLoadMethod == ZSTD_dlm_byRef) {
+        cctx->localDict.dict = dict;
+    } else {
+        void* dictBuffer = ZSTD_malloc(dictSize, cctx->customMem);
+        RETURN_ERROR_IF(!dictBuffer, memory_allocation);
+        memcpy(dictBuffer, dict, dictSize);
+        cctx->localDict.dictBuffer = dictBuffer;
+        cctx->localDict.dict = dictBuffer;
+    }
+    cctx->localDict.dictSize = dictSize;
+    cctx->localDict.dictContentType = dictContentType;
+    return 0;
+}
+
+ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(
+      ZSTD_CCtx* cctx, const void* dict, size_t dictSize)
+{
+    return ZSTD_CCtx_loadDictionary_advanced(
+            cctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
+}
+
+ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize)
+{
+    return ZSTD_CCtx_loadDictionary_advanced(
+            cctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
+}
+
+
+size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
+{
+    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
+    /* Free the existing local cdict (if any) to save memory. */
+    ZSTD_clearAllDicts(cctx);
+    cctx->cdict = cdict;
+    return 0;
+}
+
+size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize)
+{
+    return ZSTD_CCtx_refPrefix_advanced(cctx, prefix, prefixSize, ZSTD_dct_rawContent);
+}
+
+size_t ZSTD_CCtx_refPrefix_advanced(
+        ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
+{
+    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
+    ZSTD_clearAllDicts(cctx);
+    cctx->prefixDict.dict = prefix;
+    cctx->prefixDict.dictSize = prefixSize;
+    cctx->prefixDict.dictContentType = dictContentType;
+    return 0;
+}
+
+/*! ZSTD_CCtx_reset() :
+ *  Also dumps dictionary */
+size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
+{
+    if ( (reset == ZSTD_reset_session_only)
+      || (reset == ZSTD_reset_session_and_parameters) ) {
+        cctx->streamStage = zcss_init;
+        cctx->pledgedSrcSizePlusOne = 0;
+    }
+    if ( (reset == ZSTD_reset_parameters)
+      || (reset == ZSTD_reset_session_and_parameters) ) {
+        RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
+        ZSTD_clearAllDicts(cctx);
+        return ZSTD_CCtxParams_reset(&cctx->requestedParams);
+    }
+    return 0;
+}
+
+
+/** ZSTD_checkCParams() :
+    control CParam values remain within authorized range.
+    @return : 0, or an error code if one value is beyond authorized range */
+size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
+{
+    BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
+    BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
+    BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
+    BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
+    BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
+    BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
+    BOUNDCHECK(ZSTD_c_strategy,  cParams.strategy);
+    return 0;
+}
+
+/** ZSTD_clampCParams() :
+ *  make CParam values within valid range.
+ *  @return : valid CParams */
+static ZSTD_compressionParameters
+ZSTD_clampCParams(ZSTD_compressionParameters cParams)
+{
+#   define CLAMP_TYPE(cParam, val, type) {                                \
+        ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \
+        if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound;      \
+        else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
+    }
+#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
+    CLAMP(ZSTD_c_windowLog, cParams.windowLog);
+    CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
+    CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
+    CLAMP(ZSTD_c_searchLog, cParams.searchLog);
+    CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
+    CLAMP(ZSTD_c_targetLength,cParams.targetLength);
+    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
+    return cParams;
+}
+
+/** ZSTD_cycleLog() :
+ *  condition for correct operation : hashLog > 1 */
+static U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
+{
+    U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
+    return hashLog - btScale;
+}
+
+/** ZSTD_adjustCParams_internal() :
+ *  optimize `cPar` for a specified input (`srcSize` and `dictSize`).
+ *  mostly downsize to reduce memory consumption and initialization latency.
+ * `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known.
+ *  note : for the time being, `srcSize==0` means "unknown" too, for compatibility with older convention.
+ *  condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */
+static ZSTD_compressionParameters
+ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
+                            unsigned long long srcSize,
+                            size_t dictSize)
+{
+    static const U64 minSrcSize = 513; /* (1<<9) + 1 */
+    static const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
+    assert(ZSTD_checkCParams(cPar)==0);
+
+    if (dictSize && (srcSize+1<2) /* ZSTD_CONTENTSIZE_UNKNOWN and 0 mean "unknown" */ )
+        srcSize = minSrcSize;  /* presumed small when there is a dictionary */
+    else if (srcSize == 0)
+        srcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* 0 == unknown : presumed large */
+
+    /* resize windowLog if input is small enough, to use less memory */
+    if ( (srcSize < maxWindowResize)
+      && (dictSize < maxWindowResize) )  {
+        U32 const tSize = (U32)(srcSize + dictSize);
+        static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;
+        U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :
+                            ZSTD_highbit32(tSize-1) + 1;
+        if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
+    }
+    if (cPar.hashLog > cPar.windowLog+1) cPar.hashLog = cPar.windowLog+1;
+    {   U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
+        if (cycleLog > cPar.windowLog)
+            cPar.chainLog -= (cycleLog - cPar.windowLog);
+    }
+
+    if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
+        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
+
+    return cPar;
+}
+
+ZSTD_compressionParameters
+ZSTD_adjustCParams(ZSTD_compressionParameters cPar,
+                   unsigned long long srcSize,
+                   size_t dictSize)
+{
+    cPar = ZSTD_clampCParams(cPar);   /* resulting cPar is necessarily valid (all parameters within range) */
+    return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize);
+}
+
+ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
+        const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize)
+{
+    ZSTD_compressionParameters cParams = ZSTD_getCParams(CCtxParams->compressionLevel, srcSizeHint, dictSize);
+    if (CCtxParams->ldmParams.enableLdm) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
+    if (CCtxParams->cParams.windowLog) cParams.windowLog = CCtxParams->cParams.windowLog;
+    if (CCtxParams->cParams.hashLog) cParams.hashLog = CCtxParams->cParams.hashLog;
+    if (CCtxParams->cParams.chainLog) cParams.chainLog = CCtxParams->cParams.chainLog;
+    if (CCtxParams->cParams.searchLog) cParams.searchLog = CCtxParams->cParams.searchLog;
+    if (CCtxParams->cParams.minMatch) cParams.minMatch = CCtxParams->cParams.minMatch;
+    if (CCtxParams->cParams.targetLength) cParams.targetLength = CCtxParams->cParams.targetLength;
+    if (CCtxParams->cParams.strategy) cParams.strategy = CCtxParams->cParams.strategy;
+    assert(!ZSTD_checkCParams(cParams));
+    return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize);
+}
+
+static size_t
+ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
+                       const U32 forCCtx)
+{
+    size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog);
+    size_t const hSize = ((size_t)1) << cParams->hashLog;
+    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
+    size_t const h3Size = ((size_t)1) << hashLog3;
+    size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
+    size_t const optPotentialSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits)) * sizeof(U32)
+                          + (ZSTD_OPT_NUM+1) * (sizeof(ZSTD_match_t)+sizeof(ZSTD_optimal_t));
+    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
+                                ? optPotentialSpace
+                                : 0;
+    DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
+                (U32)chainSize, (U32)hSize, (U32)h3Size);
+    return tableSpace + optSpace;
+}
+
+size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)
+{
+    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
+    {   ZSTD_compressionParameters const cParams =
+                ZSTD_getCParamsFromCCtxParams(params, 0, 0);
+        size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
+        U32    const divider = (cParams.minMatch==3) ? 3 : 4;
+        size_t const maxNbSeq = blockSize / divider;
+        size_t const tokenSpace = WILDCOPY_OVERLENGTH + blockSize + 11*maxNbSeq;
+        size_t const entropySpace = HUF_WORKSPACE_SIZE;
+        size_t const blockStateSpace = 2 * sizeof(ZSTD_compressedBlockState_t);
+        size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 1);
+
+        size_t const ldmSpace = ZSTD_ldm_getTableSize(params->ldmParams);
+        size_t const ldmSeqSpace = ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize) * sizeof(rawSeq);
+
+        size_t const neededSpace = entropySpace + blockStateSpace + tokenSpace +
+                                   matchStateSize + ldmSpace + ldmSeqSpace;
+
+        DEBUGLOG(5, "sizeof(ZSTD_CCtx) : %u", (U32)sizeof(ZSTD_CCtx));
+        DEBUGLOG(5, "estimate workSpace : %u", (U32)neededSpace);
+        return sizeof(ZSTD_CCtx) + neededSpace;
+    }
+}
+
+size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams)
+{
+    ZSTD_CCtx_params const params = ZSTD_makeCCtxParamsFromCParams(cParams);
+    return ZSTD_estimateCCtxSize_usingCCtxParams(&params);
+}
+
+static size_t ZSTD_estimateCCtxSize_internal(int compressionLevel)
+{
+    ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0);
+    return ZSTD_estimateCCtxSize_usingCParams(cParams);
+}
+
+size_t ZSTD_estimateCCtxSize(int compressionLevel)
+{
+    int level;
+    size_t memBudget = 0;
+    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
+        size_t const newMB = ZSTD_estimateCCtxSize_internal(level);
+        if (newMB > memBudget) memBudget = newMB;
+    }
+    return memBudget;
+}
+
+size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
+{
+    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
+    {   ZSTD_compressionParameters const cParams =
+                ZSTD_getCParamsFromCCtxParams(params, 0, 0);
+        size_t const CCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(params);
+        size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
+        size_t const inBuffSize = ((size_t)1 << cParams.windowLog) + blockSize;
+        size_t const outBuffSize = ZSTD_compressBound(blockSize) + 1;
+        size_t const streamingSize = inBuffSize + outBuffSize;
+
+        return CCtxSize + streamingSize;
+    }
+}
+
+size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
+{
+    ZSTD_CCtx_params const params = ZSTD_makeCCtxParamsFromCParams(cParams);
+    return ZSTD_estimateCStreamSize_usingCCtxParams(&params);
+}
+
+static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
+{
+    ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0);
+    return ZSTD_estimateCStreamSize_usingCParams(cParams);
+}
+
+size_t ZSTD_estimateCStreamSize(int compressionLevel)
+{
+    int level;
+    size_t memBudget = 0;
+    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
+        size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
+        if (newMB > memBudget) memBudget = newMB;
+    }
+    return memBudget;
+}
+
+/* ZSTD_getFrameProgression():
+ * tells how much data has been consumed (input) and produced (output) for current frame.
+ * able to count progression inside worker threads (non-blocking mode).
+ */
+ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx)
+{
+#ifdef ZSTD_MULTITHREAD
+    if (cctx->appliedParams.nbWorkers > 0) {
+        return ZSTDMT_getFrameProgression(cctx->mtctx);
+    }
+#endif
+    {   ZSTD_frameProgression fp;
+        size_t const buffered = (cctx->inBuff == NULL) ? 0 :
+                                cctx->inBuffPos - cctx->inToCompress;
+        if (buffered) assert(cctx->inBuffPos >= cctx->inToCompress);
+        assert(buffered <= ZSTD_BLOCKSIZE_MAX);
+        fp.ingested = cctx->consumedSrcSize + buffered;
+        fp.consumed = cctx->consumedSrcSize;
+        fp.produced = cctx->producedCSize;
+        fp.flushed  = cctx->producedCSize;   /* simplified; some data might still be left within streaming output buffer */
+        fp.currentJobID = 0;
+        fp.nbActiveWorkers = 0;
+        return fp;
+}   }
+
+/*! ZSTD_toFlushNow()
+ *  Only useful for multithreading scenarios currently (nbWorkers >= 1).
+ */
+size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx)
+{
+#ifdef ZSTD_MULTITHREAD
+    if (cctx->appliedParams.nbWorkers > 0) {
+        return ZSTDMT_toFlushNow(cctx->mtctx);
+    }
+#endif
+    (void)cctx;
+    return 0;   /* over-simplification; could also check if context is currently running in streaming mode, and in which case, report how many bytes are left to be flushed within output buffer */
+}
+
+
+
+static U32 ZSTD_equivalentCParams(ZSTD_compressionParameters cParams1,
+                                  ZSTD_compressionParameters cParams2)
+{
+    return (cParams1.hashLog  == cParams2.hashLog)
+         & (cParams1.chainLog == cParams2.chainLog)
+         & (cParams1.strategy == cParams2.strategy)   /* opt parser space */
+         & ((cParams1.minMatch==3) == (cParams2.minMatch==3));  /* hashlog3 space */
+}
+
+static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1,
+                                    ZSTD_compressionParameters cParams2)
+{
+    (void)cParams1;
+    (void)cParams2;
+    assert(cParams1.windowLog    == cParams2.windowLog);
+    assert(cParams1.chainLog     == cParams2.chainLog);
+    assert(cParams1.hashLog      == cParams2.hashLog);
+    assert(cParams1.searchLog    == cParams2.searchLog);
+    assert(cParams1.minMatch     == cParams2.minMatch);
+    assert(cParams1.targetLength == cParams2.targetLength);
+    assert(cParams1.strategy     == cParams2.strategy);
+}
+
+/** The parameters are equivalent if ldm is not enabled in both sets or
+ *  all the parameters are equivalent. */
+static U32 ZSTD_equivalentLdmParams(ldmParams_t ldmParams1,
+                                    ldmParams_t ldmParams2)
+{
+    return (!ldmParams1.enableLdm && !ldmParams2.enableLdm) ||
+           (ldmParams1.enableLdm == ldmParams2.enableLdm &&
+            ldmParams1.hashLog == ldmParams2.hashLog &&
+            ldmParams1.bucketSizeLog == ldmParams2.bucketSizeLog &&
+            ldmParams1.minMatchLength == ldmParams2.minMatchLength &&
+            ldmParams1.hashRateLog == ldmParams2.hashRateLog);
+}
+
+typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e;
+
+/* ZSTD_sufficientBuff() :
+ * check internal buffers exist for streaming if buffPol == ZSTDb_buffered .
+ * Note : they are assumed to be correctly sized if ZSTD_equivalentCParams()==1 */
+static U32 ZSTD_sufficientBuff(size_t bufferSize1, size_t maxNbSeq1,
+                            size_t maxNbLit1,
+                            ZSTD_buffered_policy_e buffPol2,
+                            ZSTD_compressionParameters cParams2,
+                            U64 pledgedSrcSize)
+{
+    size_t const windowSize2 = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize));
+    size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize2);
+    size_t const maxNbSeq2 = blockSize2 / ((cParams2.minMatch == 3) ? 3 : 4);
+    size_t const maxNbLit2 = blockSize2;
+    size_t const neededBufferSize2 = (buffPol2==ZSTDb_buffered) ? windowSize2 + blockSize2 : 0;
+    DEBUGLOG(4, "ZSTD_sufficientBuff: is neededBufferSize2=%u <= bufferSize1=%u",
+                (U32)neededBufferSize2, (U32)bufferSize1);
+    DEBUGLOG(4, "ZSTD_sufficientBuff: is maxNbSeq2=%u <= maxNbSeq1=%u",
+                (U32)maxNbSeq2, (U32)maxNbSeq1);
+    DEBUGLOG(4, "ZSTD_sufficientBuff: is maxNbLit2=%u <= maxNbLit1=%u",
+                (U32)maxNbLit2, (U32)maxNbLit1);
+    return (maxNbLit2 <= maxNbLit1)
+         & (maxNbSeq2 <= maxNbSeq1)
+         & (neededBufferSize2 <= bufferSize1);
+}
+
+/** Equivalence for resetCCtx purposes */
+static U32 ZSTD_equivalentParams(ZSTD_CCtx_params params1,
+                                 ZSTD_CCtx_params params2,
+                                 size_t buffSize1,
+                                 size_t maxNbSeq1, size_t maxNbLit1,
+                                 ZSTD_buffered_policy_e buffPol2,
+                                 U64 pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTD_equivalentParams: pledgedSrcSize=%u", (U32)pledgedSrcSize);
+    if (!ZSTD_equivalentCParams(params1.cParams, params2.cParams)) {
+      DEBUGLOG(4, "ZSTD_equivalentCParams() == 0");
+      return 0;
+    }
+    if (!ZSTD_equivalentLdmParams(params1.ldmParams, params2.ldmParams)) {
+      DEBUGLOG(4, "ZSTD_equivalentLdmParams() == 0");
+      return 0;
+    }
+    if (!ZSTD_sufficientBuff(buffSize1, maxNbSeq1, maxNbLit1, buffPol2,
+                             params2.cParams, pledgedSrcSize)) {
+      DEBUGLOG(4, "ZSTD_sufficientBuff() == 0");
+      return 0;
+    }
+    return 1;
+}
+
+static void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs)
+{
+    int i;
+    for (i = 0; i < ZSTD_REP_NUM; ++i)
+        bs->rep[i] = repStartValue[i];
+    bs->entropy.huf.repeatMode = HUF_repeat_none;
+    bs->entropy.fse.offcode_repeatMode = FSE_repeat_none;
+    bs->entropy.fse.matchlength_repeatMode = FSE_repeat_none;
+    bs->entropy.fse.litlength_repeatMode = FSE_repeat_none;
+}
+
+/*! ZSTD_invalidateMatchState()
+ *  Invalidate all the matches in the match finder tables.
+ *  Requires nextSrc and base to be set (can be NULL).
+ */
+static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms)
+{
+    ZSTD_window_clear(&ms->window);
+
+    ms->nextToUpdate = ms->window.dictLimit;
+    ms->loadedDictEnd = 0;
+    ms->opt.litLengthSum = 0;  /* force reset of btopt stats */
+    ms->dictMatchState = NULL;
+}
+
+/*! ZSTD_continueCCtx() :
+ *  reuse CCtx without reset (note : requires no dictionary) */
+static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_CCtx_params params, U64 pledgedSrcSize)
+{
+    size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize));
+    size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
+    DEBUGLOG(4, "ZSTD_continueCCtx: re-use context in place");
+
+    cctx->blockSize = blockSize;   /* previous block size could be different even for same windowLog, due to pledgedSrcSize */
+    cctx->appliedParams = params;
+    cctx->blockState.matchState.cParams = params.cParams;
+    cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
+    cctx->consumedSrcSize = 0;
+    cctx->producedCSize = 0;
+    if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)
+        cctx->appliedParams.fParams.contentSizeFlag = 0;
+    DEBUGLOG(4, "pledged content size : %u ; flag : %u",
+        (U32)pledgedSrcSize, cctx->appliedParams.fParams.contentSizeFlag);
+    cctx->stage = ZSTDcs_init;
+    cctx->dictID = 0;
+    if (params.ldmParams.enableLdm)
+        ZSTD_window_clear(&cctx->ldmState.window);
+    ZSTD_referenceExternalSequences(cctx, NULL, 0);
+    ZSTD_invalidateMatchState(&cctx->blockState.matchState);
+    ZSTD_reset_compressedBlockState(cctx->blockState.prevCBlock);
+    XXH64_reset(&cctx->xxhState, 0);
+    return 0;
+}
+
+typedef enum { ZSTDcrp_continue, ZSTDcrp_noMemset } ZSTD_compResetPolicy_e;
+
+typedef enum { ZSTD_resetTarget_CDict, ZSTD_resetTarget_CCtx } ZSTD_resetTarget_e;
+
+static void*
+ZSTD_reset_matchState(ZSTD_matchState_t* ms,
+                      void* ptr,
+                const ZSTD_compressionParameters* cParams,
+                      ZSTD_compResetPolicy_e const crp, ZSTD_resetTarget_e const forWho)
+{
+    size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog);
+    size_t const hSize = ((size_t)1) << cParams->hashLog;
+    U32    const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
+    size_t const h3Size = ((size_t)1) << hashLog3;
+    size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
+
+    assert(((size_t)ptr & 3) == 0);
+
+    ms->hashLog3 = hashLog3;
+    memset(&ms->window, 0, sizeof(ms->window));
+    ms->window.dictLimit = 1;    /* start from 1, so that 1st position is valid */
+    ms->window.lowLimit = 1;     /* it ensures first and later CCtx usages compress the same */
+    ms->window.nextSrc = ms->window.base + 1;   /* see issue #1241 */
+    ZSTD_invalidateMatchState(ms);
+
+    /* opt parser space */
+    if ((forWho == ZSTD_resetTarget_CCtx) && (cParams->strategy >= ZSTD_btopt)) {
+        DEBUGLOG(4, "reserving optimal parser space");
+        ms->opt.litFreq = (unsigned*)ptr;
+        ms->opt.litLengthFreq = ms->opt.litFreq + (1<<Litbits);
+        ms->opt.matchLengthFreq = ms->opt.litLengthFreq + (MaxLL+1);
+        ms->opt.offCodeFreq = ms->opt.matchLengthFreq + (MaxML+1);
+        ptr = ms->opt.offCodeFreq + (MaxOff+1);
+        ms->opt.matchTable = (ZSTD_match_t*)ptr;
+        ptr = ms->opt.matchTable + ZSTD_OPT_NUM+1;
+        ms->opt.priceTable = (ZSTD_optimal_t*)ptr;
+        ptr = ms->opt.priceTable + ZSTD_OPT_NUM+1;
+    }
+
+    /* table Space */
+    DEBUGLOG(4, "reset table : %u", crp!=ZSTDcrp_noMemset);
+    assert(((size_t)ptr & 3) == 0);  /* ensure ptr is properly aligned */
+    if (crp!=ZSTDcrp_noMemset) memset(ptr, 0, tableSpace);   /* reset tables only */
+    ms->hashTable = (U32*)(ptr);
+    ms->chainTable = ms->hashTable + hSize;
+    ms->hashTable3 = ms->chainTable + chainSize;
+    ptr = ms->hashTable3 + h3Size;
+
+    ms->cParams = *cParams;
+
+    assert(((size_t)ptr & 3) == 0);
+    return ptr;
+}
+
+/* ZSTD_indexTooCloseToMax() :
+ * minor optimization : prefer memset() rather than reduceIndex()
+ * which is measurably slow in some circumstances (reported for Visual Studio).
+ * Works when re-using a context for a lot of smallish inputs :
+ * if all inputs are smaller than ZSTD_INDEXOVERFLOW_MARGIN,
+ * memset() will be triggered before reduceIndex().
+ */
+#define ZSTD_INDEXOVERFLOW_MARGIN (16 MB)
+static int ZSTD_indexTooCloseToMax(ZSTD_window_t w)
+{
+    return (size_t)(w.nextSrc - w.base) > (ZSTD_CURRENT_MAX - ZSTD_INDEXOVERFLOW_MARGIN);
+}
+
+#define ZSTD_WORKSPACETOOLARGE_FACTOR 3 /* define "workspace is too large" as this number of times larger than needed */
+#define ZSTD_WORKSPACETOOLARGE_MAXDURATION 128  /* when workspace is continuously too large
+                                         * during at least this number of times,
+                                         * context's memory usage is considered wasteful,
+                                         * because it's sized to handle a worst case scenario which rarely happens.
+                                         * In which case, resize it down to free some memory */
+
+/*! ZSTD_resetCCtx_internal() :
+    note : `params` are assumed fully validated at this stage */
+static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
+                                      ZSTD_CCtx_params params,
+                                      U64 const pledgedSrcSize,
+                                      ZSTD_compResetPolicy_e const crp,
+                                      ZSTD_buffered_policy_e const zbuff)
+{
+    DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u, wlog=%u",
+                (U32)pledgedSrcSize, params.cParams.windowLog);
+    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
+
+    if (crp == ZSTDcrp_continue) {
+        if (ZSTD_equivalentParams(zc->appliedParams, params,
+                                  zc->inBuffSize,
+                                  zc->seqStore.maxNbSeq, zc->seqStore.maxNbLit,
+                                  zbuff, pledgedSrcSize) ) {
+            DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> consider continue mode");
+            zc->workSpaceOversizedDuration += (zc->workSpaceOversizedDuration > 0);   /* if it was too large, it still is */
+            if (zc->workSpaceOversizedDuration <= ZSTD_WORKSPACETOOLARGE_MAXDURATION) {
+                DEBUGLOG(4, "continue mode confirmed (wLog1=%u, blockSize1=%zu)",
+                            zc->appliedParams.cParams.windowLog, zc->blockSize);
+                if (ZSTD_indexTooCloseToMax(zc->blockState.matchState.window)) {
+                    /* prefer a reset, faster than a rescale */
+                    ZSTD_reset_matchState(&zc->blockState.matchState,
+                                           zc->entropyWorkspace + HUF_WORKSPACE_SIZE_U32,
+                                          &params.cParams,
+                                           crp, ZSTD_resetTarget_CCtx);
+                }
+                return ZSTD_continueCCtx(zc, params, pledgedSrcSize);
+    }   }   }
+    DEBUGLOG(4, "ZSTD_equivalentParams()==0 -> reset CCtx");
+
+    if (params.ldmParams.enableLdm) {
+        /* Adjust long distance matching parameters */
+        ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
+        assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);
+        assert(params.ldmParams.hashRateLog < 32);
+        zc->ldmState.hashPower = ZSTD_rollingHash_primePower(params.ldmParams.minMatchLength);
+    }
+
+    {   size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize));
+        size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
+        U32    const divider = (params.cParams.minMatch==3) ? 3 : 4;
+        size_t const maxNbSeq = blockSize / divider;
+        size_t const tokenSpace = WILDCOPY_OVERLENGTH + blockSize + 11*maxNbSeq;
+        size_t const buffOutSize = (zbuff==ZSTDb_buffered) ? ZSTD_compressBound(blockSize)+1 : 0;
+        size_t const buffInSize = (zbuff==ZSTDb_buffered) ? windowSize + blockSize : 0;
+        size_t const matchStateSize = ZSTD_sizeof_matchState(&params.cParams, /* forCCtx */ 1);
+        size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params.ldmParams, blockSize);
+        void* ptr;   /* used to partition workSpace */
+
+        /* Check if workSpace is large enough, alloc a new one if needed */
+        {   size_t const entropySpace = HUF_WORKSPACE_SIZE;
+            size_t const blockStateSpace = 2 * sizeof(ZSTD_compressedBlockState_t);
+            size_t const bufferSpace = buffInSize + buffOutSize;
+            size_t const ldmSpace = ZSTD_ldm_getTableSize(params.ldmParams);
+            size_t const ldmSeqSpace = maxNbLdmSeq * sizeof(rawSeq);
+
+            size_t const neededSpace = entropySpace + blockStateSpace + ldmSpace +
+                                       ldmSeqSpace + matchStateSize + tokenSpace +
+                                       bufferSpace;
+
+            int const workSpaceTooSmall = zc->workSpaceSize < neededSpace;
+            int const workSpaceTooLarge = zc->workSpaceSize > ZSTD_WORKSPACETOOLARGE_FACTOR * neededSpace;
+            int const workSpaceWasteful = workSpaceTooLarge && (zc->workSpaceOversizedDuration > ZSTD_WORKSPACETOOLARGE_MAXDURATION);
+            zc->workSpaceOversizedDuration = workSpaceTooLarge ? zc->workSpaceOversizedDuration+1 : 0;
+
+            DEBUGLOG(4, "Need %zuKB workspace, including %zuKB for match state, and %zuKB for buffers",
+                        neededSpace>>10, matchStateSize>>10, bufferSpace>>10);
+            DEBUGLOG(4, "windowSize: %zu - blockSize: %zu", windowSize, blockSize);
+
+            if (workSpaceTooSmall || workSpaceWasteful) {
+                DEBUGLOG(4, "Resize workSpaceSize from %zuKB to %zuKB",
+                            zc->workSpaceSize >> 10,
+                            neededSpace >> 10);
+
+                RETURN_ERROR_IF(zc->staticSize, memory_allocation, "static cctx : no resize");
+
+                zc->workSpaceSize = 0;
+                ZSTD_free(zc->workSpace, zc->customMem);
+                zc->workSpace = ZSTD_malloc(neededSpace, zc->customMem);
+                RETURN_ERROR_IF(zc->workSpace == NULL, memory_allocation);
+                zc->workSpaceSize = neededSpace;
+                zc->workSpaceOversizedDuration = 0;
+
+                /* Statically sized space.
+                 * entropyWorkspace never moves,
+                 * though prev/next block swap places */
+                assert(((size_t)zc->workSpace & 3) == 0);   /* ensure correct alignment */
+                assert(zc->workSpaceSize >= 2 * sizeof(ZSTD_compressedBlockState_t));
+                zc->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)zc->workSpace;
+                zc->blockState.nextCBlock = zc->blockState.prevCBlock + 1;
+                ptr = zc->blockState.nextCBlock + 1;
+                zc->entropyWorkspace = (U32*)ptr;
+        }   }
+
+        /* init params */
+        zc->appliedParams = params;
+        zc->blockState.matchState.cParams = params.cParams;
+        zc->pledgedSrcSizePlusOne = pledgedSrcSize+1;
+        zc->consumedSrcSize = 0;
+        zc->producedCSize = 0;
+        if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)
+            zc->appliedParams.fParams.contentSizeFlag = 0;
+        DEBUGLOG(4, "pledged content size : %u ; flag : %u",
+            (unsigned)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag);
+        zc->blockSize = blockSize;
+
+        XXH64_reset(&zc->xxhState, 0);
+        zc->stage = ZSTDcs_init;
+        zc->dictID = 0;
+
+        ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);
+
+        ptr = ZSTD_reset_matchState(&zc->blockState.matchState,
+                                     zc->entropyWorkspace + HUF_WORKSPACE_SIZE_U32,
+                                    &params.cParams,
+                                     crp, ZSTD_resetTarget_CCtx);
+
+        /* ldm hash table */
+        /* initialize bucketOffsets table later for pointer alignment */
+        if (params.ldmParams.enableLdm) {
+            size_t const ldmHSize = ((size_t)1) << params.ldmParams.hashLog;
+            memset(ptr, 0, ldmHSize * sizeof(ldmEntry_t));
+            assert(((size_t)ptr & 3) == 0); /* ensure ptr is properly aligned */
+            zc->ldmState.hashTable = (ldmEntry_t*)ptr;
+            ptr = zc->ldmState.hashTable + ldmHSize;
+            zc->ldmSequences = (rawSeq*)ptr;
+            ptr = zc->ldmSequences + maxNbLdmSeq;
+            zc->maxNbLdmSequences = maxNbLdmSeq;
+
+            memset(&zc->ldmState.window, 0, sizeof(zc->ldmState.window));
+        }
+        assert(((size_t)ptr & 3) == 0); /* ensure ptr is properly aligned */
+
+        /* sequences storage */
+        zc->seqStore.maxNbSeq = maxNbSeq;
+        zc->seqStore.sequencesStart = (seqDef*)ptr;
+        ptr = zc->seqStore.sequencesStart + maxNbSeq;
+        zc->seqStore.llCode = (BYTE*) ptr;
+        zc->seqStore.mlCode = zc->seqStore.llCode + maxNbSeq;
+        zc->seqStore.ofCode = zc->seqStore.mlCode + maxNbSeq;
+        zc->seqStore.litStart = zc->seqStore.ofCode + maxNbSeq;
+        /* ZSTD_wildcopy() is used to copy into the literals buffer,
+         * so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes.
+         */
+        zc->seqStore.maxNbLit = blockSize;
+        ptr = zc->seqStore.litStart + blockSize + WILDCOPY_OVERLENGTH;
+
+        /* ldm bucketOffsets table */
+        if (params.ldmParams.enableLdm) {
+            size_t const ldmBucketSize =
+                  ((size_t)1) << (params.ldmParams.hashLog -
+                                  params.ldmParams.bucketSizeLog);
+            memset(ptr, 0, ldmBucketSize);
+            zc->ldmState.bucketOffsets = (BYTE*)ptr;
+            ptr = zc->ldmState.bucketOffsets + ldmBucketSize;
+            ZSTD_window_clear(&zc->ldmState.window);
+        }
+        ZSTD_referenceExternalSequences(zc, NULL, 0);
+
+        /* buffers */
+        zc->inBuffSize = buffInSize;
+        zc->inBuff = (char*)ptr;
+        zc->outBuffSize = buffOutSize;
+        zc->outBuff = zc->inBuff + buffInSize;
+
+        return 0;
+    }
+}
+
+/* ZSTD_invalidateRepCodes() :
+ * ensures next compression will not use repcodes from previous block.
+ * Note : only works with regular variant;
+ *        do not use with extDict variant ! */
+void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
+    int i;
+    for (i=0; i<ZSTD_REP_NUM; i++) cctx->blockState.prevCBlock->rep[i] = 0;
+    assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
+}
+
+/* These are the approximate sizes for each strategy past which copying the
+ * dictionary tables into the working context is faster than using them
+ * in-place.
+ */
+static const size_t attachDictSizeCutoffs[ZSTD_STRATEGY_MAX+1] = {
+    8 KB,  /* unused */
+    8 KB,  /* ZSTD_fast */
+    16 KB, /* ZSTD_dfast */
+    32 KB, /* ZSTD_greedy */
+    32 KB, /* ZSTD_lazy */
+    32 KB, /* ZSTD_lazy2 */
+    32 KB, /* ZSTD_btlazy2 */
+    32 KB, /* ZSTD_btopt */
+    8 KB,  /* ZSTD_btultra */
+    8 KB   /* ZSTD_btultra2 */
+};
+
+static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,
+                                 ZSTD_CCtx_params params,
+                                 U64 pledgedSrcSize)
+{
+    size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];
+    return ( pledgedSrcSize <= cutoff
+          || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
+          || params.attachDictPref == ZSTD_dictForceAttach )
+        && params.attachDictPref != ZSTD_dictForceCopy
+        && !params.forceWindow; /* dictMatchState isn't correctly
+                                 * handled in _enforceMaxDist */
+}
+
+static size_t
+ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,
+                        const ZSTD_CDict* cdict,
+                        ZSTD_CCtx_params params,
+                        U64 pledgedSrcSize,
+                        ZSTD_buffered_policy_e zbuff)
+{
+    {   const ZSTD_compressionParameters* const cdict_cParams = &cdict->matchState.cParams;
+        unsigned const windowLog = params.cParams.windowLog;
+        assert(windowLog != 0);
+        /* Resize working context table params for input only, since the dict
+         * has its own tables. */
+        params.cParams = ZSTD_adjustCParams_internal(*cdict_cParams, pledgedSrcSize, 0);
+        params.cParams.windowLog = windowLog;
+        ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
+                                ZSTDcrp_continue, zbuff);
+        assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
+    }
+
+    {   const U32 cdictEnd = (U32)( cdict->matchState.window.nextSrc
+                                  - cdict->matchState.window.base);
+        const U32 cdictLen = cdictEnd - cdict->matchState.window.dictLimit;
+        if (cdictLen == 0) {
+            /* don't even attach dictionaries with no contents */
+            DEBUGLOG(4, "skipping attaching empty dictionary");
+        } else {
+            DEBUGLOG(4, "attaching dictionary into context");
+            cctx->blockState.matchState.dictMatchState = &cdict->matchState;
+
+            /* prep working match state so dict matches never have negative indices
+             * when they are translated to the working context's index space. */
+            if (cctx->blockState.matchState.window.dictLimit < cdictEnd) {
+                cctx->blockState.matchState.window.nextSrc =
+                    cctx->blockState.matchState.window.base + cdictEnd;
+                ZSTD_window_clear(&cctx->blockState.matchState.window);
+            }
+            /* loadedDictEnd is expressed within the referential of the active context */
+            cctx->blockState.matchState.loadedDictEnd = cctx->blockState.matchState.window.dictLimit;
+    }   }
+
+    cctx->dictID = cdict->dictID;
+
+    /* copy block state */
+    memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));
+
+    return 0;
+}
+
+static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
+                            const ZSTD_CDict* cdict,
+                            ZSTD_CCtx_params params,
+                            U64 pledgedSrcSize,
+                            ZSTD_buffered_policy_e zbuff)
+{
+    const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;
+
+    DEBUGLOG(4, "copying dictionary into context");
+
+    {   unsigned const windowLog = params.cParams.windowLog;
+        assert(windowLog != 0);
+        /* Copy only compression parameters related to tables. */
+        params.cParams = *cdict_cParams;
+        params.cParams.windowLog = windowLog;
+        ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
+                                ZSTDcrp_noMemset, zbuff);
+        assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
+        assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog);
+        assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog);
+    }
+
+    /* copy tables */
+    {   size_t const chainSize = (cdict_cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cdict_cParams->chainLog);
+        size_t const hSize =  (size_t)1 << cdict_cParams->hashLog;
+        size_t const tableSpace = (chainSize + hSize) * sizeof(U32);
+        assert((U32*)cctx->blockState.matchState.chainTable == (U32*)cctx->blockState.matchState.hashTable + hSize);  /* chainTable must follow hashTable */
+        assert((U32*)cctx->blockState.matchState.hashTable3 == (U32*)cctx->blockState.matchState.chainTable + chainSize);
+        assert((U32*)cdict->matchState.chainTable == (U32*)cdict->matchState.hashTable + hSize);  /* chainTable must follow hashTable */
+        assert((U32*)cdict->matchState.hashTable3 == (U32*)cdict->matchState.chainTable + chainSize);
+        memcpy(cctx->blockState.matchState.hashTable, cdict->matchState.hashTable, tableSpace);   /* presumes all tables follow each other */
+    }
+
+    /* Zero the hashTable3, since the cdict never fills it */
+    {   size_t const h3Size = (size_t)1 << cctx->blockState.matchState.hashLog3;
+        assert(cdict->matchState.hashLog3 == 0);
+        memset(cctx->blockState.matchState.hashTable3, 0, h3Size * sizeof(U32));
+    }
+
+    /* copy dictionary offsets */
+    {   ZSTD_matchState_t const* srcMatchState = &cdict->matchState;
+        ZSTD_matchState_t* dstMatchState = &cctx->blockState.matchState;
+        dstMatchState->window       = srcMatchState->window;
+        dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
+        dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
+    }
+
+    cctx->dictID = cdict->dictID;
+
+    /* copy block state */
+    memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));
+
+    return 0;
+}
+
+/* We have a choice between copying the dictionary context into the working
+ * context, or referencing the dictionary context from the working context
+ * in-place. We decide here which strategy to use. */
+static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx,
+                            const ZSTD_CDict* cdict,
+                            ZSTD_CCtx_params params,
+                            U64 pledgedSrcSize,
+                            ZSTD_buffered_policy_e zbuff)
+{
+
+    DEBUGLOG(4, "ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)",
+                (unsigned)pledgedSrcSize);
+
+    if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) {
+        return ZSTD_resetCCtx_byAttachingCDict(
+            cctx, cdict, params, pledgedSrcSize, zbuff);
+    } else {
+        return ZSTD_resetCCtx_byCopyingCDict(
+            cctx, cdict, params, pledgedSrcSize, zbuff);
+    }
+}
+
+/*! ZSTD_copyCCtx_internal() :
+ *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
+ *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
+ *  The "context", in this case, refers to the hash and chain tables,
+ *  entropy tables, and dictionary references.
+ * `windowLog` value is enforced if != 0, otherwise value is copied from srcCCtx.
+ * @return : 0, or an error code */
+static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
+                            const ZSTD_CCtx* srcCCtx,
+                            ZSTD_frameParameters fParams,
+                            U64 pledgedSrcSize,
+                            ZSTD_buffered_policy_e zbuff)
+{
+    DEBUGLOG(5, "ZSTD_copyCCtx_internal");
+    RETURN_ERROR_IF(srcCCtx->stage!=ZSTDcs_init, stage_wrong);
+
+    memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem));
+    {   ZSTD_CCtx_params params = dstCCtx->requestedParams;
+        /* Copy only compression parameters related to tables. */
+        params.cParams = srcCCtx->appliedParams.cParams;
+        params.fParams = fParams;
+        ZSTD_resetCCtx_internal(dstCCtx, params, pledgedSrcSize,
+                                ZSTDcrp_noMemset, zbuff);
+        assert(dstCCtx->appliedParams.cParams.windowLog == srcCCtx->appliedParams.cParams.windowLog);
+        assert(dstCCtx->appliedParams.cParams.strategy == srcCCtx->appliedParams.cParams.strategy);
+        assert(dstCCtx->appliedParams.cParams.hashLog == srcCCtx->appliedParams.cParams.hashLog);
+        assert(dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog);
+        assert(dstCCtx->blockState.matchState.hashLog3 == srcCCtx->blockState.matchState.hashLog3);
+    }
+
+    /* copy tables */
+    {   size_t const chainSize = (srcCCtx->appliedParams.cParams.strategy == ZSTD_fast) ? 0 : ((size_t)1 << srcCCtx->appliedParams.cParams.chainLog);
+        size_t const hSize =  (size_t)1 << srcCCtx->appliedParams.cParams.hashLog;
+        size_t const h3Size = (size_t)1 << srcCCtx->blockState.matchState.hashLog3;
+        size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
+        assert((U32*)dstCCtx->blockState.matchState.chainTable == (U32*)dstCCtx->blockState.matchState.hashTable + hSize);  /* chainTable must follow hashTable */
+        assert((U32*)dstCCtx->blockState.matchState.hashTable3 == (U32*)dstCCtx->blockState.matchState.chainTable + chainSize);
+        memcpy(dstCCtx->blockState.matchState.hashTable, srcCCtx->blockState.matchState.hashTable, tableSpace);   /* presumes all tables follow each other */
+    }
+
+    /* copy dictionary offsets */
+    {
+        const ZSTD_matchState_t* srcMatchState = &srcCCtx->blockState.matchState;
+        ZSTD_matchState_t* dstMatchState = &dstCCtx->blockState.matchState;
+        dstMatchState->window       = srcMatchState->window;
+        dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
+        dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
+    }
+    dstCCtx->dictID = srcCCtx->dictID;
+
+    /* copy block state */
+    memcpy(dstCCtx->blockState.prevCBlock, srcCCtx->blockState.prevCBlock, sizeof(*srcCCtx->blockState.prevCBlock));
+
+    return 0;
+}
+
+/*! ZSTD_copyCCtx() :
+ *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
+ *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
+ *  pledgedSrcSize==0 means "unknown".
+*   @return : 0, or an error code */
+size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long long pledgedSrcSize)
+{
+    ZSTD_frameParameters fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
+    ZSTD_buffered_policy_e const zbuff = (ZSTD_buffered_policy_e)(srcCCtx->inBuffSize>0);
+    ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1);
+    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
+    fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN);
+
+    return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx,
+                                fParams, pledgedSrcSize,
+                                zbuff);
+}
+
+
+#define ZSTD_ROWSIZE 16
+/*! ZSTD_reduceTable() :
+ *  reduce table indexes by `reducerValue`, or squash to zero.
+ *  PreserveMark preserves "unsorted mark" for btlazy2 strategy.
+ *  It must be set to a clear 0/1 value, to remove branch during inlining.
+ *  Presume table size is a multiple of ZSTD_ROWSIZE
+ *  to help auto-vectorization */
+FORCE_INLINE_TEMPLATE void
+ZSTD_reduceTable_internal (U32* const table, U32 const size, U32 const reducerValue, int const preserveMark)
+{
+    int const nbRows = (int)size / ZSTD_ROWSIZE;
+    int cellNb = 0;
+    int rowNb;
+    assert((size & (ZSTD_ROWSIZE-1)) == 0);  /* multiple of ZSTD_ROWSIZE */
+    assert(size < (1U<<31));   /* can be casted to int */
+    for (rowNb=0 ; rowNb < nbRows ; rowNb++) {
+        int column;
+        for (column=0; column<ZSTD_ROWSIZE; column++) {
+            if (preserveMark) {
+                U32 const adder = (table[cellNb] == ZSTD_DUBT_UNSORTED_MARK) ? reducerValue : 0;
+                table[cellNb] += adder;
+            }
+            if (table[cellNb] < reducerValue) table[cellNb] = 0;
+            else table[cellNb] -= reducerValue;
+            cellNb++;
+    }   }
+}
+
+static void ZSTD_reduceTable(U32* const table, U32 const size, U32 const reducerValue)
+{
+    ZSTD_reduceTable_internal(table, size, reducerValue, 0);
+}
+
+static void ZSTD_reduceTable_btlazy2(U32* const table, U32 const size, U32 const reducerValue)
+{
+    ZSTD_reduceTable_internal(table, size, reducerValue, 1);
+}
+
+/*! ZSTD_reduceIndex() :
+*   rescale all indexes to avoid future overflow (indexes are U32) */
+static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const U32 reducerValue)
+{
+    {   U32 const hSize = (U32)1 << params->cParams.hashLog;
+        ZSTD_reduceTable(ms->hashTable, hSize, reducerValue);
+    }
+
+    if (params->cParams.strategy != ZSTD_fast) {
+        U32 const chainSize = (U32)1 << params->cParams.chainLog;
+        if (params->cParams.strategy == ZSTD_btlazy2)
+            ZSTD_reduceTable_btlazy2(ms->chainTable, chainSize, reducerValue);
+        else
+            ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue);
+    }
+
+    if (ms->hashLog3) {
+        U32 const h3Size = (U32)1 << ms->hashLog3;
+        ZSTD_reduceTable(ms->hashTable3, h3Size, reducerValue);
+    }
+}
+
+
+/*-*******************************************************
+*  Block entropic compression
+*********************************************************/
+
+/* See doc/zstd_compression_format.md for detailed format description */
+
+static size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
+{
+    U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
+    RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
+                    dstSize_tooSmall);
+    MEM_writeLE24(dst, cBlockHeader24);
+    memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);
+    return ZSTD_blockHeaderSize + srcSize;
+}
+
+void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
+{
+    const seqDef* const sequences = seqStorePtr->sequencesStart;
+    BYTE* const llCodeTable = seqStorePtr->llCode;
+    BYTE* const ofCodeTable = seqStorePtr->ofCode;
+    BYTE* const mlCodeTable = seqStorePtr->mlCode;
+    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
+    U32 u;
+    assert(nbSeq <= seqStorePtr->maxNbSeq);
+    for (u=0; u<nbSeq; u++) {
+        U32 const llv = sequences[u].litLength;
+        U32 const mlv = sequences[u].matchLength;
+        llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
+        ofCodeTable[u] = (BYTE)ZSTD_highbit32(sequences[u].offset);
+        mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
+    }
+    if (seqStorePtr->longLengthID==1)
+        llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
+    if (seqStorePtr->longLengthID==2)
+        mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
+}
+
+static int ZSTD_disableLiteralsCompression(const ZSTD_CCtx_params* cctxParams)
+{
+    switch (cctxParams->literalCompressionMode) {
+    case ZSTD_lcm_huffman:
+        return 0;
+    case ZSTD_lcm_uncompressed:
+        return 1;
+    default:
+        assert(0 /* impossible: pre-validated */);
+        /* fall-through */
+    case ZSTD_lcm_auto:
+        return (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0);
+    }
+}
+
+/* ZSTD_compressSequences_internal():
+ * actually compresses both literals and sequences */
+MEM_STATIC size_t
+ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
+                          const ZSTD_entropyCTables_t* prevEntropy,
+                                ZSTD_entropyCTables_t* nextEntropy,
+                          const ZSTD_CCtx_params* cctxParams,
+                                void* dst, size_t dstCapacity,
+                                void* workspace, size_t wkspSize,
+                          const int bmi2)
+{
+    const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
+    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
+    unsigned count[MaxSeq+1];
+    FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
+    FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
+    FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
+    U32 LLtype, Offtype, MLtype;   /* compressed, raw or rle */
+    const seqDef* const sequences = seqStorePtr->sequencesStart;
+    const BYTE* const ofCodeTable = seqStorePtr->ofCode;
+    const BYTE* const llCodeTable = seqStorePtr->llCode;
+    const BYTE* const mlCodeTable = seqStorePtr->mlCode;
+    BYTE* const ostart = (BYTE*)dst;
+    BYTE* const oend = ostart + dstCapacity;
+    BYTE* op = ostart;
+    size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
+    BYTE* seqHead;
+    BYTE* lastNCount = NULL;
+
+    DEBUGLOG(5, "ZSTD_compressSequences_internal (nbSeq=%zu)", nbSeq);
+    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
+
+    /* Compress literals */
+    {   const BYTE* const literals = seqStorePtr->litStart;
+        size_t const litSize = (size_t)(seqStorePtr->lit - literals);
+        size_t const cSize = ZSTD_compressLiterals(
+                                    &prevEntropy->huf, &nextEntropy->huf,
+                                    cctxParams->cParams.strategy,
+                                    ZSTD_disableLiteralsCompression(cctxParams),
+                                    op, dstCapacity,
+                                    literals, litSize,
+                                    workspace, wkspSize,
+                                    bmi2);
+        FORWARD_IF_ERROR(cSize);
+        assert(cSize <= dstCapacity);
+        op += cSize;
+    }
+
+    /* Sequences Header */
+    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
+                    dstSize_tooSmall);
+    if (nbSeq < 0x7F)
+        *op++ = (BYTE)nbSeq;
+    else if (nbSeq < LONGNBSEQ)
+        op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
+    else
+        op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
+    assert(op <= oend);
+    if (nbSeq==0) {
+        /* Copy the old tables over as if we repeated them */
+        memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
+        return (size_t)(op - ostart);
+    }
+
+    /* seqHead : flags for FSE encoding type */
+    seqHead = op++;
+    assert(op <= oend);
+
+    /* convert length/distances into codes */
+    ZSTD_seqToCodes(seqStorePtr);
+    /* build CTable for Literal Lengths */
+    {   unsigned max = MaxLL;
+        size_t const mostFrequent = HIST_countFast_wksp(count, &max, llCodeTable, nbSeq, workspace, wkspSize);   /* can't fail */
+        DEBUGLOG(5, "Building LL table");
+        nextEntropy->fse.litlength_repeatMode = prevEntropy->fse.litlength_repeatMode;
+        LLtype = ZSTD_selectEncodingType(&nextEntropy->fse.litlength_repeatMode,
+                                        count, max, mostFrequent, nbSeq,
+                                        LLFSELog, prevEntropy->fse.litlengthCTable,
+                                        LL_defaultNorm, LL_defaultNormLog,
+                                        ZSTD_defaultAllowed, strategy);
+        assert(set_basic < set_compressed && set_rle < set_compressed);
+        assert(!(LLtype < set_compressed && nextEntropy->fse.litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
+        {   size_t const countSize = ZSTD_buildCTable(op, (size_t)(oend - op), CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
+                                                    count, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL,
+                                                    prevEntropy->fse.litlengthCTable, sizeof(prevEntropy->fse.litlengthCTable),
+                                                    workspace, wkspSize);
+            FORWARD_IF_ERROR(countSize);
+            if (LLtype == set_compressed)
+                lastNCount = op;
+            op += countSize;
+            assert(op <= oend);
+    }   }
+    /* build CTable for Offsets */
+    {   unsigned max = MaxOff;
+        size_t const mostFrequent = HIST_countFast_wksp(count, &max, ofCodeTable, nbSeq, workspace, wkspSize);  /* can't fail */
+        /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
+        ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
+        DEBUGLOG(5, "Building OF table");
+        nextEntropy->fse.offcode_repeatMode = prevEntropy->fse.offcode_repeatMode;
+        Offtype = ZSTD_selectEncodingType(&nextEntropy->fse.offcode_repeatMode,
+                                        count, max, mostFrequent, nbSeq,
+                                        OffFSELog, prevEntropy->fse.offcodeCTable,
+                                        OF_defaultNorm, OF_defaultNormLog,
+                                        defaultPolicy, strategy);
+        assert(!(Offtype < set_compressed && nextEntropy->fse.offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
+        {   size_t const countSize = ZSTD_buildCTable(op, (size_t)(oend - op), CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
+                                                    count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
+                                                    prevEntropy->fse.offcodeCTable, sizeof(prevEntropy->fse.offcodeCTable),
+                                                    workspace, wkspSize);
+            FORWARD_IF_ERROR(countSize);
+            if (Offtype == set_compressed)
+                lastNCount = op;
+            op += countSize;
+            assert(op <= oend);
+    }   }
+    /* build CTable for MatchLengths */
+    {   unsigned max = MaxML;
+        size_t const mostFrequent = HIST_countFast_wksp(count, &max, mlCodeTable, nbSeq, workspace, wkspSize);   /* can't fail */
+        DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
+        nextEntropy->fse.matchlength_repeatMode = prevEntropy->fse.matchlength_repeatMode;
+        MLtype = ZSTD_selectEncodingType(&nextEntropy->fse.matchlength_repeatMode,
+                                        count, max, mostFrequent, nbSeq,
+                                        MLFSELog, prevEntropy->fse.matchlengthCTable,
+                                        ML_defaultNorm, ML_defaultNormLog,
+                                        ZSTD_defaultAllowed, strategy);
+        assert(!(MLtype < set_compressed && nextEntropy->fse.matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
+        {   size_t const countSize = ZSTD_buildCTable(op, (size_t)(oend - op), CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
+                                                    count, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML,
+                                                    prevEntropy->fse.matchlengthCTable, sizeof(prevEntropy->fse.matchlengthCTable),
+                                                    workspace, wkspSize);
+            FORWARD_IF_ERROR(countSize);
+            if (MLtype == set_compressed)
+                lastNCount = op;
+            op += countSize;
+            assert(op <= oend);
+    }   }
+
+    *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
+
+    {   size_t const bitstreamSize = ZSTD_encodeSequences(
+                                        op, (size_t)(oend - op),
+                                        CTable_MatchLength, mlCodeTable,
+                                        CTable_OffsetBits, ofCodeTable,
+                                        CTable_LitLength, llCodeTable,
+                                        sequences, nbSeq,
+                                        longOffsets, bmi2);
+        FORWARD_IF_ERROR(bitstreamSize);
+        op += bitstreamSize;
+        assert(op <= oend);
+        /* zstd versions <= 1.3.4 mistakenly report corruption when
+         * FSE_readNCount() receives a buffer < 4 bytes.
+         * Fixed by https://github.com/facebook/zstd/pull/1146.
+         * This can happen when the last set_compressed table present is 2
+         * bytes and the bitstream is only one byte.
+         * In this exceedingly rare case, we will simply emit an uncompressed
+         * block, since it isn't worth optimizing.
+         */
+        if (lastNCount && (op - lastNCount) < 4) {
+            /* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
+            assert(op - lastNCount == 3);
+            DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
+                        "emitting an uncompressed block.");
+            return 0;
+        }
+    }
+
+    DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
+    return (size_t)(op - ostart);
+}
+
+MEM_STATIC size_t
+ZSTD_compressSequences(seqStore_t* seqStorePtr,
+                       const ZSTD_entropyCTables_t* prevEntropy,
+                             ZSTD_entropyCTables_t* nextEntropy,
+                       const ZSTD_CCtx_params* cctxParams,
+                             void* dst, size_t dstCapacity,
+                             size_t srcSize,
+                             void* workspace, size_t wkspSize,
+                             int bmi2)
+{
+    size_t const cSize = ZSTD_compressSequences_internal(
+                            seqStorePtr, prevEntropy, nextEntropy, cctxParams,
+                            dst, dstCapacity,
+                            workspace, wkspSize, bmi2);
+    if (cSize == 0) return 0;
+    /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
+     * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
+     */
+    if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity))
+        return 0;  /* block not compressed */
+    FORWARD_IF_ERROR(cSize);
+
+    /* Check compressibility */
+    {   size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
+        if (cSize >= maxCSize) return 0;  /* block not compressed */
+    }
+
+    return cSize;
+}
+
+/* ZSTD_selectBlockCompressor() :
+ * Not static, but internal use only (used by long distance matcher)
+ * assumption : strat is a valid strategy */
+ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_dictMode_e dictMode)
+{
+    static const ZSTD_blockCompressor blockCompressor[3][ZSTD_STRATEGY_MAX+1] = {
+        { ZSTD_compressBlock_fast  /* default for 0 */,
+          ZSTD_compressBlock_fast,
+          ZSTD_compressBlock_doubleFast,
+          ZSTD_compressBlock_greedy,
+          ZSTD_compressBlock_lazy,
+          ZSTD_compressBlock_lazy2,
+          ZSTD_compressBlock_btlazy2,
+          ZSTD_compressBlock_btopt,
+          ZSTD_compressBlock_btultra,
+          ZSTD_compressBlock_btultra2 },
+        { ZSTD_compressBlock_fast_extDict  /* default for 0 */,
+          ZSTD_compressBlock_fast_extDict,
+          ZSTD_compressBlock_doubleFast_extDict,
+          ZSTD_compressBlock_greedy_extDict,
+          ZSTD_compressBlock_lazy_extDict,
+          ZSTD_compressBlock_lazy2_extDict,
+          ZSTD_compressBlock_btlazy2_extDict,
+          ZSTD_compressBlock_btopt_extDict,
+          ZSTD_compressBlock_btultra_extDict,
+          ZSTD_compressBlock_btultra_extDict },
+        { ZSTD_compressBlock_fast_dictMatchState  /* default for 0 */,
+          ZSTD_compressBlock_fast_dictMatchState,
+          ZSTD_compressBlock_doubleFast_dictMatchState,
+          ZSTD_compressBlock_greedy_dictMatchState,
+          ZSTD_compressBlock_lazy_dictMatchState,
+          ZSTD_compressBlock_lazy2_dictMatchState,
+          ZSTD_compressBlock_btlazy2_dictMatchState,
+          ZSTD_compressBlock_btopt_dictMatchState,
+          ZSTD_compressBlock_btultra_dictMatchState,
+          ZSTD_compressBlock_btultra_dictMatchState }
+    };
+    ZSTD_blockCompressor selectedCompressor;
+    ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);
+
+    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
+    selectedCompressor = blockCompressor[(int)dictMode][(int)strat];
+    assert(selectedCompressor != NULL);
+    return selectedCompressor;
+}
+
+static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
+                                   const BYTE* anchor, size_t lastLLSize)
+{
+    memcpy(seqStorePtr->lit, anchor, lastLLSize);
+    seqStorePtr->lit += lastLLSize;
+}
+
+void ZSTD_resetSeqStore(seqStore_t* ssPtr)
+{
+    ssPtr->lit = ssPtr->litStart;
+    ssPtr->sequences = ssPtr->sequencesStart;
+    ssPtr->longLengthID = 0;
+}
+
+typedef enum { ZSTDbss_compress, ZSTDbss_noCompress } ZSTD_buildSeqStore_e;
+
+static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
+{
+    ZSTD_matchState_t* const ms = &zc->blockState.matchState;
+    DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
+    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
+    /* Assert that we have correctly flushed the ctx params into the ms's copy */
+    ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
+    if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) {
+        ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);
+        return ZSTDbss_noCompress; /* don't even attempt compression below a certain srcSize */
+    }
+    ZSTD_resetSeqStore(&(zc->seqStore));
+    /* required for optimal parser to read stats from dictionary */
+    ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy;
+    /* tell the optimal parser how we expect to compress literals */
+    ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode;
+    /* a gap between an attached dict and the current window is not safe,
+     * they must remain adjacent,
+     * and when that stops being the case, the dict must be unset */
+    assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit);
+
+    /* limited update after a very long match */
+    {   const BYTE* const base = ms->window.base;
+        const BYTE* const istart = (const BYTE*)src;
+        const U32 current = (U32)(istart-base);
+        if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1));   /* ensure no overflow */
+        if (current > ms->nextToUpdate + 384)
+            ms->nextToUpdate = current - MIN(192, (U32)(current - ms->nextToUpdate - 384));
+    }
+
+    /* select and store sequences */
+    {   ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms);
+        size_t lastLLSize;
+        {   int i;
+            for (i = 0; i < ZSTD_REP_NUM; ++i)
+                zc->blockState.nextCBlock->rep[i] = zc->blockState.prevCBlock->rep[i];
+        }
+        if (zc->externSeqStore.pos < zc->externSeqStore.size) {
+            assert(!zc->appliedParams.ldmParams.enableLdm);
+            /* Updates ldmSeqStore.pos */
+            lastLLSize =
+                ZSTD_ldm_blockCompress(&zc->externSeqStore,
+                                       ms, &zc->seqStore,
+                                       zc->blockState.nextCBlock->rep,
+                                       src, srcSize);
+            assert(zc->externSeqStore.pos <= zc->externSeqStore.size);
+        } else if (zc->appliedParams.ldmParams.enableLdm) {
+            rawSeqStore_t ldmSeqStore = {NULL, 0, 0, 0};
+
+            ldmSeqStore.seq = zc->ldmSequences;
+            ldmSeqStore.capacity = zc->maxNbLdmSequences;
+            /* Updates ldmSeqStore.size */
+            FORWARD_IF_ERROR(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore,
+                                               &zc->appliedParams.ldmParams,
+                                               src, srcSize));
+            /* Updates ldmSeqStore.pos */
+            lastLLSize =
+                ZSTD_ldm_blockCompress(&ldmSeqStore,
+                                       ms, &zc->seqStore,
+                                       zc->blockState.nextCBlock->rep,
+                                       src, srcSize);
+            assert(ldmSeqStore.pos == ldmSeqStore.size);
+        } else {   /* not long range mode */
+            ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy, dictMode);
+            lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);
+        }
+        {   const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize;
+            ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);
+    }   }
+    return ZSTDbss_compress;
+}
+
+static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
+                                        void* dst, size_t dstCapacity,
+                                        const void* src, size_t srcSize)
+{
+    size_t cSize;
+    DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
+                (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
+                (unsigned)zc->blockState.matchState.nextToUpdate);
+
+    {   const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
+        FORWARD_IF_ERROR(bss);
+        if (bss == ZSTDbss_noCompress) { cSize = 0; goto out; }
+    }
+
+    /* encode sequences and literals */
+    cSize = ZSTD_compressSequences(&zc->seqStore,
+            &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
+            &zc->appliedParams,
+            dst, dstCapacity,
+            srcSize,
+            zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
+            zc->bmi2);
+
+out:
+    if (!ZSTD_isError(cSize) && cSize != 0) {
+        /* confirm repcodes and entropy tables when emitting a compressed block */
+        ZSTD_compressedBlockState_t* const tmp = zc->blockState.prevCBlock;
+        zc->blockState.prevCBlock = zc->blockState.nextCBlock;
+        zc->blockState.nextCBlock = tmp;
+    }
+    /* We check that dictionaries have offset codes available for the first
+     * block. After the first block, the offcode table might not have large
+     * enough codes to represent the offsets in the data.
+     */
+    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
+        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
+
+    return cSize;
+}
+
+
+static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, void const* ip, void const* iend)
+{
+    if (ZSTD_window_needOverflowCorrection(ms->window, iend)) {
+        U32 const maxDist = (U32)1 << params->cParams.windowLog;
+        U32 const cycleLog = ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy);
+        U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip);
+        ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30);
+        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30);
+        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);
+        ZSTD_reduceIndex(ms, params, correction);
+        if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;
+        else ms->nextToUpdate -= correction;
+        /* invalidate dictionaries on overflow correction */
+        ms->loadedDictEnd = 0;
+        ms->dictMatchState = NULL;
+    }
+}
+
+
+/*! ZSTD_compress_frameChunk() :
+*   Compress a chunk of data into one or multiple blocks.
+*   All blocks will be terminated, all input will be consumed.
+*   Function will issue an error if there is not enough `dstCapacity` to hold the compressed content.
+*   Frame is supposed already started (header already produced)
+*   @return : compressed size, or an error code
+*/
+static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx,
+                                     void* dst, size_t dstCapacity,
+                               const void* src, size_t srcSize,
+                                     U32 lastFrameChunk)
+{
+    size_t blockSize = cctx->blockSize;
+    size_t remaining = srcSize;
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* const ostart = (BYTE*)dst;
+    BYTE* op = ostart;
+    U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
+    assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);
+
+    DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (unsigned)blockSize);
+    if (cctx->appliedParams.fParams.checksumFlag && srcSize)
+        XXH64_update(&cctx->xxhState, src, srcSize);
+
+    while (remaining) {
+        ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
+        U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
+
+        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE,
+                        dstSize_tooSmall,
+                        "not enough space to store compressed block");
+        if (remaining < blockSize) blockSize = remaining;
+
+        ZSTD_overflowCorrectIfNeeded(ms, &cctx->appliedParams, ip, ip + blockSize);
+        ZSTD_checkDictValidity(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);
+
+        /* Ensure hash/chain table insertion resumes no sooner than lowlimit */
+        if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;
+
+        {   size_t cSize = ZSTD_compressBlock_internal(cctx,
+                                op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
+                                ip, blockSize);
+            FORWARD_IF_ERROR(cSize);
+
+            if (cSize == 0) {  /* block is not compressible */
+                cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
+                FORWARD_IF_ERROR(cSize);
+            } else {
+                U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
+                MEM_writeLE24(op, cBlockHeader24);
+                cSize += ZSTD_blockHeaderSize;
+            }
+
+            ip += blockSize;
+            assert(remaining >= blockSize);
+            remaining -= blockSize;
+            op += cSize;
+            assert(dstCapacity >= cSize);
+            dstCapacity -= cSize;
+            DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
+                        (unsigned)cSize);
+    }   }
+
+    if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
+    return (size_t)(op-ostart);
+}
+
+
+static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
+                                    ZSTD_CCtx_params params, U64 pledgedSrcSize, U32 dictID)
+{   BYTE* const op = (BYTE*)dst;
+    U32   const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536);   /* 0-3 */
+    U32   const dictIDSizeCode = params.fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength;   /* 0-3 */
+    U32   const checksumFlag = params.fParams.checksumFlag>0;
+    U32   const windowSize = (U32)1 << params.cParams.windowLog;
+    U32   const singleSegment = params.fParams.contentSizeFlag && (windowSize >= pledgedSrcSize);
+    BYTE  const windowLogByte = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
+    U32   const fcsCode = params.fParams.contentSizeFlag ?
+                     (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0;  /* 0-3 */
+    BYTE  const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
+    size_t pos=0;
+
+    assert(!(params.fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));
+    RETURN_ERROR_IF(dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX, dstSize_tooSmall);
+    DEBUGLOG(4, "ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u",
+                !params.fParams.noDictIDFlag, (unsigned)dictID, (unsigned)dictIDSizeCode);
+
+    if (params.format == ZSTD_f_zstd1) {
+        MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
+        pos = 4;
+    }
+    op[pos++] = frameHeaderDescriptionByte;
+    if (!singleSegment) op[pos++] = windowLogByte;
+    switch(dictIDSizeCode)
+    {
+        default:  assert(0); /* impossible */
+        case 0 : break;
+        case 1 : op[pos] = (BYTE)(dictID); pos++; break;
+        case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break;
+        case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break;
+    }
+    switch(fcsCode)
+    {
+        default:  assert(0); /* impossible */
+        case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break;
+        case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break;
+        case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break;
+        case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break;
+    }
+    return pos;
+}
+
+/* ZSTD_writeLastEmptyBlock() :
+ * output an empty Block with end-of-frame mark to complete a frame
+ * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
+ *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
+ */
+size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)
+{
+    RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall);
+    {   U32 const cBlockHeader24 = 1 /*lastBlock*/ + (((U32)bt_raw)<<1);  /* 0 size */
+        MEM_writeLE24(dst, cBlockHeader24);
+        return ZSTD_blockHeaderSize;
+    }
+}
+
+size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq)
+{
+    RETURN_ERROR_IF(cctx->stage != ZSTDcs_init, stage_wrong);
+    RETURN_ERROR_IF(cctx->appliedParams.ldmParams.enableLdm,
+                    parameter_unsupported);
+    cctx->externSeqStore.seq = seq;
+    cctx->externSeqStore.size = nbSeq;
+    cctx->externSeqStore.capacity = nbSeq;
+    cctx->externSeqStore.pos = 0;
+    return 0;
+}
+
+
+static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
+                              void* dst, size_t dstCapacity,
+                        const void* src, size_t srcSize,
+                               U32 frame, U32 lastFrameChunk)
+{
+    ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
+    size_t fhSize = 0;
+
+    DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
+                cctx->stage, (unsigned)srcSize);
+    RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,
+                    "missing init (ZSTD_compressBegin)");
+
+    if (frame && (cctx->stage==ZSTDcs_init)) {
+        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams,
+                                       cctx->pledgedSrcSizePlusOne-1, cctx->dictID);
+        FORWARD_IF_ERROR(fhSize);
+        assert(fhSize <= dstCapacity);
+        dstCapacity -= fhSize;
+        dst = (char*)dst + fhSize;
+        cctx->stage = ZSTDcs_ongoing;
+    }
+
+    if (!srcSize) return fhSize;  /* do not generate an empty block if no input */
+
+    if (!ZSTD_window_update(&ms->window, src, srcSize)) {
+        ms->nextToUpdate = ms->window.dictLimit;
+    }
+    if (cctx->appliedParams.ldmParams.enableLdm) {
+        ZSTD_window_update(&cctx->ldmState.window, src, srcSize);
+    }
+
+    if (!frame) {
+        /* overflow check and correction for block mode */
+        ZSTD_overflowCorrectIfNeeded(ms, &cctx->appliedParams, src, (BYTE const*)src + srcSize);
+    }
+
+    DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
+    {   size_t const cSize = frame ?
+                             ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
+                             ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize);
+        FORWARD_IF_ERROR(cSize);
+        cctx->consumedSrcSize += srcSize;
+        cctx->producedCSize += (cSize + fhSize);
+        assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
+        if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
+            ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
+            RETURN_ERROR_IF(
+                cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne,
+                srcSize_wrong,
+                "error : pledgedSrcSize = %u, while realSrcSize >= %u",
+                (unsigned)cctx->pledgedSrcSizePlusOne-1,
+                (unsigned)cctx->consumedSrcSize);
+        }
+        return cSize + fhSize;
+    }
+}
+
+size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
+                              void* dst, size_t dstCapacity,
+                        const void* src, size_t srcSize)
+{
+    DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
+    return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
+}
+
+
+size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)
+{
+    ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;
+    assert(!ZSTD_checkCParams(cParams));
+    return MIN (ZSTD_BLOCKSIZE_MAX, (U32)1 << cParams.windowLog);
+}
+
+size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
+    { size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
+      RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong); }
+
+    return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
+}
+
+/*! ZSTD_loadDictionaryContent() :
+ *  @return : 0, or an error code
+ */
+static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
+                                         ZSTD_CCtx_params const* params,
+                                         const void* src, size_t srcSize,
+                                         ZSTD_dictTableLoadMethod_e dtlm)
+{
+    const BYTE* ip = (const BYTE*) src;
+    const BYTE* const iend = ip + srcSize;
+
+    ZSTD_window_update(&ms->window, src, srcSize);
+    ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);
+
+    /* Assert that we the ms params match the params we're being given */
+    ZSTD_assertEqualCParams(params->cParams, ms->cParams);
+
+    if (srcSize <= HASH_READ_SIZE) return 0;
+
+    while (iend - ip > HASH_READ_SIZE) {
+        size_t const remaining = (size_t)(iend - ip);
+        size_t const chunk = MIN(remaining, ZSTD_CHUNKSIZE_MAX);
+        const BYTE* const ichunk = ip + chunk;
+
+        ZSTD_overflowCorrectIfNeeded(ms, params, ip, ichunk);
+
+        switch(params->cParams.strategy)
+        {
+        case ZSTD_fast:
+            ZSTD_fillHashTable(ms, ichunk, dtlm);
+            break;
+        case ZSTD_dfast:
+            ZSTD_fillDoubleHashTable(ms, ichunk, dtlm);
+            break;
+
+        case ZSTD_greedy:
+        case ZSTD_lazy:
+        case ZSTD_lazy2:
+            if (chunk >= HASH_READ_SIZE)
+                ZSTD_insertAndFindFirstIndex(ms, ichunk-HASH_READ_SIZE);
+            break;
+
+        case ZSTD_btlazy2:   /* we want the dictionary table fully sorted */
+        case ZSTD_btopt:
+        case ZSTD_btultra:
+        case ZSTD_btultra2:
+            if (chunk >= HASH_READ_SIZE)
+                ZSTD_updateTree(ms, ichunk-HASH_READ_SIZE, ichunk);
+            break;
+
+        default:
+            assert(0);  /* not possible : not a valid strategy id */
+        }
+
+        ip = ichunk;
+    }
+
+    ms->nextToUpdate = (U32)(iend - ms->window.base);
+    return 0;
+}
+
+
+/* Dictionaries that assign zero probability to symbols that show up causes problems
+   when FSE encoding.  Refuse dictionaries that assign zero probability to symbols
+   that we may encounter during compression.
+   NOTE: This behavior is not standard and could be improved in the future. */
+static size_t ZSTD_checkDictNCount(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue) {
+    U32 s;
+    RETURN_ERROR_IF(dictMaxSymbolValue < maxSymbolValue, dictionary_corrupted);
+    for (s = 0; s <= maxSymbolValue; ++s) {
+        RETURN_ERROR_IF(normalizedCounter[s] == 0, dictionary_corrupted);
+    }
+    return 0;
+}
+
+
+/* Dictionary format :
+ * See :
+ * https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#dictionary-format
+ */
+/*! ZSTD_loadZstdDictionary() :
+ * @return : dictID, or an error code
+ *  assumptions : magic number supposed already checked
+ *                dictSize supposed > 8
+ */
+static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs,
+                                      ZSTD_matchState_t* ms,
+                                      ZSTD_CCtx_params const* params,
+                                      const void* dict, size_t dictSize,
+                                      ZSTD_dictTableLoadMethod_e dtlm,
+                                      void* workspace)
+{
+    const BYTE* dictPtr = (const BYTE*)dict;
+    const BYTE* const dictEnd = dictPtr + dictSize;
+    short offcodeNCount[MaxOff+1];
+    unsigned offcodeMaxValue = MaxOff;
+    size_t dictID;
+
+    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
+    assert(dictSize > 8);
+    assert(MEM_readLE32(dictPtr) == ZSTD_MAGIC_DICTIONARY);
+
+    dictPtr += 4;   /* skip magic number */
+    dictID = params->fParams.noDictIDFlag ? 0 :  MEM_readLE32(dictPtr);
+    dictPtr += 4;
+
+    {   unsigned maxSymbolValue = 255;
+        size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)bs->entropy.huf.CTable, &maxSymbolValue, dictPtr, dictEnd-dictPtr);
+        RETURN_ERROR_IF(HUF_isError(hufHeaderSize), dictionary_corrupted);
+        RETURN_ERROR_IF(maxSymbolValue < 255, dictionary_corrupted);
+        dictPtr += hufHeaderSize;
+    }
+
+    {   unsigned offcodeLog;
+        size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
+        RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted);
+        RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted);
+        /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
+        /* fill all offset symbols to avoid garbage at end of table */
+        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
+                bs->entropy.fse.offcodeCTable,
+                offcodeNCount, MaxOff, offcodeLog,
+                workspace, HUF_WORKSPACE_SIZE)),
+            dictionary_corrupted);
+        dictPtr += offcodeHeaderSize;
+    }
+
+    {   short matchlengthNCount[MaxML+1];
+        unsigned matchlengthMaxValue = MaxML, matchlengthLog;
+        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
+        RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted);
+        RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted);
+        /* Every match length code must have non-zero probability */
+        FORWARD_IF_ERROR( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML));
+        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
+                bs->entropy.fse.matchlengthCTable,
+                matchlengthNCount, matchlengthMaxValue, matchlengthLog,
+                workspace, HUF_WORKSPACE_SIZE)),
+            dictionary_corrupted);
+        dictPtr += matchlengthHeaderSize;
+    }
+
+    {   short litlengthNCount[MaxLL+1];
+        unsigned litlengthMaxValue = MaxLL, litlengthLog;
+        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
+        RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted);
+        RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted);
+        /* Every literal length code must have non-zero probability */
+        FORWARD_IF_ERROR( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL));
+        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
+                bs->entropy.fse.litlengthCTable,
+                litlengthNCount, litlengthMaxValue, litlengthLog,
+                workspace, HUF_WORKSPACE_SIZE)),
+            dictionary_corrupted);
+        dictPtr += litlengthHeaderSize;
+    }
+
+    RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted);
+    bs->rep[0] = MEM_readLE32(dictPtr+0);
+    bs->rep[1] = MEM_readLE32(dictPtr+4);
+    bs->rep[2] = MEM_readLE32(dictPtr+8);
+    dictPtr += 12;
+
+    {   size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
+        U32 offcodeMax = MaxOff;
+        if (dictContentSize <= ((U32)-1) - 128 KB) {
+            U32 const maxOffset = (U32)dictContentSize + 128 KB; /* The maximum offset that must be supported */
+            offcodeMax = ZSTD_highbit32(maxOffset); /* Calculate minimum offset code required to represent maxOffset */
+        }
+        /* All offset values <= dictContentSize + 128 KB must be representable */
+        FORWARD_IF_ERROR(ZSTD_checkDictNCount(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff)));
+        /* All repCodes must be <= dictContentSize and != 0*/
+        {   U32 u;
+            for (u=0; u<3; u++) {
+                RETURN_ERROR_IF(bs->rep[u] == 0, dictionary_corrupted);
+                RETURN_ERROR_IF(bs->rep[u] > dictContentSize, dictionary_corrupted);
+        }   }
+
+        bs->entropy.huf.repeatMode = HUF_repeat_valid;
+        bs->entropy.fse.offcode_repeatMode = FSE_repeat_valid;
+        bs->entropy.fse.matchlength_repeatMode = FSE_repeat_valid;
+        bs->entropy.fse.litlength_repeatMode = FSE_repeat_valid;
+        FORWARD_IF_ERROR(ZSTD_loadDictionaryContent(ms, params, dictPtr, dictContentSize, dtlm));
+        return dictID;
+    }
+}
+
+/** ZSTD_compress_insertDictionary() :
+*   @return : dictID, or an error code */
+static size_t
+ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
+                               ZSTD_matchState_t* ms,
+                         const ZSTD_CCtx_params* params,
+                         const void* dict, size_t dictSize,
+                               ZSTD_dictContentType_e dictContentType,
+                               ZSTD_dictTableLoadMethod_e dtlm,
+                               void* workspace)
+{
+    DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize);
+    if ((dict==NULL) || (dictSize<=8)) return 0;
+
+    ZSTD_reset_compressedBlockState(bs);
+
+    /* dict restricted modes */
+    if (dictContentType == ZSTD_dct_rawContent)
+        return ZSTD_loadDictionaryContent(ms, params, dict, dictSize, dtlm);
+
+    if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) {
+        if (dictContentType == ZSTD_dct_auto) {
+            DEBUGLOG(4, "raw content dictionary detected");
+            return ZSTD_loadDictionaryContent(ms, params, dict, dictSize, dtlm);
+        }
+        RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong);
+        assert(0);   /* impossible */
+    }
+
+    /* dict as full zstd dictionary */
+    return ZSTD_loadZstdDictionary(bs, ms, params, dict, dictSize, dtlm, workspace);
+}
+
+/*! ZSTD_compressBegin_internal() :
+ * @return : 0, or an error code */
+static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
+                                    const void* dict, size_t dictSize,
+                                    ZSTD_dictContentType_e dictContentType,
+                                    ZSTD_dictTableLoadMethod_e dtlm,
+                                    const ZSTD_CDict* cdict,
+                                    ZSTD_CCtx_params params, U64 pledgedSrcSize,
+                                    ZSTD_buffered_policy_e zbuff)
+{
+    DEBUGLOG(4, "ZSTD_compressBegin_internal: wlog=%u", params.cParams.windowLog);
+    /* params are supposed to be fully validated at this point */
+    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
+    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
+
+    if (cdict && cdict->dictContentSize>0) {
+        return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);
+    }
+
+    FORWARD_IF_ERROR( ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
+                                     ZSTDcrp_continue, zbuff) );
+    {   size_t const dictID = ZSTD_compress_insertDictionary(
+                cctx->blockState.prevCBlock, &cctx->blockState.matchState,
+                &params, dict, dictSize, dictContentType, dtlm, cctx->entropyWorkspace);
+        FORWARD_IF_ERROR(dictID);
+        assert(dictID <= UINT_MAX);
+        cctx->dictID = (U32)dictID;
+    }
+    return 0;
+}
+
+size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
+                                    const void* dict, size_t dictSize,
+                                    ZSTD_dictContentType_e dictContentType,
+                                    ZSTD_dictTableLoadMethod_e dtlm,
+                                    const ZSTD_CDict* cdict,
+                                    ZSTD_CCtx_params params,
+                                    unsigned long long pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params.cParams.windowLog);
+    /* compression parameters verification and optimization */
+    FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) );
+    return ZSTD_compressBegin_internal(cctx,
+                                       dict, dictSize, dictContentType, dtlm,
+                                       cdict,
+                                       params, pledgedSrcSize,
+                                       ZSTDb_not_buffered);
+}
+
+/*! ZSTD_compressBegin_advanced() :
+*   @return : 0, or an error code */
+size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
+                             const void* dict, size_t dictSize,
+                                   ZSTD_parameters params, unsigned long long pledgedSrcSize)
+{
+    ZSTD_CCtx_params const cctxParams =
+            ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
+    return ZSTD_compressBegin_advanced_internal(cctx,
+                                            dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast,
+                                            NULL /*cdict*/,
+                                            cctxParams, pledgedSrcSize);
+}
+
+size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
+{
+    ZSTD_parameters const params = ZSTD_getParams(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize);
+    ZSTD_CCtx_params const cctxParams =
+            ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
+    DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize);
+    return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
+                                       cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
+}
+
+size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
+{
+    return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel);
+}
+
+
+/*! ZSTD_writeEpilogue() :
+*   Ends a frame.
+*   @return : nb of bytes written into dst (or an error code) */
+static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
+{
+    BYTE* const ostart = (BYTE*)dst;
+    BYTE* op = ostart;
+    size_t fhSize = 0;
+
+    DEBUGLOG(4, "ZSTD_writeEpilogue");
+    RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing");
+
+    /* special case : empty frame */
+    if (cctx->stage == ZSTDcs_init) {
+        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams, 0, 0);
+        FORWARD_IF_ERROR(fhSize);
+        dstCapacity -= fhSize;
+        op += fhSize;
+        cctx->stage = ZSTDcs_ongoing;
+    }
+
+    if (cctx->stage != ZSTDcs_ending) {
+        /* write one last empty block, make it the "last" block */
+        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0;
+        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall);
+        MEM_writeLE32(op, cBlockHeader24);
+        op += ZSTD_blockHeaderSize;
+        dstCapacity -= ZSTD_blockHeaderSize;
+    }
+
+    if (cctx->appliedParams.fParams.checksumFlag) {
+        U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
+        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall);
+        DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum);
+        MEM_writeLE32(op, checksum);
+        op += 4;
+    }
+
+    cctx->stage = ZSTDcs_created;  /* return to "created but no init" status */
+    return op-ostart;
+}
+
+size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
+                         void* dst, size_t dstCapacity,
+                   const void* src, size_t srcSize)
+{
+    size_t endResult;
+    size_t const cSize = ZSTD_compressContinue_internal(cctx,
+                                dst, dstCapacity, src, srcSize,
+                                1 /* frame mode */, 1 /* last chunk */);
+    FORWARD_IF_ERROR(cSize);
+    endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
+    FORWARD_IF_ERROR(endResult);
+    assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
+    if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
+        ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
+        DEBUGLOG(4, "end of frame : controlling src size");
+        RETURN_ERROR_IF(
+            cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1,
+            srcSize_wrong,
+             "error : pledgedSrcSize = %u, while realSrcSize = %u",
+            (unsigned)cctx->pledgedSrcSizePlusOne-1,
+            (unsigned)cctx->consumedSrcSize);
+    }
+    return cSize + endResult;
+}
+
+
+static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx,
+                                      void* dst, size_t dstCapacity,
+                                const void* src, size_t srcSize,
+                                const void* dict,size_t dictSize,
+                                      ZSTD_parameters params)
+{
+    ZSTD_CCtx_params const cctxParams =
+            ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
+    DEBUGLOG(4, "ZSTD_compress_internal");
+    return ZSTD_compress_advanced_internal(cctx,
+                                           dst, dstCapacity,
+                                           src, srcSize,
+                                           dict, dictSize,
+                                           cctxParams);
+}
+
+size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
+                               void* dst, size_t dstCapacity,
+                         const void* src, size_t srcSize,
+                         const void* dict,size_t dictSize,
+                               ZSTD_parameters params)
+{
+    DEBUGLOG(4, "ZSTD_compress_advanced");
+    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams));
+    return ZSTD_compress_internal(cctx,
+                                  dst, dstCapacity,
+                                  src, srcSize,
+                                  dict, dictSize,
+                                  params);
+}
+
+/* Internal */
+size_t ZSTD_compress_advanced_internal(
+        ZSTD_CCtx* cctx,
+        void* dst, size_t dstCapacity,
+        const void* src, size_t srcSize,
+        const void* dict,size_t dictSize,
+        ZSTD_CCtx_params params)
+{
+    DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
+    FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
+                         dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
+                         params, srcSize, ZSTDb_not_buffered) );
+    return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
+}
+
+size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
+                               void* dst, size_t dstCapacity,
+                         const void* src, size_t srcSize,
+                         const void* dict, size_t dictSize,
+                               int compressionLevel)
+{
+    ZSTD_parameters const params = ZSTD_getParams(compressionLevel, srcSize + (!srcSize), dict ? dictSize : 0);
+    ZSTD_CCtx_params cctxParams = ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
+    assert(params.fParams.contentSizeFlag == 1);
+    return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, cctxParams);
+}
+
+size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
+                         void* dst, size_t dstCapacity,
+                   const void* src, size_t srcSize,
+                         int compressionLevel)
+{
+    DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (unsigned)srcSize);
+    assert(cctx != NULL);
+    return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
+}
+
+size_t ZSTD_compress(void* dst, size_t dstCapacity,
+               const void* src, size_t srcSize,
+                     int compressionLevel)
+{
+    size_t result;
+    ZSTD_CCtx ctxBody;
+    ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);
+    result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);
+    ZSTD_freeCCtxContent(&ctxBody);   /* can't free ctxBody itself, as it's on stack; free only heap content */
+    return result;
+}
+
+
+/* =====  Dictionary API  ===== */
+
+/*! ZSTD_estimateCDictSize_advanced() :
+ *  Estimate amount of memory that will be needed to create a dictionary with following arguments */
+size_t ZSTD_estimateCDictSize_advanced(
+        size_t dictSize, ZSTD_compressionParameters cParams,
+        ZSTD_dictLoadMethod_e dictLoadMethod)
+{
+    DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
+    return sizeof(ZSTD_CDict) + HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0)
+           + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
+}
+
+size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
+{
+    ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
+    return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy);
+}
+
+size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict)
+{
+    if (cdict==NULL) return 0;   /* support sizeof on NULL */
+    DEBUGLOG(5, "sizeof(*cdict) : %u", (unsigned)sizeof(*cdict));
+    return cdict->workspaceSize + (cdict->dictBuffer ? cdict->dictContentSize : 0) + sizeof(*cdict);
+}
+
+static size_t ZSTD_initCDict_internal(
+                    ZSTD_CDict* cdict,
+              const void* dictBuffer, size_t dictSize,
+                    ZSTD_dictLoadMethod_e dictLoadMethod,
+                    ZSTD_dictContentType_e dictContentType,
+                    ZSTD_compressionParameters cParams)
+{
+    DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (unsigned)dictContentType);
+    assert(!ZSTD_checkCParams(cParams));
+    cdict->matchState.cParams = cParams;
+    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {
+        cdict->dictBuffer = NULL;
+        cdict->dictContent = dictBuffer;
+    } else {
+        void* const internalBuffer = ZSTD_malloc(dictSize, cdict->customMem);
+        cdict->dictBuffer = internalBuffer;
+        cdict->dictContent = internalBuffer;
+        RETURN_ERROR_IF(!internalBuffer, memory_allocation);
+        memcpy(internalBuffer, dictBuffer, dictSize);
+    }
+    cdict->dictContentSize = dictSize;
+
+    /* Reset the state to no dictionary */
+    ZSTD_reset_compressedBlockState(&cdict->cBlockState);
+    {   void* const end = ZSTD_reset_matchState(&cdict->matchState,
+                            (U32*)cdict->workspace + HUF_WORKSPACE_SIZE_U32,
+                            &cParams,
+                             ZSTDcrp_continue, ZSTD_resetTarget_CDict);
+        assert(end == (char*)cdict->workspace + cdict->workspaceSize);
+        (void)end;
+    }
+    /* (Maybe) load the dictionary
+     * Skips loading the dictionary if it is <= 8 bytes.
+     */
+    {   ZSTD_CCtx_params params;
+        memset(&params, 0, sizeof(params));
+        params.compressionLevel = ZSTD_CLEVEL_DEFAULT;
+        params.fParams.contentSizeFlag = 1;
+        params.cParams = cParams;
+        {   size_t const dictID = ZSTD_compress_insertDictionary(
+                    &cdict->cBlockState, &cdict->matchState, &params,
+                    cdict->dictContent, cdict->dictContentSize,
+                    dictContentType, ZSTD_dtlm_full, cdict->workspace);
+            FORWARD_IF_ERROR(dictID);
+            assert(dictID <= (size_t)(U32)-1);
+            cdict->dictID = (U32)dictID;
+        }
+    }
+
+    return 0;
+}
+
+ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
+                                      ZSTD_dictLoadMethod_e dictLoadMethod,
+                                      ZSTD_dictContentType_e dictContentType,
+                                      ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
+{
+    DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (unsigned)dictContentType);
+    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
+
+    {   ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
+        size_t const workspaceSize = HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0);
+        void* const workspace = ZSTD_malloc(workspaceSize, customMem);
+
+        if (!cdict || !workspace) {
+            ZSTD_free(cdict, customMem);
+            ZSTD_free(workspace, customMem);
+            return NULL;
+        }
+        cdict->customMem = customMem;
+        cdict->workspace = workspace;
+        cdict->workspaceSize = workspaceSize;
+        if (ZSTD_isError( ZSTD_initCDict_internal(cdict,
+                                        dictBuffer, dictSize,
+                                        dictLoadMethod, dictContentType,
+                                        cParams) )) {
+            ZSTD_freeCDict(cdict);
+            return NULL;
+        }
+
+        return cdict;
+    }
+}
+
+ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel)
+{
+    ZSTD_compressionParameters cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
+    return ZSTD_createCDict_advanced(dict, dictSize,
+                                     ZSTD_dlm_byCopy, ZSTD_dct_auto,
+                                     cParams, ZSTD_defaultCMem);
+}
+
+ZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int compressionLevel)
+{
+    ZSTD_compressionParameters cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
+    return ZSTD_createCDict_advanced(dict, dictSize,
+                                     ZSTD_dlm_byRef, ZSTD_dct_auto,
+                                     cParams, ZSTD_defaultCMem);
+}
+
+size_t ZSTD_freeCDict(ZSTD_CDict* cdict)
+{
+    if (cdict==NULL) return 0;   /* support free on NULL */
+    {   ZSTD_customMem const cMem = cdict->customMem;
+        ZSTD_free(cdict->workspace, cMem);
+        ZSTD_free(cdict->dictBuffer, cMem);
+        ZSTD_free(cdict, cMem);
+        return 0;
+    }
+}
+
+/*! ZSTD_initStaticCDict_advanced() :
+ *  Generate a digested dictionary in provided memory area.
+ *  workspace: The memory area to emplace the dictionary into.
+ *             Provided pointer must 8-bytes aligned.
+ *             It must outlive dictionary usage.
+ *  workspaceSize: Use ZSTD_estimateCDictSize()
+ *                 to determine how large workspace must be.
+ *  cParams : use ZSTD_getCParams() to transform a compression level
+ *            into its relevants cParams.
+ * @return : pointer to ZSTD_CDict*, or NULL if error (size too small)
+ *  Note : there is no corresponding "free" function.
+ *         Since workspace was allocated externally, it must be freed externally.
+ */
+const ZSTD_CDict* ZSTD_initStaticCDict(
+                                 void* workspace, size_t workspaceSize,
+                           const void* dict, size_t dictSize,
+                                 ZSTD_dictLoadMethod_e dictLoadMethod,
+                                 ZSTD_dictContentType_e dictContentType,
+                                 ZSTD_compressionParameters cParams)
+{
+    size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0);
+    size_t const neededSize = sizeof(ZSTD_CDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize)
+                            + HUF_WORKSPACE_SIZE + matchStateSize;
+    ZSTD_CDict* const cdict = (ZSTD_CDict*) workspace;
+    void* ptr;
+    if ((size_t)workspace & 7) return NULL;  /* 8-aligned */
+    DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u",
+        (unsigned)workspaceSize, (unsigned)neededSize, (unsigned)(workspaceSize < neededSize));
+    if (workspaceSize < neededSize) return NULL;
+
+    if (dictLoadMethod == ZSTD_dlm_byCopy) {
+        memcpy(cdict+1, dict, dictSize);
+        dict = cdict+1;
+        ptr = (char*)workspace + sizeof(ZSTD_CDict) + dictSize;
+    } else {
+        ptr = cdict+1;
+    }
+    cdict->workspace = ptr;
+    cdict->workspaceSize = HUF_WORKSPACE_SIZE + matchStateSize;
+
+    if (ZSTD_isError( ZSTD_initCDict_internal(cdict,
+                                              dict, dictSize,
+                                              ZSTD_dlm_byRef, dictContentType,
+                                              cParams) ))
+        return NULL;
+
+    return cdict;
+}
+
+ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict)
+{
+    assert(cdict != NULL);
+    return cdict->matchState.cParams;
+}
+
+/* ZSTD_compressBegin_usingCDict_advanced() :
+ * cdict must be != NULL */
+size_t ZSTD_compressBegin_usingCDict_advanced(
+    ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,
+    ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced");
+    RETURN_ERROR_IF(cdict==NULL, dictionary_wrong);
+    {   ZSTD_CCtx_params params = cctx->requestedParams;
+        params.cParams = ZSTD_getCParamsFromCDict(cdict);
+        /* Increase window log to fit the entire dictionary and source if the
+         * source size is known. Limit the increase to 19, which is the
+         * window log for compression level 1 with the largest source size.
+         */
+        if (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
+            U32 const limitedSrcSize = (U32)MIN(pledgedSrcSize, 1U << 19);
+            U32 const limitedSrcLog = limitedSrcSize > 1 ? ZSTD_highbit32(limitedSrcSize - 1) + 1 : 1;
+            params.cParams.windowLog = MAX(params.cParams.windowLog, limitedSrcLog);
+        }
+        params.fParams = fParams;
+        return ZSTD_compressBegin_internal(cctx,
+                                           NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast,
+                                           cdict,
+                                           params, pledgedSrcSize,
+                                           ZSTDb_not_buffered);
+    }
+}
+
+/* ZSTD_compressBegin_usingCDict() :
+ * pledgedSrcSize=0 means "unknown"
+ * if pledgedSrcSize>0, it will enable contentSizeFlag */
+size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
+{
+    ZSTD_frameParameters const fParams = { 0 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
+    DEBUGLOG(4, "ZSTD_compressBegin_usingCDict : dictIDFlag == %u", !fParams.noDictIDFlag);
+    return ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN);
+}
+
+size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
+                                void* dst, size_t dstCapacity,
+                                const void* src, size_t srcSize,
+                                const ZSTD_CDict* cdict, ZSTD_frameParameters fParams)
+{
+    FORWARD_IF_ERROR(ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, srcSize));   /* will check if cdict != NULL */
+    return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
+}
+
+/*! ZSTD_compress_usingCDict() :
+ *  Compression using a digested Dictionary.
+ *  Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times.
+ *  Note that compression parameters are decided at CDict creation time
+ *  while frame parameters are hardcoded */
+size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
+                                void* dst, size_t dstCapacity,
+                                const void* src, size_t srcSize,
+                                const ZSTD_CDict* cdict)
+{
+    ZSTD_frameParameters const fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
+    return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
+}
+
+
+
+/* ******************************************************************
+*  Streaming
+********************************************************************/
+
+ZSTD_CStream* ZSTD_createCStream(void)
+{
+    DEBUGLOG(3, "ZSTD_createCStream");
+    return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
+}
+
+ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)
+{
+    return ZSTD_initStaticCCtx(workspace, workspaceSize);
+}
+
+ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)
+{   /* CStream and CCtx are now same object */
+    return ZSTD_createCCtx_advanced(customMem);
+}
+
+size_t ZSTD_freeCStream(ZSTD_CStream* zcs)
+{
+    return ZSTD_freeCCtx(zcs);   /* same object */
+}
+
+
+
+/*======   Initialization   ======*/
+
+size_t ZSTD_CStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }
+
+size_t ZSTD_CStreamOutSize(void)
+{
+    return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + 4 /* 32-bits hash */ ;
+}
+
+static size_t ZSTD_resetCStream_internal(ZSTD_CStream* cctx,
+                    const void* const dict, size_t const dictSize, ZSTD_dictContentType_e const dictContentType,
+                    const ZSTD_CDict* const cdict,
+                    ZSTD_CCtx_params params, unsigned long long const pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTD_resetCStream_internal");
+    /* Finalize the compression parameters */
+    params.cParams = ZSTD_getCParamsFromCCtxParams(&params, pledgedSrcSize, dictSize);
+    /* params are supposed to be fully validated at this point */
+    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
+    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
+
+    FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
+                                         dict, dictSize, dictContentType, ZSTD_dtlm_fast,
+                                         cdict,
+                                         params, pledgedSrcSize,
+                                         ZSTDb_buffered) );
+
+    cctx->inToCompress = 0;
+    cctx->inBuffPos = 0;
+    cctx->inBuffTarget = cctx->blockSize
+                      + (cctx->blockSize == pledgedSrcSize);   /* for small input: avoid automatic flush on reaching end of block, since it would require to add a 3-bytes null block to end frame */
+    cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0;
+    cctx->streamStage = zcss_load;
+    cctx->frameEnded = 0;
+    return 0;   /* ready to go */
+}
+
+/* ZSTD_resetCStream():
+ * pledgedSrcSize == 0 means "unknown" */
+size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
+{
+    /* temporary : 0 interpreted as "unknown" during transition period.
+     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
+     * 0 will be interpreted as "empty" in the future.
+     */
+    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
+    DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
+    return 0;
+}
+
+/*! ZSTD_initCStream_internal() :
+ *  Note : for lib/compress only. Used by zstdmt_compress.c.
+ *  Assumption 1 : params are valid
+ *  Assumption 2 : either dict, or cdict, is defined, not both */
+size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
+                    const void* dict, size_t dictSize, const ZSTD_CDict* cdict,
+                    ZSTD_CCtx_params params, unsigned long long pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTD_initCStream_internal");
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
+    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
+    zcs->requestedParams = params;
+    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
+    if (dict) {
+        FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) );
+    } else {
+        /* Dictionary is cleared if !cdict */
+        FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) );
+    }
+    return 0;
+}
+
+/* ZSTD_initCStream_usingCDict_advanced() :
+ * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
+size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
+                                            const ZSTD_CDict* cdict,
+                                            ZSTD_frameParameters fParams,
+                                            unsigned long long pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
+    zcs->requestedParams.fParams = fParams;
+    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) );
+    return 0;
+}
+
+/* note : cdict must outlive compression session */
+size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
+{
+    DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) );
+    return 0;
+}
+
+
+/* ZSTD_initCStream_advanced() :
+ * pledgedSrcSize must be exact.
+ * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
+ * dict is loaded with default parameters ZSTD_dm_auto and ZSTD_dlm_byCopy. */
+size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
+                                 const void* dict, size_t dictSize,
+                                 ZSTD_parameters params, unsigned long long pss)
+{
+    /* for compatibility with older programs relying on this behavior.
+     * Users should now specify ZSTD_CONTENTSIZE_UNKNOWN.
+     * This line will be removed in the future.
+     */
+    U64 const pledgedSrcSize = (pss==0 && params.fParams.contentSizeFlag==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
+    DEBUGLOG(4, "ZSTD_initCStream_advanced");
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
+    FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) );
+    zcs->requestedParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
+    FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) );
+    return 0;
+}
+
+size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
+{
+    DEBUGLOG(4, "ZSTD_initCStream_usingDict");
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) );
+    return 0;
+}
+
+size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
+{
+    /* temporary : 0 interpreted as "unknown" during transition period.
+     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
+     * 0 will be interpreted as "empty" in the future.
+     */
+    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
+    DEBUGLOG(4, "ZSTD_initCStream_srcSize");
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
+    return 0;
+}
+
+size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
+{
+    DEBUGLOG(4, "ZSTD_initCStream");
+    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) );
+    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) );
+    return 0;
+}
+
+/*======   Compression   ======*/
+
+static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx)
+{
+    size_t hintInSize = cctx->inBuffTarget - cctx->inBuffPos;
+    if (hintInSize==0) hintInSize = cctx->blockSize;
+    return hintInSize;
+}
+
+static size_t ZSTD_limitCopy(void* dst, size_t dstCapacity,
+                       const void* src, size_t srcSize)
+{
+    size_t const length = MIN(dstCapacity, srcSize);
+    if (length) memcpy(dst, src, length);
+    return length;
+}
+
+/** ZSTD_compressStream_generic():
+ *  internal function for all *compressStream*() variants
+ *  non-static, because can be called from zstdmt_compress.c
+ * @return : hint size for next input */
+static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
+                                          ZSTD_outBuffer* output,
+                                          ZSTD_inBuffer* input,
+                                          ZSTD_EndDirective const flushMode)
+{
+    const char* const istart = (const char*)input->src;
+    const char* const iend = istart + input->size;
+    const char* ip = istart + input->pos;
+    char* const ostart = (char*)output->dst;
+    char* const oend = ostart + output->size;
+    char* op = ostart + output->pos;
+    U32 someMoreWork = 1;
+
+    /* check expectations */
+    DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode);
+    assert(zcs->inBuff != NULL);
+    assert(zcs->inBuffSize > 0);
+    assert(zcs->outBuff !=  NULL);
+    assert(zcs->outBuffSize > 0);
+    assert(output->pos <= output->size);
+    assert(input->pos <= input->size);
+
+    while (someMoreWork) {
+        switch(zcs->streamStage)
+        {
+        case zcss_init:
+            RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
+
+        case zcss_load:
+            if ( (flushMode == ZSTD_e_end)
+              && ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip))  /* enough dstCapacity */
+              && (zcs->inBuffPos == 0) ) {
+                /* shortcut to compression pass directly into output buffer */
+                size_t const cSize = ZSTD_compressEnd(zcs,
+                                                op, oend-op, ip, iend-ip);
+                DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
+                FORWARD_IF_ERROR(cSize);
+                ip = iend;
+                op += cSize;
+                zcs->frameEnded = 1;
+                ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+                someMoreWork = 0; break;
+            }
+            /* complete loading into inBuffer */
+            {   size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
+                size_t const loaded = ZSTD_limitCopy(
+                                        zcs->inBuff + zcs->inBuffPos, toLoad,
+                                        ip, iend-ip);
+                zcs->inBuffPos += loaded;
+                ip += loaded;
+                if ( (flushMode == ZSTD_e_continue)
+                  && (zcs->inBuffPos < zcs->inBuffTarget) ) {
+                    /* not enough input to fill full block : stop here */
+                    someMoreWork = 0; break;
+                }
+                if ( (flushMode == ZSTD_e_flush)
+                  && (zcs->inBuffPos == zcs->inToCompress) ) {
+                    /* empty */
+                    someMoreWork = 0; break;
+                }
+            }
+            /* compress current block (note : this stage cannot be stopped in the middle) */
+            DEBUGLOG(5, "stream compression stage (flushMode==%u)", flushMode);
+            {   void* cDst;
+                size_t cSize;
+                size_t const iSize = zcs->inBuffPos - zcs->inToCompress;
+                size_t oSize = oend-op;
+                unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend);
+                if (oSize >= ZSTD_compressBound(iSize))
+                    cDst = op;   /* compress into output buffer, to skip flush stage */
+                else
+                    cDst = zcs->outBuff, oSize = zcs->outBuffSize;
+                cSize = lastBlock ?
+                        ZSTD_compressEnd(zcs, cDst, oSize,
+                                    zcs->inBuff + zcs->inToCompress, iSize) :
+                        ZSTD_compressContinue(zcs, cDst, oSize,
+                                    zcs->inBuff + zcs->inToCompress, iSize);
+                FORWARD_IF_ERROR(cSize);
+                zcs->frameEnded = lastBlock;
+                /* prepare next block */
+                zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
+                if (zcs->inBuffTarget > zcs->inBuffSize)
+                    zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize;
+                DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u",
+                         (unsigned)zcs->inBuffTarget, (unsigned)zcs->inBuffSize);
+                if (!lastBlock)
+                    assert(zcs->inBuffTarget <= zcs->inBuffSize);
+                zcs->inToCompress = zcs->inBuffPos;
+                if (cDst == op) {  /* no need to flush */
+                    op += cSize;
+                    if (zcs->frameEnded) {
+                        DEBUGLOG(5, "Frame completed directly in outBuffer");
+                        someMoreWork = 0;
+                        ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+                    }
+                    break;
+                }
+                zcs->outBuffContentSize = cSize;
+                zcs->outBuffFlushedSize = 0;
+                zcs->streamStage = zcss_flush; /* pass-through to flush stage */
+            }
+	    /* fall-through */
+        case zcss_flush:
+            DEBUGLOG(5, "flush stage");
+            {   size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
+                size_t const flushed = ZSTD_limitCopy(op, (size_t)(oend-op),
+                            zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
+                DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
+                            (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);
+                op += flushed;
+                zcs->outBuffFlushedSize += flushed;
+                if (toFlush!=flushed) {
+                    /* flush not fully completed, presumably because dst is too small */
+                    assert(op==oend);
+                    someMoreWork = 0;
+                    break;
+                }
+                zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
+                if (zcs->frameEnded) {
+                    DEBUGLOG(5, "Frame completed on flush");
+                    someMoreWork = 0;
+                    ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+                    break;
+                }
+                zcs->streamStage = zcss_load;
+                break;
+            }
+
+        default: /* impossible */
+            assert(0);
+        }
+    }
+
+    input->pos = ip - istart;
+    output->pos = op - ostart;
+    if (zcs->frameEnded) return 0;
+    return ZSTD_nextInputSizeHint(zcs);
+}
+
+static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx)
+{
+#ifdef ZSTD_MULTITHREAD
+    if (cctx->appliedParams.nbWorkers >= 1) {
+        assert(cctx->mtctx != NULL);
+        return ZSTDMT_nextInputSizeHint(cctx->mtctx);
+    }
+#endif
+    return ZSTD_nextInputSizeHint(cctx);
+
+}
+
+size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
+{
+    FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) );
+    return ZSTD_nextInputSizeHint_MTorST(zcs);
+}
+
+
+size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
+                             ZSTD_outBuffer* output,
+                             ZSTD_inBuffer* input,
+                             ZSTD_EndDirective endOp)
+{
+    DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
+    /* check conditions */
+    RETURN_ERROR_IF(output->pos > output->size, GENERIC);
+    RETURN_ERROR_IF(input->pos  > input->size, GENERIC);
+    assert(cctx!=NULL);
+
+    /* transparent initialization stage */
+    if (cctx->streamStage == zcss_init) {
+        ZSTD_CCtx_params params = cctx->requestedParams;
+        ZSTD_prefixDict const prefixDict = cctx->prefixDict;
+        FORWARD_IF_ERROR( ZSTD_initLocalDict(cctx) ); /* Init the local dict if present. */
+        memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));   /* single usage */
+        assert(prefixDict.dict==NULL || cctx->cdict==NULL);    /* only one can be set */
+        DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
+        if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1;  /* auto-fix pledgedSrcSize */
+        params.cParams = ZSTD_getCParamsFromCCtxParams(
+                &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);
+
+
+#ifdef ZSTD_MULTITHREAD
+        if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) {
+            params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */
+        }
+        if (params.nbWorkers > 0) {
+            /* mt context creation */
+            if (cctx->mtctx == NULL) {
+                DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
+                            params.nbWorkers);
+                cctx->mtctx = ZSTDMT_createCCtx_advanced(params.nbWorkers, cctx->customMem);
+                RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation);
+            }
+            /* mt compression */
+            DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
+            FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
+                        cctx->mtctx,
+                        prefixDict.dict, prefixDict.dictSize, ZSTD_dct_rawContent,
+                        cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) );
+            cctx->streamStage = zcss_load;
+            cctx->appliedParams.nbWorkers = params.nbWorkers;
+        } else
+#endif
+        {   FORWARD_IF_ERROR( ZSTD_resetCStream_internal(cctx,
+                            prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
+                            cctx->cdict,
+                            params, cctx->pledgedSrcSizePlusOne-1) );
+            assert(cctx->streamStage == zcss_load);
+            assert(cctx->appliedParams.nbWorkers == 0);
+    }   }
+    /* end of transparent initialization stage */
+
+    /* compression stage */
+#ifdef ZSTD_MULTITHREAD
+    if (cctx->appliedParams.nbWorkers > 0) {
+        int const forceMaxProgress = (endOp == ZSTD_e_flush || endOp == ZSTD_e_end);
+        size_t flushMin;
+        assert(forceMaxProgress || endOp == ZSTD_e_continue /* Protection for a new flush type */);
+        if (cctx->cParamsChanged) {
+            ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);
+            cctx->cParamsChanged = 0;
+        }
+        do {
+            flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
+            if ( ZSTD_isError(flushMin)
+              || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
+                ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
+            }
+            FORWARD_IF_ERROR(flushMin);
+        } while (forceMaxProgress && flushMin != 0 && output->pos < output->size);
+        DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
+        /* Either we don't require maximum forward progress, we've finished the
+         * flush, or we are out of output space.
+         */
+        assert(!forceMaxProgress || flushMin == 0 || output->pos == output->size);
+        return flushMin;
+    }
+#endif
+    FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) );
+    DEBUGLOG(5, "completed ZSTD_compressStream2");
+    return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */
+}
+
+size_t ZSTD_compressStream2_simpleArgs (
+                            ZSTD_CCtx* cctx,
+                            void* dst, size_t dstCapacity, size_t* dstPos,
+                      const void* src, size_t srcSize, size_t* srcPos,
+                            ZSTD_EndDirective endOp)
+{
+    ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
+    ZSTD_inBuffer  input  = { src, srcSize, *srcPos };
+    /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
+    size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
+    *dstPos = output.pos;
+    *srcPos = input.pos;
+    return cErr;
+}
+
+size_t ZSTD_compress2(ZSTD_CCtx* cctx,
+                      void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{
+    ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
+    {   size_t oPos = 0;
+        size_t iPos = 0;
+        size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
+                                        dst, dstCapacity, &oPos,
+                                        src, srcSize, &iPos,
+                                        ZSTD_e_end);
+        FORWARD_IF_ERROR(result);
+        if (result != 0) {  /* compression not completed, due to lack of output space */
+            assert(oPos == dstCapacity);
+            RETURN_ERROR(dstSize_tooSmall);
+        }
+        assert(iPos == srcSize);   /* all input is expected consumed */
+        return oPos;
+    }
+}
+
+/*======   Finalize   ======*/
+
+/*! ZSTD_flushStream() :
+ * @return : amount of data remaining to flush */
+size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
+{
+    ZSTD_inBuffer input = { NULL, 0, 0 };
+    return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
+}
+
+
+size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
+{
+    ZSTD_inBuffer input = { NULL, 0, 0 };
+    size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
+    FORWARD_IF_ERROR( remainingToFlush );
+    if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush;   /* minimal estimation */
+    /* single thread mode : attempt to calculate remaining to flush more precisely */
+    {   size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;
+        size_t const checksumSize = (size_t)(zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4);
+        size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize;
+        DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
+        return toFlush;
+    }
+}
+
+
+/*-=====  Pre-defined compression levels  =====-*/
+
+#define ZSTD_MAX_CLEVEL     22
+int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
+int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
+
+static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {
+{   /* "default" - for any srcSize > 256 KB */
+    /* W,  C,  H,  S,  L, TL, strat */
+    { 19, 12, 13,  1,  6,  1, ZSTD_fast    },  /* base for negative levels */
+    { 19, 13, 14,  1,  7,  0, ZSTD_fast    },  /* level  1 */
+    { 20, 15, 16,  1,  6,  0, ZSTD_fast    },  /* level  2 */
+    { 21, 16, 17,  1,  5,  1, ZSTD_dfast   },  /* level  3 */
+    { 21, 18, 18,  1,  5,  1, ZSTD_dfast   },  /* level  4 */
+    { 21, 18, 19,  2,  5,  2, ZSTD_greedy  },  /* level  5 */
+    { 21, 19, 19,  3,  5,  4, ZSTD_greedy  },  /* level  6 */
+    { 21, 19, 19,  3,  5,  8, ZSTD_lazy    },  /* level  7 */
+    { 21, 19, 19,  3,  5, 16, ZSTD_lazy2   },  /* level  8 */
+    { 21, 19, 20,  4,  5, 16, ZSTD_lazy2   },  /* level  9 */
+    { 22, 20, 21,  4,  5, 16, ZSTD_lazy2   },  /* level 10 */
+    { 22, 21, 22,  4,  5, 16, ZSTD_lazy2   },  /* level 11 */
+    { 22, 21, 22,  5,  5, 16, ZSTD_lazy2   },  /* level 12 */
+    { 22, 21, 22,  5,  5, 32, ZSTD_btlazy2 },  /* level 13 */
+    { 22, 22, 23,  5,  5, 32, ZSTD_btlazy2 },  /* level 14 */
+    { 22, 23, 23,  6,  5, 32, ZSTD_btlazy2 },  /* level 15 */
+    { 22, 22, 22,  5,  5, 48, ZSTD_btopt   },  /* level 16 */
+    { 23, 23, 22,  5,  4, 64, ZSTD_btopt   },  /* level 17 */
+    { 23, 23, 22,  6,  3, 64, ZSTD_btultra },  /* level 18 */
+    { 23, 24, 22,  7,  3,256, ZSTD_btultra2},  /* level 19 */
+    { 25, 25, 23,  7,  3,256, ZSTD_btultra2},  /* level 20 */
+    { 26, 26, 24,  7,  3,512, ZSTD_btultra2},  /* level 21 */
+    { 27, 27, 25,  9,  3,999, ZSTD_btultra2},  /* level 22 */
+},
+{   /* for srcSize <= 256 KB */
+    /* W,  C,  H,  S,  L,  T, strat */
+    { 18, 12, 13,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */
+    { 18, 13, 14,  1,  6,  0, ZSTD_fast    },  /* level  1 */
+    { 18, 14, 14,  1,  5,  1, ZSTD_dfast   },  /* level  2 */
+    { 18, 16, 16,  1,  4,  1, ZSTD_dfast   },  /* level  3 */
+    { 18, 16, 17,  2,  5,  2, ZSTD_greedy  },  /* level  4.*/
+    { 18, 18, 18,  3,  5,  2, ZSTD_greedy  },  /* level  5.*/
+    { 18, 18, 19,  3,  5,  4, ZSTD_lazy    },  /* level  6.*/
+    { 18, 18, 19,  4,  4,  4, ZSTD_lazy    },  /* level  7 */
+    { 18, 18, 19,  4,  4,  8, ZSTD_lazy2   },  /* level  8 */
+    { 18, 18, 19,  5,  4,  8, ZSTD_lazy2   },  /* level  9 */
+    { 18, 18, 19,  6,  4,  8, ZSTD_lazy2   },  /* level 10 */
+    { 18, 18, 19,  5,  4, 12, ZSTD_btlazy2 },  /* level 11.*/
+    { 18, 19, 19,  7,  4, 12, ZSTD_btlazy2 },  /* level 12.*/
+    { 18, 18, 19,  4,  4, 16, ZSTD_btopt   },  /* level 13 */
+    { 18, 18, 19,  4,  3, 32, ZSTD_btopt   },  /* level 14.*/
+    { 18, 18, 19,  6,  3,128, ZSTD_btopt   },  /* level 15.*/
+    { 18, 19, 19,  6,  3,128, ZSTD_btultra },  /* level 16.*/
+    { 18, 19, 19,  8,  3,256, ZSTD_btultra },  /* level 17.*/
+    { 18, 19, 19,  6,  3,128, ZSTD_btultra2},  /* level 18.*/
+    { 18, 19, 19,  8,  3,256, ZSTD_btultra2},  /* level 19.*/
+    { 18, 19, 19, 10,  3,512, ZSTD_btultra2},  /* level 20.*/
+    { 18, 19, 19, 12,  3,512, ZSTD_btultra2},  /* level 21.*/
+    { 18, 19, 19, 13,  3,999, ZSTD_btultra2},  /* level 22.*/
+},
+{   /* for srcSize <= 128 KB */
+    /* W,  C,  H,  S,  L,  T, strat */
+    { 17, 12, 12,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */
+    { 17, 12, 13,  1,  6,  0, ZSTD_fast    },  /* level  1 */
+    { 17, 13, 15,  1,  5,  0, ZSTD_fast    },  /* level  2 */
+    { 17, 15, 16,  2,  5,  1, ZSTD_dfast   },  /* level  3 */
+    { 17, 17, 17,  2,  4,  1, ZSTD_dfast   },  /* level  4 */
+    { 17, 16, 17,  3,  4,  2, ZSTD_greedy  },  /* level  5 */
+    { 17, 17, 17,  3,  4,  4, ZSTD_lazy    },  /* level  6 */
+    { 17, 17, 17,  3,  4,  8, ZSTD_lazy2   },  /* level  7 */
+    { 17, 17, 17,  4,  4,  8, ZSTD_lazy2   },  /* level  8 */
+    { 17, 17, 17,  5,  4,  8, ZSTD_lazy2   },  /* level  9 */
+    { 17, 17, 17,  6,  4,  8, ZSTD_lazy2   },  /* level 10 */
+    { 17, 17, 17,  5,  4,  8, ZSTD_btlazy2 },  /* level 11 */
+    { 17, 18, 17,  7,  4, 12, ZSTD_btlazy2 },  /* level 12 */
+    { 17, 18, 17,  3,  4, 12, ZSTD_btopt   },  /* level 13.*/
+    { 17, 18, 17,  4,  3, 32, ZSTD_btopt   },  /* level 14.*/
+    { 17, 18, 17,  6,  3,256, ZSTD_btopt   },  /* level 15.*/
+    { 17, 18, 17,  6,  3,128, ZSTD_btultra },  /* level 16.*/
+    { 17, 18, 17,  8,  3,256, ZSTD_btultra },  /* level 17.*/
+    { 17, 18, 17, 10,  3,512, ZSTD_btultra },  /* level 18.*/
+    { 17, 18, 17,  5,  3,256, ZSTD_btultra2},  /* level 19.*/
+    { 17, 18, 17,  7,  3,512, ZSTD_btultra2},  /* level 20.*/
+    { 17, 18, 17,  9,  3,512, ZSTD_btultra2},  /* level 21.*/
+    { 17, 18, 17, 11,  3,999, ZSTD_btultra2},  /* level 22.*/
+},
+{   /* for srcSize <= 16 KB */
+    /* W,  C,  H,  S,  L,  T, strat */
+    { 14, 12, 13,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */
+    { 14, 14, 15,  1,  5,  0, ZSTD_fast    },  /* level  1 */
+    { 14, 14, 15,  1,  4,  0, ZSTD_fast    },  /* level  2 */
+    { 14, 14, 15,  2,  4,  1, ZSTD_dfast   },  /* level  3 */
+    { 14, 14, 14,  4,  4,  2, ZSTD_greedy  },  /* level  4 */
+    { 14, 14, 14,  3,  4,  4, ZSTD_lazy    },  /* level  5.*/
+    { 14, 14, 14,  4,  4,  8, ZSTD_lazy2   },  /* level  6 */
+    { 14, 14, 14,  6,  4,  8, ZSTD_lazy2   },  /* level  7 */
+    { 14, 14, 14,  8,  4,  8, ZSTD_lazy2   },  /* level  8.*/
+    { 14, 15, 14,  5,  4,  8, ZSTD_btlazy2 },  /* level  9.*/
+    { 14, 15, 14,  9,  4,  8, ZSTD_btlazy2 },  /* level 10.*/
+    { 14, 15, 14,  3,  4, 12, ZSTD_btopt   },  /* level 11.*/
+    { 14, 15, 14,  4,  3, 24, ZSTD_btopt   },  /* level 12.*/
+    { 14, 15, 14,  5,  3, 32, ZSTD_btultra },  /* level 13.*/
+    { 14, 15, 15,  6,  3, 64, ZSTD_btultra },  /* level 14.*/
+    { 14, 15, 15,  7,  3,256, ZSTD_btultra },  /* level 15.*/
+    { 14, 15, 15,  5,  3, 48, ZSTD_btultra2},  /* level 16.*/
+    { 14, 15, 15,  6,  3,128, ZSTD_btultra2},  /* level 17.*/
+    { 14, 15, 15,  7,  3,256, ZSTD_btultra2},  /* level 18.*/
+    { 14, 15, 15,  8,  3,256, ZSTD_btultra2},  /* level 19.*/
+    { 14, 15, 15,  8,  3,512, ZSTD_btultra2},  /* level 20.*/
+    { 14, 15, 15,  9,  3,512, ZSTD_btultra2},  /* level 21.*/
+    { 14, 15, 15, 10,  3,999, ZSTD_btultra2},  /* level 22.*/
+},
+};
+
+/*! ZSTD_getCParams() :
+ * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
+ *  Size values are optional, provide 0 if not known or unused */
+ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
+{
+    size_t const addedSize = srcSizeHint ? 0 : 500;
+    U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : ZSTD_CONTENTSIZE_UNKNOWN;  /* intentional overflow for srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN */
+    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
+    int row = compressionLevel;
+    DEBUGLOG(5, "ZSTD_getCParams (cLevel=%i)", compressionLevel);
+    if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT;   /* 0 == default */
+    if (compressionLevel < 0) row = 0;   /* entry 0 is baseline for fast mode */
+    if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
+    {   ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
+        if (compressionLevel < 0) cp.targetLength = (unsigned)(-compressionLevel);   /* acceleration factor */
+        return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize);               /* refine parameters based on srcSize & dictSize */
+    }
+}
+
+/*! ZSTD_getParams() :
+ *  same idea as ZSTD_getCParams()
+ * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
+ *  Fields of `ZSTD_frameParameters` are set to default values */
+ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) {
+    ZSTD_parameters params;
+    ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, srcSizeHint, dictSize);
+    DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
+    memset(&params, 0, sizeof(params));
+    params.cParams = cParams;
+    params.fParams.contentSizeFlag = 1;
+    return params;
+}
diff --git a/src/zstd_compress_internal.h b/src/zstd_compress_internal.h
new file mode 100644
index 0000000..6d623cc
--- /dev/null
+++ b/src/zstd_compress_internal.h
@@ -0,0 +1,961 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* This header contains definitions
+ * that shall **only** be used by modules within lib/compress.
+ */
+
+#ifndef ZSTD_COMPRESS_H
+#define ZSTD_COMPRESS_H
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include "zstd_internal.h"
+#ifdef ZSTD_MULTITHREAD
+#  include "zstdmt_compress.h"
+#endif
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*-*************************************
+*  Constants
+***************************************/
+#define kSearchStrength      8
+#define HASH_READ_SIZE       8
+#define ZSTD_DUBT_UNSORTED_MARK 1   /* For btlazy2 strategy, index ZSTD_DUBT_UNSORTED_MARK==1 means "unsorted".
+                                       It could be confused for a real successor at index "1", if sorted as larger than its predecessor.
+                                       It's not a big deal though : candidate will just be sorted again.
+                                       Additionally, candidate position 1 will be lost.
+                                       But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss.
+                                       The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be mishandled after table re-use with a different strategy.
+                                       This constant is required by ZSTD_compressBlock_btlazy2() and ZSTD_reduceTable_internal() */
+
+
+/*-*************************************
+*  Context memory management
+***************************************/
+typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;
+typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
+
+typedef struct ZSTD_prefixDict_s {
+    const void* dict;
+    size_t dictSize;
+    ZSTD_dictContentType_e dictContentType;
+} ZSTD_prefixDict;
+
+typedef struct {
+    void* dictBuffer;
+    void const* dict;
+    size_t dictSize;
+    ZSTD_dictContentType_e dictContentType;
+    ZSTD_CDict* cdict;
+} ZSTD_localDict;
+
+typedef struct {
+    U32 CTable[HUF_CTABLE_SIZE_U32(255)];
+    HUF_repeat repeatMode;
+} ZSTD_hufCTables_t;
+
+typedef struct {
+    FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
+    FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
+    FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
+    FSE_repeat offcode_repeatMode;
+    FSE_repeat matchlength_repeatMode;
+    FSE_repeat litlength_repeatMode;
+} ZSTD_fseCTables_t;
+
+typedef struct {
+    ZSTD_hufCTables_t huf;
+    ZSTD_fseCTables_t fse;
+} ZSTD_entropyCTables_t;
+
+typedef struct {
+    U32 off;
+    U32 len;
+} ZSTD_match_t;
+
+typedef struct {
+    int price;
+    U32 off;
+    U32 mlen;
+    U32 litlen;
+    U32 rep[ZSTD_REP_NUM];
+} ZSTD_optimal_t;
+
+typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;
+
+typedef struct {
+    /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */
+    unsigned* litFreq;           /* table of literals statistics, of size 256 */
+    unsigned* litLengthFreq;     /* table of litLength statistics, of size (MaxLL+1) */
+    unsigned* matchLengthFreq;   /* table of matchLength statistics, of size (MaxML+1) */
+    unsigned* offCodeFreq;       /* table of offCode statistics, of size (MaxOff+1) */
+    ZSTD_match_t* matchTable;    /* list of found matches, of size ZSTD_OPT_NUM+1 */
+    ZSTD_optimal_t* priceTable;  /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */
+
+    U32  litSum;                 /* nb of literals */
+    U32  litLengthSum;           /* nb of litLength codes */
+    U32  matchLengthSum;         /* nb of matchLength codes */
+    U32  offCodeSum;             /* nb of offset codes */
+    U32  litSumBasePrice;        /* to compare to log2(litfreq) */
+    U32  litLengthSumBasePrice;  /* to compare to log2(llfreq)  */
+    U32  matchLengthSumBasePrice;/* to compare to log2(mlfreq)  */
+    U32  offCodeSumBasePrice;    /* to compare to log2(offreq)  */
+    ZSTD_OptPrice_e priceType;   /* prices can be determined dynamically, or follow a pre-defined cost structure */
+    const ZSTD_entropyCTables_t* symbolCosts;  /* pre-calculated dictionary statistics */
+    ZSTD_literalCompressionMode_e literalCompressionMode;
+} optState_t;
+
+typedef struct {
+  ZSTD_entropyCTables_t entropy;
+  U32 rep[ZSTD_REP_NUM];
+} ZSTD_compressedBlockState_t;
+
+typedef struct {
+    BYTE const* nextSrc;    /* next block here to continue on current prefix */
+    BYTE const* base;       /* All regular indexes relative to this position */
+    BYTE const* dictBase;   /* extDict indexes relative to this position */
+    U32 dictLimit;          /* below that point, need extDict */
+    U32 lowLimit;           /* below that point, no more valid data */
+} ZSTD_window_t;
+
+typedef struct ZSTD_matchState_t ZSTD_matchState_t;
+struct ZSTD_matchState_t {
+    ZSTD_window_t window;   /* State for window round buffer management */
+    U32 loadedDictEnd;      /* index of end of dictionary, within context's referential.
+                             * When loadedDictEnd != 0, a dictionary is in use, and still valid.
+                             * This relies on a mechanism to set loadedDictEnd=0 when dictionary is no longer within distance.
+                             * Such mechanism is provided within ZSTD_window_enforceMaxDist() and ZSTD_checkDictValidity().
+                             * When dict referential is copied into active context (i.e. not attached),
+                             * loadedDictEnd == dictSize, since referential starts from zero.
+                             */
+    U32 nextToUpdate;       /* index from which to continue table update */
+    U32 hashLog3;           /* dispatch table for matches of len==3 : larger == faster, more memory */
+    U32* hashTable;
+    U32* hashTable3;
+    U32* chainTable;
+    optState_t opt;         /* optimal parser state */
+    const ZSTD_matchState_t* dictMatchState;
+    ZSTD_compressionParameters cParams;
+};
+
+typedef struct {
+    ZSTD_compressedBlockState_t* prevCBlock;
+    ZSTD_compressedBlockState_t* nextCBlock;
+    ZSTD_matchState_t matchState;
+} ZSTD_blockState_t;
+
+typedef struct {
+    U32 offset;
+    U32 checksum;
+} ldmEntry_t;
+
+typedef struct {
+    ZSTD_window_t window;   /* State for the window round buffer management */
+    ldmEntry_t* hashTable;
+    BYTE* bucketOffsets;    /* Next position in bucket to insert entry */
+    U64 hashPower;          /* Used to compute the rolling hash.
+                             * Depends on ldmParams.minMatchLength */
+} ldmState_t;
+
+typedef struct {
+    U32 enableLdm;          /* 1 if enable long distance matching */
+    U32 hashLog;            /* Log size of hashTable */
+    U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */
+    U32 minMatchLength;     /* Minimum match length */
+    U32 hashRateLog;       /* Log number of entries to skip */
+    U32 windowLog;          /* Window log for the LDM */
+} ldmParams_t;
+
+typedef struct {
+    U32 offset;
+    U32 litLength;
+    U32 matchLength;
+} rawSeq;
+
+typedef struct {
+  rawSeq* seq;     /* The start of the sequences */
+  size_t pos;      /* The position where reading stopped. <= size. */
+  size_t size;     /* The number of sequences. <= capacity. */
+  size_t capacity; /* The capacity starting from `seq` pointer */
+} rawSeqStore_t;
+
+struct ZSTD_CCtx_params_s {
+    ZSTD_format_e format;
+    ZSTD_compressionParameters cParams;
+    ZSTD_frameParameters fParams;
+
+    int compressionLevel;
+    int forceWindow;           /* force back-references to respect limit of
+                                * 1<<wLog, even for dictionary */
+    size_t targetCBlockSize;   /* Tries to fit compressed block size to be around targetCBlockSize.
+                                * No target when targetCBlockSize == 0.
+                                * There is no guarantee on compressed block size */
+
+    ZSTD_dictAttachPref_e attachDictPref;
+    ZSTD_literalCompressionMode_e literalCompressionMode;
+
+    /* Multithreading: used to pass parameters to mtctx */
+    int nbWorkers;
+    size_t jobSize;
+    int overlapLog;
+    int rsyncable;
+
+    /* Long distance matching parameters */
+    ldmParams_t ldmParams;
+
+    /* Internal use, for createCCtxParams() and freeCCtxParams() only */
+    ZSTD_customMem customMem;
+};  /* typedef'd to ZSTD_CCtx_params within "zstd.h" */
+
+struct ZSTD_CCtx_s {
+    ZSTD_compressionStage_e stage;
+    int cParamsChanged;                  /* == 1 if cParams(except wlog) or compression level are changed in requestedParams. Triggers transmission of new params to ZSTDMT (if available) then reset to 0. */
+    int bmi2;                            /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
+    ZSTD_CCtx_params requestedParams;
+    ZSTD_CCtx_params appliedParams;
+    U32   dictID;
+
+    int workSpaceOversizedDuration;
+    void* workSpace;
+    size_t workSpaceSize;
+    size_t blockSize;
+    unsigned long long pledgedSrcSizePlusOne;  /* this way, 0 (default) == unknown */
+    unsigned long long consumedSrcSize;
+    unsigned long long producedCSize;
+    XXH64_state_t xxhState;
+    ZSTD_customMem customMem;
+    size_t staticSize;
+
+    seqStore_t seqStore;      /* sequences storage ptrs */
+    ldmState_t ldmState;      /* long distance matching state */
+    rawSeq* ldmSequences;     /* Storage for the ldm output sequences */
+    size_t maxNbLdmSequences;
+    rawSeqStore_t externSeqStore; /* Mutable reference to external sequences */
+    ZSTD_blockState_t blockState;
+    U32* entropyWorkspace;  /* entropy workspace of HUF_WORKSPACE_SIZE bytes */
+
+    /* streaming */
+    char*  inBuff;
+    size_t inBuffSize;
+    size_t inToCompress;
+    size_t inBuffPos;
+    size_t inBuffTarget;
+    char*  outBuff;
+    size_t outBuffSize;
+    size_t outBuffContentSize;
+    size_t outBuffFlushedSize;
+    ZSTD_cStreamStage streamStage;
+    U32    frameEnded;
+
+    /* Dictionary */
+    ZSTD_localDict localDict;
+    const ZSTD_CDict* cdict;
+    ZSTD_prefixDict prefixDict;   /* single-usage dictionary */
+
+    /* Multi-threading */
+#ifdef ZSTD_MULTITHREAD
+    ZSTDMT_CCtx* mtctx;
+#endif
+};
+
+typedef enum { ZSTD_dtlm_fast, ZSTD_dtlm_full } ZSTD_dictTableLoadMethod_e;
+
+typedef enum { ZSTD_noDict = 0, ZSTD_extDict = 1, ZSTD_dictMatchState = 2 } ZSTD_dictMode_e;
+
+
+typedef size_t (*ZSTD_blockCompressor) (
+        ZSTD_matchState_t* bs, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_dictMode_e dictMode);
+
+
+MEM_STATIC U32 ZSTD_LLcode(U32 litLength)
+{
+    static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
+                                       8,  9, 10, 11, 12, 13, 14, 15,
+                                      16, 16, 17, 17, 18, 18, 19, 19,
+                                      20, 20, 20, 20, 21, 21, 21, 21,
+                                      22, 22, 22, 22, 22, 22, 22, 22,
+                                      23, 23, 23, 23, 23, 23, 23, 23,
+                                      24, 24, 24, 24, 24, 24, 24, 24,
+                                      24, 24, 24, 24, 24, 24, 24, 24 };
+    static const U32 LL_deltaCode = 19;
+    return (litLength > 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
+}
+
+/* ZSTD_MLcode() :
+ * note : mlBase = matchLength - MINMATCH;
+ *        because it's the format it's stored in seqStore->sequences */
+MEM_STATIC U32 ZSTD_MLcode(U32 mlBase)
+{
+    static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+                                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                                      32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
+                                      38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
+                                      40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+                                      41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
+    static const U32 ML_deltaCode = 36;
+    return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
+}
+
+/* ZSTD_cParam_withinBounds:
+ * @return 1 if value is within cParam bounds,
+ * 0 otherwise */
+MEM_STATIC int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)
+{
+    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
+    if (ZSTD_isError(bounds.error)) return 0;
+    if (value < bounds.lowerBound) return 0;
+    if (value > bounds.upperBound) return 0;
+    return 1;
+}
+
+/* ZSTD_minGain() :
+ * minimum compression required
+ * to generate a compress block or a compressed literals section.
+ * note : use same formula for both situations */
+MEM_STATIC size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)
+{
+    U32 const minlog = (strat>=ZSTD_btultra) ? (U32)(strat) - 1 : 6;
+    ZSTD_STATIC_ASSERT(ZSTD_btultra == 8);
+    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
+    return (srcSize >> minlog) + 2;
+}
+
+/*! ZSTD_storeSeq() :
+ *  Store a sequence (literal length, literals, offset code and match length code) into seqStore_t.
+ *  `offsetCode` : distance to match + 3 (values 1-3 are repCodes).
+ *  `mlBase` : matchLength - MINMATCH
+*/
+MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t mlBase)
+{
+#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6)
+    static const BYTE* g_start = NULL;
+    if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
+    {   U32 const pos = (U32)((const BYTE*)literals - g_start);
+        DEBUGLOG(6, "Cpos%7u :%3u literals, match%4u bytes at offCode%7u",
+               pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode);
+    }
+#endif
+    assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);
+    /* copy Literals */
+    assert(seqStorePtr->maxNbLit <= 128 KB);
+    assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit);
+    ZSTD_wildcopy(seqStorePtr->lit, literals, (ptrdiff_t)litLength, ZSTD_no_overlap);
+    seqStorePtr->lit += litLength;
+
+    /* literal Length */
+    if (litLength>0xFFFF) {
+        assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
+        seqStorePtr->longLengthID = 1;
+        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
+    }
+    seqStorePtr->sequences[0].litLength = (U16)litLength;
+
+    /* match offset */
+    seqStorePtr->sequences[0].offset = offsetCode + 1;
+
+    /* match Length */
+    if (mlBase>0xFFFF) {
+        assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
+        seqStorePtr->longLengthID = 2;
+        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
+    }
+    seqStorePtr->sequences[0].matchLength = (U16)mlBase;
+
+    seqStorePtr->sequences++;
+}
+
+
+/*-*************************************
+*  Match length counter
+***************************************/
+static unsigned ZSTD_NbCommonBytes (size_t val)
+{
+    if (MEM_isLittleEndian()) {
+        if (MEM_64bits()) {
+#       if defined(_MSC_VER) && defined(_WIN64)
+            unsigned long r = 0;
+            _BitScanForward64( &r, (U64)val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 4)
+            return (__builtin_ctzll((U64)val) >> 3);
+#       else
+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2,
+                                                     0, 3, 1, 3, 1, 4, 2, 7,
+                                                     0, 2, 3, 6, 1, 5, 3, 5,
+                                                     1, 3, 4, 4, 2, 5, 6, 7,
+                                                     7, 0, 1, 2, 3, 3, 4, 6,
+                                                     2, 6, 5, 5, 3, 4, 5, 6,
+                                                     7, 1, 2, 4, 6, 4, 4, 5,
+                                                     7, 2, 6, 5, 7, 6, 7, 7 };
+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
+#       endif
+        } else { /* 32 bits */
+#       if defined(_MSC_VER)
+            unsigned long r=0;
+            _BitScanForward( &r, (U32)val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_ctz((U32)val) >> 3);
+#       else
+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0,
+                                                     3, 2, 2, 1, 3, 2, 0, 1,
+                                                     3, 3, 1, 2, 2, 2, 2, 0,
+                                                     3, 1, 2, 0, 1, 0, 1, 1 };
+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
+#       endif
+        }
+    } else {  /* Big Endian CPU */
+        if (MEM_64bits()) {
+#       if defined(_MSC_VER) && defined(_WIN64)
+            unsigned long r = 0;
+            _BitScanReverse64( &r, val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 4)
+            return (__builtin_clzll(val) >> 3);
+#       else
+            unsigned r;
+            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
+            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
+            r += (!val);
+            return r;
+#       endif
+        } else { /* 32 bits */
+#       if defined(_MSC_VER)
+            unsigned long r = 0;
+            _BitScanReverse( &r, (unsigned long)val );
+            return (unsigned)(r>>3);
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_clz((U32)val) >> 3);
+#       else
+            unsigned r;
+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
+            r += (!val);
+            return r;
+#       endif
+    }   }
+}
+
+
+MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit)
+{
+    const BYTE* const pStart = pIn;
+    const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);
+
+    if (pIn < pInLoopLimit) {
+        { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
+          if (diff) return ZSTD_NbCommonBytes(diff); }
+        pIn+=sizeof(size_t); pMatch+=sizeof(size_t);
+        while (pIn < pInLoopLimit) {
+            size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
+            if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
+            pIn += ZSTD_NbCommonBytes(diff);
+            return (size_t)(pIn - pStart);
+    }   }
+    if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
+    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
+    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
+    return (size_t)(pIn - pStart);
+}
+
+/** ZSTD_count_2segments() :
+ *  can count match length with `ip` & `match` in 2 different segments.
+ *  convention : on reaching mEnd, match count continue starting from iStart
+ */
+MEM_STATIC size_t
+ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
+                     const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
+{
+    const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
+    size_t const matchLength = ZSTD_count(ip, match, vEnd);
+    if (match + matchLength != mEnd) return matchLength;
+    DEBUGLOG(7, "ZSTD_count_2segments: found a 2-parts match (current length==%zu)", matchLength);
+    DEBUGLOG(7, "distance from match beginning to end dictionary = %zi", mEnd - match);
+    DEBUGLOG(7, "distance from current pos to end buffer = %zi", iEnd - ip);
+    DEBUGLOG(7, "next byte : ip==%02X, istart==%02X", ip[matchLength], *iStart);
+    DEBUGLOG(7, "final match length = %zu", matchLength + ZSTD_count(ip+matchLength, iStart, iEnd));
+    return matchLength + ZSTD_count(ip+matchLength, iStart, iEnd);
+}
+
+
+/*-*************************************
+ *  Hashes
+ ***************************************/
+static const U32 prime3bytes = 506832829U;
+static U32    ZSTD_hash3(U32 u, U32 h) { return ((u << (32-24)) * prime3bytes)  >> (32-h) ; }
+MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); } /* only in zstd_opt.h */
+
+static const U32 prime4bytes = 2654435761U;
+static U32    ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32-h) ; }
+static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); }
+
+static const U64 prime5bytes = 889523592379ULL;
+static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u  << (64-40)) * prime5bytes) >> (64-h)) ; }
+static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); }
+
+static const U64 prime6bytes = 227718039650203ULL;
+static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; }
+static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); }
+
+static const U64 prime7bytes = 58295818150454627ULL;
+static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u  << (64-56)) * prime7bytes) >> (64-h)) ; }
+static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); }
+
+static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;
+static size_t ZSTD_hash8(U64 u, U32 h) { return (size_t)(((u) * prime8bytes) >> (64-h)) ; }
+static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); }
+
+MEM_STATIC size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
+{
+    switch(mls)
+    {
+    default:
+    case 4: return ZSTD_hash4Ptr(p, hBits);
+    case 5: return ZSTD_hash5Ptr(p, hBits);
+    case 6: return ZSTD_hash6Ptr(p, hBits);
+    case 7: return ZSTD_hash7Ptr(p, hBits);
+    case 8: return ZSTD_hash8Ptr(p, hBits);
+    }
+}
+
+/** ZSTD_ipow() :
+ * Return base^exponent.
+ */
+static U64 ZSTD_ipow(U64 base, U64 exponent)
+{
+    U64 power = 1;
+    while (exponent) {
+      if (exponent & 1) power *= base;
+      exponent >>= 1;
+      base *= base;
+    }
+    return power;
+}
+
+#define ZSTD_ROLL_HASH_CHAR_OFFSET 10
+
+/** ZSTD_rollingHash_append() :
+ * Add the buffer to the hash value.
+ */
+static U64 ZSTD_rollingHash_append(U64 hash, void const* buf, size_t size)
+{
+    BYTE const* istart = (BYTE const*)buf;
+    size_t pos;
+    for (pos = 0; pos < size; ++pos) {
+        hash *= prime8bytes;
+        hash += istart[pos] + ZSTD_ROLL_HASH_CHAR_OFFSET;
+    }
+    return hash;
+}
+
+/** ZSTD_rollingHash_compute() :
+ * Compute the rolling hash value of the buffer.
+ */
+MEM_STATIC U64 ZSTD_rollingHash_compute(void const* buf, size_t size)
+{
+    return ZSTD_rollingHash_append(0, buf, size);
+}
+
+/** ZSTD_rollingHash_primePower() :
+ * Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash
+ * over a window of length bytes.
+ */
+MEM_STATIC U64 ZSTD_rollingHash_primePower(U32 length)
+{
+    return ZSTD_ipow(prime8bytes, length - 1);
+}
+
+/** ZSTD_rollingHash_rotate() :
+ * Rotate the rolling hash by one byte.
+ */
+MEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64 primePower)
+{
+    hash -= (toRemove + ZSTD_ROLL_HASH_CHAR_OFFSET) * primePower;
+    hash *= prime8bytes;
+    hash += toAdd + ZSTD_ROLL_HASH_CHAR_OFFSET;
+    return hash;
+}
+
+/*-*************************************
+*  Round buffer management
+***************************************/
+#if (ZSTD_WINDOWLOG_MAX_64 > 31)
+# error "ZSTD_WINDOWLOG_MAX is too large : would overflow ZSTD_CURRENT_MAX"
+#endif
+/* Max current allowed */
+#define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX))
+/* Maximum chunk size before overflow correction needs to be called again */
+#define ZSTD_CHUNKSIZE_MAX                                                     \
+    ( ((U32)-1)                  /* Maximum ending current index */            \
+    - ZSTD_CURRENT_MAX)          /* Maximum beginning lowLimit */
+
+/**
+ * ZSTD_window_clear():
+ * Clears the window containing the history by simply setting it to empty.
+ */
+MEM_STATIC void ZSTD_window_clear(ZSTD_window_t* window)
+{
+    size_t const endT = (size_t)(window->nextSrc - window->base);
+    U32 const end = (U32)endT;
+
+    window->lowLimit = end;
+    window->dictLimit = end;
+}
+
+/**
+ * ZSTD_window_hasExtDict():
+ * Returns non-zero if the window has a non-empty extDict.
+ */
+MEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window)
+{
+    return window.lowLimit < window.dictLimit;
+}
+
+/**
+ * ZSTD_matchState_dictMode():
+ * Inspects the provided matchState and figures out what dictMode should be
+ * passed to the compressor.
+ */
+MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_matchState_t *ms)
+{
+    return ZSTD_window_hasExtDict(ms->window) ?
+        ZSTD_extDict :
+        ms->dictMatchState != NULL ?
+            ZSTD_dictMatchState :
+            ZSTD_noDict;
+}
+
+/**
+ * ZSTD_window_needOverflowCorrection():
+ * Returns non-zero if the indices are getting too large and need overflow
+ * protection.
+ */
+MEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window,
+                                                  void const* srcEnd)
+{
+    U32 const current = (U32)((BYTE const*)srcEnd - window.base);
+    return current > ZSTD_CURRENT_MAX;
+}
+
+/**
+ * ZSTD_window_correctOverflow():
+ * Reduces the indices to protect from index overflow.
+ * Returns the correction made to the indices, which must be applied to every
+ * stored index.
+ *
+ * The least significant cycleLog bits of the indices must remain the same,
+ * which may be 0. Every index up to maxDist in the past must be valid.
+ * NOTE: (maxDist & cycleMask) must be zero.
+ */
+MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
+                                           U32 maxDist, void const* src)
+{
+    /* preemptive overflow correction:
+     * 1. correction is large enough:
+     *    lowLimit > (3<<29) ==> current > 3<<29 + 1<<windowLog
+     *    1<<windowLog <= newCurrent < 1<<chainLog + 1<<windowLog
+     *
+     *    current - newCurrent
+     *    > (3<<29 + 1<<windowLog) - (1<<windowLog + 1<<chainLog)
+     *    > (3<<29) - (1<<chainLog)
+     *    > (3<<29) - (1<<30)             (NOTE: chainLog <= 30)
+     *    > 1<<29
+     *
+     * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow:
+     *    After correction, current is less than (1<<chainLog + 1<<windowLog).
+     *    In 64-bit mode we are safe, because we have 64-bit ptrdiff_t.
+     *    In 32-bit mode we are safe, because (chainLog <= 29), so
+     *    ip+ZSTD_CHUNKSIZE_MAX - cctx->base < 1<<32.
+     * 3. (cctx->lowLimit + 1<<windowLog) < 1<<32:
+     *    windowLog <= 31 ==> 3<<29 + 1<<windowLog < 7<<29 < 1<<32.
+     */
+    U32 const cycleMask = (1U << cycleLog) - 1;
+    U32 const current = (U32)((BYTE const*)src - window->base);
+    U32 const newCurrent = (current & cycleMask) + maxDist;
+    U32 const correction = current - newCurrent;
+    assert((maxDist & cycleMask) == 0);
+    assert(current > newCurrent);
+    /* Loose bound, should be around 1<<29 (see above) */
+    assert(correction > 1<<28);
+
+    window->base += correction;
+    window->dictBase += correction;
+    window->lowLimit -= correction;
+    window->dictLimit -= correction;
+
+    DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x", correction,
+             window->lowLimit);
+    return correction;
+}
+
+/**
+ * ZSTD_window_enforceMaxDist():
+ * Updates lowLimit so that:
+ *    (srcEnd - base) - lowLimit == maxDist + loadedDictEnd
+ *
+ * It ensures index is valid as long as index >= lowLimit.
+ * This must be called before a block compression call.
+ *
+ * loadedDictEnd is only defined if a dictionary is in use for current compression.
+ * As the name implies, loadedDictEnd represents the index at end of dictionary.
+ * The value lies within context's referential, it can be directly compared to blockEndIdx.
+ *
+ * If loadedDictEndPtr is NULL, no dictionary is in use, and we use loadedDictEnd == 0.
+ * If loadedDictEndPtr is not NULL, we set it to zero after updating lowLimit.
+ * This is because dictionaries are allowed to be referenced fully
+ * as long as the last byte of the dictionary is in the window.
+ * Once input has progressed beyond window size, dictionary cannot be referenced anymore.
+ *
+ * In normal dict mode, the dictionary lies between lowLimit and dictLimit.
+ * In dictMatchState mode, lowLimit and dictLimit are the same,
+ * and the dictionary is below them.
+ * forceWindow and dictMatchState are therefore incompatible.
+ */
+MEM_STATIC void
+ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
+                     const void* blockEnd,
+                           U32   maxDist,
+                           U32*  loadedDictEndPtr,
+                     const ZSTD_matchState_t** dictMatchStatePtr)
+{
+    U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
+    U32 const loadedDictEnd = (loadedDictEndPtr != NULL) ? *loadedDictEndPtr : 0;
+    DEBUGLOG(5, "ZSTD_window_enforceMaxDist: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u",
+                (unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);
+
+    /* - When there is no dictionary : loadedDictEnd == 0.
+         In which case, the test (blockEndIdx > maxDist) is merely to avoid
+         overflowing next operation `newLowLimit = blockEndIdx - maxDist`.
+       - When there is a standard dictionary :
+         Index referential is copied from the dictionary,
+         which means it starts from 0.
+         In which case, loadedDictEnd == dictSize,
+         and it makes sense to compare `blockEndIdx > maxDist + dictSize`
+         since `blockEndIdx` also starts from zero.
+       - When there is an attached dictionary :
+         loadedDictEnd is expressed within the referential of the context,
+         so it can be directly compared against blockEndIdx.
+    */
+    if (blockEndIdx > maxDist + loadedDictEnd) {
+        U32 const newLowLimit = blockEndIdx - maxDist;
+        if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;
+        if (window->dictLimit < window->lowLimit) {
+            DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u",
+                        (unsigned)window->dictLimit, (unsigned)window->lowLimit);
+            window->dictLimit = window->lowLimit;
+        }
+        /* On reaching window size, dictionaries are invalidated */
+        if (loadedDictEndPtr) *loadedDictEndPtr = 0;
+        if (dictMatchStatePtr) *dictMatchStatePtr = NULL;
+    }
+}
+
+/* Similar to ZSTD_window_enforceMaxDist(),
+ * but only invalidates dictionary
+ * when input progresses beyond window size.
+ * assumption : loadedDictEndPtr and dictMatchStatePtr are valid (non NULL)
+ *              loadedDictEnd uses same referential as window->base
+ *              maxDist is the window size */
+MEM_STATIC void
+ZSTD_checkDictValidity(const ZSTD_window_t* window,
+                       const void* blockEnd,
+                             U32   maxDist,
+                             U32*  loadedDictEndPtr,
+                       const ZSTD_matchState_t** dictMatchStatePtr)
+{
+    assert(loadedDictEndPtr != NULL);
+    assert(dictMatchStatePtr != NULL);
+    {   U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
+        U32 const loadedDictEnd = *loadedDictEndPtr;
+        DEBUGLOG(5, "ZSTD_checkDictValidity: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u",
+                    (unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);
+        assert(blockEndIdx >= loadedDictEnd);
+
+        if (blockEndIdx > loadedDictEnd + maxDist) {
+            /* On reaching window size, dictionaries are invalidated.
+             * For simplification, if window size is reached anywhere within next block,
+             * the dictionary is invalidated for the full block.
+             */
+            DEBUGLOG(6, "invalidating dictionary for current block (distance > windowSize)");
+            *loadedDictEndPtr = 0;
+            *dictMatchStatePtr = NULL;
+        } else {
+            if (*loadedDictEndPtr != 0) {
+                DEBUGLOG(6, "dictionary considered valid for current block");
+    }   }   }
+}
+
+/**
+ * ZSTD_window_update():
+ * Updates the window by appending [src, src + srcSize) to the window.
+ * If it is not contiguous, the current prefix becomes the extDict, and we
+ * forget about the extDict. Handles overlap of the prefix and extDict.
+ * Returns non-zero if the segment is contiguous.
+ */
+MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window,
+                                  void const* src, size_t srcSize)
+{
+    BYTE const* const ip = (BYTE const*)src;
+    U32 contiguous = 1;
+    DEBUGLOG(5, "ZSTD_window_update");
+    /* Check if blocks follow each other */
+    if (src != window->nextSrc) {
+        /* not contiguous */
+        size_t const distanceFromBase = (size_t)(window->nextSrc - window->base);
+        DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit);
+        window->lowLimit = window->dictLimit;
+        assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */
+        window->dictLimit = (U32)distanceFromBase;
+        window->dictBase = window->base;
+        window->base = ip - distanceFromBase;
+        // ms->nextToUpdate = window->dictLimit;
+        if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit;   /* too small extDict */
+        contiguous = 0;
+    }
+    window->nextSrc = ip + srcSize;
+    /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */
+    if ( (ip+srcSize > window->dictBase + window->lowLimit)
+       & (ip < window->dictBase + window->dictLimit)) {
+        ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase;
+        U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx;
+        window->lowLimit = lowLimitMax;
+        DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit);
+    }
+    return contiguous;
+}
+
+MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 current, unsigned windowLog)
+{
+    U32    const maxDistance = 1U << windowLog;
+    U32    const lowestValid = ms->window.lowLimit;
+    U32    const withinWindow = (current - lowestValid > maxDistance) ? current - maxDistance : lowestValid;
+    U32    const isDictionary = (ms->loadedDictEnd != 0);
+    U32    const matchLowest = isDictionary ? lowestValid : withinWindow;
+    return matchLowest;
+}
+
+
+
+/* debug functions */
+#if (DEBUGLEVEL>=2)
+
+MEM_STATIC double ZSTD_fWeight(U32 rawStat)
+{
+    U32 const fp_accuracy = 8;
+    U32 const fp_multiplier = (1 << fp_accuracy);
+    U32 const newStat = rawStat + 1;
+    U32 const hb = ZSTD_highbit32(newStat);
+    U32 const BWeight = hb * fp_multiplier;
+    U32 const FWeight = (newStat << fp_accuracy) >> hb;
+    U32 const weight = BWeight + FWeight;
+    assert(hb + fp_accuracy < 31);
+    return (double)weight / fp_multiplier;
+}
+
+/* display a table content,
+ * listing each element, its frequency, and its predicted bit cost */
+MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max)
+{
+    unsigned u, sum;
+    for (u=0, sum=0; u<=max; u++) sum += table[u];
+    DEBUGLOG(2, "total nb elts: %u", sum);
+    for (u=0; u<=max; u++) {
+        DEBUGLOG(2, "%2u: %5u  (%.2f)",
+                u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) );
+    }
+}
+
+#endif
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+
+/* ==============================================================
+ * Private declarations
+ * These prototypes shall only be called from within lib/compress
+ * ============================================================== */
+
+/* ZSTD_getCParamsFromCCtxParams() :
+ * cParams are built depending on compressionLevel, src size hints,
+ * LDM and manually set compression parameters.
+ */
+ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
+        const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize);
+
+/*! ZSTD_initCStream_internal() :
+ *  Private use only. Init streaming operation.
+ *  expects params to be valid.
+ *  must receive dict, or cdict, or none, but not both.
+ *  @return : 0, or an error code */
+size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
+                     const void* dict, size_t dictSize,
+                     const ZSTD_CDict* cdict,
+                     ZSTD_CCtx_params  params, unsigned long long pledgedSrcSize);
+
+void ZSTD_resetSeqStore(seqStore_t* ssPtr);
+
+/*! ZSTD_getCParamsFromCDict() :
+ *  as the name implies */
+ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);
+
+/* ZSTD_compressBegin_advanced_internal() :
+ * Private use only. To be called from zstdmt_compress.c. */
+size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
+                                    const void* dict, size_t dictSize,
+                                    ZSTD_dictContentType_e dictContentType,
+                                    ZSTD_dictTableLoadMethod_e dtlm,
+                                    const ZSTD_CDict* cdict,
+                                    ZSTD_CCtx_params params,
+                                    unsigned long long pledgedSrcSize);
+
+/* ZSTD_compress_advanced_internal() :
+ * Private use only. To be called from zstdmt_compress.c. */
+size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,
+                                       void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize,
+                                 const void* dict,size_t dictSize,
+                                 ZSTD_CCtx_params params);
+
+
+/* ZSTD_writeLastEmptyBlock() :
+ * output an empty Block with end-of-frame mark to complete a frame
+ * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
+ *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
+ */
+size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity);
+
+
+/* ZSTD_referenceExternalSequences() :
+ * Must be called before starting a compression operation.
+ * seqs must parse a prefix of the source.
+ * This cannot be used when long range matching is enabled.
+ * Zstd will use these sequences, and pass the literals to a secondary block
+ * compressor.
+ * @return : An error code on failure.
+ * NOTE: seqs are not verified! Invalid sequences can cause out-of-bounds memory
+ * access and data corruption.
+ */
+size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq);
+
+
+#endif /* ZSTD_COMPRESS_H */
diff --git a/src/zstd_compress_literals.c b/src/zstd_compress_literals.c
new file mode 100644
index 0000000..eb3e5a4
--- /dev/null
+++ b/src/zstd_compress_literals.c
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+ /*-*************************************
+ *  Dependencies
+ ***************************************/
+#include "zstd_compress_literals.h"
+
+size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    BYTE* const ostart = (BYTE* const)dst;
+    U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);
+
+    RETURN_ERROR_IF(srcSize + flSize > dstCapacity, dstSize_tooSmall);
+
+    switch(flSize)
+    {
+        case 1: /* 2 - 1 - 5 */
+            ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3));
+            break;
+        case 2: /* 2 - 2 - 12 */
+            MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4)));
+            break;
+        case 3: /* 2 - 2 - 20 */
+            MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4)));
+            break;
+        default:   /* not necessary : flSize is {1,2,3} */
+            assert(0);
+    }
+
+    memcpy(ostart + flSize, src, srcSize);
+    return srcSize + flSize;
+}
+
+size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    BYTE* const ostart = (BYTE* const)dst;
+    U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);
+
+    (void)dstCapacity;  /* dstCapacity already guaranteed to be >=4, hence large enough */
+
+    switch(flSize)
+    {
+        case 1: /* 2 - 1 - 5 */
+            ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3));
+            break;
+        case 2: /* 2 - 2 - 12 */
+            MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4)));
+            break;
+        case 3: /* 2 - 2 - 20 */
+            MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4)));
+            break;
+        default:   /* not necessary : flSize is {1,2,3} */
+            assert(0);
+    }
+
+    ostart[flSize] = *(const BYTE*)src;
+    return flSize+1;
+}
+
+size_t ZSTD_compressLiterals (ZSTD_hufCTables_t const* prevHuf,
+                              ZSTD_hufCTables_t* nextHuf,
+                              ZSTD_strategy strategy, int disableLiteralCompression,
+                              void* dst, size_t dstCapacity,
+                        const void* src, size_t srcSize,
+                              void* workspace, size_t wkspSize,
+                        const int bmi2)
+{
+    size_t const minGain = ZSTD_minGain(srcSize, strategy);
+    size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);
+    BYTE*  const ostart = (BYTE*)dst;
+    U32 singleStream = srcSize < 256;
+    symbolEncodingType_e hType = set_compressed;
+    size_t cLitSize;
+
+    DEBUGLOG(5,"ZSTD_compressLiterals (disableLiteralCompression=%i)",
+                disableLiteralCompression);
+
+    /* Prepare nextEntropy assuming reusing the existing table */
+    memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
+
+    if (disableLiteralCompression)
+        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
+
+    /* small ? don't even attempt compression (speed opt) */
+#   define COMPRESS_LITERALS_SIZE_MIN 63
+    {   size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;
+        if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
+    }
+
+    RETURN_ERROR_IF(dstCapacity < lhSize+1, dstSize_tooSmall, "not enough space for compression");
+    {   HUF_repeat repeat = prevHuf->repeatMode;
+        int const preferRepeat = strategy < ZSTD_lazy ? srcSize <= 1024 : 0;
+        if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;
+        cLitSize = singleStream ? HUF_compress1X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
+                                      workspace, wkspSize, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2)
+                                : HUF_compress4X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
+                                      workspace, wkspSize, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2);
+        if (repeat != HUF_repeat_none) {
+            /* reused the existing table */
+            hType = set_repeat;
+        }
+    }
+
+    if ((cLitSize==0) | (cLitSize >= srcSize - minGain) | ERR_isError(cLitSize)) {
+        memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
+        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
+    }
+    if (cLitSize==1) {
+        memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
+        return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);
+    }
+
+    if (hType == set_compressed) {
+        /* using a newly constructed table */
+        nextHuf->repeatMode = HUF_repeat_check;
+    }
+
+    /* Build header */
+    switch(lhSize)
+    {
+    case 3: /* 2 - 2 - 10 - 10 */
+        {   U32 const lhc = hType + ((!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14);
+            MEM_writeLE24(ostart, lhc);
+            break;
+        }
+    case 4: /* 2 - 2 - 14 - 14 */
+        {   U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18);
+            MEM_writeLE32(ostart, lhc);
+            break;
+        }
+    case 5: /* 2 - 2 - 18 - 18 */
+        {   U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22);
+            MEM_writeLE32(ostart, lhc);
+            ostart[4] = (BYTE)(cLitSize >> 10);
+            break;
+        }
+    default:  /* not possible : lhSize is {3,4,5} */
+        assert(0);
+    }
+    return lhSize+cLitSize;
+}
diff --git a/src/zstd_compress_literals.h b/src/zstd_compress_literals.h
new file mode 100644
index 0000000..7adbecc
--- /dev/null
+++ b/src/zstd_compress_literals.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_COMPRESS_LITERALS_H
+#define ZSTD_COMPRESS_LITERALS_H
+
+#include "zstd_compress_internal.h" /* ZSTD_hufCTables_t, ZSTD_minGain() */
+
+
+size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+size_t ZSTD_compressLiterals (ZSTD_hufCTables_t const* prevHuf,
+                              ZSTD_hufCTables_t* nextHuf,
+                              ZSTD_strategy strategy, int disableLiteralCompression,
+                              void* dst, size_t dstCapacity,
+                        const void* src, size_t srcSize,
+                              void* workspace, size_t wkspSize,
+                        const int bmi2);
+
+#endif /* ZSTD_COMPRESS_LITERALS_H */
diff --git a/src/zstd_compress_sequences.c b/src/zstd_compress_sequences.c
new file mode 100644
index 0000000..3c3deae
--- /dev/null
+++ b/src/zstd_compress_sequences.c
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+ /*-*************************************
+ *  Dependencies
+ ***************************************/
+#include "zstd_compress_sequences.h"
+
+/**
+ * -log2(x / 256) lookup table for x in [0, 256).
+ * If x == 0: Return 0
+ * Else: Return floor(-log2(x / 256) * 256)
+ */
+static unsigned const kInverseProbabilityLog256[256] = {
+    0,    2048, 1792, 1642, 1536, 1453, 1386, 1329, 1280, 1236, 1197, 1162,
+    1130, 1100, 1073, 1047, 1024, 1001, 980,  960,  941,  923,  906,  889,
+    874,  859,  844,  830,  817,  804,  791,  779,  768,  756,  745,  734,
+    724,  714,  704,  694,  685,  676,  667,  658,  650,  642,  633,  626,
+    618,  610,  603,  595,  588,  581,  574,  567,  561,  554,  548,  542,
+    535,  529,  523,  517,  512,  506,  500,  495,  489,  484,  478,  473,
+    468,  463,  458,  453,  448,  443,  438,  434,  429,  424,  420,  415,
+    411,  407,  402,  398,  394,  390,  386,  382,  377,  373,  370,  366,
+    362,  358,  354,  350,  347,  343,  339,  336,  332,  329,  325,  322,
+    318,  315,  311,  308,  305,  302,  298,  295,  292,  289,  286,  282,
+    279,  276,  273,  270,  267,  264,  261,  258,  256,  253,  250,  247,
+    244,  241,  239,  236,  233,  230,  228,  225,  222,  220,  217,  215,
+    212,  209,  207,  204,  202,  199,  197,  194,  192,  190,  187,  185,
+    182,  180,  178,  175,  173,  171,  168,  166,  164,  162,  159,  157,
+    155,  153,  151,  149,  146,  144,  142,  140,  138,  136,  134,  132,
+    130,  128,  126,  123,  121,  119,  117,  115,  114,  112,  110,  108,
+    106,  104,  102,  100,  98,   96,   94,   93,   91,   89,   87,   85,
+    83,   82,   80,   78,   76,   74,   73,   71,   69,   67,   66,   64,
+    62,   61,   59,   57,   55,   54,   52,   50,   49,   47,   46,   44,
+    42,   41,   39,   37,   36,   34,   33,   31,   30,   28,   26,   25,
+    23,   22,   20,   19,   17,   16,   14,   13,   11,   10,   8,    7,
+    5,    4,    2,    1,
+};
+
+static unsigned ZSTD_getFSEMaxSymbolValue(FSE_CTable const* ctable) {
+  void const* ptr = ctable;
+  U16 const* u16ptr = (U16 const*)ptr;
+  U32 const maxSymbolValue = MEM_read16(u16ptr + 1);
+  return maxSymbolValue;
+}
+
+/**
+ * Returns the cost in bytes of encoding the normalized count header.
+ * Returns an error if any of the helper functions return an error.
+ */
+static size_t ZSTD_NCountCost(unsigned const* count, unsigned const max,
+                              size_t const nbSeq, unsigned const FSELog)
+{
+    BYTE wksp[FSE_NCOUNTBOUND];
+    S16 norm[MaxSeq + 1];
+    const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
+    FORWARD_IF_ERROR(FSE_normalizeCount(norm, tableLog, count, nbSeq, max));
+    return FSE_writeNCount(wksp, sizeof(wksp), norm, max, tableLog);
+}
+
+/**
+ * Returns the cost in bits of encoding the distribution described by count
+ * using the entropy bound.
+ */
+static size_t ZSTD_entropyCost(unsigned const* count, unsigned const max, size_t const total)
+{
+    unsigned cost = 0;
+    unsigned s;
+    for (s = 0; s <= max; ++s) {
+        unsigned norm = (unsigned)((256 * count[s]) / total);
+        if (count[s] != 0 && norm == 0)
+            norm = 1;
+        assert(count[s] < total);
+        cost += count[s] * kInverseProbabilityLog256[norm];
+    }
+    return cost >> 8;
+}
+
+/**
+ * Returns the cost in bits of encoding the distribution in count using ctable.
+ * Returns an error if ctable cannot represent all the symbols in count.
+ */
+static size_t ZSTD_fseBitCost(
+    FSE_CTable const* ctable,
+    unsigned const* count,
+    unsigned const max)
+{
+    unsigned const kAccuracyLog = 8;
+    size_t cost = 0;
+    unsigned s;
+    FSE_CState_t cstate;
+    FSE_initCState(&cstate, ctable);
+    RETURN_ERROR_IF(ZSTD_getFSEMaxSymbolValue(ctable) < max, GENERIC,
+                    "Repeat FSE_CTable has maxSymbolValue %u < %u",
+                    ZSTD_getFSEMaxSymbolValue(ctable), max);
+    for (s = 0; s <= max; ++s) {
+        unsigned const tableLog = cstate.stateLog;
+        unsigned const badCost = (tableLog + 1) << kAccuracyLog;
+        unsigned const bitCost = FSE_bitCost(cstate.symbolTT, tableLog, s, kAccuracyLog);
+        if (count[s] == 0)
+            continue;
+        RETURN_ERROR_IF(bitCost >= badCost, GENERIC,
+                        "Repeat FSE_CTable has Prob[%u] == 0", s);
+        cost += count[s] * bitCost;
+    }
+    return cost >> kAccuracyLog;
+}
+
+/**
+ * Returns the cost in bits of encoding the distribution in count using the
+ * table described by norm. The max symbol support by norm is assumed >= max.
+ * norm must be valid for every symbol with non-zero probability in count.
+ */
+static size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
+                                    unsigned const* count, unsigned const max)
+{
+    unsigned const shift = 8 - accuracyLog;
+    size_t cost = 0;
+    unsigned s;
+    assert(accuracyLog <= 8);
+    for (s = 0; s <= max; ++s) {
+        unsigned const normAcc = norm[s] != -1 ? norm[s] : 1;
+        unsigned const norm256 = normAcc << shift;
+        assert(norm256 > 0);
+        assert(norm256 < 256);
+        cost += count[s] * kInverseProbabilityLog256[norm256];
+    }
+    return cost >> 8;
+}
+
+symbolEncodingType_e
+ZSTD_selectEncodingType(
+        FSE_repeat* repeatMode, unsigned const* count, unsigned const max,
+        size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,
+        FSE_CTable const* prevCTable,
+        short const* defaultNorm, U32 defaultNormLog,
+        ZSTD_defaultPolicy_e const isDefaultAllowed,
+        ZSTD_strategy const strategy)
+{
+    ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0);
+    if (mostFrequent == nbSeq) {
+        *repeatMode = FSE_repeat_none;
+        if (isDefaultAllowed && nbSeq <= 2) {
+            /* Prefer set_basic over set_rle when there are 2 or less symbols,
+             * since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.
+             * If basic encoding isn't possible, always choose RLE.
+             */
+            DEBUGLOG(5, "Selected set_basic");
+            return set_basic;
+        }
+        DEBUGLOG(5, "Selected set_rle");
+        return set_rle;
+    }
+    if (strategy < ZSTD_lazy) {
+        if (isDefaultAllowed) {
+            size_t const staticFse_nbSeq_max = 1000;
+            size_t const mult = 10 - strategy;
+            size_t const baseLog = 3;
+            size_t const dynamicFse_nbSeq_min = (((size_t)1 << defaultNormLog) * mult) >> baseLog;  /* 28-36 for offset, 56-72 for lengths */
+            assert(defaultNormLog >= 5 && defaultNormLog <= 6);  /* xx_DEFAULTNORMLOG */
+            assert(mult <= 9 && mult >= 7);
+            if ( (*repeatMode == FSE_repeat_valid)
+              && (nbSeq < staticFse_nbSeq_max) ) {
+                DEBUGLOG(5, "Selected set_repeat");
+                return set_repeat;
+            }
+            if ( (nbSeq < dynamicFse_nbSeq_min)
+              || (mostFrequent < (nbSeq >> (defaultNormLog-1))) ) {
+                DEBUGLOG(5, "Selected set_basic");
+                /* The format allows default tables to be repeated, but it isn't useful.
+                 * When using simple heuristics to select encoding type, we don't want
+                 * to confuse these tables with dictionaries. When running more careful
+                 * analysis, we don't need to waste time checking both repeating tables
+                 * and default tables.
+                 */
+                *repeatMode = FSE_repeat_none;
+                return set_basic;
+            }
+        }
+    } else {
+        size_t const basicCost = isDefaultAllowed ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, count, max) : ERROR(GENERIC);
+        size_t const repeatCost = *repeatMode != FSE_repeat_none ? ZSTD_fseBitCost(prevCTable, count, max) : ERROR(GENERIC);
+        size_t const NCountCost = ZSTD_NCountCost(count, max, nbSeq, FSELog);
+        size_t const compressedCost = (NCountCost << 3) + ZSTD_entropyCost(count, max, nbSeq);
+
+        if (isDefaultAllowed) {
+            assert(!ZSTD_isError(basicCost));
+            assert(!(*repeatMode == FSE_repeat_valid && ZSTD_isError(repeatCost)));
+        }
+        assert(!ZSTD_isError(NCountCost));
+        assert(compressedCost < ERROR(maxCode));
+        DEBUGLOG(5, "Estimated bit costs: basic=%u\trepeat=%u\tcompressed=%u",
+                    (unsigned)basicCost, (unsigned)repeatCost, (unsigned)compressedCost);
+        if (basicCost <= repeatCost && basicCost <= compressedCost) {
+            DEBUGLOG(5, "Selected set_basic");
+            assert(isDefaultAllowed);
+            *repeatMode = FSE_repeat_none;
+            return set_basic;
+        }
+        if (repeatCost <= compressedCost) {
+            DEBUGLOG(5, "Selected set_repeat");
+            assert(!ZSTD_isError(repeatCost));
+            return set_repeat;
+        }
+        assert(compressedCost < basicCost && compressedCost < repeatCost);
+    }
+    DEBUGLOG(5, "Selected set_compressed");
+    *repeatMode = FSE_repeat_check;
+    return set_compressed;
+}
+
+size_t
+ZSTD_buildCTable(void* dst, size_t dstCapacity,
+                FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
+                unsigned* count, U32 max,
+                const BYTE* codeTable, size_t nbSeq,
+                const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
+                const FSE_CTable* prevCTable, size_t prevCTableSize,
+                void* workspace, size_t workspaceSize)
+{
+    BYTE* op = (BYTE*)dst;
+    const BYTE* const oend = op + dstCapacity;
+    DEBUGLOG(6, "ZSTD_buildCTable (dstCapacity=%u)", (unsigned)dstCapacity);
+
+    switch (type) {
+    case set_rle:
+        FORWARD_IF_ERROR(FSE_buildCTable_rle(nextCTable, (BYTE)max));
+        RETURN_ERROR_IF(dstCapacity==0, dstSize_tooSmall);
+        *op = codeTable[0];
+        return 1;
+    case set_repeat:
+        memcpy(nextCTable, prevCTable, prevCTableSize);
+        return 0;
+    case set_basic:
+        FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize));  /* note : could be pre-calculated */
+        return 0;
+    case set_compressed: {
+        S16 norm[MaxSeq + 1];
+        size_t nbSeq_1 = nbSeq;
+        const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
+        if (count[codeTable[nbSeq-1]] > 1) {
+            count[codeTable[nbSeq-1]]--;
+            nbSeq_1--;
+        }
+        assert(nbSeq_1 > 1);
+        FORWARD_IF_ERROR(FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max));
+        {   size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog);   /* overflow protected */
+            FORWARD_IF_ERROR(NCountSize);
+            FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, norm, max, tableLog, workspace, workspaceSize));
+            return NCountSize;
+        }
+    }
+    default: assert(0); RETURN_ERROR(GENERIC);
+    }
+}
+
+FORCE_INLINE_TEMPLATE size_t
+ZSTD_encodeSequences_body(
+            void* dst, size_t dstCapacity,
+            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
+            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
+            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
+            seqDef const* sequences, size_t nbSeq, int longOffsets)
+{
+    BIT_CStream_t blockStream;
+    FSE_CState_t  stateMatchLength;
+    FSE_CState_t  stateOffsetBits;
+    FSE_CState_t  stateLitLength;
+
+    RETURN_ERROR_IF(
+        ERR_isError(BIT_initCStream(&blockStream, dst, dstCapacity)),
+        dstSize_tooSmall, "not enough space remaining");
+    DEBUGLOG(6, "available space for bitstream : %i  (dstCapacity=%u)",
+                (int)(blockStream.endPtr - blockStream.startPtr),
+                (unsigned)dstCapacity);
+
+    /* first symbols */
+    FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
+    FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]);
+    FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);
+    BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);
+    if (MEM_32bits()) BIT_flushBits(&blockStream);
+    BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]);
+    if (MEM_32bits()) BIT_flushBits(&blockStream);
+    if (longOffsets) {
+        U32 const ofBits = ofCodeTable[nbSeq-1];
+        int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
+        if (extraBits) {
+            BIT_addBits(&blockStream, sequences[nbSeq-1].offset, extraBits);
+            BIT_flushBits(&blockStream);
+        }
+        BIT_addBits(&blockStream, sequences[nbSeq-1].offset >> extraBits,
+                    ofBits - extraBits);
+    } else {
+        BIT_addBits(&blockStream, sequences[nbSeq-1].offset, ofCodeTable[nbSeq-1]);
+    }
+    BIT_flushBits(&blockStream);
+
+    {   size_t n;
+        for (n=nbSeq-2 ; n<nbSeq ; n--) {      /* intentional underflow */
+            BYTE const llCode = llCodeTable[n];
+            BYTE const ofCode = ofCodeTable[n];
+            BYTE const mlCode = mlCodeTable[n];
+            U32  const llBits = LL_bits[llCode];
+            U32  const ofBits = ofCode;
+            U32  const mlBits = ML_bits[mlCode];
+            DEBUGLOG(6, "encoding: litlen:%2u - matchlen:%2u - offCode:%7u",
+                        (unsigned)sequences[n].litLength,
+                        (unsigned)sequences[n].matchLength + MINMATCH,
+                        (unsigned)sequences[n].offset);
+                                                                            /* 32b*/  /* 64b*/
+                                                                            /* (7)*/  /* (7)*/
+            FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
+            FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
+            if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
+            FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */
+            if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
+                BIT_flushBits(&blockStream);                                /* (7)*/
+            BIT_addBits(&blockStream, sequences[n].litLength, llBits);
+            if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
+            BIT_addBits(&blockStream, sequences[n].matchLength, mlBits);
+            if (MEM_32bits() || (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream);
+            if (longOffsets) {
+                int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
+                if (extraBits) {
+                    BIT_addBits(&blockStream, sequences[n].offset, extraBits);
+                    BIT_flushBits(&blockStream);                            /* (7)*/
+                }
+                BIT_addBits(&blockStream, sequences[n].offset >> extraBits,
+                            ofBits - extraBits);                            /* 31 */
+            } else {
+                BIT_addBits(&blockStream, sequences[n].offset, ofBits);     /* 31 */
+            }
+            BIT_flushBits(&blockStream);                                    /* (7)*/
+            DEBUGLOG(7, "remaining space : %i", (int)(blockStream.endPtr - blockStream.ptr));
+    }   }
+
+    DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog);
+    FSE_flushCState(&blockStream, &stateMatchLength);
+    DEBUGLOG(6, "ZSTD_encodeSequences: flushing Off state with %u bits", stateOffsetBits.stateLog);
+    FSE_flushCState(&blockStream, &stateOffsetBits);
+    DEBUGLOG(6, "ZSTD_encodeSequences: flushing LL state with %u bits", stateLitLength.stateLog);
+    FSE_flushCState(&blockStream, &stateLitLength);
+
+    {   size_t const streamSize = BIT_closeCStream(&blockStream);
+        RETURN_ERROR_IF(streamSize==0, dstSize_tooSmall, "not enough space");
+        return streamSize;
+    }
+}
+
+static size_t
+ZSTD_encodeSequences_default(
+            void* dst, size_t dstCapacity,
+            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
+            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
+            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
+            seqDef const* sequences, size_t nbSeq, int longOffsets)
+{
+    return ZSTD_encodeSequences_body(dst, dstCapacity,
+                                    CTable_MatchLength, mlCodeTable,
+                                    CTable_OffsetBits, ofCodeTable,
+                                    CTable_LitLength, llCodeTable,
+                                    sequences, nbSeq, longOffsets);
+}
+
+
+#if DYNAMIC_BMI2
+
+static TARGET_ATTRIBUTE("bmi2") size_t
+ZSTD_encodeSequences_bmi2(
+            void* dst, size_t dstCapacity,
+            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
+            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
+            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
+            seqDef const* sequences, size_t nbSeq, int longOffsets)
+{
+    return ZSTD_encodeSequences_body(dst, dstCapacity,
+                                    CTable_MatchLength, mlCodeTable,
+                                    CTable_OffsetBits, ofCodeTable,
+                                    CTable_LitLength, llCodeTable,
+                                    sequences, nbSeq, longOffsets);
+}
+
+#endif
+
+size_t ZSTD_encodeSequences(
+            void* dst, size_t dstCapacity,
+            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
+            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
+            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
+            seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2)
+{
+    DEBUGLOG(5, "ZSTD_encodeSequences: dstCapacity = %u", (unsigned)dstCapacity);
+#if DYNAMIC_BMI2
+    if (bmi2) {
+        return ZSTD_encodeSequences_bmi2(dst, dstCapacity,
+                                         CTable_MatchLength, mlCodeTable,
+                                         CTable_OffsetBits, ofCodeTable,
+                                         CTable_LitLength, llCodeTable,
+                                         sequences, nbSeq, longOffsets);
+    }
+#endif
+    (void)bmi2;
+    return ZSTD_encodeSequences_default(dst, dstCapacity,
+                                        CTable_MatchLength, mlCodeTable,
+                                        CTable_OffsetBits, ofCodeTable,
+                                        CTable_LitLength, llCodeTable,
+                                        sequences, nbSeq, longOffsets);
+}
diff --git a/src/zstd_compress_sequences.h b/src/zstd_compress_sequences.h
new file mode 100644
index 0000000..f5234d9
--- /dev/null
+++ b/src/zstd_compress_sequences.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_COMPRESS_SEQUENCES_H
+#define ZSTD_COMPRESS_SEQUENCES_H
+
+#include "fse.h" /* FSE_repeat, FSE_CTable */
+#include "zstd_internal.h" /* symbolEncodingType_e, ZSTD_strategy */
+
+typedef enum {
+    ZSTD_defaultDisallowed = 0,
+    ZSTD_defaultAllowed = 1
+} ZSTD_defaultPolicy_e;
+
+symbolEncodingType_e
+ZSTD_selectEncodingType(
+        FSE_repeat* repeatMode, unsigned const* count, unsigned const max,
+        size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,
+        FSE_CTable const* prevCTable,
+        short const* defaultNorm, U32 defaultNormLog,
+        ZSTD_defaultPolicy_e const isDefaultAllowed,
+        ZSTD_strategy const strategy);
+
+size_t
+ZSTD_buildCTable(void* dst, size_t dstCapacity,
+                FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
+                unsigned* count, U32 max,
+                const BYTE* codeTable, size_t nbSeq,
+                const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
+                const FSE_CTable* prevCTable, size_t prevCTableSize,
+                void* workspace, size_t workspaceSize);
+
+size_t ZSTD_encodeSequences(
+            void* dst, size_t dstCapacity,
+            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
+            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
+            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
+            seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2);
+
+#endif /* ZSTD_COMPRESS_SEQUENCES_H */
diff --git a/src/zstd_ddict.c b/src/zstd_ddict.c
new file mode 100644
index 0000000..0af3d23
--- /dev/null
+++ b/src/zstd_ddict.c
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* zstd_ddict.c :
+ * concentrates all logic that needs to know the internals of ZSTD_DDict object */
+
+/*-*******************************************************
+*  Dependencies
+*********************************************************/
+#include <string.h>      /* memcpy, memmove, memset */
+#include "cpu.h"         /* bmi2 */
+#include "mem.h"         /* low level memory routines */
+#define FSE_STATIC_LINKING_ONLY
+#include "fse.h"
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
+#include "zstd_decompress_internal.h"
+#include "zstd_ddict.h"
+
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
+#  include "zstd_legacy.h"
+#endif
+
+
+
+/*-*******************************************************
+*  Types
+*********************************************************/
+struct ZSTD_DDict_s {
+    void* dictBuffer;
+    const void* dictContent;
+    size_t dictSize;
+    ZSTD_entropyDTables_t entropy;
+    U32 dictID;
+    U32 entropyPresent;
+    ZSTD_customMem cMem;
+};  /* typedef'd to ZSTD_DDict within "zstd.h" */
+
+const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict)
+{
+    assert(ddict != NULL);
+    return ddict->dictContent;
+}
+
+size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict)
+{
+    assert(ddict != NULL);
+    return ddict->dictSize;
+}
+
+void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
+{
+    DEBUGLOG(4, "ZSTD_copyDDictParameters");
+    assert(dctx != NULL);
+    assert(ddict != NULL);
+    dctx->dictID = ddict->dictID;
+    dctx->prefixStart = ddict->dictContent;
+    dctx->virtualStart = ddict->dictContent;
+    dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;
+    dctx->previousDstEnd = dctx->dictEnd;
+    if (ddict->entropyPresent) {
+        dctx->litEntropy = 1;
+        dctx->fseEntropy = 1;
+        dctx->LLTptr = ddict->entropy.LLTable;
+        dctx->MLTptr = ddict->entropy.MLTable;
+        dctx->OFTptr = ddict->entropy.OFTable;
+        dctx->HUFptr = ddict->entropy.hufTable;
+        dctx->entropy.rep[0] = ddict->entropy.rep[0];
+        dctx->entropy.rep[1] = ddict->entropy.rep[1];
+        dctx->entropy.rep[2] = ddict->entropy.rep[2];
+    } else {
+        dctx->litEntropy = 0;
+        dctx->fseEntropy = 0;
+    }
+}
+
+
+static size_t
+ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
+                           ZSTD_dictContentType_e dictContentType)
+{
+    ddict->dictID = 0;
+    ddict->entropyPresent = 0;
+    if (dictContentType == ZSTD_dct_rawContent) return 0;
+
+    if (ddict->dictSize < 8) {
+        if (dictContentType == ZSTD_dct_fullDict)
+            return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */
+        return 0;   /* pure content mode */
+    }
+    {   U32 const magic = MEM_readLE32(ddict->dictContent);
+        if (magic != ZSTD_MAGIC_DICTIONARY) {
+            if (dictContentType == ZSTD_dct_fullDict)
+                return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */
+            return 0;   /* pure content mode */
+        }
+    }
+    ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);
+
+    /* load entropy tables */
+    RETURN_ERROR_IF(ZSTD_isError(ZSTD_loadDEntropy(
+            &ddict->entropy, ddict->dictContent, ddict->dictSize)),
+        dictionary_corrupted);
+    ddict->entropyPresent = 1;
+    return 0;
+}
+
+
+static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
+                                      const void* dict, size_t dictSize,
+                                      ZSTD_dictLoadMethod_e dictLoadMethod,
+                                      ZSTD_dictContentType_e dictContentType)
+{
+    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {
+        ddict->dictBuffer = NULL;
+        ddict->dictContent = dict;
+        if (!dict) dictSize = 0;
+    } else {
+        void* const internalBuffer = ZSTD_malloc(dictSize, ddict->cMem);
+        ddict->dictBuffer = internalBuffer;
+        ddict->dictContent = internalBuffer;
+        if (!internalBuffer) return ERROR(memory_allocation);
+        memcpy(internalBuffer, dict, dictSize);
+    }
+    ddict->dictSize = dictSize;
+    ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001);  /* cover both little and big endian */
+
+    /* parse dictionary content */
+    FORWARD_IF_ERROR( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) );
+
+    return 0;
+}
+
+ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
+                                      ZSTD_dictLoadMethod_e dictLoadMethod,
+                                      ZSTD_dictContentType_e dictContentType,
+                                      ZSTD_customMem customMem)
+{
+    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
+
+    {   ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(sizeof(ZSTD_DDict), customMem);
+        if (ddict == NULL) return NULL;
+        ddict->cMem = customMem;
+        {   size_t const initResult = ZSTD_initDDict_internal(ddict,
+                                            dict, dictSize,
+                                            dictLoadMethod, dictContentType);
+            if (ZSTD_isError(initResult)) {
+                ZSTD_freeDDict(ddict);
+                return NULL;
+        }   }
+        return ddict;
+    }
+}
+
+/*! ZSTD_createDDict() :
+*   Create a digested dictionary, to start decompression without startup delay.
+*   `dict` content is copied inside DDict.
+*   Consequently, `dict` can be released after `ZSTD_DDict` creation */
+ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)
+{
+    ZSTD_customMem const allocator = { NULL, NULL, NULL };
+    return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
+}
+
+/*! ZSTD_createDDict_byReference() :
+ *  Create a digested dictionary, to start decompression without startup delay.
+ *  Dictionary content is simply referenced, it will be accessed during decompression.
+ *  Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */
+ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)
+{
+    ZSTD_customMem const allocator = { NULL, NULL, NULL };
+    return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
+}
+
+
+const ZSTD_DDict* ZSTD_initStaticDDict(
+                                void* sBuffer, size_t sBufferSize,
+                                const void* dict, size_t dictSize,
+                                ZSTD_dictLoadMethod_e dictLoadMethod,
+                                ZSTD_dictContentType_e dictContentType)
+{
+    size_t const neededSpace = sizeof(ZSTD_DDict)
+                             + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
+    ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;
+    assert(sBuffer != NULL);
+    assert(dict != NULL);
+    if ((size_t)sBuffer & 7) return NULL;   /* 8-aligned */
+    if (sBufferSize < neededSpace) return NULL;
+    if (dictLoadMethod == ZSTD_dlm_byCopy) {
+        memcpy(ddict+1, dict, dictSize);  /* local copy */
+        dict = ddict+1;
+    }
+    if (ZSTD_isError( ZSTD_initDDict_internal(ddict,
+                                              dict, dictSize,
+                                              ZSTD_dlm_byRef, dictContentType) ))
+        return NULL;
+    return ddict;
+}
+
+
+size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
+{
+    if (ddict==NULL) return 0;   /* support free on NULL */
+    {   ZSTD_customMem const cMem = ddict->cMem;
+        ZSTD_free(ddict->dictBuffer, cMem);
+        ZSTD_free(ddict, cMem);
+        return 0;
+    }
+}
+
+/*! ZSTD_estimateDDictSize() :
+ *  Estimate amount of memory that will be needed to create a dictionary for decompression.
+ *  Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */
+size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
+{
+    return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
+}
+
+size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)
+{
+    if (ddict==NULL) return 0;   /* support sizeof on NULL */
+    return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
+}
+
+/*! ZSTD_getDictID_fromDDict() :
+ *  Provides the dictID of the dictionary loaded into `ddict`.
+ *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
+ *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
+unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
+{
+    if (ddict==NULL) return 0;
+    return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize);
+}
diff --git a/src/zstd_ddict.h b/src/zstd_ddict.h
new file mode 100644
index 0000000..0479d11
--- /dev/null
+++ b/src/zstd_ddict.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+#ifndef ZSTD_DDICT_H
+#define ZSTD_DDICT_H
+
+/*-*******************************************************
+ *  Dependencies
+ *********************************************************/
+#include <stddef.h>   /* size_t */
+#include "zstd.h"     /* ZSTD_DDict, and several public functions */
+
+
+/*-*******************************************************
+ *  Interface
+ *********************************************************/
+
+/* note: several prototypes are already published in `zstd.h` :
+ * ZSTD_createDDict()
+ * ZSTD_createDDict_byReference()
+ * ZSTD_createDDict_advanced()
+ * ZSTD_freeDDict()
+ * ZSTD_initStaticDDict()
+ * ZSTD_sizeof_DDict()
+ * ZSTD_estimateDDictSize()
+ * ZSTD_getDictID_fromDict()
+ */
+
+const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict);
+size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict);
+
+void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
+
+
+
+#endif /* ZSTD_DDICT_H */
diff --git a/src/zstd_decompress.c b/src/zstd_decompress.c
new file mode 100644
index 0000000..751060b
--- /dev/null
+++ b/src/zstd_decompress.c
@@ -0,0 +1,1771 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+ * HEAPMODE :
+ * Select how default decompression function ZSTD_decompress() allocates its context,
+ * on stack (0), or into heap (1, default; requires malloc()).
+ * Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected.
+ */
+#ifndef ZSTD_HEAPMODE
+#  define ZSTD_HEAPMODE 1
+#endif
+
+/*!
+*  LEGACY_SUPPORT :
+*  if set to 1+, ZSTD_decompress() can decode older formats (v0.1+)
+*/
+#ifndef ZSTD_LEGACY_SUPPORT
+#  define ZSTD_LEGACY_SUPPORT 0
+#endif
+
+/*!
+ *  MAXWINDOWSIZE_DEFAULT :
+ *  maximum window size accepted by DStream __by default__.
+ *  Frames requiring more memory will be rejected.
+ *  It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().
+ */
+#ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
+#  define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
+#endif
+
+/*!
+ *  NO_FORWARD_PROGRESS_MAX :
+ *  maximum allowed nb of calls to ZSTD_decompressStream()
+ *  without any forward progress
+ *  (defined as: no byte read from input, and no byte flushed to output)
+ *  before triggering an error.
+ */
+#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX
+#  define ZSTD_NO_FORWARD_PROGRESS_MAX 16
+#endif
+
+
+/*-*******************************************************
+*  Dependencies
+*********************************************************/
+#include <string.h>      /* memcpy, memmove, memset */
+#include "cpu.h"         /* bmi2 */
+#include "mem.h"         /* low level memory routines */
+#define FSE_STATIC_LINKING_ONLY
+#include "fse.h"
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
+#include "zstd_internal.h"  /* blockProperties_t */
+#include "zstd_decompress_internal.h"   /* ZSTD_DCtx */
+#include "zstd_ddict.h"  /* ZSTD_DDictDictContent */
+#include "zstd_decompress_block.h"   /* ZSTD_decompressBlock_internal */
+
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
+#  include "zstd_legacy.h"
+#endif
+
+
+/*-*************************************************************
+*   Context management
+***************************************************************/
+size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
+{
+    if (dctx==NULL) return 0;   /* support sizeof NULL */
+    return sizeof(*dctx)
+           + ZSTD_sizeof_DDict(dctx->ddictLocal)
+           + dctx->inBuffSize + dctx->outBuffSize;
+}
+
+size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
+
+
+static size_t ZSTD_startingInputLength(ZSTD_format_e format)
+{
+    size_t const startingInputLength = (format==ZSTD_f_zstd1_magicless) ?
+                    ZSTD_FRAMEHEADERSIZE_PREFIX - ZSTD_FRAMEIDSIZE :
+                    ZSTD_FRAMEHEADERSIZE_PREFIX;
+    ZSTD_STATIC_ASSERT(ZSTD_FRAMEHEADERSIZE_PREFIX >= ZSTD_FRAMEIDSIZE);
+    /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */
+    assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) );
+    return startingInputLength;
+}
+
+static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
+{
+    dctx->format = ZSTD_f_zstd1;  /* ZSTD_decompressBegin() invokes ZSTD_startingInputLength() with argument dctx->format */
+    dctx->staticSize  = 0;
+    dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
+    dctx->ddict       = NULL;
+    dctx->ddictLocal  = NULL;
+    dctx->dictEnd     = NULL;
+    dctx->ddictIsCold = 0;
+    dctx->dictUses = ZSTD_dont_use;
+    dctx->inBuff      = NULL;
+    dctx->inBuffSize  = 0;
+    dctx->outBuffSize = 0;
+    dctx->streamStage = zdss_init;
+    dctx->legacyContext = NULL;
+    dctx->previousLegacyVersion = 0;
+    dctx->noForwardProgress = 0;
+    dctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
+}
+
+ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)
+{
+    ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;
+
+    if ((size_t)workspace & 7) return NULL;  /* 8-aligned */
+    if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL;  /* minimum size */
+
+    ZSTD_initDCtx_internal(dctx);
+    dctx->staticSize = workspaceSize;
+    dctx->inBuff = (char*)(dctx+1);
+    return dctx;
+}
+
+ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
+{
+    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
+
+    {   ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_malloc(sizeof(*dctx), customMem);
+        if (!dctx) return NULL;
+        dctx->customMem = customMem;
+        ZSTD_initDCtx_internal(dctx);
+        return dctx;
+    }
+}
+
+ZSTD_DCtx* ZSTD_createDCtx(void)
+{
+    DEBUGLOG(3, "ZSTD_createDCtx");
+    return ZSTD_createDCtx_advanced(ZSTD_defaultCMem);
+}
+
+static void ZSTD_clearDict(ZSTD_DCtx* dctx)
+{
+    ZSTD_freeDDict(dctx->ddictLocal);
+    dctx->ddictLocal = NULL;
+    dctx->ddict = NULL;
+    dctx->dictUses = ZSTD_dont_use;
+}
+
+size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
+{
+    if (dctx==NULL) return 0;   /* support free on NULL */
+    RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
+    {   ZSTD_customMem const cMem = dctx->customMem;
+        ZSTD_clearDict(dctx);
+        ZSTD_free(dctx->inBuff, cMem);
+        dctx->inBuff = NULL;
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
+        if (dctx->legacyContext)
+            ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion);
+#endif
+        ZSTD_free(dctx, cMem);
+        return 0;
+    }
+}
+
+/* no longer useful */
+void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
+{
+    size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx);
+    memcpy(dstDCtx, srcDCtx, toCopy);  /* no need to copy workspace */
+}
+
+
+/*-*************************************************************
+ *   Frame header decoding
+ ***************************************************************/
+
+/*! ZSTD_isFrame() :
+ *  Tells if the content of `buffer` starts with a valid Frame Identifier.
+ *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
+ *  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
+ *  Note 3 : Skippable Frame Identifiers are considered valid. */
+unsigned ZSTD_isFrame(const void* buffer, size_t size)
+{
+    if (size < ZSTD_FRAMEIDSIZE) return 0;
+    {   U32 const magic = MEM_readLE32(buffer);
+        if (magic == ZSTD_MAGICNUMBER) return 1;
+        if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
+    }
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
+    if (ZSTD_isLegacy(buffer, size)) return 1;
+#endif
+    return 0;
+}
+
+/** ZSTD_frameHeaderSize_internal() :
+ *  srcSize must be large enough to reach header size fields.
+ *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless.
+ * @return : size of the Frame Header
+ *           or an error code, which can be tested with ZSTD_isError() */
+static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format)
+{
+    size_t const minInputSize = ZSTD_startingInputLength(format);
+    RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong);
+
+    {   BYTE const fhd = ((const BYTE*)src)[minInputSize-1];
+        U32 const dictID= fhd & 3;
+        U32 const singleSegment = (fhd >> 5) & 1;
+        U32 const fcsId = fhd >> 6;
+        return minInputSize + !singleSegment
+             + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]
+             + (singleSegment && !fcsId);
+    }
+}
+
+/** ZSTD_frameHeaderSize() :
+ *  srcSize must be >= ZSTD_frameHeaderSize_prefix.
+ * @return : size of the Frame Header,
+ *           or an error code (if srcSize is too small) */
+size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
+{
+    return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);
+}
+
+
+/** ZSTD_getFrameHeader_advanced() :
+ *  decode Frame Header, or require larger `srcSize`.
+ *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless
+ * @return : 0, `zfhPtr` is correctly filled,
+ *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
+ *           or an error code, which can be tested using ZSTD_isError() */
+size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t const minInputSize = ZSTD_startingInputLength(format);
+
+    memset(zfhPtr, 0, sizeof(*zfhPtr));   /* not strictly necessary, but static analyzer do not understand that zfhPtr is only going to be read only if return value is zero, since they are 2 different signals */
+    if (srcSize < minInputSize) return minInputSize;
+    RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter");
+
+    if ( (format != ZSTD_f_zstd1_magicless)
+      && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) {
+        if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
+            /* skippable frame */
+            if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
+                return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */
+            memset(zfhPtr, 0, sizeof(*zfhPtr));
+            zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);
+            zfhPtr->frameType = ZSTD_skippableFrame;
+            return 0;
+        }
+        RETURN_ERROR(prefix_unknown);
+    }
+
+    /* ensure there is enough `srcSize` to fully read/decode frame header */
+    {   size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format);
+        if (srcSize < fhsize) return fhsize;
+        zfhPtr->headerSize = (U32)fhsize;
+    }
+
+    {   BYTE const fhdByte = ip[minInputSize-1];
+        size_t pos = minInputSize;
+        U32 const dictIDSizeCode = fhdByte&3;
+        U32 const checksumFlag = (fhdByte>>2)&1;
+        U32 const singleSegment = (fhdByte>>5)&1;
+        U32 const fcsID = fhdByte>>6;
+        U64 windowSize = 0;
+        U32 dictID = 0;
+        U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
+        RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,
+                        "reserved bits, must be zero");
+
+        if (!singleSegment) {
+            BYTE const wlByte = ip[pos++];
+            U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
+            RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge);
+            windowSize = (1ULL << windowLog);
+            windowSize += (windowSize >> 3) * (wlByte&7);
+        }
+        switch(dictIDSizeCode)
+        {
+            default: assert(0);  /* impossible */
+            case 0 : break;
+            case 1 : dictID = ip[pos]; pos++; break;
+            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
+            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
+        }
+        switch(fcsID)
+        {
+            default: assert(0);  /* impossible */
+            case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
+            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
+            case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
+            case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
+        }
+        if (singleSegment) windowSize = frameContentSize;
+
+        zfhPtr->frameType = ZSTD_frame;
+        zfhPtr->frameContentSize = frameContentSize;
+        zfhPtr->windowSize = windowSize;
+        zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
+        zfhPtr->dictID = dictID;
+        zfhPtr->checksumFlag = checksumFlag;
+    }
+    return 0;
+}
+
+/** ZSTD_getFrameHeader() :
+ *  decode Frame Header, or require larger `srcSize`.
+ *  note : this function does not consume input, it only reads it.
+ * @return : 0, `zfhPtr` is correctly filled,
+ *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
+ *           or an error code, which can be tested using ZSTD_isError() */
+size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize)
+{
+    return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1);
+}
+
+
+/** ZSTD_getFrameContentSize() :
+ *  compatible with legacy mode
+ * @return : decompressed size of the single frame pointed to be `src` if known, otherwise
+ *         - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
+ *         - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */
+unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
+{
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
+    if (ZSTD_isLegacy(src, srcSize)) {
+        unsigned long long const ret = ZSTD_getDecompressedSize_legacy(src, srcSize);
+        return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret;
+    }
+#endif
+    {   ZSTD_frameHeader zfh;
+        if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0)
+            return ZSTD_CONTENTSIZE_ERROR;
+        if (zfh.frameType == ZSTD_skippableFrame) {
+            return 0;
+        } else {
+            return zfh.frameContentSize;
+    }   }
+}
+
+static size_t readSkippableFrameSize(void const* src, size_t srcSize)
+{
+    size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
+    U32 sizeU32;
+
+    RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong);
+
+    sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);
+    RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32,
+                    frameParameter_unsupported);
+    {
+        size_t const skippableSize = skippableHeaderSize + sizeU32;
+        RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong);
+        return skippableSize;
+    }
+}
+
+/** ZSTD_findDecompressedSize() :
+ *  compatible with legacy mode
+ *  `srcSize` must be the exact length of some number of ZSTD compressed and/or
+ *      skippable frames
+ *  @return : decompressed size of the frames contained */
+unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
+{
+    unsigned long long totalDstSize = 0;
+
+    while (srcSize >= ZSTD_FRAMEHEADERSIZE_PREFIX) {
+        U32 const magicNumber = MEM_readLE32(src);
+
+        if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
+            size_t const skippableSize = readSkippableFrameSize(src, srcSize);
+            if (ZSTD_isError(skippableSize)) {
+                return ZSTD_CONTENTSIZE_ERROR;
+            }
+            assert(skippableSize <= srcSize);
+
+            src = (const BYTE *)src + skippableSize;
+            srcSize -= skippableSize;
+            continue;
+        }
+
+        {   unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
+            if (ret >= ZSTD_CONTENTSIZE_ERROR) return ret;
+
+            /* check for overflow */
+            if (totalDstSize + ret < totalDstSize) return ZSTD_CONTENTSIZE_ERROR;
+            totalDstSize += ret;
+        }
+        {   size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize);
+            if (ZSTD_isError(frameSrcSize)) {
+                return ZSTD_CONTENTSIZE_ERROR;
+            }
+
+            src = (const BYTE *)src + frameSrcSize;
+            srcSize -= frameSrcSize;
+        }
+    }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
+
+    if (srcSize) return ZSTD_CONTENTSIZE_ERROR;
+
+    return totalDstSize;
+}
+
+/** ZSTD_getDecompressedSize() :
+ *  compatible with legacy mode
+ * @return : decompressed size if known, 0 otherwise
+             note : 0 can mean any of the following :
+                   - frame content is empty
+                   - decompressed size field is not present in frame header
+                   - frame header unknown / not supported
+                   - frame header not complete (`srcSize` too small) */
+unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
+{
+    unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
+    ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);
+    return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
+}
+
+
+/** ZSTD_decodeFrameHeader() :
+ * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
+ * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
+static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
+{
+    size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
+    if (ZSTD_isError(result)) return result;    /* invalid header */
+    RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small");
+#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+    /* Skip the dictID check in fuzzing mode, because it makes the search
+     * harder.
+     */
+    RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),
+                    dictionary_wrong);
+#endif
+    if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);
+    return 0;
+}
+
+static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)
+{
+    ZSTD_frameSizeInfo frameSizeInfo;
+    frameSizeInfo.compressedSize = ret;
+    frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
+    return frameSizeInfo;
+}
+
+static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize)
+{
+    ZSTD_frameSizeInfo frameSizeInfo;
+    memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
+
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
+    if (ZSTD_isLegacy(src, srcSize))
+        return ZSTD_findFrameSizeInfoLegacy(src, srcSize);
+#endif
+
+    if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
+        && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
+        frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
+        assert(ZSTD_isError(frameSizeInfo.compressedSize) ||
+               frameSizeInfo.compressedSize <= srcSize);
+        return frameSizeInfo;
+    } else {
+        const BYTE* ip = (const BYTE*)src;
+        const BYTE* const ipstart = ip;
+        size_t remainingSize = srcSize;
+        size_t nbBlocks = 0;
+        ZSTD_frameHeader zfh;
+
+        /* Extract Frame Header */
+        {   size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize);
+            if (ZSTD_isError(ret))
+                return ZSTD_errorFrameSizeInfo(ret);
+            if (ret > 0)
+                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
+        }
+
+        ip += zfh.headerSize;
+        remainingSize -= zfh.headerSize;
+
+        /* Iterate over each block */
+        while (1) {
+            blockProperties_t blockProperties;
+            size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
+            if (ZSTD_isError(cBlockSize))
+                return ZSTD_errorFrameSizeInfo(cBlockSize);
+
+            if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
+                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
+
+            ip += ZSTD_blockHeaderSize + cBlockSize;
+            remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
+            nbBlocks++;
+
+            if (blockProperties.lastBlock) break;
+        }
+
+        /* Final frame content checksum */
+        if (zfh.checksumFlag) {
+            if (remainingSize < 4)
+                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
+            ip += 4;
+        }
+
+        frameSizeInfo.compressedSize = ip - ipstart;
+        frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
+                                        ? zfh.frameContentSize
+                                        : nbBlocks * zfh.blockSizeMax;
+        return frameSizeInfo;
+    }
+}
+
+/** ZSTD_findFrameCompressedSize() :
+ *  compatible with legacy mode
+ *  `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame
+ *  `srcSize` must be at least as large as the frame contained
+ *  @return : the compressed size of the frame starting at `src` */
+size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
+{
+    ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
+    return frameSizeInfo.compressedSize;
+}
+
+/** ZSTD_decompressBound() :
+ *  compatible with legacy mode
+ *  `src` must point to the start of a ZSTD frame or a skippeable frame
+ *  `srcSize` must be at least as large as the frame contained
+ *  @return : the maximum decompressed size of the compressed source
+ */
+unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
+{
+    unsigned long long bound = 0;
+    /* Iterate over each frame */
+    while (srcSize > 0) {
+        ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
+        size_t const compressedSize = frameSizeInfo.compressedSize;
+        unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
+        if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)
+            return ZSTD_CONTENTSIZE_ERROR;
+        assert(srcSize >= compressedSize);
+        src = (const BYTE*)src + compressedSize;
+        srcSize -= compressedSize;
+        bound += decompressedBound;
+    }
+    return bound;
+}
+
+
+/*-*************************************************************
+ *   Frame decoding
+ ***************************************************************/
+
+
+void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)
+{
+    if (dst != dctx->previousDstEnd) {   /* not contiguous */
+        dctx->dictEnd = dctx->previousDstEnd;
+        dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
+        dctx->prefixStart = dst;
+        dctx->previousDstEnd = dst;
+    }
+}
+
+/** ZSTD_insertBlock() :
+ *  insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
+size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
+{
+    DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize);
+    ZSTD_checkContinuity(dctx, blockStart);
+    dctx->previousDstEnd = (const char*)blockStart + blockSize;
+    return blockSize;
+}
+
+
+static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
+                          const void* src, size_t srcSize)
+{
+    DEBUGLOG(5, "ZSTD_copyRawBlock");
+    if (dst == NULL) {
+        if (srcSize == 0) return 0;
+        RETURN_ERROR(dstBuffer_null);
+    }
+    RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
+                               BYTE b,
+                               size_t regenSize)
+{
+    if (dst == NULL) {
+        if (regenSize == 0) return 0;
+        RETURN_ERROR(dstBuffer_null);
+    }
+    RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall);
+    memset(dst, b, regenSize);
+    return regenSize;
+}
+
+
+/*! ZSTD_decompressFrame() :
+ * @dctx must be properly initialized
+ *  will update *srcPtr and *srcSizePtr,
+ *  to make *srcPtr progress by one frame. */
+static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
+                                   void* dst, size_t dstCapacity,
+                             const void** srcPtr, size_t *srcSizePtr)
+{
+    const BYTE* ip = (const BYTE*)(*srcPtr);
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* const oend = ostart + dstCapacity;
+    BYTE* op = ostart;
+    size_t remainingSrcSize = *srcSizePtr;
+
+    DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);
+
+    /* check */
+    RETURN_ERROR_IF(
+        remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN+ZSTD_blockHeaderSize,
+        srcSize_wrong);
+
+    /* Frame Header */
+    {   size_t const frameHeaderSize = ZSTD_frameHeaderSize(ip, ZSTD_FRAMEHEADERSIZE_PREFIX);
+        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
+        RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,
+                        srcSize_wrong);
+        FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) );
+        ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
+    }
+
+    /* Loop on each block */
+    while (1) {
+        size_t decodedSize;
+        blockProperties_t blockProperties;
+        size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
+        if (ZSTD_isError(cBlockSize)) return cBlockSize;
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSrcSize -= ZSTD_blockHeaderSize;
+        RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize, /* frame */ 1);
+            break;
+        case bt_raw :
+            decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);
+            break;
+        case bt_rle :
+            decodedSize = ZSTD_setRleBlock(op, oend-op, *ip, blockProperties.origSize);
+            break;
+        case bt_reserved :
+        default:
+            RETURN_ERROR(corruption_detected);
+        }
+
+        if (ZSTD_isError(decodedSize)) return decodedSize;
+        if (dctx->fParams.checksumFlag)
+            XXH64_update(&dctx->xxhState, op, decodedSize);
+        op += decodedSize;
+        ip += cBlockSize;
+        remainingSrcSize -= cBlockSize;
+        if (blockProperties.lastBlock) break;
+    }
+
+    if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
+        RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
+                        corruption_detected);
+    }
+    if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
+        U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState);
+        U32 checkRead;
+        RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong);
+        checkRead = MEM_readLE32(ip);
+        RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong);
+        ip += 4;
+        remainingSrcSize -= 4;
+    }
+
+    /* Allow caller to get size read */
+    *srcPtr = ip;
+    *srcSizePtr = remainingSrcSize;
+    return op-ostart;
+}
+
+static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
+                                        void* dst, size_t dstCapacity,
+                                  const void* src, size_t srcSize,
+                                  const void* dict, size_t dictSize,
+                                  const ZSTD_DDict* ddict)
+{
+    void* const dststart = dst;
+    int moreThan1Frame = 0;
+
+    DEBUGLOG(5, "ZSTD_decompressMultiFrame");
+    assert(dict==NULL || ddict==NULL);  /* either dict or ddict set, not both */
+
+    if (ddict) {
+        dict = ZSTD_DDict_dictContent(ddict);
+        dictSize = ZSTD_DDict_dictSize(ddict);
+    }
+
+    while (srcSize >= ZSTD_FRAMEHEADERSIZE_PREFIX) {
+
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
+        if (ZSTD_isLegacy(src, srcSize)) {
+            size_t decodedSize;
+            size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
+            if (ZSTD_isError(frameSize)) return frameSize;
+            RETURN_ERROR_IF(dctx->staticSize, memory_allocation,
+                "legacy support is not compatible with static dctx");
+
+            decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);
+            if (ZSTD_isError(decodedSize)) return decodedSize;
+
+            assert(decodedSize <=- dstCapacity);
+            dst = (BYTE*)dst + decodedSize;
+            dstCapacity -= decodedSize;
+
+            src = (const BYTE*)src + frameSize;
+            srcSize -= frameSize;
+
+            continue;
+        }
+#endif
+
+        {   U32 const magicNumber = MEM_readLE32(src);
+            DEBUGLOG(4, "reading magic number %08X (expecting %08X)",
+                        (unsigned)magicNumber, ZSTD_MAGICNUMBER);
+            if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
+                size_t const skippableSize = readSkippableFrameSize(src, srcSize);
+                FORWARD_IF_ERROR(skippableSize);
+                assert(skippableSize <= srcSize);
+
+                src = (const BYTE *)src + skippableSize;
+                srcSize -= skippableSize;
+                continue;
+        }   }
+
+        if (ddict) {
+            /* we were called from ZSTD_decompress_usingDDict */
+            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict));
+        } else {
+            /* this will initialize correctly with no dict if dict == NULL, so
+             * use this in all cases but ddict */
+            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize));
+        }
+        ZSTD_checkContinuity(dctx, dst);
+
+        {   const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
+                                                    &src, &srcSize);
+            RETURN_ERROR_IF(
+                (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)
+             && (moreThan1Frame==1),
+                srcSize_wrong,
+                "at least one frame successfully completed, but following "
+                "bytes are garbage: it's more likely to be a srcSize error, "
+                "specifying more bytes than compressed size of frame(s). This "
+                "error message replaces ERROR(prefix_unknown), which would be "
+                "confusing, as the first header is actually correct. Note that "
+                "one could be unlucky, it might be a corruption error instead, "
+                "happening right at the place where we expect zstd magic "
+                "bytes. But this is _much_ less likely than a srcSize field "
+                "error.");
+            if (ZSTD_isError(res)) return res;
+            assert(res <= dstCapacity);
+            dst = (BYTE*)dst + res;
+            dstCapacity -= res;
+        }
+        moreThan1Frame = 1;
+    }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
+
+    RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed");
+
+    return (BYTE*)dst - (BYTE*)dststart;
+}
+
+size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
+                                 void* dst, size_t dstCapacity,
+                           const void* src, size_t srcSize,
+                           const void* dict, size_t dictSize)
+{
+    return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
+}
+
+
+static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
+{
+    switch (dctx->dictUses) {
+    default:
+        assert(0 /* Impossible */);
+        /* fall-through */
+    case ZSTD_dont_use:
+        ZSTD_clearDict(dctx);
+        return NULL;
+    case ZSTD_use_indefinitely:
+        return dctx->ddict;
+    case ZSTD_use_once:
+        dctx->dictUses = ZSTD_dont_use;
+        return dctx->ddict;
+    }
+}
+
+size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
+}
+
+
+size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
+    size_t regenSize;
+    ZSTD_DCtx* const dctx = ZSTD_createDCtx();
+    RETURN_ERROR_IF(dctx==NULL, memory_allocation);
+    regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
+    ZSTD_freeDCtx(dctx);
+    return regenSize;
+#else   /* stack mode */
+    ZSTD_DCtx dctx;
+    ZSTD_initDCtx_internal(&dctx);
+    return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
+#endif
+}
+
+
+/*-**************************************
+*   Advanced Streaming Decompression API
+*   Bufferless and synchronous
+****************************************/
+size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }
+
+ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
+    switch(dctx->stage)
+    {
+    default:   /* should not happen */
+        assert(0);
+    case ZSTDds_getFrameHeaderSize:
+    case ZSTDds_decodeFrameHeader:
+        return ZSTDnit_frameHeader;
+    case ZSTDds_decodeBlockHeader:
+        return ZSTDnit_blockHeader;
+    case ZSTDds_decompressBlock:
+        return ZSTDnit_block;
+    case ZSTDds_decompressLastBlock:
+        return ZSTDnit_lastBlock;
+    case ZSTDds_checkChecksum:
+        return ZSTDnit_checksum;
+    case ZSTDds_decodeSkippableHeader:
+    case ZSTDds_skipFrame:
+        return ZSTDnit_skippableFrame;
+    }
+}
+
+static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
+
+/** ZSTD_decompressContinue() :
+ *  srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
+ *  @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
+ *            or an error code, which can be tested using ZSTD_isError() */
+size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
+    /* Sanity check */
+    RETURN_ERROR_IF(srcSize != dctx->expected, srcSize_wrong, "not allowed");
+    if (dstCapacity) ZSTD_checkContinuity(dctx, dst);
+
+    switch (dctx->stage)
+    {
+    case ZSTDds_getFrameHeaderSize :
+        assert(src != NULL);
+        if (dctx->format == ZSTD_f_zstd1) {  /* allows header */
+            assert(srcSize >= ZSTD_FRAMEIDSIZE);  /* to read skippable magic number */
+            if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {        /* skippable frame */
+                memcpy(dctx->headerBuffer, src, srcSize);
+                dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize;  /* remaining to load to get full skippable frame header */
+                dctx->stage = ZSTDds_decodeSkippableHeader;
+                return 0;
+        }   }
+        dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
+        if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
+        memcpy(dctx->headerBuffer, src, srcSize);
+        dctx->expected = dctx->headerSize - srcSize;
+        dctx->stage = ZSTDds_decodeFrameHeader;
+        return 0;
+
+    case ZSTDds_decodeFrameHeader:
+        assert(src != NULL);
+        memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);
+        FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize));
+        dctx->expected = ZSTD_blockHeaderSize;
+        dctx->stage = ZSTDds_decodeBlockHeader;
+        return 0;
+
+    case ZSTDds_decodeBlockHeader:
+        {   blockProperties_t bp;
+            size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
+            if (ZSTD_isError(cBlockSize)) return cBlockSize;
+            RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum");
+            dctx->expected = cBlockSize;
+            dctx->bType = bp.blockType;
+            dctx->rleSize = bp.origSize;
+            if (cBlockSize) {
+                dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
+                return 0;
+            }
+            /* empty block */
+            if (bp.lastBlock) {
+                if (dctx->fParams.checksumFlag) {
+                    dctx->expected = 4;
+                    dctx->stage = ZSTDds_checkChecksum;
+                } else {
+                    dctx->expected = 0; /* end of frame */
+                    dctx->stage = ZSTDds_getFrameHeaderSize;
+                }
+            } else {
+                dctx->expected = ZSTD_blockHeaderSize;  /* jump to next header */
+                dctx->stage = ZSTDds_decodeBlockHeader;
+            }
+            return 0;
+        }
+
+    case ZSTDds_decompressLastBlock:
+    case ZSTDds_decompressBlock:
+        DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock");
+        {   size_t rSize;
+            switch(dctx->bType)
+            {
+            case bt_compressed:
+                DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
+                rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1);
+                break;
+            case bt_raw :
+                rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
+                break;
+            case bt_rle :
+                rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
+                break;
+            case bt_reserved :   /* should never happen */
+            default:
+                RETURN_ERROR(corruption_detected);
+            }
+            if (ZSTD_isError(rSize)) return rSize;
+            RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
+            DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
+            dctx->decodedSize += rSize;
+            if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize);
+
+            if (dctx->stage == ZSTDds_decompressLastBlock) {   /* end of frame */
+                DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
+                RETURN_ERROR_IF(
+                    dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
+                 && dctx->decodedSize != dctx->fParams.frameContentSize,
+                    corruption_detected);
+                if (dctx->fParams.checksumFlag) {  /* another round for frame checksum */
+                    dctx->expected = 4;
+                    dctx->stage = ZSTDds_checkChecksum;
+                } else {
+                    dctx->expected = 0;   /* ends here */
+                    dctx->stage = ZSTDds_getFrameHeaderSize;
+                }
+            } else {
+                dctx->stage = ZSTDds_decodeBlockHeader;
+                dctx->expected = ZSTD_blockHeaderSize;
+                dctx->previousDstEnd = (char*)dst + rSize;
+            }
+            return rSize;
+        }
+
+    case ZSTDds_checkChecksum:
+        assert(srcSize == 4);  /* guaranteed by dctx->expected */
+        {   U32 const h32 = (U32)XXH64_digest(&dctx->xxhState);
+            U32 const check32 = MEM_readLE32(src);
+            DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32);
+            RETURN_ERROR_IF(check32 != h32, checksum_wrong);
+            dctx->expected = 0;
+            dctx->stage = ZSTDds_getFrameHeaderSize;
+            return 0;
+        }
+
+    case ZSTDds_decodeSkippableHeader:
+        assert(src != NULL);
+        assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
+        memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize);   /* complete skippable header */
+        dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE);   /* note : dctx->expected can grow seriously large, beyond local buffer size */
+        dctx->stage = ZSTDds_skipFrame;
+        return 0;
+
+    case ZSTDds_skipFrame:
+        dctx->expected = 0;
+        dctx->stage = ZSTDds_getFrameHeaderSize;
+        return 0;
+
+    default:
+        assert(0);   /* impossible */
+        RETURN_ERROR(GENERIC);   /* some compiler require default to do something */
+    }
+}
+
+
+static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    dctx->dictEnd = dctx->previousDstEnd;
+    dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
+    dctx->prefixStart = dict;
+    dctx->previousDstEnd = (const char*)dict + dictSize;
+    return 0;
+}
+
+/*! ZSTD_loadDEntropy() :
+ *  dict : must point at beginning of a valid zstd dictionary.
+ * @return : size of entropy tables read */
+size_t
+ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
+                  const void* const dict, size_t const dictSize)
+{
+    const BYTE* dictPtr = (const BYTE*)dict;
+    const BYTE* const dictEnd = dictPtr + dictSize;
+
+    RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted);
+    assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY);   /* dict must be valid */
+    dictPtr += 8;   /* skip header = magic + dictID */
+
+    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
+    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
+    ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
+    {   void* const workspace = &entropy->LLTable;   /* use fse tables as temporary workspace; implies fse tables are grouped together */
+        size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
+#ifdef HUF_FORCE_DECOMPRESS_X1
+        /* in minimal huffman, we always use X1 variants */
+        size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
+                                                dictPtr, dictEnd - dictPtr,
+                                                workspace, workspaceSize);
+#else
+        size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,
+                                                dictPtr, dictEnd - dictPtr,
+                                                workspace, workspaceSize);
+#endif
+        RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted);
+        dictPtr += hSize;
+    }
+
+    {   short offcodeNCount[MaxOff+1];
+        unsigned offcodeMaxValue = MaxOff, offcodeLog;
+        size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
+        RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted);
+        RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted);
+        RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted);
+        ZSTD_buildFSETable( entropy->OFTable,
+                            offcodeNCount, offcodeMaxValue,
+                            OF_base, OF_bits,
+                            offcodeLog);
+        dictPtr += offcodeHeaderSize;
+    }
+
+    {   short matchlengthNCount[MaxML+1];
+        unsigned matchlengthMaxValue = MaxML, matchlengthLog;
+        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
+        RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted);
+        RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted);
+        RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted);
+        ZSTD_buildFSETable( entropy->MLTable,
+                            matchlengthNCount, matchlengthMaxValue,
+                            ML_base, ML_bits,
+                            matchlengthLog);
+        dictPtr += matchlengthHeaderSize;
+    }
+
+    {   short litlengthNCount[MaxLL+1];
+        unsigned litlengthMaxValue = MaxLL, litlengthLog;
+        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
+        RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted);
+        RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted);
+        RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted);
+        ZSTD_buildFSETable( entropy->LLTable,
+                            litlengthNCount, litlengthMaxValue,
+                            LL_base, LL_bits,
+                            litlengthLog);
+        dictPtr += litlengthHeaderSize;
+    }
+
+    RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted);
+    {   int i;
+        size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));
+        for (i=0; i<3; i++) {
+            U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4;
+            RETURN_ERROR_IF(rep==0 || rep >= dictContentSize,
+                            dictionary_corrupted);
+            entropy->rep[i] = rep;
+    }   }
+
+    return dictPtr - (const BYTE*)dict;
+}
+
+static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
+    {   U32 const magic = MEM_readLE32(dict);
+        if (magic != ZSTD_MAGIC_DICTIONARY) {
+            return ZSTD_refDictContent(dctx, dict, dictSize);   /* pure content mode */
+    }   }
+    dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
+
+    /* load entropy tables */
+    {   size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
+        RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted);
+        dict = (const char*)dict + eSize;
+        dictSize -= eSize;
+    }
+    dctx->litEntropy = dctx->fseEntropy = 1;
+
+    /* reference dictionary content */
+    return ZSTD_refDictContent(dctx, dict, dictSize);
+}
+
+size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
+{
+    assert(dctx != NULL);
+    dctx->expected = ZSTD_startingInputLength(dctx->format);  /* dctx->format must be properly set */
+    dctx->stage = ZSTDds_getFrameHeaderSize;
+    dctx->decodedSize = 0;
+    dctx->previousDstEnd = NULL;
+    dctx->prefixStart = NULL;
+    dctx->virtualStart = NULL;
+    dctx->dictEnd = NULL;
+    dctx->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001);  /* cover both little and big endian */
+    dctx->litEntropy = dctx->fseEntropy = 0;
+    dctx->dictID = 0;
+    ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
+    memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue));  /* initial repcodes */
+    dctx->LLTptr = dctx->entropy.LLTable;
+    dctx->MLTptr = dctx->entropy.MLTable;
+    dctx->OFTptr = dctx->entropy.OFTable;
+    dctx->HUFptr = dctx->entropy.hufTable;
+    return 0;
+}
+
+size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) );
+    if (dict && dictSize)
+        RETURN_ERROR_IF(
+            ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
+            dictionary_corrupted);
+    return 0;
+}
+
+
+/* ======   ZSTD_DDict   ====== */
+
+size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
+{
+    DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
+    assert(dctx != NULL);
+    if (ddict) {
+        const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
+        size_t const dictSize = ZSTD_DDict_dictSize(ddict);
+        const void* const dictEnd = dictStart + dictSize;
+        dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
+        DEBUGLOG(4, "DDict is %s",
+                    dctx->ddictIsCold ? "~cold~" : "hot!");
+    }
+    FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) );
+    if (ddict) {   /* NULL ddict is equivalent to no dictionary */
+        ZSTD_copyDDictParameters(dctx, ddict);
+    }
+    return 0;
+}
+
+/*! ZSTD_getDictID_fromDict() :
+ *  Provides the dictID stored within dictionary.
+ *  if @return == 0, the dictionary is not conformant with Zstandard specification.
+ *  It can still be loaded, but as a content-only dictionary. */
+unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
+{
+    if (dictSize < 8) return 0;
+    if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;
+    return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
+}
+
+/*! ZSTD_getDictID_fromFrame() :
+ *  Provides the dictID required to decompress frame stored within `src`.
+ *  If @return == 0, the dictID could not be decoded.
+ *  This could for one of the following reasons :
+ *  - The frame does not require a dictionary (most common case).
+ *  - The frame was built with dictID intentionally removed.
+ *    Needed dictionary is a hidden information.
+ *    Note : this use case also happens when using a non-conformant dictionary.
+ *  - `srcSize` is too small, and as a result, frame header could not be decoded.
+ *    Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`.
+ *  - This is not a Zstandard frame.
+ *  When identifying the exact failure cause, it's possible to use
+ *  ZSTD_getFrameHeader(), which will provide a more precise error code. */
+unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
+{
+    ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0 };
+    size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize);
+    if (ZSTD_isError(hError)) return 0;
+    return zfp.dictID;
+}
+
+
+/*! ZSTD_decompress_usingDDict() :
+*   Decompression using a pre-digested Dictionary
+*   Use dictionary without significant overhead. */
+size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
+                                  void* dst, size_t dstCapacity,
+                            const void* src, size_t srcSize,
+                            const ZSTD_DDict* ddict)
+{
+    /* pass content and size in case legacy frames are encountered */
+    return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
+                                     NULL, 0,
+                                     ddict);
+}
+
+
+/*=====================================
+*   Streaming decompression
+*====================================*/
+
+ZSTD_DStream* ZSTD_createDStream(void)
+{
+    DEBUGLOG(3, "ZSTD_createDStream");
+    return ZSTD_createDStream_advanced(ZSTD_defaultCMem);
+}
+
+ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
+{
+    return ZSTD_initStaticDCtx(workspace, workspaceSize);
+}
+
+ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
+{
+    return ZSTD_createDCtx_advanced(customMem);
+}
+
+size_t ZSTD_freeDStream(ZSTD_DStream* zds)
+{
+    return ZSTD_freeDCtx(zds);
+}
+
+
+/* ***  Initialization  *** */
+
+size_t ZSTD_DStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
+size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
+
+size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
+                                   const void* dict, size_t dictSize,
+                                         ZSTD_dictLoadMethod_e dictLoadMethod,
+                                         ZSTD_dictContentType_e dictContentType)
+{
+    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong);
+    ZSTD_clearDict(dctx);
+    if (dict && dictSize >= 8) {
+        dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);
+        RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation);
+        dctx->ddict = dctx->ddictLocal;
+        dctx->dictUses = ZSTD_use_indefinitely;
+    }
+    return 0;
+}
+
+size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
+}
+
+size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
+}
+
+size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
+{
+    FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType));
+    dctx->dictUses = ZSTD_use_once;
+    return 0;
+}
+
+size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
+{
+    return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
+}
+
+
+/* ZSTD_initDStream_usingDict() :
+ * return : expected size, aka ZSTD_FRAMEHEADERSIZE_PREFIX.
+ * this function cannot fail */
+size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
+{
+    DEBUGLOG(4, "ZSTD_initDStream_usingDict");
+    FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) );
+    return ZSTD_FRAMEHEADERSIZE_PREFIX;
+}
+
+/* note : this variant can't fail */
+size_t ZSTD_initDStream(ZSTD_DStream* zds)
+{
+    DEBUGLOG(4, "ZSTD_initDStream");
+    return ZSTD_initDStream_usingDDict(zds, NULL);
+}
+
+/* ZSTD_initDStream_usingDDict() :
+ * ddict will just be referenced, and must outlive decompression session
+ * this function cannot fail */
+size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
+{
+    FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) );
+    FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) );
+    return ZSTD_FRAMEHEADERSIZE_PREFIX;
+}
+
+/* ZSTD_resetDStream() :
+ * return : expected size, aka ZSTD_FRAMEHEADERSIZE_PREFIX.
+ * this function cannot fail */
+size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
+{
+    FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only));
+    return ZSTD_FRAMEHEADERSIZE_PREFIX;
+}
+
+
+size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
+{
+    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong);
+    ZSTD_clearDict(dctx);
+    if (ddict) {
+        dctx->ddict = ddict;
+        dctx->dictUses = ZSTD_use_indefinitely;
+    }
+    return 0;
+}
+
+/* ZSTD_DCtx_setMaxWindowSize() :
+ * note : no direct equivalence in ZSTD_DCtx_setParameter,
+ * since this version sets windowSize, and the other sets windowLog */
+size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
+{
+    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);
+    size_t const min = (size_t)1 << bounds.lowerBound;
+    size_t const max = (size_t)1 << bounds.upperBound;
+    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong);
+    RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound);
+    RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound);
+    dctx->maxWindowSize = maxWindowSize;
+    return 0;
+}
+
+size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
+{
+    return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, format);
+}
+
+ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
+{
+    ZSTD_bounds bounds = { 0, 0, 0 };
+    switch(dParam) {
+        case ZSTD_d_windowLogMax:
+            bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
+            bounds.upperBound = ZSTD_WINDOWLOG_MAX;
+            return bounds;
+        case ZSTD_d_format:
+            bounds.lowerBound = (int)ZSTD_f_zstd1;
+            bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
+            ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
+            return bounds;
+        default:;
+    }
+    bounds.error = ERROR(parameter_unsupported);
+    return bounds;
+}
+
+/* ZSTD_dParam_withinBounds:
+ * @return 1 if value is within dParam bounds,
+ * 0 otherwise */
+static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
+{
+    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
+    if (ZSTD_isError(bounds.error)) return 0;
+    if (value < bounds.lowerBound) return 0;
+    if (value > bounds.upperBound) return 0;
+    return 1;
+}
+
+#define CHECK_DBOUNDS(p,v) {                \
+    RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound); \
+}
+
+size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
+{
+    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong);
+    switch(dParam) {
+        case ZSTD_d_windowLogMax:
+            if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;
+            CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
+            dctx->maxWindowSize = ((size_t)1) << value;
+            return 0;
+        case ZSTD_d_format:
+            CHECK_DBOUNDS(ZSTD_d_format, value);
+            dctx->format = (ZSTD_format_e)value;
+            return 0;
+        default:;
+    }
+    RETURN_ERROR(parameter_unsupported);
+}
+
+size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
+{
+    if ( (reset == ZSTD_reset_session_only)
+      || (reset == ZSTD_reset_session_and_parameters) ) {
+        dctx->streamStage = zdss_init;
+        dctx->noForwardProgress = 0;
+    }
+    if ( (reset == ZSTD_reset_parameters)
+      || (reset == ZSTD_reset_session_and_parameters) ) {
+        RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong);
+        ZSTD_clearDict(dctx);
+        dctx->format = ZSTD_f_zstd1;
+        dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
+    }
+    return 0;
+}
+
+
+size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
+{
+    return ZSTD_sizeof_DCtx(dctx);
+}
+
+size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize)
+{
+    size_t const blockSize = (size_t) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
+    unsigned long long const neededRBSize = windowSize + blockSize + (WILDCOPY_OVERLENGTH * 2);
+    unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
+    size_t const minRBSize = (size_t) neededSize;
+    RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,
+                    frameParameter_windowTooLarge);
+    return minRBSize;
+}
+
+size_t ZSTD_estimateDStreamSize(size_t windowSize)
+{
+    size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
+    size_t const inBuffSize = blockSize;  /* no block can be larger */
+    size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);
+    return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
+}
+
+size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
+{
+    U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;   /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
+    ZSTD_frameHeader zfh;
+    size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
+    if (ZSTD_isError(err)) return err;
+    RETURN_ERROR_IF(err>0, srcSize_wrong);
+    RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,
+                    frameParameter_windowTooLarge);
+    return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
+}
+
+
+/* *****   Decompression   ***** */
+
+MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    size_t const length = MIN(dstCapacity, srcSize);
+    memcpy(dst, src, length);
+    return length;
+}
+
+
+size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
+{
+    const char* const istart = (const char*)(input->src) + input->pos;
+    const char* const iend = (const char*)(input->src) + input->size;
+    const char* ip = istart;
+    char* const ostart = (char*)(output->dst) + output->pos;
+    char* const oend = (char*)(output->dst) + output->size;
+    char* op = ostart;
+    U32 someMoreWork = 1;
+
+    DEBUGLOG(5, "ZSTD_decompressStream");
+    RETURN_ERROR_IF(
+        input->pos > input->size,
+        srcSize_wrong,
+        "forbidden. in: pos: %u   vs size: %u",
+        (U32)input->pos, (U32)input->size);
+    RETURN_ERROR_IF(
+        output->pos > output->size,
+        dstSize_tooSmall,
+        "forbidden. out: pos: %u   vs size: %u",
+        (U32)output->pos, (U32)output->size);
+    DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos));
+
+    while (someMoreWork) {
+        switch(zds->streamStage)
+        {
+        case zdss_init :
+            DEBUGLOG(5, "stage zdss_init => transparent reset ");
+            zds->streamStage = zdss_loadHeader;
+            zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
+            zds->legacyVersion = 0;
+            zds->hostageByte = 0;
+            /* fall-through */
+
+        case zdss_loadHeader :
+            DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip));
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
+            if (zds->legacyVersion) {
+                RETURN_ERROR_IF(zds->staticSize, memory_allocation,
+                    "legacy support is incompatible with static dctx");
+                {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);
+                    if (hint==0) zds->streamStage = zdss_init;
+                    return hint;
+            }   }
+#endif
+            {   size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
+                DEBUGLOG(5, "header size : %u", (U32)hSize);
+                if (ZSTD_isError(hSize)) {
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
+                    U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart);
+                    if (legacyVersion) {
+                        ZSTD_DDict const* const ddict = ZSTD_getDDict(zds);
+                        const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL;
+                        size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0;
+                        DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion);
+                        RETURN_ERROR_IF(zds->staticSize, memory_allocation,
+                            "legacy support is incompatible with static dctx");
+                        FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext,
+                                    zds->previousLegacyVersion, legacyVersion,
+                                    dict, dictSize));
+                        zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;
+                        {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
+                            if (hint==0) zds->streamStage = zdss_init;   /* or stay in stage zdss_loadHeader */
+                            return hint;
+                    }   }
+#endif
+                    return hSize;   /* error */
+                }
+                if (hSize != 0) {   /* need more input */
+                    size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */
+                    size_t const remainingInput = (size_t)(iend-ip);
+                    assert(iend >= ip);
+                    if (toLoad > remainingInput) {   /* not enough input to load full header */
+                        if (remainingInput > 0) {
+                            memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
+                            zds->lhSize += remainingInput;
+                        }
+                        input->pos = input->size;
+                        return (MAX(ZSTD_FRAMEHEADERSIZE_MIN, hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */
+                    }
+                    assert(ip != NULL);
+                    memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
+                    break;
+            }   }
+
+            /* check for single-pass mode opportunity */
+            if (zds->fParams.frameContentSize && zds->fParams.windowSize /* skippable frame if == 0 */
+                && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
+                size_t const cSize = ZSTD_findFrameCompressedSize(istart, iend-istart);
+                if (cSize <= (size_t)(iend-istart)) {
+                    /* shortcut : using single-pass mode */
+                    size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, oend-op, istart, cSize, ZSTD_getDDict(zds));
+                    if (ZSTD_isError(decompressedSize)) return decompressedSize;
+                    DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
+                    ip = istart + cSize;
+                    op += decompressedSize;
+                    zds->expected = 0;
+                    zds->streamStage = zdss_init;
+                    someMoreWork = 0;
+                    break;
+            }   }
+
+            /* Consume header (see ZSTDds_decodeFrameHeader) */
+            DEBUGLOG(4, "Consume header");
+            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)));
+
+            if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {  /* skippable frame */
+                zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
+                zds->stage = ZSTDds_skipFrame;
+            } else {
+                FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize));
+                zds->expected = ZSTD_blockHeaderSize;
+                zds->stage = ZSTDds_decodeBlockHeader;
+            }
+
+            /* control buffer memory usage */
+            DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
+                        (U32)(zds->fParams.windowSize >>10),
+                        (U32)(zds->maxWindowSize >> 10) );
+            zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
+            RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,
+                            frameParameter_windowTooLarge);
+
+            /* Adapt buffer sizes to frame header instructions */
+            {   size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */);
+                size_t const neededOutBuffSize = ZSTD_decodingBufferSize_min(zds->fParams.windowSize, zds->fParams.frameContentSize);
+                if ((zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize)) {
+                    size_t const bufferSize = neededInBuffSize + neededOutBuffSize;
+                    DEBUGLOG(4, "inBuff  : from %u to %u",
+                                (U32)zds->inBuffSize, (U32)neededInBuffSize);
+                    DEBUGLOG(4, "outBuff : from %u to %u",
+                                (U32)zds->outBuffSize, (U32)neededOutBuffSize);
+                    if (zds->staticSize) {  /* static DCtx */
+                        DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize);
+                        assert(zds->staticSize >= sizeof(ZSTD_DCtx));  /* controlled at init */
+                        RETURN_ERROR_IF(
+                            bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
+                            memory_allocation);
+                    } else {
+                        ZSTD_free(zds->inBuff, zds->customMem);
+                        zds->inBuffSize = 0;
+                        zds->outBuffSize = 0;
+                        zds->inBuff = (char*)ZSTD_malloc(bufferSize, zds->customMem);
+                        RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation);
+                    }
+                    zds->inBuffSize = neededInBuffSize;
+                    zds->outBuff = zds->inBuff + zds->inBuffSize;
+                    zds->outBuffSize = neededOutBuffSize;
+            }   }
+            zds->streamStage = zdss_read;
+            /* fall-through */
+
+        case zdss_read:
+            DEBUGLOG(5, "stage zdss_read");
+            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
+                DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize);
+                if (neededInSize==0) {  /* end of frame */
+                    zds->streamStage = zdss_init;
+                    someMoreWork = 0;
+                    break;
+                }
+                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */
+                    int const isSkipFrame = ZSTD_isSkipFrame(zds);
+                    size_t const decodedSize = ZSTD_decompressContinue(zds,
+                        zds->outBuff + zds->outStart, (isSkipFrame ? 0 : zds->outBuffSize - zds->outStart),
+                        ip, neededInSize);
+                    if (ZSTD_isError(decodedSize)) return decodedSize;
+                    ip += neededInSize;
+                    if (!decodedSize && !isSkipFrame) break;   /* this was just a header */
+                    zds->outEnd = zds->outStart + decodedSize;
+                    zds->streamStage = zdss_flush;
+                    break;
+            }   }
+            if (ip==iend) { someMoreWork = 0; break; }   /* no more input */
+            zds->streamStage = zdss_load;
+            /* fall-through */
+
+        case zdss_load:
+            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
+                size_t const toLoad = neededInSize - zds->inPos;
+                int const isSkipFrame = ZSTD_isSkipFrame(zds);
+                size_t loadedSize;
+                if (isSkipFrame) {
+                    loadedSize = MIN(toLoad, (size_t)(iend-ip));
+                } else {
+                    RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
+                                    corruption_detected,
+                                    "should never happen");
+                    loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, iend-ip);
+                }
+                ip += loadedSize;
+                zds->inPos += loadedSize;
+                if (loadedSize < toLoad) { someMoreWork = 0; break; }   /* not enough input, wait for more */
+
+                /* decode loaded input */
+                {   size_t const decodedSize = ZSTD_decompressContinue(zds,
+                        zds->outBuff + zds->outStart, zds->outBuffSize - zds->outStart,
+                        zds->inBuff, neededInSize);
+                    if (ZSTD_isError(decodedSize)) return decodedSize;
+                    zds->inPos = 0;   /* input is consumed */
+                    if (!decodedSize && !isSkipFrame) { zds->streamStage = zdss_read; break; }   /* this was just a header */
+                    zds->outEnd = zds->outStart +  decodedSize;
+            }   }
+            zds->streamStage = zdss_flush;
+            /* fall-through */
+
+        case zdss_flush:
+            {   size_t const toFlushSize = zds->outEnd - zds->outStart;
+                size_t const flushedSize = ZSTD_limitCopy(op, oend-op, zds->outBuff + zds->outStart, toFlushSize);
+                op += flushedSize;
+                zds->outStart += flushedSize;
+                if (flushedSize == toFlushSize) {  /* flush completed */
+                    zds->streamStage = zdss_read;
+                    if ( (zds->outBuffSize < zds->fParams.frameContentSize)
+                      && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {
+                        DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)",
+                                (int)(zds->outBuffSize - zds->outStart),
+                                (U32)zds->fParams.blockSizeMax);
+                        zds->outStart = zds->outEnd = 0;
+                    }
+                    break;
+            }   }
+            /* cannot complete flush */
+            someMoreWork = 0;
+            break;
+
+        default:
+            assert(0);    /* impossible */
+            RETURN_ERROR(GENERIC);   /* some compiler require default to do something */
+    }   }
+
+    /* result */
+    input->pos = (size_t)(ip - (const char*)(input->src));
+    output->pos = (size_t)(op - (char*)(output->dst));
+    if ((ip==istart) && (op==ostart)) {  /* no forward progress */
+        zds->noForwardProgress ++;
+        if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
+            RETURN_ERROR_IF(op==oend, dstSize_tooSmall);
+            RETURN_ERROR_IF(ip==iend, srcSize_wrong);
+            assert(0);
+        }
+    } else {
+        zds->noForwardProgress = 0;
+    }
+    {   size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);
+        if (!nextSrcSizeHint) {   /* frame fully decoded */
+            if (zds->outEnd == zds->outStart) {  /* output fully flushed */
+                if (zds->hostageByte) {
+                    if (input->pos >= input->size) {
+                        /* can't release hostage (not present) */
+                        zds->streamStage = zdss_read;
+                        return 1;
+                    }
+                    input->pos++;  /* release hostage */
+                }   /* zds->hostageByte */
+                return 0;
+            }  /* zds->outEnd == zds->outStart */
+            if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */
+                input->pos--;   /* note : pos > 0, otherwise, impossible to finish reading last block */
+                zds->hostageByte=1;
+            }
+            return 1;
+        }  /* nextSrcSizeHint==0 */
+        nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block);   /* preload header of next block */
+        assert(zds->inPos <= nextSrcSizeHint);
+        nextSrcSizeHint -= zds->inPos;   /* part already loaded*/
+        return nextSrcSizeHint;
+    }
+}
+
+size_t ZSTD_decompressStream_simpleArgs (
+                            ZSTD_DCtx* dctx,
+                            void* dst, size_t dstCapacity, size_t* dstPos,
+                      const void* src, size_t srcSize, size_t* srcPos)
+{
+    ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
+    ZSTD_inBuffer  input  = { src, srcSize, *srcPos };
+    /* ZSTD_compress_generic() will check validity of dstPos and srcPos */
+    size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
+    *dstPos = output.pos;
+    *srcPos = input.pos;
+    return cErr;
+}
diff --git a/src/zstd_decompress_block.c b/src/zstd_decompress_block.c
new file mode 100644
index 0000000..cbcfc08
--- /dev/null
+++ b/src/zstd_decompress_block.c
@@ -0,0 +1,1325 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* zstd_decompress_block :
+ * this module takes care of decompressing _compressed_ block */
+
+/*-*******************************************************
+*  Dependencies
+*********************************************************/
+#include <string.h>      /* memcpy, memmove, memset */
+#include "compiler.h"    /* prefetch */
+#include "cpu.h"         /* bmi2 */
+#include "mem.h"         /* low level memory routines */
+#define FSE_STATIC_LINKING_ONLY
+#include "fse.h"
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
+#include "zstd_internal.h"
+#include "zstd_decompress_internal.h"   /* ZSTD_DCtx */
+#include "zstd_ddict.h"  /* ZSTD_DDictDictContent */
+#include "zstd_decompress_block.h"
+
+/*_*******************************************************
+*  Macros
+**********************************************************/
+
+/* These two optional macros force the use one way or another of the two
+ * ZSTD_decompressSequences implementations. You can't force in both directions
+ * at the same time.
+ */
+#if defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+#error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!"
+#endif
+
+
+/*_*******************************************************
+*  Memory operations
+**********************************************************/
+static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+
+/*-*************************************************************
+ *   Block decoding
+ ***************************************************************/
+
+/*! ZSTD_getcBlockSize() :
+ *  Provides the size of compressed block from block header `src` */
+size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
+                          blockProperties_t* bpPtr)
+{
+    RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong);
+
+    {   U32 const cBlockHeader = MEM_readLE24(src);
+        U32 const cSize = cBlockHeader >> 3;
+        bpPtr->lastBlock = cBlockHeader & 1;
+        bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
+        bpPtr->origSize = cSize;   /* only useful for RLE */
+        if (bpPtr->blockType == bt_rle) return 1;
+        RETURN_ERROR_IF(bpPtr->blockType == bt_reserved, corruption_detected);
+        return cSize;
+    }
+}
+
+
+/* Hidden declaration for fullbench */
+size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
+                          const void* src, size_t srcSize);
+/*! ZSTD_decodeLiteralsBlock() :
+ * @return : nb of bytes read from src (< srcSize )
+ *  note : symbol not declared but exposed for fullbench */
+size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
+{
+    DEBUGLOG(5, "ZSTD_decodeLiteralsBlock");
+    RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected);
+
+    {   const BYTE* const istart = (const BYTE*) src;
+        symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
+
+        switch(litEncType)
+        {
+        case set_repeat:
+            DEBUGLOG(5, "set_repeat flag : re-using stats from previous compressed literals block");
+            RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted);
+            /* fall-through */
+
+        case set_compressed:
+            RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3");
+            {   size_t lhSize, litSize, litCSize;
+                U32 singleStream=0;
+                U32 const lhlCode = (istart[0] >> 2) & 3;
+                U32 const lhc = MEM_readLE32(istart);
+                size_t hufSuccess;
+                switch(lhlCode)
+                {
+                case 0: case 1: default:   /* note : default is impossible, since lhlCode into [0..3] */
+                    /* 2 - 2 - 10 - 10 */
+                    singleStream = !lhlCode;
+                    lhSize = 3;
+                    litSize  = (lhc >> 4) & 0x3FF;
+                    litCSize = (lhc >> 14) & 0x3FF;
+                    break;
+                case 2:
+                    /* 2 - 2 - 14 - 14 */
+                    lhSize = 4;
+                    litSize  = (lhc >> 4) & 0x3FFF;
+                    litCSize = lhc >> 18;
+                    break;
+                case 3:
+                    /* 2 - 2 - 18 - 18 */
+                    lhSize = 5;
+                    litSize  = (lhc >> 4) & 0x3FFFF;
+                    litCSize = (lhc >> 22) + ((size_t)istart[4] << 10);
+                    break;
+                }
+                RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected);
+                RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected);
+
+                /* prefetch huffman table if cold */
+                if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {
+                    PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));
+                }
+
+                if (litEncType==set_repeat) {
+                    if (singleStream) {
+                        hufSuccess = HUF_decompress1X_usingDTable_bmi2(
+                            dctx->litBuffer, litSize, istart+lhSize, litCSize,
+                            dctx->HUFptr, dctx->bmi2);
+                    } else {
+                        hufSuccess = HUF_decompress4X_usingDTable_bmi2(
+                            dctx->litBuffer, litSize, istart+lhSize, litCSize,
+                            dctx->HUFptr, dctx->bmi2);
+                    }
+                } else {
+                    if (singleStream) {
+#if defined(HUF_FORCE_DECOMPRESS_X2)
+                        hufSuccess = HUF_decompress1X_DCtx_wksp(
+                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
+                            istart+lhSize, litCSize, dctx->workspace,
+                            sizeof(dctx->workspace));
+#else
+                        hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2(
+                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
+                            istart+lhSize, litCSize, dctx->workspace,
+                            sizeof(dctx->workspace), dctx->bmi2);
+#endif
+                    } else {
+                        hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2(
+                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
+                            istart+lhSize, litCSize, dctx->workspace,
+                            sizeof(dctx->workspace), dctx->bmi2);
+                    }
+                }
+
+                RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected);
+
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                dctx->litEntropy = 1;
+                if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
+                memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+                return litCSize + lhSize;
+            }
+
+        case set_basic:
+            {   size_t litSize, lhSize;
+                U32 const lhlCode = ((istart[0]) >> 2) & 3;
+                switch(lhlCode)
+                {
+                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
+                    lhSize = 1;
+                    litSize = istart[0] >> 3;
+                    break;
+                case 1:
+                    lhSize = 2;
+                    litSize = MEM_readLE16(istart) >> 4;
+                    break;
+                case 3:
+                    lhSize = 3;
+                    litSize = MEM_readLE24(istart) >> 4;
+                    break;
+                }
+
+                if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
+                    RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected);
+                    memcpy(dctx->litBuffer, istart+lhSize, litSize);
+                    dctx->litPtr = dctx->litBuffer;
+                    dctx->litSize = litSize;
+                    memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+                    return lhSize+litSize;
+                }
+                /* direct reference into compressed stream */
+                dctx->litPtr = istart+lhSize;
+                dctx->litSize = litSize;
+                return lhSize+litSize;
+            }
+
+        case set_rle:
+            {   U32 const lhlCode = ((istart[0]) >> 2) & 3;
+                size_t litSize, lhSize;
+                switch(lhlCode)
+                {
+                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
+                    lhSize = 1;
+                    litSize = istart[0] >> 3;
+                    break;
+                case 1:
+                    lhSize = 2;
+                    litSize = MEM_readLE16(istart) >> 4;
+                    break;
+                case 3:
+                    lhSize = 3;
+                    litSize = MEM_readLE24(istart) >> 4;
+                    RETURN_ERROR_IF(srcSize<4, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4");
+                    break;
+                }
+                RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected);
+                memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                return lhSize+1;
+            }
+        default:
+            RETURN_ERROR(corruption_detected, "impossible");
+        }
+    }
+}
+
+/* Default FSE distribution tables.
+ * These are pre-calculated FSE decoding tables using default distributions as defined in specification :
+ * https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#default-distributions
+ * They were generated programmatically with following method :
+ * - start from default distributions, present in /lib/common/zstd_internal.h
+ * - generate tables normally, using ZSTD_buildFSETable()
+ * - printout the content of tables
+ * - pretify output, report below, test with fuzzer to ensure it's correct */
+
+/* Default FSE distribution table for Literal Lengths */
+static const ZSTD_seqSymbol LL_defaultDTable[(1<<LL_DEFAULTNORMLOG)+1] = {
+     {  1,  1,  1, LL_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
+     /* nextState, nbAddBits, nbBits, baseVal */
+     {  0,  0,  4,    0},  { 16,  0,  4,    0},
+     { 32,  0,  5,    1},  {  0,  0,  5,    3},
+     {  0,  0,  5,    4},  {  0,  0,  5,    6},
+     {  0,  0,  5,    7},  {  0,  0,  5,    9},
+     {  0,  0,  5,   10},  {  0,  0,  5,   12},
+     {  0,  0,  6,   14},  {  0,  1,  5,   16},
+     {  0,  1,  5,   20},  {  0,  1,  5,   22},
+     {  0,  2,  5,   28},  {  0,  3,  5,   32},
+     {  0,  4,  5,   48},  { 32,  6,  5,   64},
+     {  0,  7,  5,  128},  {  0,  8,  6,  256},
+     {  0, 10,  6, 1024},  {  0, 12,  6, 4096},
+     { 32,  0,  4,    0},  {  0,  0,  4,    1},
+     {  0,  0,  5,    2},  { 32,  0,  5,    4},
+     {  0,  0,  5,    5},  { 32,  0,  5,    7},
+     {  0,  0,  5,    8},  { 32,  0,  5,   10},
+     {  0,  0,  5,   11},  {  0,  0,  6,   13},
+     { 32,  1,  5,   16},  {  0,  1,  5,   18},
+     { 32,  1,  5,   22},  {  0,  2,  5,   24},
+     { 32,  3,  5,   32},  {  0,  3,  5,   40},
+     {  0,  6,  4,   64},  { 16,  6,  4,   64},
+     { 32,  7,  5,  128},  {  0,  9,  6,  512},
+     {  0, 11,  6, 2048},  { 48,  0,  4,    0},
+     { 16,  0,  4,    1},  { 32,  0,  5,    2},
+     { 32,  0,  5,    3},  { 32,  0,  5,    5},
+     { 32,  0,  5,    6},  { 32,  0,  5,    8},
+     { 32,  0,  5,    9},  { 32,  0,  5,   11},
+     { 32,  0,  5,   12},  {  0,  0,  6,   15},
+     { 32,  1,  5,   18},  { 32,  1,  5,   20},
+     { 32,  2,  5,   24},  { 32,  2,  5,   28},
+     { 32,  3,  5,   40},  { 32,  4,  5,   48},
+     {  0, 16,  6,65536},  {  0, 15,  6,32768},
+     {  0, 14,  6,16384},  {  0, 13,  6, 8192},
+};   /* LL_defaultDTable */
+
+/* Default FSE distribution table for Offset Codes */
+static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = {
+    {  1,  1,  1, OF_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
+    /* nextState, nbAddBits, nbBits, baseVal */
+    {  0,  0,  5,    0},     {  0,  6,  4,   61},
+    {  0,  9,  5,  509},     {  0, 15,  5,32765},
+    {  0, 21,  5,2097149},   {  0,  3,  5,    5},
+    {  0,  7,  4,  125},     {  0, 12,  5, 4093},
+    {  0, 18,  5,262141},    {  0, 23,  5,8388605},
+    {  0,  5,  5,   29},     {  0,  8,  4,  253},
+    {  0, 14,  5,16381},     {  0, 20,  5,1048573},
+    {  0,  2,  5,    1},     { 16,  7,  4,  125},
+    {  0, 11,  5, 2045},     {  0, 17,  5,131069},
+    {  0, 22,  5,4194301},   {  0,  4,  5,   13},
+    { 16,  8,  4,  253},     {  0, 13,  5, 8189},
+    {  0, 19,  5,524285},    {  0,  1,  5,    1},
+    { 16,  6,  4,   61},     {  0, 10,  5, 1021},
+    {  0, 16,  5,65533},     {  0, 28,  5,268435453},
+    {  0, 27,  5,134217725}, {  0, 26,  5,67108861},
+    {  0, 25,  5,33554429},  {  0, 24,  5,16777213},
+};   /* OF_defaultDTable */
+
+
+/* Default FSE distribution table for Match Lengths */
+static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
+    {  1,  1,  1, ML_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
+    /* nextState, nbAddBits, nbBits, baseVal */
+    {  0,  0,  6,    3},  {  0,  0,  4,    4},
+    { 32,  0,  5,    5},  {  0,  0,  5,    6},
+    {  0,  0,  5,    8},  {  0,  0,  5,    9},
+    {  0,  0,  5,   11},  {  0,  0,  6,   13},
+    {  0,  0,  6,   16},  {  0,  0,  6,   19},
+    {  0,  0,  6,   22},  {  0,  0,  6,   25},
+    {  0,  0,  6,   28},  {  0,  0,  6,   31},
+    {  0,  0,  6,   34},  {  0,  1,  6,   37},
+    {  0,  1,  6,   41},  {  0,  2,  6,   47},
+    {  0,  3,  6,   59},  {  0,  4,  6,   83},
+    {  0,  7,  6,  131},  {  0,  9,  6,  515},
+    { 16,  0,  4,    4},  {  0,  0,  4,    5},
+    { 32,  0,  5,    6},  {  0,  0,  5,    7},
+    { 32,  0,  5,    9},  {  0,  0,  5,   10},
+    {  0,  0,  6,   12},  {  0,  0,  6,   15},
+    {  0,  0,  6,   18},  {  0,  0,  6,   21},
+    {  0,  0,  6,   24},  {  0,  0,  6,   27},
+    {  0,  0,  6,   30},  {  0,  0,  6,   33},
+    {  0,  1,  6,   35},  {  0,  1,  6,   39},
+    {  0,  2,  6,   43},  {  0,  3,  6,   51},
+    {  0,  4,  6,   67},  {  0,  5,  6,   99},
+    {  0,  8,  6,  259},  { 32,  0,  4,    4},
+    { 48,  0,  4,    4},  { 16,  0,  4,    5},
+    { 32,  0,  5,    7},  { 32,  0,  5,    8},
+    { 32,  0,  5,   10},  { 32,  0,  5,   11},
+    {  0,  0,  6,   14},  {  0,  0,  6,   17},
+    {  0,  0,  6,   20},  {  0,  0,  6,   23},
+    {  0,  0,  6,   26},  {  0,  0,  6,   29},
+    {  0,  0,  6,   32},  {  0, 16,  6,65539},
+    {  0, 15,  6,32771},  {  0, 14,  6,16387},
+    {  0, 13,  6, 8195},  {  0, 12,  6, 4099},
+    {  0, 11,  6, 2051},  {  0, 10,  6, 1027},
+};   /* ML_defaultDTable */
+
+
+static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U32 nbAddBits)
+{
+    void* ptr = dt;
+    ZSTD_seqSymbol_header* const DTableH = (ZSTD_seqSymbol_header*)ptr;
+    ZSTD_seqSymbol* const cell = dt + 1;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->nbBits = 0;
+    cell->nextState = 0;
+    assert(nbAddBits < 255);
+    cell->nbAdditionalBits = (BYTE)nbAddBits;
+    cell->baseValue = baseValue;
+}
+
+
+/* ZSTD_buildFSETable() :
+ * generate FSE decoding table for one symbol (ll, ml or off)
+ * cannot fail if input is valid =>
+ * all inputs are presumed validated at this stage */
+void
+ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
+            const short* normalizedCounter, unsigned maxSymbolValue,
+            const U32* baseValue, const U32* nbAdditionalBits,
+            unsigned tableLog)
+{
+    ZSTD_seqSymbol* const tableDecode = dt+1;
+    U16 symbolNext[MaxSeq+1];
+
+    U32 const maxSV1 = maxSymbolValue + 1;
+    U32 const tableSize = 1 << tableLog;
+    U32 highThreshold = tableSize-1;
+
+    /* Sanity Checks */
+    assert(maxSymbolValue <= MaxSeq);
+    assert(tableLog <= MaxFSELog);
+
+    /* Init, lay down lowprob symbols */
+    {   ZSTD_seqSymbol_header DTableH;
+        DTableH.tableLog = tableLog;
+        DTableH.fastMode = 1;
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
+            U32 s;
+            for (s=0; s<maxSV1; s++) {
+                if (normalizedCounter[s]==-1) {
+                    tableDecode[highThreshold--].baseValue = s;
+                    symbolNext[s] = 1;
+                } else {
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
+                    assert(normalizedCounter[s]>=0);
+                    symbolNext[s] = (U16)normalizedCounter[s];
+        }   }   }
+        memcpy(dt, &DTableH, sizeof(DTableH));
+    }
+
+    /* Spread symbols */
+    {   U32 const tableMask = tableSize-1;
+        U32 const step = FSE_TABLESTEP(tableSize);
+        U32 s, position = 0;
+        for (s=0; s<maxSV1; s++) {
+            int i;
+            for (i=0; i<normalizedCounter[s]; i++) {
+                tableDecode[position].baseValue = s;
+                position = (position + step) & tableMask;
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }   }
+        assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+    }
+
+    /* Build Decoding table */
+    {   U32 u;
+        for (u=0; u<tableSize; u++) {
+            U32 const symbol = tableDecode[u].baseValue;
+            U32 const nextState = symbolNext[symbol]++;
+            tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
+            tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
+            assert(nbAdditionalBits[symbol] < 255);
+            tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol];
+            tableDecode[u].baseValue = baseValue[symbol];
+    }   }
+}
+
+
+/*! ZSTD_buildSeqTable() :
+ * @return : nb bytes read from src,
+ *           or an error code if it fails */
+static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr,
+                                 symbolEncodingType_e type, unsigned max, U32 maxLog,
+                                 const void* src, size_t srcSize,
+                                 const U32* baseValue, const U32* nbAdditionalBits,
+                                 const ZSTD_seqSymbol* defaultTable, U32 flagRepeatTable,
+                                 int ddictIsCold, int nbSeq)
+{
+    switch(type)
+    {
+    case set_rle :
+        RETURN_ERROR_IF(!srcSize, srcSize_wrong);
+        RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected);
+        {   U32 const symbol = *(const BYTE*)src;
+            U32 const baseline = baseValue[symbol];
+            U32 const nbBits = nbAdditionalBits[symbol];
+            ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits);
+        }
+        *DTablePtr = DTableSpace;
+        return 1;
+    case set_basic :
+        *DTablePtr = defaultTable;
+        return 0;
+    case set_repeat:
+        RETURN_ERROR_IF(!flagRepeatTable, corruption_detected);
+        /* prefetch FSE table if used */
+        if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {
+            const void* const pStart = *DTablePtr;
+            size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
+            PREFETCH_AREA(pStart, pSize);
+        }
+        return 0;
+    case set_compressed :
+        {   unsigned tableLog;
+            S16 norm[MaxSeq+1];
+            size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
+            RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected);
+            RETURN_ERROR_IF(tableLog > maxLog, corruption_detected);
+            ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog);
+            *DTablePtr = DTableSpace;
+            return headerSize;
+        }
+    default :
+        assert(0);
+        RETURN_ERROR(GENERIC, "impossible");
+    }
+}
+
+size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
+                             const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* ip = istart;
+    int nbSeq;
+    DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
+
+    /* check */
+    RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong);
+
+    /* SeqHead */
+    nbSeq = *ip++;
+    if (!nbSeq) {
+        *nbSeqPtr=0;
+        RETURN_ERROR_IF(srcSize != 1, srcSize_wrong);
+        return 1;
+    }
+    if (nbSeq > 0x7F) {
+        if (nbSeq == 0xFF) {
+            RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong);
+            nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
+        } else {
+            RETURN_ERROR_IF(ip >= iend, srcSize_wrong);
+            nbSeq = ((nbSeq-0x80)<<8) + *ip++;
+        }
+    }
+    *nbSeqPtr = nbSeq;
+
+    /* FSE table descriptors */
+    RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong); /* minimum possible size: 1 byte for symbol encoding types */
+    {   symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
+        symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
+        symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
+        ip++;
+
+        /* Build DTables */
+        {   size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
+                                                      LLtype, MaxLL, LLFSELog,
+                                                      ip, iend-ip,
+                                                      LL_base, LL_bits,
+                                                      LL_defaultDTable, dctx->fseEntropy,
+                                                      dctx->ddictIsCold, nbSeq);
+            RETURN_ERROR_IF(ZSTD_isError(llhSize), corruption_detected);
+            ip += llhSize;
+        }
+
+        {   size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
+                                                      OFtype, MaxOff, OffFSELog,
+                                                      ip, iend-ip,
+                                                      OF_base, OF_bits,
+                                                      OF_defaultDTable, dctx->fseEntropy,
+                                                      dctx->ddictIsCold, nbSeq);
+            RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected);
+            ip += ofhSize;
+        }
+
+        {   size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
+                                                      MLtype, MaxML, MLFSELog,
+                                                      ip, iend-ip,
+                                                      ML_base, ML_bits,
+                                                      ML_defaultDTable, dctx->fseEntropy,
+                                                      dctx->ddictIsCold, nbSeq);
+            RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected);
+            ip += mlhSize;
+        }
+    }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t matchLength;
+    size_t offset;
+    const BYTE* match;
+} seq_t;
+
+typedef struct {
+    size_t state;
+    const ZSTD_seqSymbol* table;
+} ZSTD_fseState;
+
+typedef struct {
+    BIT_DStream_t DStream;
+    ZSTD_fseState stateLL;
+    ZSTD_fseState stateOffb;
+    ZSTD_fseState stateML;
+    size_t prevOffset[ZSTD_REP_NUM];
+    const BYTE* prefixStart;
+    const BYTE* dictEnd;
+    size_t pos;
+} seqState_t;
+
+
+/* ZSTD_execSequenceLast7():
+ * exceptional case : decompress a match starting within last 7 bytes of output buffer.
+ * requires more careful checks, to ensure there is no overflow.
+ * performance does not matter though.
+ * note : this case is supposed to be never generated "naturally" by reference encoder,
+ *        since in most cases it needs at least 8 bytes to look for a match.
+ *        but it's allowed by the specification. */
+FORCE_NOINLINE
+size_t ZSTD_execSequenceLast7(BYTE* op,
+                              BYTE* const oend, seq_t sequence,
+                              const BYTE** litPtr, const BYTE* const litLimit,
+                              const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
+{
+    BYTE* const oLitEnd = op + sequence.litLength;
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
+
+    /* check */
+    RETURN_ERROR_IF(oMatchEnd>oend, dstSize_tooSmall, "last match must fit within dstBuffer");
+    RETURN_ERROR_IF(iLitEnd > litLimit, corruption_detected, "try to read beyond literal buffer");
+
+    /* copy literals */
+    while (op < oLitEnd) *op++ = *(*litPtr)++;
+
+    /* copy Match */
+    if (sequence.offset > (size_t)(oLitEnd - base)) {
+        /* offset beyond prefix */
+        RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - vBase),corruption_detected);
+        match = dictEnd - (base-match);
+        if (match + sequence.matchLength <= dictEnd) {
+            memmove(oLitEnd, match, sequence.matchLength);
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {   size_t const length1 = dictEnd - match;
+            memmove(oLitEnd, match, length1);
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = base;
+    }   }
+    while (op < oMatchEnd) *op++ = *match++;
+    return sequenceLength;
+}
+
+
+HINT_INLINE
+size_t ZSTD_execSequence(BYTE* op,
+                         BYTE* const oend, seq_t sequence,
+                         const BYTE** litPtr, const BYTE* const litLimit,
+                         const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
+{
+    BYTE* const oLitEnd = op + sequence.litLength;
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
+
+    /* check */
+    RETURN_ERROR_IF(oMatchEnd>oend, dstSize_tooSmall, "last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend");
+    RETURN_ERROR_IF(iLitEnd > litLimit, corruption_detected, "over-read beyond lit buffer");
+    if (oLitEnd>oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
+
+    /* copy Literals */
+    if (sequence.litLength > 8)
+        ZSTD_wildcopy_16min(op, (*litPtr), sequence.litLength, ZSTD_no_overlap);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
+    else
+        ZSTD_copy8(op, *litPtr);
+    op = oLitEnd;
+    *litPtr = iLitEnd;   /* update for next sequence */
+
+    /* copy Match */
+    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
+        /* offset beyond prefix -> go into extDict */
+        RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected);
+        match = dictEnd + (match - prefixStart);
+        if (match + sequence.matchLength <= dictEnd) {
+            memmove(oLitEnd, match, sequence.matchLength);
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {   size_t const length1 = dictEnd - match;
+            memmove(oLitEnd, match, length1);
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = prefixStart;
+            if (op > oend_w || sequence.matchLength < MINMATCH) {
+              U32 i;
+              for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
+              return sequenceLength;
+            }
+    }   }
+    /* Requirement: op <= oend_w && sequence.matchLength >= MINMATCH */
+
+    /* match within prefix */
+    if (sequence.offset < 8) {
+        /* close range match, overlap */
+        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */
+        int const sub2 = dec64table[sequence.offset];
+        op[0] = match[0];
+        op[1] = match[1];
+        op[2] = match[2];
+        op[3] = match[3];
+        match += dec32table[sequence.offset];
+        ZSTD_copy4(op+4, match);
+        match -= sub2;
+    } else {
+        ZSTD_copy8(op, match);
+    }
+    op += 8; match += 8;
+
+    if (oMatchEnd > oend-(16-MINMATCH)) {
+        if (op < oend_w) {
+            ZSTD_wildcopy(op, match, oend_w - op, ZSTD_overlap_src_before_dst);
+            match += oend_w - op;
+            op = oend_w;
+        }
+        while (op < oMatchEnd) *op++ = *match++;
+    } else {
+        ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8, ZSTD_overlap_src_before_dst);   /* works even if matchLength < 8 */
+    }
+    return sequenceLength;
+}
+
+
+HINT_INLINE
+size_t ZSTD_execSequenceLong(BYTE* op,
+                             BYTE* const oend, seq_t sequence,
+                             const BYTE** litPtr, const BYTE* const litLimit,
+                             const BYTE* const prefixStart, const BYTE* const dictStart, const BYTE* const dictEnd)
+{
+    BYTE* const oLitEnd = op + sequence.litLength;
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
+    const BYTE* match = sequence.match;
+
+    /* check */
+    RETURN_ERROR_IF(oMatchEnd > oend, dstSize_tooSmall, "last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend");
+    RETURN_ERROR_IF(iLitEnd > litLimit, corruption_detected, "over-read beyond lit buffer");
+    if (oLitEnd > oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, dictStart, dictEnd);
+
+    /* copy Literals */
+    if (sequence.litLength > 8)
+        ZSTD_wildcopy_16min(op, *litPtr, sequence.litLength, ZSTD_no_overlap);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
+    else
+        ZSTD_copy8(op, *litPtr);  /* note : op <= oLitEnd <= oend_w == oend - 8 */
+
+    op = oLitEnd;
+    *litPtr = iLitEnd;   /* update for next sequence */
+
+    /* copy Match */
+    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
+        /* offset beyond prefix */
+        RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - dictStart), corruption_detected);
+        if (match + sequence.matchLength <= dictEnd) {
+            memmove(oLitEnd, match, sequence.matchLength);
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {   size_t const length1 = dictEnd - match;
+            memmove(oLitEnd, match, length1);
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = prefixStart;
+            if (op > oend_w || sequence.matchLength < MINMATCH) {
+              U32 i;
+              for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
+              return sequenceLength;
+            }
+    }   }
+    assert(op <= oend_w);
+    assert(sequence.matchLength >= MINMATCH);
+
+    /* match within prefix */
+    if (sequence.offset < 8) {
+        /* close range match, overlap */
+        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */
+        int const sub2 = dec64table[sequence.offset];
+        op[0] = match[0];
+        op[1] = match[1];
+        op[2] = match[2];
+        op[3] = match[3];
+        match += dec32table[sequence.offset];
+        ZSTD_copy4(op+4, match);
+        match -= sub2;
+    } else {
+        ZSTD_copy8(op, match);
+    }
+    op += 8; match += 8;
+
+    if (oMatchEnd > oend-(16-MINMATCH)) {
+        if (op < oend_w) {
+            ZSTD_wildcopy(op, match, oend_w - op, ZSTD_overlap_src_before_dst);
+            match += oend_w - op;
+            op = oend_w;
+        }
+        while (op < oMatchEnd) *op++ = *match++;
+    } else {
+        ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8, ZSTD_overlap_src_before_dst);   /* works even if matchLength < 8 */
+    }
+    return sequenceLength;
+}
+
+static void
+ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
+{
+    const void* ptr = dt;
+    const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;
+    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
+    DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits",
+                (U32)DStatePtr->state, DTableH->tableLog);
+    BIT_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+FORCE_INLINE_TEMPLATE void
+ZSTD_updateFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD)
+{
+    ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    size_t const lowBits = BIT_readBits(bitD, nbBits);
+    DStatePtr->state = DInfo.nextState + lowBits;
+}
+
+/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum
+ * offset bits. But we can only read at most (STREAM_ACCUMULATOR_MIN_32 - 1)
+ * bits before reloading. This value is the maximum number of bytes we read
+ * after reloading when we are decoding long offsets.
+ */
+#define LONG_OFFSETS_MAX_EXTRA_BITS_32                       \
+    (ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32       \
+        ? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32  \
+        : 0)
+
+typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e;
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
+FORCE_INLINE_TEMPLATE seq_t
+ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
+{
+    seq_t seq;
+    U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits;
+    U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits;
+    U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits;
+    U32 const totalBits = llBits+mlBits+ofBits;
+    U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue;
+    U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue;
+    U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue;
+
+    /* sequence */
+    {   size_t offset;
+        if (!ofBits)
+            offset = 0;
+        else {
+            ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
+            ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
+            assert(ofBits <= MaxOff);
+            if (MEM_32bits() && longOffsets && (ofBits >= STREAM_ACCUMULATOR_MIN_32)) {
+                U32 const extraBits = ofBits - MIN(ofBits, 32 - seqState->DStream.bitsConsumed);
+                offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
+                BIT_reloadDStream(&seqState->DStream);
+                if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
+                assert(extraBits <= LONG_OFFSETS_MAX_EXTRA_BITS_32);   /* to avoid another reload */
+            } else {
+                offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/);   /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */
+                if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
+            }
+        }
+
+        if (ofBits <= 1) {
+            offset += (llBase==0);
+            if (offset) {
+                size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
+                temp += !temp;   /* 0 is not valid; input is corrupted; force offset to 1 */
+                if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
+                seqState->prevOffset[1] = seqState->prevOffset[0];
+                seqState->prevOffset[0] = offset = temp;
+            } else {  /* offset == 0 */
+                offset = seqState->prevOffset[0];
+            }
+        } else {
+            seqState->prevOffset[2] = seqState->prevOffset[1];
+            seqState->prevOffset[1] = seqState->prevOffset[0];
+            seqState->prevOffset[0] = offset;
+        }
+        seq.offset = offset;
+    }
+
+    seq.matchLength = mlBase
+                    + ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/) : 0);  /* <=  16 bits */
+    if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
+        BIT_reloadDStream(&seqState->DStream);
+    if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
+        BIT_reloadDStream(&seqState->DStream);
+    /* Ensure there are enough bits to read the rest of data in 64-bit mode. */
+    ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
+
+    seq.litLength = llBase
+                  + ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits/*>0*/) : 0);    /* <=  16 bits */
+    if (MEM_32bits())
+        BIT_reloadDStream(&seqState->DStream);
+
+    DEBUGLOG(6, "seq: litL=%u, matchL=%u, offset=%u",
+                (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);
+
+    /* ANS state update */
+    ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream);    /* <=  9 bits */
+    ZSTD_updateFseState(&seqState->stateML, &seqState->DStream);    /* <=  9 bits */
+    if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
+    ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream);  /* <=  8 bits */
+
+    return seq;
+}
+
+FORCE_INLINE_TEMPLATE size_t
+DONT_VECTORIZE
+ZSTD_decompressSequences_body( ZSTD_DCtx* dctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize, int nbSeq,
+                         const ZSTD_longOffset_e isLongOffset)
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* const oend = ostart + maxDstSize;
+    BYTE* op = ostart;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
+    const BYTE* const vBase = (const BYTE*) (dctx->virtualStart);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
+    DEBUGLOG(5, "ZSTD_decompressSequences_body");
+
+    /* Regen sequences */
+    if (nbSeq) {
+        seqState_t seqState;
+        dctx->fseEntropy = 1;
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
+        RETURN_ERROR_IF(
+            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
+            corruption_detected);
+        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
+        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
+        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
+
+        ZSTD_STATIC_ASSERT(
+                BIT_DStream_unfinished < BIT_DStream_completed &&
+                BIT_DStream_endOfBuffer < BIT_DStream_completed &&
+                BIT_DStream_completed < BIT_DStream_overflow);
+
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; ) {
+            nbSeq--;
+            {   seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset);
+                size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, prefixStart, vBase, dictEnd);
+                DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize);
+                if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
+                op += oneSeqSize;
+        }   }
+
+        /* check if reached exact end */
+        DEBUGLOG(5, "ZSTD_decompressSequences_body: after decode loop, remaining nbSeq : %i", nbSeq);
+        RETURN_ERROR_IF(nbSeq, corruption_detected);
+        RETURN_ERROR_IF(BIT_reloadDStream(&seqState.DStream) < BIT_DStream_completed, corruption_detected);
+        /* save reps for next block */
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
+    }
+
+    /* last literal segment */
+    {   size_t const lastLLSize = litEnd - litPtr;
+        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall);
+        memcpy(op, litPtr, lastLLSize);
+        op += lastLLSize;
+    }
+
+    return op-ostart;
+}
+
+static size_t
+ZSTD_decompressSequences_default(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
+                           const ZSTD_longOffset_e isLongOffset)
+{
+    return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
+
+
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
+FORCE_INLINE_TEMPLATE seq_t
+ZSTD_decodeSequenceLong(seqState_t* seqState, ZSTD_longOffset_e const longOffsets)
+{
+    seq_t seq;
+    U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits;
+    U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits;
+    U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits;
+    U32 const totalBits = llBits+mlBits+ofBits;
+    U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue;
+    U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue;
+    U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue;
+
+    /* sequence */
+    {   size_t offset;
+        if (!ofBits)
+            offset = 0;
+        else {
+            ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
+            ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
+            assert(ofBits <= MaxOff);
+            if (MEM_32bits() && longOffsets) {
+                U32 const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN_32-1);
+                offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
+                if (MEM_32bits() || extraBits) BIT_reloadDStream(&seqState->DStream);
+                if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
+            } else {
+                offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits);   /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */
+                if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
+            }
+        }
+
+        if (ofBits <= 1) {
+            offset += (llBase==0);
+            if (offset) {
+                size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
+                temp += !temp;   /* 0 is not valid; input is corrupted; force offset to 1 */
+                if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
+                seqState->prevOffset[1] = seqState->prevOffset[0];
+                seqState->prevOffset[0] = offset = temp;
+            } else {
+                offset = seqState->prevOffset[0];
+            }
+        } else {
+            seqState->prevOffset[2] = seqState->prevOffset[1];
+            seqState->prevOffset[1] = seqState->prevOffset[0];
+            seqState->prevOffset[0] = offset;
+        }
+        seq.offset = offset;
+    }
+
+    seq.matchLength = mlBase + ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits) : 0);  /* <=  16 bits */
+    if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
+        BIT_reloadDStream(&seqState->DStream);
+    if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
+        BIT_reloadDStream(&seqState->DStream);
+    /* Verify that there is enough bits to read the rest of the data in 64-bit mode. */
+    ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
+
+    seq.litLength = llBase + ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits) : 0);    /* <=  16 bits */
+    if (MEM_32bits())
+        BIT_reloadDStream(&seqState->DStream);
+
+    {   size_t const pos = seqState->pos + seq.litLength;
+        const BYTE* const matchBase = (seq.offset > pos) ? seqState->dictEnd : seqState->prefixStart;
+        seq.match = matchBase + pos - seq.offset;  /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted.
+                                                    * No consequence though : no memory access will occur, overly large offset will be detected in ZSTD_execSequenceLong() */
+        seqState->pos = pos + seq.matchLength;
+    }
+
+    /* ANS state update */
+    ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream);    /* <=  9 bits */
+    ZSTD_updateFseState(&seqState->stateML, &seqState->DStream);    /* <=  9 bits */
+    if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
+    ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream);  /* <=  8 bits */
+
+    return seq;
+}
+
+FORCE_INLINE_TEMPLATE size_t
+ZSTD_decompressSequencesLong_body(
+                               ZSTD_DCtx* dctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize, int nbSeq,
+                         const ZSTD_longOffset_e isLongOffset)
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* const oend = ostart + maxDstSize;
+    BYTE* op = ostart;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
+    const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
+
+    /* Regen sequences */
+    if (nbSeq) {
+#define STORED_SEQS 4
+#define STORED_SEQS_MASK (STORED_SEQS-1)
+#define ADVANCED_SEQS 4
+        seq_t sequences[STORED_SEQS];
+        int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
+        seqState_t seqState;
+        int seqNb;
+        dctx->fseEntropy = 1;
+        { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
+        seqState.prefixStart = prefixStart;
+        seqState.pos = (size_t)(op-prefixStart);
+        seqState.dictEnd = dictEnd;
+        assert(iend >= ip);
+        RETURN_ERROR_IF(
+            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
+            corruption_detected);
+        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
+        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
+        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
+
+        /* prepare in advance */
+        for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
+            sequences[seqNb] = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
+            PREFETCH_L1(sequences[seqNb].match); PREFETCH_L1(sequences[seqNb].match + sequences[seqNb].matchLength - 1); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
+        }
+        RETURN_ERROR_IF(seqNb<seqAdvance, corruption_detected);
+
+        /* decode and decompress */
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
+            seq_t const sequence = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
+            size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
+            PREFETCH_L1(sequence.match); PREFETCH_L1(sequence.match + sequence.matchLength - 1); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
+            sequences[seqNb & STORED_SEQS_MASK] = sequence;
+            op += oneSeqSize;
+        }
+        RETURN_ERROR_IF(seqNb<nbSeq, corruption_detected);
+
+        /* finish queue */
+        seqNb -= seqAdvance;
+        for ( ; seqNb<nbSeq ; seqNb++) {
+            size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[seqNb&STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
+            op += oneSeqSize;
+        }
+
+        /* save reps for next block */
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
+    }
+
+    /* last literal segment */
+    {   size_t const lastLLSize = litEnd - litPtr;
+        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall);
+        memcpy(op, litPtr, lastLLSize);
+        op += lastLLSize;
+    }
+
+    return op-ostart;
+}
+
+static size_t
+ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
+                           const ZSTD_longOffset_e isLongOffset)
+{
+    return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
+
+
+
+#if DYNAMIC_BMI2
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
+static TARGET_ATTRIBUTE("bmi2") size_t
+DONT_VECTORIZE
+ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
+                           const ZSTD_longOffset_e isLongOffset)
+{
+    return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
+static TARGET_ATTRIBUTE("bmi2") size_t
+ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
+                           const ZSTD_longOffset_e isLongOffset)
+{
+    return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
+
+#endif /* DYNAMIC_BMI2 */
+
+typedef size_t (*ZSTD_decompressSequences_t)(
+                            ZSTD_DCtx* dctx,
+                            void* dst, size_t maxDstSize,
+                            const void* seqStart, size_t seqSize, int nbSeq,
+                            const ZSTD_longOffset_e isLongOffset);
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
+static size_t
+ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
+                   const void* seqStart, size_t seqSize, int nbSeq,
+                   const ZSTD_longOffset_e isLongOffset)
+{
+    DEBUGLOG(5, "ZSTD_decompressSequences");
+#if DYNAMIC_BMI2
+    if (dctx->bmi2) {
+        return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+    }
+#endif
+  return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
+
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
+/* ZSTD_decompressSequencesLong() :
+ * decompression function triggered when a minimum share of offsets is considered "long",
+ * aka out of cache.
+ * note : "long" definition seems overloaded here, sometimes meaning "wider than bitstream register", and sometimes meaning "farther than memory cache distance".
+ * This function will try to mitigate main memory latency through the use of prefetching */
+static size_t
+ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
+                             void* dst, size_t maxDstSize,
+                             const void* seqStart, size_t seqSize, int nbSeq,
+                             const ZSTD_longOffset_e isLongOffset)
+{
+    DEBUGLOG(5, "ZSTD_decompressSequencesLong");
+#if DYNAMIC_BMI2
+    if (dctx->bmi2) {
+        return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+    }
+#endif
+  return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
+
+
+
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+/* ZSTD_getLongOffsetsShare() :
+ * condition : offTable must be valid
+ * @return : "share" of long offsets (arbitrarily defined as > (1<<23))
+ *           compared to maximum possible of (1<<OffFSELog) */
+static unsigned
+ZSTD_getLongOffsetsShare(const ZSTD_seqSymbol* offTable)
+{
+    const void* ptr = offTable;
+    U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog;
+    const ZSTD_seqSymbol* table = offTable + 1;
+    U32 const max = 1 << tableLog;
+    U32 u, total = 0;
+    DEBUGLOG(5, "ZSTD_getLongOffsetsShare: (tableLog=%u)", tableLog);
+
+    assert(max <= (1 << OffFSELog));  /* max not too large */
+    for (u=0; u<max; u++) {
+        if (table[u].nbAdditionalBits > 22) total += 1;
+    }
+
+    assert(tableLog <= OffFSELog);
+    total <<= (OffFSELog - tableLog);  /* scale to OffFSELog */
+
+    return total;
+}
+#endif
+
+
+size_t
+ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
+                              void* dst, size_t dstCapacity,
+                        const void* src, size_t srcSize, const int frame)
+{   /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+    /* isLongOffset must be true if there are long offsets.
+     * Offsets are long if they are larger than 2^STREAM_ACCUMULATOR_MIN.
+     * We don't expect that to be the case in 64-bit mode.
+     * In block mode, window size is not known, so we have to be conservative.
+     * (note: but it could be evaluated from current-lowLimit)
+     */
+    ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame || (dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN))));
+    DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize);
+
+    RETURN_ERROR_IF(srcSize >= ZSTD_BLOCKSIZE_MAX, srcSize_wrong);
+
+    /* Decode literals section */
+    {   size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
+        DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize);
+        if (ZSTD_isError(litCSize)) return litCSize;
+        ip += litCSize;
+        srcSize -= litCSize;
+    }
+
+    /* Build Decoding Tables */
+    {
+        /* These macros control at build-time which decompressor implementation
+         * we use. If neither is defined, we do some inspection and dispatch at
+         * runtime.
+         */
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+        int usePrefetchDecoder = dctx->ddictIsCold;
+#endif
+        int nbSeq;
+        size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);
+        if (ZSTD_isError(seqHSize)) return seqHSize;
+        ip += seqHSize;
+        srcSize -= seqHSize;
+
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+        if ( !usePrefetchDecoder
+          && (!frame || (dctx->fParams.windowSize > (1<<24)))
+          && (nbSeq>ADVANCED_SEQS) ) {  /* could probably use a larger nbSeq limit */
+            U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr);
+            U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */
+            usePrefetchDecoder = (shareLongOffsets >= minShare);
+        }
+#endif
+
+        dctx->ddictIsCold = 0;
+
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+        if (usePrefetchDecoder)
+#endif
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
+            return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
+#endif
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
+        /* else */
+        return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);
+#endif
+    }
+}
+
+
+size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{
+    size_t dSize;
+    ZSTD_checkContinuity(dctx, dst);
+    dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0);
+    dctx->previousDstEnd = (char*)dst + dSize;
+    return dSize;
+}
diff --git a/src/zstd_decompress_block.h b/src/zstd_decompress_block.h
new file mode 100644
index 0000000..7e92960
--- /dev/null
+++ b/src/zstd_decompress_block.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+#ifndef ZSTD_DEC_BLOCK_H
+#define ZSTD_DEC_BLOCK_H
+
+/*-*******************************************************
+ *  Dependencies
+ *********************************************************/
+#include <stddef.h>   /* size_t */
+#include "zstd.h"    /* DCtx, and some public functions */
+#include "zstd_internal.h"  /* blockProperties_t, and some public functions */
+#include "zstd_decompress_internal.h"  /* ZSTD_seqSymbol */
+
+
+/* ===   Prototypes   === */
+
+/* note: prototypes already published within `zstd.h` :
+ * ZSTD_decompressBlock()
+ */
+
+/* note: prototypes already published within `zstd_internal.h` :
+ * ZSTD_getcBlockSize()
+ * ZSTD_decodeSeqHeaders()
+ */
+
+
+/* ZSTD_decompressBlock_internal() :
+ * decompress block, starting at `src`,
+ * into destination buffer `dst`.
+ * @return : decompressed block size,
+ *           or an error code (which can be tested using ZSTD_isError())
+ */
+size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
+                               void* dst, size_t dstCapacity,
+                         const void* src, size_t srcSize, const int frame);
+
+/* ZSTD_buildFSETable() :
+ * generate FSE decoding table for one symbol (ll, ml or off)
+ * this function must be called with valid parameters only
+ * (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.)
+ * in which case it cannot fail.
+ * Internal use only.
+ */
+void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
+             const short* normalizedCounter, unsigned maxSymbolValue,
+             const U32* baseValue, const U32* nbAdditionalBits,
+                   unsigned tableLog);
+
+
+#endif /* ZSTD_DEC_BLOCK_H */
diff --git a/src/zstd_decompress_internal.h b/src/zstd_decompress_internal.h
new file mode 100644
index 0000000..ccbdfa0
--- /dev/null
+++ b/src/zstd_decompress_internal.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/* zstd_decompress_internal:
+ * objects and definitions shared within lib/decompress modules */
+
+ #ifndef ZSTD_DECOMPRESS_INTERNAL_H
+ #define ZSTD_DECOMPRESS_INTERNAL_H
+
+
+/*-*******************************************************
+ *  Dependencies
+ *********************************************************/
+#include "mem.h"             /* BYTE, U16, U32 */
+#include "zstd_internal.h"   /* ZSTD_seqSymbol */
+
+
+
+/*-*******************************************************
+ *  Constants
+ *********************************************************/
+static const U32 LL_base[MaxLL+1] = {
+                 0,    1,    2,     3,     4,     5,     6,      7,
+                 8,    9,   10,    11,    12,    13,    14,     15,
+                16,   18,   20,    22,    24,    28,    32,     40,
+                48,   64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
+                0x2000, 0x4000, 0x8000, 0x10000 };
+
+static const U32 OF_base[MaxOff+1] = {
+                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,
+                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,
+                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
+                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD };
+
+static const U32 OF_bits[MaxOff+1] = {
+                     0,  1,  2,  3,  4,  5,  6,  7,
+                     8,  9, 10, 11, 12, 13, 14, 15,
+                    16, 17, 18, 19, 20, 21, 22, 23,
+                    24, 25, 26, 27, 28, 29, 30, 31 };
+
+static const U32 ML_base[MaxML+1] = {
+                     3,  4,  5,    6,     7,     8,     9,    10,
+                    11, 12, 13,   14,    15,    16,    17,    18,
+                    19, 20, 21,   22,    23,    24,    25,    26,
+                    27, 28, 29,   30,    31,    32,    33,    34,
+                    35, 37, 39,   41,    43,    47,    51,    59,
+                    67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
+                    0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
+
+
+/*-*******************************************************
+ *  Decompression types
+ *********************************************************/
+ typedef struct {
+     U32 fastMode;
+     U32 tableLog;
+ } ZSTD_seqSymbol_header;
+
+ typedef struct {
+     U16  nextState;
+     BYTE nbAdditionalBits;
+     BYTE nbBits;
+     U32  baseValue;
+ } ZSTD_seqSymbol;
+
+ #define SEQSYMBOL_TABLE_SIZE(log)   (1 + (1 << (log)))
+
+typedef struct {
+    ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)];    /* Note : Space reserved for FSE Tables */
+    ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)];   /* is also used as temporary workspace while building hufTable during DDict creation */
+    ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)];    /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */
+    HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)];  /* can accommodate HUF_decompress4X */
+    U32 rep[ZSTD_REP_NUM];
+} ZSTD_entropyDTables_t;
+
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
+               ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,
+               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;
+
+typedef enum { zdss_init=0, zdss_loadHeader,
+               zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
+
+typedef enum {
+    ZSTD_use_indefinitely = -1,  /* Use the dictionary indefinitely */
+    ZSTD_dont_use = 0,           /* Do not use the dictionary (if one exists free it) */
+    ZSTD_use_once = 1            /* Use the dictionary once and set to ZSTD_dont_use */
+} ZSTD_dictUses_e;
+
+struct ZSTD_DCtx_s
+{
+    const ZSTD_seqSymbol* LLTptr;
+    const ZSTD_seqSymbol* MLTptr;
+    const ZSTD_seqSymbol* OFTptr;
+    const HUF_DTable* HUFptr;
+    ZSTD_entropyDTables_t entropy;
+    U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];   /* space needed when building huffman tables */
+    const void* previousDstEnd;   /* detect continuity */
+    const void* prefixStart;      /* start of current segment */
+    const void* virtualStart;     /* virtual start of previous segment if it was just before current one */
+    const void* dictEnd;          /* end of previous segment */
+    size_t expected;
+    ZSTD_frameHeader fParams;
+    U64 decodedSize;
+    blockType_e bType;            /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */
+    ZSTD_dStage stage;
+    U32 litEntropy;
+    U32 fseEntropy;
+    XXH64_state_t xxhState;
+    size_t headerSize;
+    ZSTD_format_e format;
+    const BYTE* litPtr;
+    ZSTD_customMem customMem;
+    size_t litSize;
+    size_t rleSize;
+    size_t staticSize;
+    int bmi2;                     /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
+
+    /* dictionary */
+    ZSTD_DDict* ddictLocal;
+    const ZSTD_DDict* ddict;     /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */
+    U32 dictID;
+    int ddictIsCold;             /* if == 1 : dictionary is "new" for working context, and presumed "cold" (not in cpu cache) */
+    ZSTD_dictUses_e dictUses;
+
+    /* streaming */
+    ZSTD_dStreamStage streamStage;
+    char*  inBuff;
+    size_t inBuffSize;
+    size_t inPos;
+    size_t maxWindowSize;
+    char*  outBuff;
+    size_t outBuffSize;
+    size_t outStart;
+    size_t outEnd;
+    size_t lhSize;
+    void* legacyContext;
+    U32 previousLegacyVersion;
+    U32 legacyVersion;
+    U32 hostageByte;
+    int noForwardProgress;
+
+    /* workspace */
+    BYTE litBuffer[ZSTD_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];
+    BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];
+};  /* typedef'd to ZSTD_DCtx within "zstd.h" */
+
+
+/*-*******************************************************
+ *  Shared internal functions
+ *********************************************************/
+
+/*! ZSTD_loadDEntropy() :
+ *  dict : must point at beginning of a valid zstd dictionary.
+ * @return : size of entropy tables read */
+size_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
+                   const void* const dict, size_t const dictSize);
+
+/*! ZSTD_checkContinuity() :
+ *  check if next `dst` follows previous position, where decompression ended.
+ *  If yes, do nothing (continue on current segment).
+ *  If not, classify previous segment as "external dictionary", and start a new segment.
+ *  This function cannot fail. */
+void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst);
+
+
+#endif /* ZSTD_DECOMPRESS_INTERNAL_H */
diff --git a/src/zstd_double_fast.c b/src/zstd_double_fast.c
new file mode 100644
index 0000000..54467cc
--- /dev/null
+++ b/src/zstd_double_fast.c
@@ -0,0 +1,518 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#include "zstd_compress_internal.h"
+#include "zstd_double_fast.h"
+
+
+void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
+                              void const* end, ZSTD_dictTableLoadMethod_e dtlm)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const hashLarge = ms->hashTable;
+    U32  const hBitsL = cParams->hashLog;
+    U32  const mls = cParams->minMatch;
+    U32* const hashSmall = ms->chainTable;
+    U32  const hBitsS = cParams->chainLog;
+    const BYTE* const base = ms->window.base;
+    const BYTE* ip = base + ms->nextToUpdate;
+    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
+    const U32 fastHashFillStep = 3;
+
+    /* Always insert every fastHashFillStep position into the hash tables.
+     * Insert the other positions into the large hash table if their entry
+     * is empty.
+     */
+    for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) {
+        U32 const current = (U32)(ip - base);
+        U32 i;
+        for (i = 0; i < fastHashFillStep; ++i) {
+            size_t const smHash = ZSTD_hashPtr(ip + i, hBitsS, mls);
+            size_t const lgHash = ZSTD_hashPtr(ip + i, hBitsL, 8);
+            if (i == 0)
+                hashSmall[smHash] = current + i;
+            if (i == 0 || hashLarge[lgHash] == 0)
+                hashLarge[lgHash] = current + i;
+            /* Only load extra positions for ZSTD_dtlm_full */
+            if (dtlm == ZSTD_dtlm_fast)
+                break;
+    }   }
+}
+
+
+FORCE_INLINE_TEMPLATE
+size_t ZSTD_compressBlock_doubleFast_generic(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize,
+        U32 const mls /* template */, ZSTD_dictMode_e const dictMode)
+{
+    ZSTD_compressionParameters const* cParams = &ms->cParams;
+    U32* const hashLong = ms->hashTable;
+    const U32 hBitsL = cParams->hashLog;
+    U32* const hashSmall = ms->chainTable;
+    const U32 hBitsS = cParams->chainLog;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
+    const U32 lowestValid = ms->window.dictLimit;
+    const U32 maxDistance = 1U << cParams->windowLog;
+    /* presumes that, if there is a dictionary, it must be using Attach mode */
+    const U32 prefixLowestIndex = (endIndex - lowestValid > maxDistance) ? endIndex - maxDistance : lowestValid;
+    const BYTE* const prefixLowest = base + prefixLowestIndex;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - HASH_READ_SIZE;
+    U32 offset_1=rep[0], offset_2=rep[1];
+    U32 offsetSaved = 0;
+
+    const ZSTD_matchState_t* const dms = ms->dictMatchState;
+    const ZSTD_compressionParameters* const dictCParams =
+                                     dictMode == ZSTD_dictMatchState ?
+                                     &dms->cParams : NULL;
+    const U32* const dictHashLong  = dictMode == ZSTD_dictMatchState ?
+                                     dms->hashTable : NULL;
+    const U32* const dictHashSmall = dictMode == ZSTD_dictMatchState ?
+                                     dms->chainTable : NULL;
+    const U32 dictStartIndex       = dictMode == ZSTD_dictMatchState ?
+                                     dms->window.dictLimit : 0;
+    const BYTE* const dictBase     = dictMode == ZSTD_dictMatchState ?
+                                     dms->window.base : NULL;
+    const BYTE* const dictStart    = dictMode == ZSTD_dictMatchState ?
+                                     dictBase + dictStartIndex : NULL;
+    const BYTE* const dictEnd      = dictMode == ZSTD_dictMatchState ?
+                                     dms->window.nextSrc : NULL;
+    const U32 dictIndexDelta       = dictMode == ZSTD_dictMatchState ?
+                                     prefixLowestIndex - (U32)(dictEnd - dictBase) :
+                                     0;
+    const U32 dictHBitsL           = dictMode == ZSTD_dictMatchState ?
+                                     dictCParams->hashLog : hBitsL;
+    const U32 dictHBitsS           = dictMode == ZSTD_dictMatchState ?
+                                     dictCParams->chainLog : hBitsS;
+    const U32 dictAndPrefixLength  = (U32)(ip - prefixLowest + dictEnd - dictStart);
+
+    DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_generic");
+
+    assert(dictMode == ZSTD_noDict || dictMode == ZSTD_dictMatchState);
+
+    /* if a dictionary is attached, it must be within window range */
+    if (dictMode == ZSTD_dictMatchState) {
+        assert(lowestValid + maxDistance >= endIndex);
+    }
+
+    /* init */
+    ip += (dictAndPrefixLength == 0);
+    if (dictMode == ZSTD_noDict) {
+        U32 const maxRep = (U32)(ip - prefixLowest);
+        if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0;
+        if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0;
+    }
+    if (dictMode == ZSTD_dictMatchState) {
+        /* dictMatchState repCode checks don't currently handle repCode == 0
+         * disabling. */
+        assert(offset_1 <= dictAndPrefixLength);
+        assert(offset_2 <= dictAndPrefixLength);
+    }
+
+    /* Main Search Loop */
+    while (ip < ilimit) {   /* < instead of <=, because repcode check at (ip+1) */
+        size_t mLength;
+        U32 offset;
+        size_t const h2 = ZSTD_hashPtr(ip, hBitsL, 8);
+        size_t const h = ZSTD_hashPtr(ip, hBitsS, mls);
+        size_t const dictHL = ZSTD_hashPtr(ip, dictHBitsL, 8);
+        size_t const dictHS = ZSTD_hashPtr(ip, dictHBitsS, mls);
+        U32 const current = (U32)(ip-base);
+        U32 const matchIndexL = hashLong[h2];
+        U32 matchIndexS = hashSmall[h];
+        const BYTE* matchLong = base + matchIndexL;
+        const BYTE* match = base + matchIndexS;
+        const U32 repIndex = current + 1 - offset_1;
+        const BYTE* repMatch = (dictMode == ZSTD_dictMatchState
+                            && repIndex < prefixLowestIndex) ?
+                               dictBase + (repIndex - dictIndexDelta) :
+                               base + repIndex;
+        hashLong[h2] = hashSmall[h] = current;   /* update hash tables */
+
+        /* check dictMatchState repcode */
+        if (dictMode == ZSTD_dictMatchState
+            && ((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
+            && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
+            const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
+            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
+            ip++;
+            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, 0, mLength-MINMATCH);
+            goto _match_stored;
+        }
+
+        /* check noDict repcode */
+        if ( dictMode == ZSTD_noDict
+          && ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) {
+            mLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;
+            ip++;
+            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, 0, mLength-MINMATCH);
+            goto _match_stored;
+        }
+
+        if (matchIndexL > prefixLowestIndex) {
+            /* check prefix long match */
+            if (MEM_read64(matchLong) == MEM_read64(ip)) {
+                mLength = ZSTD_count(ip+8, matchLong+8, iend) + 8;
+                offset = (U32)(ip-matchLong);
+                while (((ip>anchor) & (matchLong>prefixLowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */
+                goto _match_found;
+            }
+        } else if (dictMode == ZSTD_dictMatchState) {
+            /* check dictMatchState long match */
+            U32 const dictMatchIndexL = dictHashLong[dictHL];
+            const BYTE* dictMatchL = dictBase + dictMatchIndexL;
+            assert(dictMatchL < dictEnd);
+
+            if (dictMatchL > dictStart && MEM_read64(dictMatchL) == MEM_read64(ip)) {
+                mLength = ZSTD_count_2segments(ip+8, dictMatchL+8, iend, dictEnd, prefixLowest) + 8;
+                offset = (U32)(current - dictMatchIndexL - dictIndexDelta);
+                while (((ip>anchor) & (dictMatchL>dictStart)) && (ip[-1] == dictMatchL[-1])) { ip--; dictMatchL--; mLength++; } /* catch up */
+                goto _match_found;
+        }   }
+
+        if (matchIndexS > prefixLowestIndex) {
+            /* check prefix short match */
+            if (MEM_read32(match) == MEM_read32(ip)) {
+                goto _search_next_long;
+            }
+        } else if (dictMode == ZSTD_dictMatchState) {
+            /* check dictMatchState short match */
+            U32 const dictMatchIndexS = dictHashSmall[dictHS];
+            match = dictBase + dictMatchIndexS;
+            matchIndexS = dictMatchIndexS + dictIndexDelta;
+
+            if (match > dictStart && MEM_read32(match) == MEM_read32(ip)) {
+                goto _search_next_long;
+        }   }
+
+        ip += ((ip-anchor) >> kSearchStrength) + 1;
+        continue;
+
+_search_next_long:
+
+        {   size_t const hl3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
+            size_t const dictHLNext = ZSTD_hashPtr(ip+1, dictHBitsL, 8);
+            U32 const matchIndexL3 = hashLong[hl3];
+            const BYTE* matchL3 = base + matchIndexL3;
+            hashLong[hl3] = current + 1;
+
+            /* check prefix long +1 match */
+            if (matchIndexL3 > prefixLowestIndex) {
+                if (MEM_read64(matchL3) == MEM_read64(ip+1)) {
+                    mLength = ZSTD_count(ip+9, matchL3+8, iend) + 8;
+                    ip++;
+                    offset = (U32)(ip-matchL3);
+                    while (((ip>anchor) & (matchL3>prefixLowest)) && (ip[-1] == matchL3[-1])) { ip--; matchL3--; mLength++; } /* catch up */
+                    goto _match_found;
+                }
+            } else if (dictMode == ZSTD_dictMatchState) {
+                /* check dict long +1 match */
+                U32 const dictMatchIndexL3 = dictHashLong[dictHLNext];
+                const BYTE* dictMatchL3 = dictBase + dictMatchIndexL3;
+                assert(dictMatchL3 < dictEnd);
+                if (dictMatchL3 > dictStart && MEM_read64(dictMatchL3) == MEM_read64(ip+1)) {
+                    mLength = ZSTD_count_2segments(ip+1+8, dictMatchL3+8, iend, dictEnd, prefixLowest) + 8;
+                    ip++;
+                    offset = (U32)(current + 1 - dictMatchIndexL3 - dictIndexDelta);
+                    while (((ip>anchor) & (dictMatchL3>dictStart)) && (ip[-1] == dictMatchL3[-1])) { ip--; dictMatchL3--; mLength++; } /* catch up */
+                    goto _match_found;
+        }   }   }
+
+        /* if no long +1 match, explore the short match we found */
+        if (dictMode == ZSTD_dictMatchState && matchIndexS < prefixLowestIndex) {
+            mLength = ZSTD_count_2segments(ip+4, match+4, iend, dictEnd, prefixLowest) + 4;
+            offset = (U32)(current - matchIndexS);
+            while (((ip>anchor) & (match>dictStart)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
+        } else {
+            mLength = ZSTD_count(ip+4, match+4, iend) + 4;
+            offset = (U32)(ip - match);
+            while (((ip>anchor) & (match>prefixLowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
+        }
+
+        /* fall-through */
+
+_match_found:
+        offset_2 = offset_1;
+        offset_1 = offset;
+
+        ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
+
+_match_stored:
+        /* match found */
+        ip += mLength;
+        anchor = ip;
+
+        if (ip <= ilimit) {
+            /* Complementary insertion */
+            /* done after iLimit test, as candidates could be > iend-8 */
+            {   U32 const indexToInsert = current+2;
+                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;
+                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);
+                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;
+                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);
+            }
+
+            /* check immediate repcode */
+            if (dictMode == ZSTD_dictMatchState) {
+                while (ip <= ilimit) {
+                    U32 const current2 = (U32)(ip-base);
+                    U32 const repIndex2 = current2 - offset_2;
+                    const BYTE* repMatch2 = dictMode == ZSTD_dictMatchState
+                        && repIndex2 < prefixLowestIndex ?
+                            dictBase - dictIndexDelta + repIndex2 :
+                            base + repIndex2;
+                    if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */)
+                       && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
+                        const BYTE* const repEnd2 = repIndex2 < prefixLowestIndex ? dictEnd : iend;
+                        size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixLowest) + 4;
+                        U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
+                        ZSTD_storeSeq(seqStore, 0, anchor, 0, repLength2-MINMATCH);
+                        hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
+                        hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
+                        ip += repLength2;
+                        anchor = ip;
+                        continue;
+                    }
+                    break;
+            }   }
+
+            if (dictMode == ZSTD_noDict) {
+                while ( (ip <= ilimit)
+                     && ( (offset_2>0)
+                        & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {
+                    /* store sequence */
+                    size_t const rLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
+                    U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff;  /* swap offset_2 <=> offset_1 */
+                    hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = (U32)(ip-base);
+                    hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = (U32)(ip-base);
+                    ZSTD_storeSeq(seqStore, 0, anchor, 0, rLength-MINMATCH);
+                    ip += rLength;
+                    anchor = ip;
+                    continue;   /* faster when present ... (?) */
+        }   }   }
+    }   /* while (ip < ilimit) */
+
+    /* save reps for next block */
+    rep[0] = offset_1 ? offset_1 : offsetSaved;
+    rep[1] = offset_2 ? offset_2 : offsetSaved;
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+
+size_t ZSTD_compressBlock_doubleFast(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    const U32 mls = ms->cParams.minMatch;
+    switch(mls)
+    {
+    default: /* includes case 3 */
+    case 4 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_noDict);
+    case 5 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_noDict);
+    case 6 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_noDict);
+    case 7 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_noDict);
+    }
+}
+
+
+size_t ZSTD_compressBlock_doubleFast_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    const U32 mls = ms->cParams.minMatch;
+    switch(mls)
+    {
+    default: /* includes case 3 */
+    case 4 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 4, ZSTD_dictMatchState);
+    case 5 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 5, ZSTD_dictMatchState);
+    case 6 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 6, ZSTD_dictMatchState);
+    case 7 :
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, 7, ZSTD_dictMatchState);
+    }
+}
+
+
+static size_t ZSTD_compressBlock_doubleFast_extDict_generic(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize,
+        U32 const mls /* template */)
+{
+    ZSTD_compressionParameters const* cParams = &ms->cParams;
+    U32* const hashLong = ms->hashTable;
+    U32  const hBitsL = cParams->hashLog;
+    U32* const hashSmall = ms->chainTable;
+    U32  const hBitsS = cParams->chainLog;
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - 8;
+    const BYTE* const base = ms->window.base;
+    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
+    const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
+    const U32   dictStartIndex = lowLimit;
+    const U32   dictLimit = ms->window.dictLimit;
+    const U32   prefixStartIndex = (dictLimit > lowLimit) ? dictLimit : lowLimit;
+    const BYTE* const prefixStart = base + prefixStartIndex;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const BYTE* const dictStart = dictBase + dictStartIndex;
+    const BYTE* const dictEnd = dictBase + prefixStartIndex;
+    U32 offset_1=rep[0], offset_2=rep[1];
+
+    DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_extDict_generic (srcSize=%zu)", srcSize);
+
+    /* if extDict is invalidated due to maxDistance, switch to "regular" variant */
+    if (prefixStartIndex == dictStartIndex)
+        return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, src, srcSize, mls, ZSTD_noDict);
+
+    /* Search Loop */
+    while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
+        const size_t hSmall = ZSTD_hashPtr(ip, hBitsS, mls);
+        const U32 matchIndex = hashSmall[hSmall];
+        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;
+        const BYTE* match = matchBase + matchIndex;
+
+        const size_t hLong = ZSTD_hashPtr(ip, hBitsL, 8);
+        const U32 matchLongIndex = hashLong[hLong];
+        const BYTE* const matchLongBase = matchLongIndex < prefixStartIndex ? dictBase : base;
+        const BYTE* matchLong = matchLongBase + matchLongIndex;
+
+        const U32 current = (U32)(ip-base);
+        const U32 repIndex = current + 1 - offset_1;   /* offset_1 expected <= current +1 */
+        const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;
+        const BYTE* const repMatch = repBase + repIndex;
+        size_t mLength;
+        hashSmall[hSmall] = hashLong[hLong] = current;   /* update hash table */
+
+        if ((((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex doesn't overlap dict + prefix */
+            & (repIndex > dictStartIndex))
+          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
+            const BYTE* repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
+            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;
+            ip++;
+            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, 0, mLength-MINMATCH);
+        } else {
+            if ((matchLongIndex > dictStartIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) {
+                const BYTE* const matchEnd = matchLongIndex < prefixStartIndex ? dictEnd : iend;
+                const BYTE* const lowMatchPtr = matchLongIndex < prefixStartIndex ? dictStart : prefixStart;
+                U32 offset;
+                mLength = ZSTD_count_2segments(ip+8, matchLong+8, iend, matchEnd, prefixStart) + 8;
+                offset = current - matchLongIndex;
+                while (((ip>anchor) & (matchLong>lowMatchPtr)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; }   /* catch up */
+                offset_2 = offset_1;
+                offset_1 = offset;
+                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
+
+            } else if ((matchIndex > dictStartIndex) && (MEM_read32(match) == MEM_read32(ip))) {
+                size_t const h3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
+                U32 const matchIndex3 = hashLong[h3];
+                const BYTE* const match3Base = matchIndex3 < prefixStartIndex ? dictBase : base;
+                const BYTE* match3 = match3Base + matchIndex3;
+                U32 offset;
+                hashLong[h3] = current + 1;
+                if ( (matchIndex3 > dictStartIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) {
+                    const BYTE* const matchEnd = matchIndex3 < prefixStartIndex ? dictEnd : iend;
+                    const BYTE* const lowMatchPtr = matchIndex3 < prefixStartIndex ? dictStart : prefixStart;
+                    mLength = ZSTD_count_2segments(ip+9, match3+8, iend, matchEnd, prefixStart) + 8;
+                    ip++;
+                    offset = current+1 - matchIndex3;
+                    while (((ip>anchor) & (match3>lowMatchPtr)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */
+                } else {
+                    const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend;
+                    const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart;
+                    mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4;
+                    offset = current - matchIndex;
+                    while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; }   /* catch up */
+                }
+                offset_2 = offset_1;
+                offset_1 = offset;
+                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
+
+            } else {
+                ip += ((ip-anchor) >> kSearchStrength) + 1;
+                continue;
+        }   }
+
+        /* move to next sequence start */
+        ip += mLength;
+        anchor = ip;
+
+        if (ip <= ilimit) {
+            /* Complementary insertion */
+            /* done after iLimit test, as candidates could be > iend-8 */
+            {   U32 const indexToInsert = current+2;
+                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;
+                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);
+                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;
+                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);
+            }
+
+            /* check immediate repcode */
+            while (ip <= ilimit) {
+                U32 const current2 = (U32)(ip-base);
+                U32 const repIndex2 = current2 - offset_2;
+                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
+                if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3)   /* intentional overflow : ensure repIndex2 doesn't overlap dict + prefix */
+                    & (repIndex2 > dictStartIndex))
+                  && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
+                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
+                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
+                    U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
+                    ZSTD_storeSeq(seqStore, 0, anchor, 0, repLength2-MINMATCH);
+                    hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
+                    hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
+                    ip += repLength2;
+                    anchor = ip;
+                    continue;
+                }
+                break;
+    }   }   }
+
+    /* save reps for next block */
+    rep[0] = offset_1;
+    rep[1] = offset_2;
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+
+size_t ZSTD_compressBlock_doubleFast_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    U32 const mls = ms->cParams.minMatch;
+    switch(mls)
+    {
+    default: /* includes case 3 */
+    case 4 :
+        return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 4);
+    case 5 :
+        return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 5);
+    case 6 :
+        return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 6);
+    case 7 :
+        return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, src, srcSize, 7);
+    }
+}
diff --git a/src/zstd_double_fast.h b/src/zstd_double_fast.h
new file mode 100644
index 0000000..4fa31ac
--- /dev/null
+++ b/src/zstd_double_fast.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_DOUBLE_FAST_H
+#define ZSTD_DOUBLE_FAST_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "mem.h"      /* U32 */
+#include "zstd_compress_internal.h"     /* ZSTD_CCtx, size_t */
+
+void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
+                              void const* end, ZSTD_dictTableLoadMethod_e dtlm);
+size_t ZSTD_compressBlock_doubleFast(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_doubleFast_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_doubleFast_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_DOUBLE_FAST_H */
diff --git a/src/zstd_errors.h b/src/zstd_errors.h
new file mode 100644
index 0000000..92a3433
--- /dev/null
+++ b/src/zstd_errors.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_ERRORS_H_398273423
+#define ZSTD_ERRORS_H_398273423
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*===== dependency =====*/
+#include <stddef.h>   /* size_t */
+
+
+/* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
+#ifndef ZSTDERRORLIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define ZSTDERRORLIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define ZSTDERRORLIB_VISIBILITY
+#  endif
+#endif
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBILITY
+#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBILITY
+#endif
+
+/*-*********************************************
+ *  Error codes list
+ *-*********************************************
+ *  Error codes _values_ are pinned down since v1.3.1 only.
+ *  Therefore, don't rely on values if you may link to any version < v1.3.1.
+ *
+ *  Only values < 100 are considered stable.
+ *
+ *  note 1 : this API shall be used with static linking only.
+ *           dynamic linking is not yet officially supported.
+ *  note 2 : Prefer relying on the enum than on its value whenever possible
+ *           This is the only supported way to use the error list < v1.3.1
+ *  note 3 : ZSTD_isError() is always correct, whatever the library version.
+ **********************************************/
+typedef enum {
+  ZSTD_error_no_error = 0,
+  ZSTD_error_GENERIC  = 1,
+  ZSTD_error_prefix_unknown                = 10,
+  ZSTD_error_version_unsupported           = 12,
+  ZSTD_error_frameParameter_unsupported    = 14,
+  ZSTD_error_frameParameter_windowTooLarge = 16,
+  ZSTD_error_corruption_detected = 20,
+  ZSTD_error_checksum_wrong      = 22,
+  ZSTD_error_dictionary_corrupted      = 30,
+  ZSTD_error_dictionary_wrong          = 32,
+  ZSTD_error_dictionaryCreation_failed = 34,
+  ZSTD_error_parameter_unsupported   = 40,
+  ZSTD_error_parameter_outOfBound    = 42,
+  ZSTD_error_tableLog_tooLarge       = 44,
+  ZSTD_error_maxSymbolValue_tooLarge = 46,
+  ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_stage_wrong       = 60,
+  ZSTD_error_init_missing      = 62,
+  ZSTD_error_memory_allocation = 64,
+  ZSTD_error_workSpace_tooSmall= 66,
+  ZSTD_error_dstSize_tooSmall = 70,
+  ZSTD_error_srcSize_wrong    = 72,
+  ZSTD_error_dstBuffer_null   = 74,
+  /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
+  ZSTD_error_frameIndex_tooLarge = 100,
+  ZSTD_error_seekableIO          = 102,
+  ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
+} ZSTD_ErrorCode;
+
+/*! ZSTD_getErrorCode() :
+    convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
+    which can be used to compare with enum list published above */
+ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
+ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_ERRORS_H_398273423 */
diff --git a/src/zstd_fast.c b/src/zstd_fast.c
new file mode 100644
index 0000000..59267ff
--- /dev/null
+++ b/src/zstd_fast.c
@@ -0,0 +1,493 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#include "zstd_compress_internal.h"
+#include "zstd_fast.h"
+
+
+void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
+                        const void* const end,
+                        ZSTD_dictTableLoadMethod_e dtlm)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const hashTable = ms->hashTable;
+    U32  const hBits = cParams->hashLog;
+    U32  const mls = cParams->minMatch;
+    const BYTE* const base = ms->window.base;
+    const BYTE* ip = base + ms->nextToUpdate;
+    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
+    const U32 fastHashFillStep = 3;
+
+    /* Always insert every fastHashFillStep position into the hash table.
+     * Insert the other positions if their hash entry is empty.
+     */
+    for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {
+        U32 const current = (U32)(ip - base);
+        size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls);
+        hashTable[hash0] = current;
+        if (dtlm == ZSTD_dtlm_fast) continue;
+        /* Only load extra positions for ZSTD_dtlm_full */
+        {   U32 p;
+            for (p = 1; p < fastHashFillStep; ++p) {
+                size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls);
+                if (hashTable[hash] == 0) {  /* not yet filled */
+                    hashTable[hash] = current + p;
+    }   }   }   }
+}
+
+
+FORCE_INLINE_TEMPLATE
+size_t ZSTD_compressBlock_fast_generic(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize,
+        U32 const mls)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const hashTable = ms->hashTable;
+    U32 const hlog = cParams->hashLog;
+    /* support stepSize of 0 */
+    size_t const stepSize = cParams->targetLength + !(cParams->targetLength) + 1;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const istart = (const BYTE*)src;
+    /* We check ip0 (ip + 0) and ip1 (ip + 1) each loop */
+    const BYTE* ip0 = istart;
+    const BYTE* ip1;
+    const BYTE* anchor = istart;
+    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
+    const U32   maxDistance = 1U << cParams->windowLog;
+    const U32   validStartIndex = ms->window.dictLimit;
+    const U32   prefixStartIndex = (endIndex - validStartIndex > maxDistance) ? endIndex - maxDistance : validStartIndex;
+    const BYTE* const prefixStart = base + prefixStartIndex;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - HASH_READ_SIZE;
+    U32 offset_1=rep[0], offset_2=rep[1];
+    U32 offsetSaved = 0;
+
+    /* init */
+    DEBUGLOG(5, "ZSTD_compressBlock_fast_generic");
+    ip0 += (ip0 == prefixStart);
+    ip1 = ip0 + 1;
+    {
+        U32 const maxRep = (U32)(ip0 - prefixStart);
+        if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0;
+        if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0;
+    }
+
+    /* Main Search Loop */
+    while (ip1 < ilimit) {   /* < instead of <=, because check at ip0+2 */
+        size_t mLength;
+        BYTE const* ip2 = ip0 + 2;
+        size_t const h0 = ZSTD_hashPtr(ip0, hlog, mls);
+        U32 const val0 = MEM_read32(ip0);
+        size_t const h1 = ZSTD_hashPtr(ip1, hlog, mls);
+        U32 const val1 = MEM_read32(ip1);
+        U32 const current0 = (U32)(ip0-base);
+        U32 const current1 = (U32)(ip1-base);
+        U32 const matchIndex0 = hashTable[h0];
+        U32 const matchIndex1 = hashTable[h1];
+        BYTE const* repMatch = ip2-offset_1;
+        const BYTE* match0 = base + matchIndex0;
+        const BYTE* match1 = base + matchIndex1;
+        U32 offcode;
+        hashTable[h0] = current0;   /* update hash table */
+        hashTable[h1] = current1;   /* update hash table */
+
+        assert(ip0 + 1 == ip1);
+
+        if ((offset_1 > 0) & (MEM_read32(repMatch) == MEM_read32(ip2))) {
+            mLength = ip2[-1] == repMatch[-1] ? 1 : 0;
+            ip0 = ip2 - mLength;
+            match0 = repMatch - mLength;
+            offcode = 0;
+            goto _match;
+        }
+        if ((matchIndex0 > prefixStartIndex) && MEM_read32(match0) == val0) {
+            /* found a regular match */
+            goto _offset;
+        }
+        if ((matchIndex1 > prefixStartIndex) && MEM_read32(match1) == val1) {
+            /* found a regular match after one literal */
+            ip0 = ip1;
+            match0 = match1;
+            goto _offset;
+        }
+        {
+            size_t const step = ((ip0-anchor) >> (kSearchStrength - 1)) + stepSize;
+            assert(step >= 2);
+            ip0 += step;
+            ip1 += step;
+            continue;
+        }
+_offset: /* Requires: ip0, match0 */
+        /* Compute the offset code */
+        offset_2 = offset_1;
+        offset_1 = (U32)(ip0-match0);
+        offcode = offset_1 + ZSTD_REP_MOVE;
+        mLength = 0;
+        /* Count the backwards match length */
+        while (((ip0>anchor) & (match0>prefixStart))
+             && (ip0[-1] == match0[-1])) { ip0--; match0--; mLength++; } /* catch up */
+
+_match: /* Requires: ip0, match0, offcode */
+        /* Count the forward length */
+        mLength += ZSTD_count(ip0+mLength+4, match0+mLength+4, iend) + 4;
+        ZSTD_storeSeq(seqStore, ip0-anchor, anchor, offcode, mLength-MINMATCH);
+        /* match found */
+        ip0 += mLength;
+        anchor = ip0;
+        ip1 = ip0 + 1;
+
+        if (ip0 <= ilimit) {
+            /* Fill Table */
+            assert(base+current0+2 > istart);  /* check base overflow */
+            hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2;  /* here because current+2 could be > iend-8 */
+            hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);
+
+            while ( (ip0 <= ilimit)
+                 && ( (offset_2>0)
+                    & (MEM_read32(ip0) == MEM_read32(ip0 - offset_2)) )) {
+                /* store sequence */
+                size_t const rLength = ZSTD_count(ip0+4, ip0+4-offset_2, iend) + 4;
+                U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff;  /* swap offset_2 <=> offset_1 */
+                hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base);
+                ip0 += rLength;
+                ip1 = ip0 + 1;
+                ZSTD_storeSeq(seqStore, 0, anchor, 0, rLength-MINMATCH);
+                anchor = ip0;
+                continue;   /* faster when present (confirmed on gcc-8) ... (?) */
+            }
+        }
+    }
+
+    /* save reps for next block */
+    rep[0] = offset_1 ? offset_1 : offsetSaved;
+    rep[1] = offset_2 ? offset_2 : offsetSaved;
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+
+size_t ZSTD_compressBlock_fast(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    ZSTD_compressionParameters const* cParams = &ms->cParams;
+    U32 const mls = cParams->minMatch;
+    assert(ms->dictMatchState == NULL);
+    switch(mls)
+    {
+    default: /* includes case 3 */
+    case 4 :
+        return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 4);
+    case 5 :
+        return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 5);
+    case 6 :
+        return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 6);
+    case 7 :
+        return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, 7);
+    }
+}
+
+FORCE_INLINE_TEMPLATE
+size_t ZSTD_compressBlock_fast_dictMatchState_generic(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize, U32 const mls)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const hashTable = ms->hashTable;
+    U32 const hlog = cParams->hashLog;
+    /* support stepSize of 0 */
+    U32 const stepSize = cParams->targetLength + !(cParams->targetLength);
+    const BYTE* const base = ms->window.base;
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const U32   prefixStartIndex = ms->window.dictLimit;
+    const BYTE* const prefixStart = base + prefixStartIndex;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - HASH_READ_SIZE;
+    U32 offset_1=rep[0], offset_2=rep[1];
+    U32 offsetSaved = 0;
+
+    const ZSTD_matchState_t* const dms = ms->dictMatchState;
+    const ZSTD_compressionParameters* const dictCParams = &dms->cParams ;
+    const U32* const dictHashTable = dms->hashTable;
+    const U32 dictStartIndex       = dms->window.dictLimit;
+    const BYTE* const dictBase     = dms->window.base;
+    const BYTE* const dictStart    = dictBase + dictStartIndex;
+    const BYTE* const dictEnd      = dms->window.nextSrc;
+    const U32 dictIndexDelta       = prefixStartIndex - (U32)(dictEnd - dictBase);
+    const U32 dictAndPrefixLength  = (U32)(ip - prefixStart + dictEnd - dictStart);
+    const U32 dictHLog             = dictCParams->hashLog;
+
+    /* if a dictionary is still attached, it necessarily means that
+     * it is within window size. So we just check it. */
+    const U32 maxDistance = 1U << cParams->windowLog;
+    const U32 endIndex = (U32)((size_t)(ip - base) + srcSize);
+    assert(endIndex - prefixStartIndex <= maxDistance);
+    (void)maxDistance; (void)endIndex;   /* these variables are not used when assert() is disabled */
+
+    /* ensure there will be no no underflow
+     * when translating a dict index into a local index */
+    assert(prefixStartIndex >= (U32)(dictEnd - dictBase));
+
+    /* init */
+    DEBUGLOG(5, "ZSTD_compressBlock_fast_dictMatchState_generic");
+    ip += (dictAndPrefixLength == 0);
+    /* dictMatchState repCode checks don't currently handle repCode == 0
+     * disabling. */
+    assert(offset_1 <= dictAndPrefixLength);
+    assert(offset_2 <= dictAndPrefixLength);
+
+    /* Main Search Loop */
+    while (ip < ilimit) {   /* < instead of <=, because repcode check at (ip+1) */
+        size_t mLength;
+        size_t const h = ZSTD_hashPtr(ip, hlog, mls);
+        U32 const current = (U32)(ip-base);
+        U32 const matchIndex = hashTable[h];
+        const BYTE* match = base + matchIndex;
+        const U32 repIndex = current + 1 - offset_1;
+        const BYTE* repMatch = (repIndex < prefixStartIndex) ?
+                               dictBase + (repIndex - dictIndexDelta) :
+                               base + repIndex;
+        hashTable[h] = current;   /* update hash table */
+
+        if ( ((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex isn't overlapping dict + prefix */
+          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
+            const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
+            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;
+            ip++;
+            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, 0, mLength-MINMATCH);
+        } else if ( (matchIndex <= prefixStartIndex) ) {
+            size_t const dictHash = ZSTD_hashPtr(ip, dictHLog, mls);
+            U32 const dictMatchIndex = dictHashTable[dictHash];
+            const BYTE* dictMatch = dictBase + dictMatchIndex;
+            if (dictMatchIndex <= dictStartIndex ||
+                MEM_read32(dictMatch) != MEM_read32(ip)) {
+                assert(stepSize >= 1);
+                ip += ((ip-anchor) >> kSearchStrength) + stepSize;
+                continue;
+            } else {
+                /* found a dict match */
+                U32 const offset = (U32)(current-dictMatchIndex-dictIndexDelta);
+                mLength = ZSTD_count_2segments(ip+4, dictMatch+4, iend, dictEnd, prefixStart) + 4;
+                while (((ip>anchor) & (dictMatch>dictStart))
+                     && (ip[-1] == dictMatch[-1])) {
+                    ip--; dictMatch--; mLength++;
+                } /* catch up */
+                offset_2 = offset_1;
+                offset_1 = offset;
+                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
+            }
+        } else if (MEM_read32(match) != MEM_read32(ip)) {
+            /* it's not a match, and we're not going to check the dictionary */
+            assert(stepSize >= 1);
+            ip += ((ip-anchor) >> kSearchStrength) + stepSize;
+            continue;
+        } else {
+            /* found a regular match */
+            U32 const offset = (U32)(ip-match);
+            mLength = ZSTD_count(ip+4, match+4, iend) + 4;
+            while (((ip>anchor) & (match>prefixStart))
+                 && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
+            offset_2 = offset_1;
+            offset_1 = offset;
+            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
+        }
+
+        /* match found */
+        ip += mLength;
+        anchor = ip;
+
+        if (ip <= ilimit) {
+            /* Fill Table */
+            assert(base+current+2 > istart);  /* check base overflow */
+            hashTable[ZSTD_hashPtr(base+current+2, hlog, mls)] = current+2;  /* here because current+2 could be > iend-8 */
+            hashTable[ZSTD_hashPtr(ip-2, hlog, mls)] = (U32)(ip-2-base);
+
+            /* check immediate repcode */
+            while (ip <= ilimit) {
+                U32 const current2 = (U32)(ip-base);
+                U32 const repIndex2 = current2 - offset_2;
+                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ?
+                        dictBase - dictIndexDelta + repIndex2 :
+                        base + repIndex2;
+                if ( ((U32)((prefixStartIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */)
+                   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
+                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
+                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
+                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
+                    ZSTD_storeSeq(seqStore, 0, anchor, 0, repLength2-MINMATCH);
+                    hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2;
+                    ip += repLength2;
+                    anchor = ip;
+                    continue;
+                }
+                break;
+            }
+        }
+    }
+
+    /* save reps for next block */
+    rep[0] = offset_1 ? offset_1 : offsetSaved;
+    rep[1] = offset_2 ? offset_2 : offsetSaved;
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+size_t ZSTD_compressBlock_fast_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    ZSTD_compressionParameters const* cParams = &ms->cParams;
+    U32 const mls = cParams->minMatch;
+    assert(ms->dictMatchState != NULL);
+    switch(mls)
+    {
+    default: /* includes case 3 */
+    case 4 :
+        return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 4);
+    case 5 :
+        return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 5);
+    case 6 :
+        return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 6);
+    case 7 :
+        return ZSTD_compressBlock_fast_dictMatchState_generic(ms, seqStore, rep, src, srcSize, 7);
+    }
+}
+
+
+static size_t ZSTD_compressBlock_fast_extDict_generic(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize, U32 const mls)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const hashTable = ms->hashTable;
+    U32 const hlog = cParams->hashLog;
+    /* support stepSize of 0 */
+    U32 const stepSize = cParams->targetLength + !(cParams->targetLength);
+    const BYTE* const base = ms->window.base;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
+    const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
+    const U32   dictStartIndex = lowLimit;
+    const BYTE* const dictStart = dictBase + dictStartIndex;
+    const U32   dictLimit = ms->window.dictLimit;
+    const U32   prefixStartIndex = dictLimit < lowLimit ? lowLimit : dictLimit;
+    const BYTE* const prefixStart = base + prefixStartIndex;
+    const BYTE* const dictEnd = dictBase + prefixStartIndex;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - 8;
+    U32 offset_1=rep[0], offset_2=rep[1];
+
+    DEBUGLOG(5, "ZSTD_compressBlock_fast_extDict_generic");
+
+    /* switch to "regular" variant if extDict is invalidated due to maxDistance */
+    if (prefixStartIndex == dictStartIndex)
+        return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, mls);
+
+    /* Search Loop */
+    while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
+        const size_t h = ZSTD_hashPtr(ip, hlog, mls);
+        const U32    matchIndex = hashTable[h];
+        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;
+        const BYTE*  match = matchBase + matchIndex;
+        const U32    current = (U32)(ip-base);
+        const U32    repIndex = current + 1 - offset_1;
+        const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;
+        const BYTE* const repMatch = repBase + repIndex;
+        size_t mLength;
+        hashTable[h] = current;   /* update hash table */
+        assert(offset_1 <= current +1);   /* check repIndex */
+
+        if ( (((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > dictStartIndex))
+           && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
+            const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
+            mLength = ZSTD_count_2segments(ip+1 +4, repMatch +4, iend, repMatchEnd, prefixStart) + 4;
+            ip++;
+            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, 0, mLength-MINMATCH);
+        } else {
+            if ( (matchIndex < dictStartIndex) ||
+                 (MEM_read32(match) != MEM_read32(ip)) ) {
+                assert(stepSize >= 1);
+                ip += ((ip-anchor) >> kSearchStrength) + stepSize;
+                continue;
+            }
+            {   const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend;
+                const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart;
+                U32 offset;
+                mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4;
+                while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; }   /* catch up */
+                offset = current - matchIndex;
+                offset_2 = offset_1;
+                offset_1 = offset;
+                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH);
+        }   }
+
+        /* found a match : store it */
+        ip += mLength;
+        anchor = ip;
+
+        if (ip <= ilimit) {
+            /* Fill Table */
+            hashTable[ZSTD_hashPtr(base+current+2, hlog, mls)] = current+2;
+            hashTable[ZSTD_hashPtr(ip-2, hlog, mls)] = (U32)(ip-2-base);
+            /* check immediate repcode */
+            while (ip <= ilimit) {
+                U32 const current2 = (U32)(ip-base);
+                U32 const repIndex2 = current2 - offset_2;
+                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
+                if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3) & (repIndex2 > dictStartIndex))  /* intentional overflow */
+                   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
+                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
+                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
+                    U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
+                    ZSTD_storeSeq(seqStore, 0, anchor, 0, repLength2-MINMATCH);
+                    hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2;
+                    ip += repLength2;
+                    anchor = ip;
+                    continue;
+                }
+                break;
+    }   }   }
+
+    /* save reps for next block */
+    rep[0] = offset_1;
+    rep[1] = offset_2;
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+
+size_t ZSTD_compressBlock_fast_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    ZSTD_compressionParameters const* cParams = &ms->cParams;
+    U32 const mls = cParams->minMatch;
+    switch(mls)
+    {
+    default: /* includes case 3 */
+    case 4 :
+        return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 4);
+    case 5 :
+        return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 5);
+    case 6 :
+        return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 6);
+    case 7 :
+        return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, 7);
+    }
+}
diff --git a/src/zstd_fast.h b/src/zstd_fast.h
new file mode 100644
index 0000000..b74a88c
--- /dev/null
+++ b/src/zstd_fast.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_FAST_H
+#define ZSTD_FAST_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "mem.h"      /* U32 */
+#include "zstd_compress_internal.h"
+
+void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
+                        void const* end, ZSTD_dictTableLoadMethod_e dtlm);
+size_t ZSTD_compressBlock_fast(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_fast_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_fast_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_FAST_H */
diff --git a/src/zstd_h5plugin.c b/src/zstd_h5plugin.c
index 29df179..090e7b7 100644
--- a/src/zstd_h5plugin.c
+++ b/src/zstd_h5plugin.c
@@ -2,6 +2,7 @@
 #include "zstd/zstd_h5plugin.h"
 #include "zstd/zstd.h"
 #include <stddef.h>
+#include <H5Epubgen.h>
 #define ZSTD_FILTER 32015
 #define PUSH_ERR(func, minor, str, ...) H5Epush(H5E_DEFAULT, __FILE__, func, __LINE__, H5E_ERR_CLS, H5E_PLINE, minor, str, ##__VA_ARGS__)
 
@@ -29,7 +30,7 @@ int register_zstd(void){
 
     retval = H5Zregister(&filter_class);
     if(retval<0){
-        PUSH_ERR("register_zstd", H5E_CANTREGISTER, "Can't register zstd filter");
+        PUSH_ERR("register_zstd", retval, "Can't register zstd filter");
     }
     return retval;
 }
diff --git a/src/zstd_internal.h b/src/zstd_internal.h
new file mode 100644
index 0000000..585fd6b
--- /dev/null
+++ b/src/zstd_internal.h
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_CCOMMON_H_MODULE
+#define ZSTD_CCOMMON_H_MODULE
+
+/* this module contains definitions which must be identical
+ * across compression, decompression and dictBuilder.
+ * It also contains a few functions useful to at least 2 of them
+ * and which benefit from being inlined */
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include "compiler.h"
+#include "mem.h"
+#include "debug.h"                 /* assert, DEBUGLOG, RAWLOG, g_debuglevel */
+#include "error_private.h"
+#define ZSTD_STATIC_LINKING_ONLY
+#include "zstd.h"
+#define FSE_STATIC_LINKING_ONLY
+#include "fse.h"
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
+#ifndef XXH_STATIC_LINKING_ONLY
+#  define XXH_STATIC_LINKING_ONLY  /* XXH64_state_t */
+#endif
+#include "xxhash.h"                /* XXH_reset, update, digest */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* ---- static assert (debug) --- */
+#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)
+#define ZSTD_isError ERR_isError   /* for inlining */
+#define FSE_isError  ERR_isError
+#define HUF_isError  ERR_isError
+
+
+/*-*************************************
+*  shared macros
+***************************************/
+#undef MIN
+#undef MAX
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
+
+/**
+ * Return the specified error if the condition evaluates to true.
+ *
+ * In debug modes, prints additional information.
+ * In order to do that (particularly, printing the conditional that failed),
+ * this can't just wrap RETURN_ERROR().
+ */
+#define RETURN_ERROR_IF(cond, err, ...) \
+  if (cond) { \
+    RAWLOG(3, "%s:%d: ERROR!: check %s failed, returning %s", __FILE__, __LINE__, ZSTD_QUOTE(cond), ZSTD_QUOTE(ERROR(err))); \
+    RAWLOG(3, ": " __VA_ARGS__); \
+    RAWLOG(3, "\n"); \
+    return ERROR(err); \
+  }
+
+/**
+ * Unconditionally return the specified error.
+ *
+ * In debug modes, prints additional information.
+ */
+#define RETURN_ERROR(err, ...) \
+  do { \
+    RAWLOG(3, "%s:%d: ERROR!: unconditional check failed, returning %s", __FILE__, __LINE__, ZSTD_QUOTE(ERROR(err))); \
+    RAWLOG(3, ": " __VA_ARGS__); \
+    RAWLOG(3, "\n"); \
+    return ERROR(err); \
+  } while(0);
+
+/**
+ * If the provided expression evaluates to an error code, returns that error code.
+ *
+ * In debug modes, prints additional information.
+ */
+#define FORWARD_IF_ERROR(err, ...) \
+  do { \
+    size_t const err_code = (err); \
+    if (ERR_isError(err_code)) { \
+      RAWLOG(3, "%s:%d: ERROR!: forwarding error in %s: %s", __FILE__, __LINE__, ZSTD_QUOTE(err), ERR_getErrorName(err_code)); \
+      RAWLOG(3, ": " __VA_ARGS__); \
+      RAWLOG(3, "\n"); \
+      return err_code; \
+    } \
+  } while(0);
+
+
+/*-*************************************
+*  Common constants
+***************************************/
+#define ZSTD_OPT_NUM    (1<<12)
+
+#define ZSTD_REP_NUM      3                 /* number of repcodes */
+#define ZSTD_REP_MOVE     (ZSTD_REP_NUM-1)
+static const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 };
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BIT7 128
+#define BIT6  64
+#define BIT5  32
+#define BIT4  16
+#define BIT1   2
+#define BIT0   1
+
+#define ZSTD_WINDOWLOG_ABSOLUTEMIN 10
+static const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 };
+static const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 };
+
+#define ZSTD_FRAMEIDSIZE 4   /* magic number size */
+
+#define ZSTD_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
+static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;
+typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;
+
+#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
+#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */
+
+#define HufLog 12
+typedef enum { set_basic, set_rle, set_compressed, set_repeat } symbolEncodingType_e;
+
+#define LONGNBSEQ 0x7F00
+
+#define MINMATCH 3
+
+#define Litbits  8
+#define MaxLit ((1<<Litbits) - 1)
+#define MaxML   52
+#define MaxLL   35
+#define DefaultMaxOff 28
+#define MaxOff  31
+#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */
+#define MLFSELog    9
+#define LLFSELog    9
+#define OffFSELog   8
+#define MaxFSELog  MAX(MAX(MLFSELog, LLFSELog), OffFSELog)
+
+static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3,
+                                      4, 6, 7, 8, 9,10,11,12,
+                                     13,14,15,16 };
+static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2,
+                                             2, 2, 2, 2, 2, 1, 1, 1,
+                                             2, 2, 2, 2, 2, 2, 2, 2,
+                                             2, 3, 2, 1, 1, 1, 1, 1,
+                                            -1,-1,-1,-1 };
+#define LL_DEFAULTNORMLOG 6  /* for static allocation */
+static const U32 LL_defaultNormLog = LL_DEFAULTNORMLOG;
+
+static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3,
+                                      4, 4, 5, 7, 8, 9,10,11,
+                                     12,13,14,15,16 };
+static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2,
+                                             2, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1,-1,-1,
+                                            -1,-1,-1,-1,-1 };
+#define ML_DEFAULTNORMLOG 6  /* for static allocation */
+static const U32 ML_defaultNormLog = ML_DEFAULTNORMLOG;
+
+static const S16 OF_defaultNorm[DefaultMaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2,
+                                                     2, 1, 1, 1, 1, 1, 1, 1,
+                                                     1, 1, 1, 1, 1, 1, 1, 1,
+                                                    -1,-1,-1,-1,-1 };
+#define OF_DEFAULTNORMLOG 5  /* for static allocation */
+static const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG;
+
+
+/*-*******************************************
+*  Shared functions to include for inlining
+*********************************************/
+static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
+static void ZSTD_copy16(void* dst, const void* src) { memcpy(dst, src, 16); }
+#define COPY16(d,s) { ZSTD_copy16(d,s); d+=16; s+=16; }
+
+#define WILDCOPY_OVERLENGTH 8
+#define VECLEN 16
+
+typedef enum {
+    ZSTD_no_overlap,
+    ZSTD_overlap_src_before_dst,
+    /*  ZSTD_overlap_dst_before_src, */
+} ZSTD_overlap_e;
+
+/*! ZSTD_wildcopy() :
+ *  custom version of memcpy(), can overwrite up to WILDCOPY_OVERLENGTH bytes (if length==0) */
+MEM_STATIC FORCE_INLINE_ATTR DONT_VECTORIZE
+void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length, ZSTD_overlap_e ovtype)
+{
+    ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+
+    assert(diff >= 8 || (ovtype == ZSTD_no_overlap && diff < -8));
+    if (length < VECLEN || (ovtype == ZSTD_overlap_src_before_dst && diff < VECLEN)) {
+      do
+          COPY8(op, ip)
+      while (op < oend);
+    }
+    else {
+      if ((length & 8) == 0)
+        COPY8(op, ip);
+      do {
+        COPY16(op, ip);
+      }
+      while (op < oend);
+    }
+}
+
+/*! ZSTD_wildcopy_16min() :
+ *  same semantics as ZSTD_wilcopy() except guaranteed to be able to copy 16 bytes at the start */
+MEM_STATIC FORCE_INLINE_ATTR DONT_VECTORIZE
+void ZSTD_wildcopy_16min(void* dst, const void* src, ptrdiff_t length, ZSTD_overlap_e ovtype)
+{
+    ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+
+    assert(length >= 8);
+    assert(diff >= 8 || (ovtype == ZSTD_no_overlap && diff < -8));
+
+    if (ovtype == ZSTD_overlap_src_before_dst && diff < VECLEN) {
+      do
+          COPY8(op, ip)
+      while (op < oend);
+    }
+    else {
+      if ((length & 8) == 0)
+        COPY8(op, ip);
+      do {
+        COPY16(op, ip);
+      }
+      while (op < oend);
+    }
+}
+
+MEM_STATIC void ZSTD_wildcopy_e(void* dst, const void* src, void* dstEnd)   /* should be faster for decoding, but strangely, not verified on all platform */
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = (BYTE*)dstEnd;
+    do
+        COPY8(op, ip)
+    while (op < oend);
+}
+
+
+/*-*******************************************
+*  Private declarations
+*********************************************/
+typedef struct seqDef_s {
+    U32 offset;
+    U16 litLength;
+    U16 matchLength;
+} seqDef;
+
+typedef struct {
+    seqDef* sequencesStart;
+    seqDef* sequences;
+    BYTE* litStart;
+    BYTE* lit;
+    BYTE* llCode;
+    BYTE* mlCode;
+    BYTE* ofCode;
+    size_t maxNbSeq;
+    size_t maxNbLit;
+    U32   longLengthID;   /* 0 == no longLength; 1 == Lit.longLength; 2 == Match.longLength; */
+    U32   longLengthPos;
+} seqStore_t;
+
+/**
+ * Contains the compressed frame size and an upper-bound for the decompressed frame size.
+ * Note: before using `compressedSize`, check for errors using ZSTD_isError().
+ *       similarly, before using `decompressedBound`, check for errors using:
+ *          `decompressedBound != ZSTD_CONTENTSIZE_ERROR`
+ */
+typedef struct {
+    size_t compressedSize;
+    unsigned long long decompressedBound;
+} ZSTD_frameSizeInfo;   /* decompress & legacy */
+
+const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);   /* compress & dictBuilder */
+void ZSTD_seqToCodes(const seqStore_t* seqStorePtr);   /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */
+
+/* custom memory allocation functions */
+void* ZSTD_malloc(size_t size, ZSTD_customMem customMem);
+void* ZSTD_calloc(size_t size, ZSTD_customMem customMem);
+void ZSTD_free(void* ptr, ZSTD_customMem customMem);
+
+
+MEM_STATIC U32 ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus */
+{
+    assert(val != 0);
+    {
+#   if defined(_MSC_VER)   /* Visual */
+        unsigned long r=0;
+        _BitScanReverse(&r, val);
+        return (unsigned)r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */
+        return 31 - __builtin_clz(val);
+#   elif defined(__ICCARM__)    /* IAR Intrinsic */
+        return 31 - __CLZ(val);
+#   else   /* Software version */
+        static const U32 DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+        U32 v = val;
+        v |= v >> 1;
+        v |= v >> 2;
+        v |= v >> 4;
+        v |= v >> 8;
+        v |= v >> 16;
+        return DeBruijnClz[(v * 0x07C4ACDDU) >> 27];
+#   endif
+    }
+}
+
+
+/* ZSTD_invalidateRepCodes() :
+ * ensures next compression will not use repcodes from previous block.
+ * Note : only works with regular variant;
+ *        do not use with extDict variant ! */
+void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx);   /* zstdmt, adaptive_compression (shouldn't get this definition from here) */
+
+
+typedef struct {
+    blockType_e blockType;
+    U32 lastBlock;
+    U32 origSize;
+} blockProperties_t;   /* declared here for decompress and fullbench */
+
+/*! ZSTD_getcBlockSize() :
+ *  Provides the size of compressed block from block header `src` */
+/* Used by: decompress, fullbench (does not get its definition from here) */
+size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
+                          blockProperties_t* bpPtr);
+
+/*! ZSTD_decodeSeqHeaders() :
+ *  decode sequence header from src */
+/* Used by: decompress, fullbench (does not get its definition from here) */
+size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
+                       const void* src, size_t srcSize);
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* ZSTD_CCOMMON_H_MODULE */
diff --git a/src/zstd_lazy.c b/src/zstd_lazy.c
new file mode 100644
index 0000000..0af4172
--- /dev/null
+++ b/src/zstd_lazy.c
@@ -0,0 +1,1115 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#include "zstd_compress_internal.h"
+#include "zstd_lazy.h"
+
+
+/*-*************************************
+*  Binary Tree search
+***************************************/
+
+static void
+ZSTD_updateDUBT(ZSTD_matchState_t* ms,
+                const BYTE* ip, const BYTE* iend,
+                U32 mls)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const hashTable = ms->hashTable;
+    U32  const hashLog = cParams->hashLog;
+
+    U32* const bt = ms->chainTable;
+    U32  const btLog  = cParams->chainLog - 1;
+    U32  const btMask = (1 << btLog) - 1;
+
+    const BYTE* const base = ms->window.base;
+    U32 const target = (U32)(ip - base);
+    U32 idx = ms->nextToUpdate;
+
+    if (idx != target)
+        DEBUGLOG(7, "ZSTD_updateDUBT, from %u to %u (dictLimit:%u)",
+                    idx, target, ms->window.dictLimit);
+    assert(ip + 8 <= iend);   /* condition for ZSTD_hashPtr */
+    (void)iend;
+
+    assert(idx >= ms->window.dictLimit);   /* condition for valid base+idx */
+    for ( ; idx < target ; idx++) {
+        size_t const h  = ZSTD_hashPtr(base + idx, hashLog, mls);   /* assumption : ip + 8 <= iend */
+        U32    const matchIndex = hashTable[h];
+
+        U32*   const nextCandidatePtr = bt + 2*(idx&btMask);
+        U32*   const sortMarkPtr  = nextCandidatePtr + 1;
+
+        DEBUGLOG(8, "ZSTD_updateDUBT: insert %u", idx);
+        hashTable[h] = idx;   /* Update Hash Table */
+        *nextCandidatePtr = matchIndex;   /* update BT like a chain */
+        *sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK;
+    }
+    ms->nextToUpdate = target;
+}
+
+
+/** ZSTD_insertDUBT1() :
+ *  sort one already inserted but unsorted position
+ *  assumption : current >= btlow == (current - btmask)
+ *  doesn't fail */
+static void
+ZSTD_insertDUBT1(ZSTD_matchState_t* ms,
+                 U32 current, const BYTE* inputEnd,
+                 U32 nbCompares, U32 btLow,
+                 const ZSTD_dictMode_e dictMode)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const bt = ms->chainTable;
+    U32  const btLog  = cParams->chainLog - 1;
+    U32  const btMask = (1 << btLog) - 1;
+    size_t commonLengthSmaller=0, commonLengthLarger=0;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const U32 dictLimit = ms->window.dictLimit;
+    const BYTE* const ip = (current>=dictLimit) ? base + current : dictBase + current;
+    const BYTE* const iend = (current>=dictLimit) ? inputEnd : dictBase + dictLimit;
+    const BYTE* const dictEnd = dictBase + dictLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    const BYTE* match;
+    U32* smallerPtr = bt + 2*(current&btMask);
+    U32* largerPtr  = smallerPtr + 1;
+    U32 matchIndex = *smallerPtr;   /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */
+    U32 dummy32;   /* to be nullified at the end */
+    U32 const windowValid = ms->window.lowLimit;
+    U32 const maxDistance = 1U << cParams->windowLog;
+    U32 const windowLow = (current - windowValid > maxDistance) ? current - maxDistance : windowValid;
+
+
+    DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)",
+                current, dictLimit, windowLow);
+    assert(current >= btLow);
+    assert(ip < iend);   /* condition for ZSTD_count */
+
+    while (nbCompares-- && (matchIndex > windowLow)) {
+        U32* const nextPtr = bt + 2*(matchIndex & btMask);
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+        assert(matchIndex < current);
+        /* note : all candidates are now supposed sorted,
+         * but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK
+         * when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */
+
+        if ( (dictMode != ZSTD_extDict)
+          || (matchIndex+matchLength >= dictLimit)  /* both in current segment*/
+          || (current < dictLimit) /* both in extDict */) {
+            const BYTE* const mBase = ( (dictMode != ZSTD_extDict)
+                                     || (matchIndex+matchLength >= dictLimit)) ?
+                                        base : dictBase;
+            assert( (matchIndex+matchLength >= dictLimit)   /* might be wrong if extDict is incorrectly set to 0 */
+                 || (current < dictLimit) );
+            match = mBase + matchIndex;
+            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
+        } else {
+            match = dictBase + matchIndex;
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
+            if (matchIndex+matchLength >= dictLimit)
+                match = base + matchIndex;   /* preparation for next read of match[matchLength] */
+        }
+
+        DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",
+                    current, matchIndex, (U32)matchLength);
+
+        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
+            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
+        }
+
+        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */
+            /* match is smaller than current */
+            *smallerPtr = matchIndex;             /* update smaller idx */
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
+            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u",
+                        matchIndex, btLow, nextPtr[1]);
+            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */
+            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */
+        } else {
+            /* match is larger than current */
+            *largerPtr = matchIndex;
+            commonLengthLarger = matchLength;
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
+            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u",
+                        matchIndex, btLow, nextPtr[0]);
+            largerPtr = nextPtr;
+            matchIndex = nextPtr[0];
+    }   }
+
+    *smallerPtr = *largerPtr = 0;
+}
+
+
+static size_t
+ZSTD_DUBT_findBetterDictMatch (
+        ZSTD_matchState_t* ms,
+        const BYTE* const ip, const BYTE* const iend,
+        size_t* offsetPtr,
+        size_t bestLength,
+        U32 nbCompares,
+        U32 const mls,
+        const ZSTD_dictMode_e dictMode)
+{
+    const ZSTD_matchState_t * const dms = ms->dictMatchState;
+    const ZSTD_compressionParameters* const dmsCParams = &dms->cParams;
+    const U32 * const dictHashTable = dms->hashTable;
+    U32         const hashLog = dmsCParams->hashLog;
+    size_t      const h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32               dictMatchIndex = dictHashTable[h];
+
+    const BYTE* const base = ms->window.base;
+    const BYTE* const prefixStart = base + ms->window.dictLimit;
+    U32         const current = (U32)(ip-base);
+    const BYTE* const dictBase = dms->window.base;
+    const BYTE* const dictEnd = dms->window.nextSrc;
+    U32         const dictHighLimit = (U32)(dms->window.nextSrc - dms->window.base);
+    U32         const dictLowLimit = dms->window.lowLimit;
+    U32         const dictIndexDelta = ms->window.lowLimit - dictHighLimit;
+
+    U32*        const dictBt = dms->chainTable;
+    U32         const btLog  = dmsCParams->chainLog - 1;
+    U32         const btMask = (1 << btLog) - 1;
+    U32         const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;
+
+    size_t commonLengthSmaller=0, commonLengthLarger=0;
+
+    (void)dictMode;
+    assert(dictMode == ZSTD_dictMatchState);
+
+    while (nbCompares-- && (dictMatchIndex > dictLowLimit)) {
+        U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask);
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+        const BYTE* match = dictBase + dictMatchIndex;
+        matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
+        if (dictMatchIndex+matchLength >= dictHighLimit)
+            match = base + dictMatchIndex + dictIndexDelta;   /* to prepare for next usage of match[matchLength] */
+
+        if (matchLength > bestLength) {
+            U32 matchIndex = dictMatchIndex + dictIndexDelta;
+            if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {
+                DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",
+                    current, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, ZSTD_REP_MOVE + current - matchIndex, dictMatchIndex, matchIndex);
+                bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
+            }
+            if (ip+matchLength == iend) {   /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */
+                break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+            }
+        }
+
+        if (match[matchLength] < ip[matchLength]) {
+            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+            dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+        } else {
+            /* match is larger than current */
+            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */
+            commonLengthLarger = matchLength;
+            dictMatchIndex = nextPtr[0];
+        }
+    }
+
+    if (bestLength >= MINMATCH) {
+        U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex;
+        DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
+                    current, (U32)bestLength, (U32)*offsetPtr, mIndex);
+    }
+    return bestLength;
+
+}
+
+
+static size_t
+ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
+                        const BYTE* const ip, const BYTE* const iend,
+                        size_t* offsetPtr,
+                        U32 const mls,
+                        const ZSTD_dictMode_e dictMode)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32*   const hashTable = ms->hashTable;
+    U32    const hashLog = cParams->hashLog;
+    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32          matchIndex  = hashTable[h];
+
+    const BYTE* const base = ms->window.base;
+    U32    const current = (U32)(ip-base);
+    U32    const windowLow = ZSTD_getLowestMatchIndex(ms, current, cParams->windowLog);
+
+    U32*   const bt = ms->chainTable;
+    U32    const btLog  = cParams->chainLog - 1;
+    U32    const btMask = (1 << btLog) - 1;
+    U32    const btLow = (btMask >= current) ? 0 : current - btMask;
+    U32    const unsortLimit = MAX(btLow, windowLow);
+
+    U32*         nextCandidate = bt + 2*(matchIndex&btMask);
+    U32*         unsortedMark = bt + 2*(matchIndex&btMask) + 1;
+    U32          nbCompares = 1U << cParams->searchLog;
+    U32          nbCandidates = nbCompares;
+    U32          previousCandidate = 0;
+
+    DEBUGLOG(7, "ZSTD_DUBT_findBestMatch (%u) ", current);
+    assert(ip <= iend-8);   /* required for h calculation */
+
+    /* reach end of unsorted candidates list */
+    while ( (matchIndex > unsortLimit)
+         && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK)
+         && (nbCandidates > 1) ) {
+        DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted",
+                    matchIndex);
+        *unsortedMark = previousCandidate;  /* the unsortedMark becomes a reversed chain, to move up back to original position */
+        previousCandidate = matchIndex;
+        matchIndex = *nextCandidate;
+        nextCandidate = bt + 2*(matchIndex&btMask);
+        unsortedMark = bt + 2*(matchIndex&btMask) + 1;
+        nbCandidates --;
+    }
+
+    /* nullify last candidate if it's still unsorted
+     * simplification, detrimental to compression ratio, beneficial for speed */
+    if ( (matchIndex > unsortLimit)
+      && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {
+        DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",
+                    matchIndex);
+        *nextCandidate = *unsortedMark = 0;
+    }
+
+    /* batch sort stacked candidates */
+    matchIndex = previousCandidate;
+    while (matchIndex) {  /* will end on matchIndex == 0 */
+        U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;
+        U32 const nextCandidateIdx = *nextCandidateIdxPtr;
+        ZSTD_insertDUBT1(ms, matchIndex, iend,
+                         nbCandidates, unsortLimit, dictMode);
+        matchIndex = nextCandidateIdx;
+        nbCandidates++;
+    }
+
+    /* find longest match */
+    {   size_t commonLengthSmaller = 0, commonLengthLarger = 0;
+        const BYTE* const dictBase = ms->window.dictBase;
+        const U32 dictLimit = ms->window.dictLimit;
+        const BYTE* const dictEnd = dictBase + dictLimit;
+        const BYTE* const prefixStart = base + dictLimit;
+        U32* smallerPtr = bt + 2*(current&btMask);
+        U32* largerPtr  = bt + 2*(current&btMask) + 1;
+        U32 matchEndIdx = current + 8 + 1;
+        U32 dummy32;   /* to be nullified at the end */
+        size_t bestLength = 0;
+
+        matchIndex  = hashTable[h];
+        hashTable[h] = current;   /* Update Hash Table */
+
+        while (nbCompares-- && (matchIndex > windowLow)) {
+            U32* const nextPtr = bt + 2*(matchIndex & btMask);
+            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+            const BYTE* match;
+
+            if ((dictMode != ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) {
+                match = base + matchIndex;
+                matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
+            } else {
+                match = dictBase + matchIndex;
+                matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
+                if (matchIndex+matchLength >= dictLimit)
+                    match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
+            }
+
+            if (matchLength > bestLength) {
+                if (matchLength > matchEndIdx - matchIndex)
+                    matchEndIdx = matchIndex + (U32)matchLength;
+                if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) )
+                    bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
+                if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
+                    if (dictMode == ZSTD_dictMatchState) {
+                        nbCompares = 0; /* in addition to avoiding checking any
+                                         * further in this loop, make sure we
+                                         * skip checking in the dictionary. */
+                    }
+                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+                }
+            }
+
+            if (match[matchLength] < ip[matchLength]) {
+                /* match is smaller than current */
+                *smallerPtr = matchIndex;             /* update smaller idx */
+                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+                if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+                smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
+                matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+            } else {
+                /* match is larger than current */
+                *largerPtr = matchIndex;
+                commonLengthLarger = matchLength;
+                if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+                largerPtr = nextPtr;
+                matchIndex = nextPtr[0];
+        }   }
+
+        *smallerPtr = *largerPtr = 0;
+
+        if (dictMode == ZSTD_dictMatchState && nbCompares) {
+            bestLength = ZSTD_DUBT_findBetterDictMatch(
+                    ms, ip, iend,
+                    offsetPtr, bestLength, nbCompares,
+                    mls, dictMode);
+        }
+
+        assert(matchEndIdx > current+8); /* ensure nextToUpdate is increased */
+        ms->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */
+        if (bestLength >= MINMATCH) {
+            U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex;
+            DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
+                        current, (U32)bestLength, (U32)*offsetPtr, mIndex);
+        }
+        return bestLength;
+    }
+}
+
+
+/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */
+FORCE_INLINE_TEMPLATE size_t
+ZSTD_BtFindBestMatch( ZSTD_matchState_t* ms,
+                const BYTE* const ip, const BYTE* const iLimit,
+                      size_t* offsetPtr,
+                const U32 mls /* template */,
+                const ZSTD_dictMode_e dictMode)
+{
+    DEBUGLOG(7, "ZSTD_BtFindBestMatch");
+    if (ip < ms->window.base + ms->nextToUpdate) return 0;   /* skipped area */
+    ZSTD_updateDUBT(ms, ip, iLimit, mls);
+    return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offsetPtr, mls, dictMode);
+}
+
+
+static size_t
+ZSTD_BtFindBestMatch_selectMLS (  ZSTD_matchState_t* ms,
+                            const BYTE* ip, const BYTE* const iLimit,
+                                  size_t* offsetPtr)
+{
+    switch(ms->cParams.minMatch)
+    {
+    default : /* includes case 3 */
+    case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict);
+    case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict);
+    case 7 :
+    case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict);
+    }
+}
+
+
+static size_t ZSTD_BtFindBestMatch_dictMatchState_selectMLS (
+                        ZSTD_matchState_t* ms,
+                        const BYTE* ip, const BYTE* const iLimit,
+                        size_t* offsetPtr)
+{
+    switch(ms->cParams.minMatch)
+    {
+    default : /* includes case 3 */
+    case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState);
+    case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState);
+    case 7 :
+    case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState);
+    }
+}
+
+
+static size_t ZSTD_BtFindBestMatch_extDict_selectMLS (
+                        ZSTD_matchState_t* ms,
+                        const BYTE* ip, const BYTE* const iLimit,
+                        size_t* offsetPtr)
+{
+    switch(ms->cParams.minMatch)
+    {
+    default : /* includes case 3 */
+    case 4 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict);
+    case 5 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict);
+    case 7 :
+    case 6 : return ZSTD_BtFindBestMatch(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict);
+    }
+}
+
+
+
+/* *********************************
+*  Hash Chain
+***********************************/
+#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & (mask)]
+
+/* Update chains up to ip (excluded)
+   Assumption : always within prefix (i.e. not within extDict) */
+static U32 ZSTD_insertAndFindFirstIndex_internal(
+                        ZSTD_matchState_t* ms,
+                        const ZSTD_compressionParameters* const cParams,
+                        const BYTE* ip, U32 const mls)
+{
+    U32* const hashTable  = ms->hashTable;
+    const U32 hashLog = cParams->hashLog;
+    U32* const chainTable = ms->chainTable;
+    const U32 chainMask = (1 << cParams->chainLog) - 1;
+    const BYTE* const base = ms->window.base;
+    const U32 target = (U32)(ip - base);
+    U32 idx = ms->nextToUpdate;
+
+    while(idx < target) { /* catch up */
+        size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls);
+        NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];
+        hashTable[h] = idx;
+        idx++;
+    }
+
+    ms->nextToUpdate = target;
+    return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];
+}
+
+U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch);
+}
+
+
+/* inlining is important to hardwire a hot branch (template emulation) */
+FORCE_INLINE_TEMPLATE
+size_t ZSTD_HcFindBestMatch_generic (
+                        ZSTD_matchState_t* ms,
+                        const BYTE* const ip, const BYTE* const iLimit,
+                        size_t* offsetPtr,
+                        const U32 mls, const ZSTD_dictMode_e dictMode)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const chainTable = ms->chainTable;
+    const U32 chainSize = (1 << cParams->chainLog);
+    const U32 chainMask = chainSize-1;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const U32 dictLimit = ms->window.dictLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    const BYTE* const dictEnd = dictBase + dictLimit;
+    const U32 current = (U32)(ip-base);
+    const U32 maxDistance = 1U << cParams->windowLog;
+    const U32 lowestValid = ms->window.lowLimit;
+    const U32 withinMaxDistance = (current - lowestValid > maxDistance) ? current - maxDistance : lowestValid;
+    const U32 isDictionary = (ms->loadedDictEnd != 0);
+    const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;
+    const U32 minChain = current > chainSize ? current - chainSize : 0;
+    U32 nbAttempts = 1U << cParams->searchLog;
+    size_t ml=4-1;
+
+    /* HC4 match finder */
+    U32 matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls);
+
+    for ( ; (matchIndex>lowLimit) & (nbAttempts>0) ; nbAttempts--) {
+        size_t currentMl=0;
+        if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {
+            const BYTE* const match = base + matchIndex;
+            assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */
+            if (match[ml] == ip[ml])   /* potentially better */
+                currentMl = ZSTD_count(ip, match, iLimit);
+        } else {
+            const BYTE* const match = dictBase + matchIndex;
+            assert(match+4 <= dictEnd);
+            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
+                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;
+        }
+
+        /* save best solution */
+        if (currentMl > ml) {
+            ml = currentMl;
+            *offsetPtr = current - matchIndex + ZSTD_REP_MOVE;
+            if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
+        }
+
+        if (matchIndex <= minChain) break;
+        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);
+    }
+
+    if (dictMode == ZSTD_dictMatchState) {
+        const ZSTD_matchState_t* const dms = ms->dictMatchState;
+        const U32* const dmsChainTable = dms->chainTable;
+        const U32 dmsChainSize         = (1 << dms->cParams.chainLog);
+        const U32 dmsChainMask         = dmsChainSize - 1;
+        const U32 dmsLowestIndex       = dms->window.dictLimit;
+        const BYTE* const dmsBase      = dms->window.base;
+        const BYTE* const dmsEnd       = dms->window.nextSrc;
+        const U32 dmsSize              = (U32)(dmsEnd - dmsBase);
+        const U32 dmsIndexDelta        = dictLimit - dmsSize;
+        const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0;
+
+        matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)];
+
+        for ( ; (matchIndex>dmsLowestIndex) & (nbAttempts>0) ; nbAttempts--) {
+            size_t currentMl=0;
+            const BYTE* const match = dmsBase + matchIndex;
+            assert(match+4 <= dmsEnd);
+            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
+                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;
+
+            /* save best solution */
+            if (currentMl > ml) {
+                ml = currentMl;
+                *offsetPtr = current - (matchIndex + dmsIndexDelta) + ZSTD_REP_MOVE;
+                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
+            }
+
+            if (matchIndex <= dmsMinChain) break;
+            matchIndex = dmsChainTable[matchIndex & dmsChainMask];
+        }
+    }
+
+    return ml;
+}
+
+
+FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS (
+                        ZSTD_matchState_t* ms,
+                        const BYTE* ip, const BYTE* const iLimit,
+                        size_t* offsetPtr)
+{
+    switch(ms->cParams.minMatch)
+    {
+    default : /* includes case 3 */
+    case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_noDict);
+    case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_noDict);
+    case 7 :
+    case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_noDict);
+    }
+}
+
+
+static size_t ZSTD_HcFindBestMatch_dictMatchState_selectMLS (
+                        ZSTD_matchState_t* ms,
+                        const BYTE* ip, const BYTE* const iLimit,
+                        size_t* offsetPtr)
+{
+    switch(ms->cParams.minMatch)
+    {
+    default : /* includes case 3 */
+    case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_dictMatchState);
+    case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_dictMatchState);
+    case 7 :
+    case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_dictMatchState);
+    }
+}
+
+
+FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
+                        ZSTD_matchState_t* ms,
+                        const BYTE* ip, const BYTE* const iLimit,
+                        size_t* offsetPtr)
+{
+    switch(ms->cParams.minMatch)
+    {
+    default : /* includes case 3 */
+    case 4 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 4, ZSTD_extDict);
+    case 5 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 5, ZSTD_extDict);
+    case 7 :
+    case 6 : return ZSTD_HcFindBestMatch_generic(ms, ip, iLimit, offsetPtr, 6, ZSTD_extDict);
+    }
+}
+
+
+/* *******************************
+*  Common parser - lazy strategy
+*********************************/
+typedef enum { search_hashChain, search_binaryTree } searchMethod_e;
+
+FORCE_INLINE_TEMPLATE size_t
+ZSTD_compressBlock_lazy_generic(
+                        ZSTD_matchState_t* ms, seqStore_t* seqStore,
+                        U32 rep[ZSTD_REP_NUM],
+                        const void* src, size_t srcSize,
+                        const searchMethod_e searchMethod, const U32 depth,
+                        ZSTD_dictMode_e const dictMode)
+{
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - 8;
+    const BYTE* const base = ms->window.base;
+    const U32 prefixLowestIndex = ms->window.dictLimit;
+    const BYTE* const prefixLowest = base + prefixLowestIndex;
+
+    typedef size_t (*searchMax_f)(
+                        ZSTD_matchState_t* ms,
+                        const BYTE* ip, const BYTE* iLimit, size_t* offsetPtr);
+    searchMax_f const searchMax = dictMode == ZSTD_dictMatchState ?
+        (searchMethod==search_binaryTree ? ZSTD_BtFindBestMatch_dictMatchState_selectMLS
+                                         : ZSTD_HcFindBestMatch_dictMatchState_selectMLS) :
+        (searchMethod==search_binaryTree ? ZSTD_BtFindBestMatch_selectMLS
+                                         : ZSTD_HcFindBestMatch_selectMLS);
+    U32 offset_1 = rep[0], offset_2 = rep[1], savedOffset=0;
+
+    const ZSTD_matchState_t* const dms = ms->dictMatchState;
+    const U32 dictLowestIndex      = dictMode == ZSTD_dictMatchState ?
+                                     dms->window.dictLimit : 0;
+    const BYTE* const dictBase     = dictMode == ZSTD_dictMatchState ?
+                                     dms->window.base : NULL;
+    const BYTE* const dictLowest   = dictMode == ZSTD_dictMatchState ?
+                                     dictBase + dictLowestIndex : NULL;
+    const BYTE* const dictEnd      = dictMode == ZSTD_dictMatchState ?
+                                     dms->window.nextSrc : NULL;
+    const U32 dictIndexDelta       = dictMode == ZSTD_dictMatchState ?
+                                     prefixLowestIndex - (U32)(dictEnd - dictBase) :
+                                     0;
+    const U32 dictAndPrefixLength = (U32)(ip - prefixLowest + dictEnd - dictLowest);
+
+    /* init */
+    ip += (dictAndPrefixLength == 0);
+    if (dictMode == ZSTD_noDict) {
+        U32 const maxRep = (U32)(ip - prefixLowest);
+        if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0;
+        if (offset_1 > maxRep) savedOffset = offset_1, offset_1 = 0;
+    }
+    if (dictMode == ZSTD_dictMatchState) {
+        /* dictMatchState repCode checks don't currently handle repCode == 0
+         * disabling. */
+        assert(offset_1 <= dictAndPrefixLength);
+        assert(offset_2 <= dictAndPrefixLength);
+    }
+
+    /* Match Loop */
+    while (ip < ilimit) {
+        size_t matchLength=0;
+        size_t offset=0;
+        const BYTE* start=ip+1;
+
+        /* check repCode */
+        if (dictMode == ZSTD_dictMatchState) {
+            const U32 repIndex = (U32)(ip - base) + 1 - offset_1;
+            const BYTE* repMatch = (dictMode == ZSTD_dictMatchState
+                                && repIndex < prefixLowestIndex) ?
+                                   dictBase + (repIndex - dictIndexDelta) :
+                                   base + repIndex;
+            if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
+                && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
+                const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
+                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
+                if (depth==0) goto _storeSequence;
+            }
+        }
+        if ( dictMode == ZSTD_noDict
+          && ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) {
+            matchLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;
+            if (depth==0) goto _storeSequence;
+        }
+
+        /* first search (depth 0) */
+        {   size_t offsetFound = 999999999;
+            size_t const ml2 = searchMax(ms, ip, iend, &offsetFound);
+            if (ml2 > matchLength)
+                matchLength = ml2, start = ip, offset=offsetFound;
+        }
+
+        if (matchLength < 4) {
+            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */
+            continue;
+        }
+
+        /* let's try to find a better solution */
+        if (depth>=1)
+        while (ip<ilimit) {
+            ip ++;
+            if ( (dictMode == ZSTD_noDict)
+              && (offset) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
+                size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
+                int const gain2 = (int)(mlRep * 3);
+                int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1);
+                if ((mlRep >= 4) && (gain2 > gain1))
+                    matchLength = mlRep, offset = 0, start = ip;
+            }
+            if (dictMode == ZSTD_dictMatchState) {
+                const U32 repIndex = (U32)(ip - base) - offset_1;
+                const BYTE* repMatch = repIndex < prefixLowestIndex ?
+                               dictBase + (repIndex - dictIndexDelta) :
+                               base + repIndex;
+                if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
+                    && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
+                    const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
+                    size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
+                    int const gain2 = (int)(mlRep * 3);
+                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1);
+                    if ((mlRep >= 4) && (gain2 > gain1))
+                        matchLength = mlRep, offset = 0, start = ip;
+                }
+            }
+            {   size_t offset2=999999999;
+                size_t const ml2 = searchMax(ms, ip, iend, &offset2);
+                int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1));   /* raw approx */
+                int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 4);
+                if ((ml2 >= 4) && (gain2 > gain1)) {
+                    matchLength = ml2, offset = offset2, start = ip;
+                    continue;   /* search a better one */
+            }   }
+
+            /* let's find an even better one */
+            if ((depth==2) && (ip<ilimit)) {
+                ip ++;
+                if ( (dictMode == ZSTD_noDict)
+                  && (offset) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
+                    size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
+                    int const gain2 = (int)(mlRep * 4);
+                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1);
+                    if ((mlRep >= 4) && (gain2 > gain1))
+                        matchLength = mlRep, offset = 0, start = ip;
+                }
+                if (dictMode == ZSTD_dictMatchState) {
+                    const U32 repIndex = (U32)(ip - base) - offset_1;
+                    const BYTE* repMatch = repIndex < prefixLowestIndex ?
+                                   dictBase + (repIndex - dictIndexDelta) :
+                                   base + repIndex;
+                    if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
+                        && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
+                        const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
+                        size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
+                        int const gain2 = (int)(mlRep * 4);
+                        int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1);
+                        if ((mlRep >= 4) && (gain2 > gain1))
+                            matchLength = mlRep, offset = 0, start = ip;
+                    }
+                }
+                {   size_t offset2=999999999;
+                    size_t const ml2 = searchMax(ms, ip, iend, &offset2);
+                    int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1));   /* raw approx */
+                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 7);
+                    if ((ml2 >= 4) && (gain2 > gain1)) {
+                        matchLength = ml2, offset = offset2, start = ip;
+                        continue;
+            }   }   }
+            break;  /* nothing found : store previous solution */
+        }
+
+        /* NOTE:
+         * start[-offset+ZSTD_REP_MOVE-1] is undefined behavior.
+         * (-offset+ZSTD_REP_MOVE-1) is unsigned, and is added to start, which
+         * overflows the pointer, which is undefined behavior.
+         */
+        /* catch up */
+        if (offset) {
+            if (dictMode == ZSTD_noDict) {
+                while ( ((start > anchor) & (start - (offset-ZSTD_REP_MOVE) > prefixLowest))
+                     && (start[-1] == (start-(offset-ZSTD_REP_MOVE))[-1]) )  /* only search for offset within prefix */
+                    { start--; matchLength++; }
+            }
+            if (dictMode == ZSTD_dictMatchState) {
+                U32 const matchIndex = (U32)((start-base) - (offset - ZSTD_REP_MOVE));
+                const BYTE* match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta : base + matchIndex;
+                const BYTE* const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest;
+                while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */
+            }
+            offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE);
+        }
+        /* store sequence */
+_storeSequence:
+        {   size_t const litLength = start - anchor;
+            ZSTD_storeSeq(seqStore, litLength, anchor, (U32)offset, matchLength-MINMATCH);
+            anchor = ip = start + matchLength;
+        }
+
+        /* check immediate repcode */
+        if (dictMode == ZSTD_dictMatchState) {
+            while (ip <= ilimit) {
+                U32 const current2 = (U32)(ip-base);
+                U32 const repIndex = current2 - offset_2;
+                const BYTE* repMatch = dictMode == ZSTD_dictMatchState
+                    && repIndex < prefixLowestIndex ?
+                        dictBase - dictIndexDelta + repIndex :
+                        base + repIndex;
+                if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex) >= 3 /* intentional overflow */)
+                   && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
+                    const BYTE* const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend;
+                    matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd2, prefixLowest) + 4;
+                    offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset;   /* swap offset_2 <=> offset_1 */
+                    ZSTD_storeSeq(seqStore, 0, anchor, 0, matchLength-MINMATCH);
+                    ip += matchLength;
+                    anchor = ip;
+                    continue;
+                }
+                break;
+            }
+        }
+
+        if (dictMode == ZSTD_noDict) {
+            while ( ((ip <= ilimit) & (offset_2>0))
+                 && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {
+                /* store sequence */
+                matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
+                offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap repcodes */
+                ZSTD_storeSeq(seqStore, 0, anchor, 0, matchLength-MINMATCH);
+                ip += matchLength;
+                anchor = ip;
+                continue;   /* faster when present ... (?) */
+    }   }   }
+
+    /* Save reps for next block */
+    rep[0] = offset_1 ? offset_1 : savedOffset;
+    rep[1] = offset_2 ? offset_2 : savedOffset;
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+
+size_t ZSTD_compressBlock_btlazy2(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_noDict);
+}
+
+size_t ZSTD_compressBlock_lazy2(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_noDict);
+}
+
+size_t ZSTD_compressBlock_lazy(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_noDict);
+}
+
+size_t ZSTD_compressBlock_greedy(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_noDict);
+}
+
+size_t ZSTD_compressBlock_btlazy2_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_dictMatchState);
+}
+
+size_t ZSTD_compressBlock_lazy2_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_dictMatchState);
+}
+
+size_t ZSTD_compressBlock_lazy_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_dictMatchState);
+}
+
+size_t ZSTD_compressBlock_greedy_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_dictMatchState);
+}
+
+
+FORCE_INLINE_TEMPLATE
+size_t ZSTD_compressBlock_lazy_extDict_generic(
+                        ZSTD_matchState_t* ms, seqStore_t* seqStore,
+                        U32 rep[ZSTD_REP_NUM],
+                        const void* src, size_t srcSize,
+                        const searchMethod_e searchMethod, const U32 depth)
+{
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - 8;
+    const BYTE* const base = ms->window.base;
+    const U32 dictLimit = ms->window.dictLimit;
+    const U32 lowestIndex = ms->window.lowLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const BYTE* const dictEnd  = dictBase + dictLimit;
+    const BYTE* const dictStart  = dictBase + lowestIndex;
+
+    typedef size_t (*searchMax_f)(
+                        ZSTD_matchState_t* ms,
+                        const BYTE* ip, const BYTE* iLimit, size_t* offsetPtr);
+    searchMax_f searchMax = searchMethod==search_binaryTree ? ZSTD_BtFindBestMatch_extDict_selectMLS : ZSTD_HcFindBestMatch_extDict_selectMLS;
+
+    U32 offset_1 = rep[0], offset_2 = rep[1];
+
+    /* init */
+    ip += (ip == prefixStart);
+
+    /* Match Loop */
+    while (ip < ilimit) {
+        size_t matchLength=0;
+        size_t offset=0;
+        const BYTE* start=ip+1;
+        U32 current = (U32)(ip-base);
+
+        /* check repCode */
+        {   const U32 repIndex = (U32)(current+1 - offset_1);
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+            const BYTE* const repMatch = repBase + repIndex;
+            if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > lowestIndex))   /* intentional overflow */
+            if (MEM_read32(ip+1) == MEM_read32(repMatch)) {
+                /* repcode detected we should take it */
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repEnd, prefixStart) + 4;
+                if (depth==0) goto _storeSequence;
+        }   }
+
+        /* first search (depth 0) */
+        {   size_t offsetFound = 999999999;
+            size_t const ml2 = searchMax(ms, ip, iend, &offsetFound);
+            if (ml2 > matchLength)
+                matchLength = ml2, start = ip, offset=offsetFound;
+        }
+
+         if (matchLength < 4) {
+            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */
+            continue;
+        }
+
+        /* let's try to find a better solution */
+        if (depth>=1)
+        while (ip<ilimit) {
+            ip ++;
+            current++;
+            /* check repCode */
+            if (offset) {
+                const U32 repIndex = (U32)(current - offset_1);
+                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+                const BYTE* const repMatch = repBase + repIndex;
+                if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > lowestIndex))  /* intentional overflow */
+                if (MEM_read32(ip) == MEM_read32(repMatch)) {
+                    /* repcode detected */
+                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                    size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
+                    int const gain2 = (int)(repLength * 3);
+                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1);
+                    if ((repLength >= 4) && (gain2 > gain1))
+                        matchLength = repLength, offset = 0, start = ip;
+            }   }
+
+            /* search match, depth 1 */
+            {   size_t offset2=999999999;
+                size_t const ml2 = searchMax(ms, ip, iend, &offset2);
+                int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1));   /* raw approx */
+                int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 4);
+                if ((ml2 >= 4) && (gain2 > gain1)) {
+                    matchLength = ml2, offset = offset2, start = ip;
+                    continue;   /* search a better one */
+            }   }
+
+            /* let's find an even better one */
+            if ((depth==2) && (ip<ilimit)) {
+                ip ++;
+                current++;
+                /* check repCode */
+                if (offset) {
+                    const U32 repIndex = (U32)(current - offset_1);
+                    const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+                    const BYTE* const repMatch = repBase + repIndex;
+                    if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > lowestIndex))  /* intentional overflow */
+                    if (MEM_read32(ip) == MEM_read32(repMatch)) {
+                        /* repcode detected */
+                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                        size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
+                        int const gain2 = (int)(repLength * 4);
+                        int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1);
+                        if ((repLength >= 4) && (gain2 > gain1))
+                            matchLength = repLength, offset = 0, start = ip;
+                }   }
+
+                /* search match, depth 2 */
+                {   size_t offset2=999999999;
+                    size_t const ml2 = searchMax(ms, ip, iend, &offset2);
+                    int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1));   /* raw approx */
+                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 7);
+                    if ((ml2 >= 4) && (gain2 > gain1)) {
+                        matchLength = ml2, offset = offset2, start = ip;
+                        continue;
+            }   }   }
+            break;  /* nothing found : store previous solution */
+        }
+
+        /* catch up */
+        if (offset) {
+            U32 const matchIndex = (U32)((start-base) - (offset - ZSTD_REP_MOVE));
+            const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
+            const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;
+            while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */
+            offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE);
+        }
+
+        /* store sequence */
+_storeSequence:
+        {   size_t const litLength = start - anchor;
+            ZSTD_storeSeq(seqStore, litLength, anchor, (U32)offset, matchLength-MINMATCH);
+            anchor = ip = start + matchLength;
+        }
+
+        /* check immediate repcode */
+        while (ip <= ilimit) {
+            const U32 repIndex = (U32)((ip-base) - offset_2);
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+            const BYTE* const repMatch = repBase + repIndex;
+            if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > lowestIndex))  /* intentional overflow */
+            if (MEM_read32(ip) == MEM_read32(repMatch)) {
+                /* repcode detected we should take it */
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
+                offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset;   /* swap offset history */
+                ZSTD_storeSeq(seqStore, 0, anchor, 0, matchLength-MINMATCH);
+                ip += matchLength;
+                anchor = ip;
+                continue;   /* faster when present ... (?) */
+            }
+            break;
+    }   }
+
+    /* Save reps for next block */
+    rep[0] = offset_1;
+    rep[1] = offset_2;
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+
+size_t ZSTD_compressBlock_greedy_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0);
+}
+
+size_t ZSTD_compressBlock_lazy_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+
+{
+    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1);
+}
+
+size_t ZSTD_compressBlock_lazy2_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+
+{
+    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2);
+}
+
+size_t ZSTD_compressBlock_btlazy2_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+
+{
+    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2);
+}
diff --git a/src/zstd_lazy.h b/src/zstd_lazy.h
new file mode 100644
index 0000000..bb17630
--- /dev/null
+++ b/src/zstd_lazy.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_LAZY_H
+#define ZSTD_LAZY_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "zstd_compress_internal.h"
+
+U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip);
+
+void ZSTD_preserveUnsortedMark (U32* const table, U32 const size, U32 const reducerValue);  /*! used in ZSTD_reduceIndex(). preemptively increase value of ZSTD_DUBT_UNSORTED_MARK */
+
+size_t ZSTD_compressBlock_btlazy2(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_lazy2(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_lazy(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_greedy(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+size_t ZSTD_compressBlock_btlazy2_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_lazy2_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_lazy_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_greedy_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+size_t ZSTD_compressBlock_greedy_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_lazy_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_lazy2_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_btlazy2_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_LAZY_H */
diff --git a/src/zstd_ldm.c b/src/zstd_ldm.c
new file mode 100644
index 0000000..3dcf86e
--- /dev/null
+++ b/src/zstd_ldm.c
@@ -0,0 +1,597 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ */
+
+#include "zstd_ldm.h"
+
+#include "debug.h"
+#include "zstd_fast.h"          /* ZSTD_fillHashTable() */
+#include "zstd_double_fast.h"   /* ZSTD_fillDoubleHashTable() */
+
+#define LDM_BUCKET_SIZE_LOG 3
+#define LDM_MIN_MATCH_LENGTH 64
+#define LDM_HASH_RLOG 7
+#define LDM_HASH_CHAR_OFFSET 10
+
+void ZSTD_ldm_adjustParameters(ldmParams_t* params,
+                               ZSTD_compressionParameters const* cParams)
+{
+    params->windowLog = cParams->windowLog;
+    ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG <= ZSTD_LDM_BUCKETSIZELOG_MAX);
+    DEBUGLOG(4, "ZSTD_ldm_adjustParameters");
+    if (!params->bucketSizeLog) params->bucketSizeLog = LDM_BUCKET_SIZE_LOG;
+    if (!params->minMatchLength) params->minMatchLength = LDM_MIN_MATCH_LENGTH;
+    if (cParams->strategy >= ZSTD_btopt) {
+      /* Get out of the way of the optimal parser */
+      U32 const minMatch = MAX(cParams->targetLength, params->minMatchLength);
+      assert(minMatch >= ZSTD_LDM_MINMATCH_MIN);
+      assert(minMatch <= ZSTD_LDM_MINMATCH_MAX);
+      params->minMatchLength = minMatch;
+    }
+    if (params->hashLog == 0) {
+        params->hashLog = MAX(ZSTD_HASHLOG_MIN, params->windowLog - LDM_HASH_RLOG);
+        assert(params->hashLog <= ZSTD_HASHLOG_MAX);
+    }
+    if (params->hashRateLog == 0) {
+        params->hashRateLog = params->windowLog < params->hashLog
+                                   ? 0
+                                   : params->windowLog - params->hashLog;
+    }
+    params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog);
+}
+
+size_t ZSTD_ldm_getTableSize(ldmParams_t params)
+{
+    size_t const ldmHSize = ((size_t)1) << params.hashLog;
+    size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog);
+    size_t const ldmBucketSize =
+        ((size_t)1) << (params.hashLog - ldmBucketSizeLog);
+    size_t const totalSize = ldmBucketSize + ldmHSize * sizeof(ldmEntry_t);
+    return params.enableLdm ? totalSize : 0;
+}
+
+size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize)
+{
+    return params.enableLdm ? (maxChunkSize / params.minMatchLength) : 0;
+}
+
+/** ZSTD_ldm_getSmallHash() :
+ *  numBits should be <= 32
+ *  If numBits==0, returns 0.
+ *  @return : the most significant numBits of value. */
+static U32 ZSTD_ldm_getSmallHash(U64 value, U32 numBits)
+{
+    assert(numBits <= 32);
+    return numBits == 0 ? 0 : (U32)(value >> (64 - numBits));
+}
+
+/** ZSTD_ldm_getChecksum() :
+ *  numBitsToDiscard should be <= 32
+ *  @return : the next most significant 32 bits after numBitsToDiscard */
+static U32 ZSTD_ldm_getChecksum(U64 hash, U32 numBitsToDiscard)
+{
+    assert(numBitsToDiscard <= 32);
+    return (hash >> (64 - 32 - numBitsToDiscard)) & 0xFFFFFFFF;
+}
+
+/** ZSTD_ldm_getTag() ;
+ *  Given the hash, returns the most significant numTagBits bits
+ *  after (32 + hbits) bits.
+ *
+ *  If there are not enough bits remaining, return the last
+ *  numTagBits bits. */
+static U32 ZSTD_ldm_getTag(U64 hash, U32 hbits, U32 numTagBits)
+{
+    assert(numTagBits < 32 && hbits <= 32);
+    if (32 - hbits < numTagBits) {
+        return hash & (((U32)1 << numTagBits) - 1);
+    } else {
+        return (hash >> (32 - hbits - numTagBits)) & (((U32)1 << numTagBits) - 1);
+    }
+}
+
+/** ZSTD_ldm_getBucket() :
+ *  Returns a pointer to the start of the bucket associated with hash. */
+static ldmEntry_t* ZSTD_ldm_getBucket(
+        ldmState_t* ldmState, size_t hash, ldmParams_t const ldmParams)
+{
+    return ldmState->hashTable + (hash << ldmParams.bucketSizeLog);
+}
+
+/** ZSTD_ldm_insertEntry() :
+ *  Insert the entry with corresponding hash into the hash table */
+static void ZSTD_ldm_insertEntry(ldmState_t* ldmState,
+                                 size_t const hash, const ldmEntry_t entry,
+                                 ldmParams_t const ldmParams)
+{
+    BYTE* const bucketOffsets = ldmState->bucketOffsets;
+    *(ZSTD_ldm_getBucket(ldmState, hash, ldmParams) + bucketOffsets[hash]) = entry;
+    bucketOffsets[hash]++;
+    bucketOffsets[hash] &= ((U32)1 << ldmParams.bucketSizeLog) - 1;
+}
+
+/** ZSTD_ldm_makeEntryAndInsertByTag() :
+ *
+ *  Gets the small hash, checksum, and tag from the rollingHash.
+ *
+ *  If the tag matches (1 << ldmParams.hashRateLog)-1, then
+ *  creates an ldmEntry from the offset, and inserts it into the hash table.
+ *
+ *  hBits is the length of the small hash, which is the most significant hBits
+ *  of rollingHash. The checksum is the next 32 most significant bits, followed
+ *  by ldmParams.hashRateLog bits that make up the tag. */
+static void ZSTD_ldm_makeEntryAndInsertByTag(ldmState_t* ldmState,
+                                             U64 const rollingHash,
+                                             U32 const hBits,
+                                             U32 const offset,
+                                             ldmParams_t const ldmParams)
+{
+    U32 const tag = ZSTD_ldm_getTag(rollingHash, hBits, ldmParams.hashRateLog);
+    U32 const tagMask = ((U32)1 << ldmParams.hashRateLog) - 1;
+    if (tag == tagMask) {
+        U32 const hash = ZSTD_ldm_getSmallHash(rollingHash, hBits);
+        U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits);
+        ldmEntry_t entry;
+        entry.offset = offset;
+        entry.checksum = checksum;
+        ZSTD_ldm_insertEntry(ldmState, hash, entry, ldmParams);
+    }
+}
+
+/** ZSTD_ldm_countBackwardsMatch() :
+ *  Returns the number of bytes that match backwards before pIn and pMatch.
+ *
+ *  We count only bytes where pMatch >= pBase and pIn >= pAnchor. */
+static size_t ZSTD_ldm_countBackwardsMatch(
+            const BYTE* pIn, const BYTE* pAnchor,
+            const BYTE* pMatch, const BYTE* pBase)
+{
+    size_t matchLength = 0;
+    while (pIn > pAnchor && pMatch > pBase && pIn[-1] == pMatch[-1]) {
+        pIn--;
+        pMatch--;
+        matchLength++;
+    }
+    return matchLength;
+}
+
+/** ZSTD_ldm_fillFastTables() :
+ *
+ *  Fills the relevant tables for the ZSTD_fast and ZSTD_dfast strategies.
+ *  This is similar to ZSTD_loadDictionaryContent.
+ *
+ *  The tables for the other strategies are filled within their
+ *  block compressors. */
+static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms,
+                                      void const* end)
+{
+    const BYTE* const iend = (const BYTE*)end;
+
+    switch(ms->cParams.strategy)
+    {
+    case ZSTD_fast:
+        ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast);
+        break;
+
+    case ZSTD_dfast:
+        ZSTD_fillDoubleHashTable(ms, iend, ZSTD_dtlm_fast);
+        break;
+
+    case ZSTD_greedy:
+    case ZSTD_lazy:
+    case ZSTD_lazy2:
+    case ZSTD_btlazy2:
+    case ZSTD_btopt:
+    case ZSTD_btultra:
+    case ZSTD_btultra2:
+        break;
+    default:
+        assert(0);  /* not possible : not a valid strategy id */
+    }
+
+    return 0;
+}
+
+/** ZSTD_ldm_fillLdmHashTable() :
+ *
+ *  Fills hashTable from (lastHashed + 1) to iend (non-inclusive).
+ *  lastHash is the rolling hash that corresponds to lastHashed.
+ *
+ *  Returns the rolling hash corresponding to position iend-1. */
+static U64 ZSTD_ldm_fillLdmHashTable(ldmState_t* state,
+                                     U64 lastHash, const BYTE* lastHashed,
+                                     const BYTE* iend, const BYTE* base,
+                                     U32 hBits, ldmParams_t const ldmParams)
+{
+    U64 rollingHash = lastHash;
+    const BYTE* cur = lastHashed + 1;
+
+    while (cur < iend) {
+        rollingHash = ZSTD_rollingHash_rotate(rollingHash, cur[-1],
+                                              cur[ldmParams.minMatchLength-1],
+                                              state->hashPower);
+        ZSTD_ldm_makeEntryAndInsertByTag(state,
+                                         rollingHash, hBits,
+                                         (U32)(cur - base), ldmParams);
+        ++cur;
+    }
+    return rollingHash;
+}
+
+
+/** ZSTD_ldm_limitTableUpdate() :
+ *
+ *  Sets cctx->nextToUpdate to a position corresponding closer to anchor
+ *  if it is far way
+ *  (after a long match, only update tables a limited amount). */
+static void ZSTD_ldm_limitTableUpdate(ZSTD_matchState_t* ms, const BYTE* anchor)
+{
+    U32 const current = (U32)(anchor - ms->window.base);
+    if (current > ms->nextToUpdate + 1024) {
+        ms->nextToUpdate =
+            current - MIN(512, current - ms->nextToUpdate - 1024);
+    }
+}
+
+static size_t ZSTD_ldm_generateSequences_internal(
+        ldmState_t* ldmState, rawSeqStore_t* rawSeqStore,
+        ldmParams_t const* params, void const* src, size_t srcSize)
+{
+    /* LDM parameters */
+    int const extDict = ZSTD_window_hasExtDict(ldmState->window);
+    U32 const minMatchLength = params->minMatchLength;
+    U64 const hashPower = ldmState->hashPower;
+    U32 const hBits = params->hashLog - params->bucketSizeLog;
+    U32 const ldmBucketSize = 1U << params->bucketSizeLog;
+    U32 const hashRateLog = params->hashRateLog;
+    U32 const ldmTagMask = (1U << params->hashRateLog) - 1;
+    /* Prefix and extDict parameters */
+    U32 const dictLimit = ldmState->window.dictLimit;
+    U32 const lowestIndex = extDict ? ldmState->window.lowLimit : dictLimit;
+    BYTE const* const base = ldmState->window.base;
+    BYTE const* const dictBase = extDict ? ldmState->window.dictBase : NULL;
+    BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL;
+    BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL;
+    BYTE const* const lowPrefixPtr = base + dictLimit;
+    /* Input bounds */
+    BYTE const* const istart = (BYTE const*)src;
+    BYTE const* const iend = istart + srcSize;
+    BYTE const* const ilimit = iend - MAX(minMatchLength, HASH_READ_SIZE);
+    /* Input positions */
+    BYTE const* anchor = istart;
+    BYTE const* ip = istart;
+    /* Rolling hash */
+    BYTE const* lastHashed = NULL;
+    U64 rollingHash = 0;
+
+    while (ip <= ilimit) {
+        size_t mLength;
+        U32 const current = (U32)(ip - base);
+        size_t forwardMatchLength = 0, backwardMatchLength = 0;
+        ldmEntry_t* bestEntry = NULL;
+        if (ip != istart) {
+            rollingHash = ZSTD_rollingHash_rotate(rollingHash, lastHashed[0],
+                                                  lastHashed[minMatchLength],
+                                                  hashPower);
+        } else {
+            rollingHash = ZSTD_rollingHash_compute(ip, minMatchLength);
+        }
+        lastHashed = ip;
+
+        /* Do not insert and do not look for a match */
+        if (ZSTD_ldm_getTag(rollingHash, hBits, hashRateLog) != ldmTagMask) {
+           ip++;
+           continue;
+        }
+
+        /* Get the best entry and compute the match lengths */
+        {
+            ldmEntry_t* const bucket =
+                ZSTD_ldm_getBucket(ldmState,
+                                   ZSTD_ldm_getSmallHash(rollingHash, hBits),
+                                   *params);
+            ldmEntry_t* cur;
+            size_t bestMatchLength = 0;
+            U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits);
+
+            for (cur = bucket; cur < bucket + ldmBucketSize; ++cur) {
+                size_t curForwardMatchLength, curBackwardMatchLength,
+                       curTotalMatchLength;
+                if (cur->checksum != checksum || cur->offset <= lowestIndex) {
+                    continue;
+                }
+                if (extDict) {
+                    BYTE const* const curMatchBase =
+                        cur->offset < dictLimit ? dictBase : base;
+                    BYTE const* const pMatch = curMatchBase + cur->offset;
+                    BYTE const* const matchEnd =
+                        cur->offset < dictLimit ? dictEnd : iend;
+                    BYTE const* const lowMatchPtr =
+                        cur->offset < dictLimit ? dictStart : lowPrefixPtr;
+
+                    curForwardMatchLength = ZSTD_count_2segments(
+                                                ip, pMatch, iend,
+                                                matchEnd, lowPrefixPtr);
+                    if (curForwardMatchLength < minMatchLength) {
+                        continue;
+                    }
+                    curBackwardMatchLength =
+                        ZSTD_ldm_countBackwardsMatch(ip, anchor, pMatch,
+                                                     lowMatchPtr);
+                    curTotalMatchLength = curForwardMatchLength +
+                                          curBackwardMatchLength;
+                } else { /* !extDict */
+                    BYTE const* const pMatch = base + cur->offset;
+                    curForwardMatchLength = ZSTD_count(ip, pMatch, iend);
+                    if (curForwardMatchLength < minMatchLength) {
+                        continue;
+                    }
+                    curBackwardMatchLength =
+                        ZSTD_ldm_countBackwardsMatch(ip, anchor, pMatch,
+                                                     lowPrefixPtr);
+                    curTotalMatchLength = curForwardMatchLength +
+                                          curBackwardMatchLength;
+                }
+
+                if (curTotalMatchLength > bestMatchLength) {
+                    bestMatchLength = curTotalMatchLength;
+                    forwardMatchLength = curForwardMatchLength;
+                    backwardMatchLength = curBackwardMatchLength;
+                    bestEntry = cur;
+                }
+            }
+        }
+
+        /* No match found -- continue searching */
+        if (bestEntry == NULL) {
+            ZSTD_ldm_makeEntryAndInsertByTag(ldmState, rollingHash,
+                                             hBits, current,
+                                             *params);
+            ip++;
+            continue;
+        }
+
+        /* Match found */
+        mLength = forwardMatchLength + backwardMatchLength;
+        ip -= backwardMatchLength;
+
+        {
+            /* Store the sequence:
+             * ip = current - backwardMatchLength
+             * The match is at (bestEntry->offset - backwardMatchLength)
+             */
+            U32 const matchIndex = bestEntry->offset;
+            U32 const offset = current - matchIndex;
+            rawSeq* const seq = rawSeqStore->seq + rawSeqStore->size;
+
+            /* Out of sequence storage */
+            if (rawSeqStore->size == rawSeqStore->capacity)
+                return ERROR(dstSize_tooSmall);
+            seq->litLength = (U32)(ip - anchor);
+            seq->matchLength = (U32)mLength;
+            seq->offset = offset;
+            rawSeqStore->size++;
+        }
+
+        /* Insert the current entry into the hash table */
+        ZSTD_ldm_makeEntryAndInsertByTag(ldmState, rollingHash, hBits,
+                                         (U32)(lastHashed - base),
+                                         *params);
+
+        assert(ip + backwardMatchLength == lastHashed);
+
+        /* Fill the hash table from lastHashed+1 to ip+mLength*/
+        /* Heuristic: don't need to fill the entire table at end of block */
+        if (ip + mLength <= ilimit) {
+            rollingHash = ZSTD_ldm_fillLdmHashTable(
+                              ldmState, rollingHash, lastHashed,
+                              ip + mLength, base, hBits, *params);
+            lastHashed = ip + mLength - 1;
+        }
+        ip += mLength;
+        anchor = ip;
+    }
+    return iend - anchor;
+}
+
+/*! ZSTD_ldm_reduceTable() :
+ *  reduce table indexes by `reducerValue` */
+static void ZSTD_ldm_reduceTable(ldmEntry_t* const table, U32 const size,
+                                 U32 const reducerValue)
+{
+    U32 u;
+    for (u = 0; u < size; u++) {
+        if (table[u].offset < reducerValue) table[u].offset = 0;
+        else table[u].offset -= reducerValue;
+    }
+}
+
+size_t ZSTD_ldm_generateSequences(
+        ldmState_t* ldmState, rawSeqStore_t* sequences,
+        ldmParams_t const* params, void const* src, size_t srcSize)
+{
+    U32 const maxDist = 1U << params->windowLog;
+    BYTE const* const istart = (BYTE const*)src;
+    BYTE const* const iend = istart + srcSize;
+    size_t const kMaxChunkSize = 1 << 20;
+    size_t const nbChunks = (srcSize / kMaxChunkSize) + ((srcSize % kMaxChunkSize) != 0);
+    size_t chunk;
+    size_t leftoverSize = 0;
+
+    assert(ZSTD_CHUNKSIZE_MAX >= kMaxChunkSize);
+    /* Check that ZSTD_window_update() has been called for this chunk prior
+     * to passing it to this function.
+     */
+    assert(ldmState->window.nextSrc >= (BYTE const*)src + srcSize);
+    /* The input could be very large (in zstdmt), so it must be broken up into
+     * chunks to enforce the maximum distance and handle overflow correction.
+     */
+    assert(sequences->pos <= sequences->size);
+    assert(sequences->size <= sequences->capacity);
+    for (chunk = 0; chunk < nbChunks && sequences->size < sequences->capacity; ++chunk) {
+        BYTE const* const chunkStart = istart + chunk * kMaxChunkSize;
+        size_t const remaining = (size_t)(iend - chunkStart);
+        BYTE const *const chunkEnd =
+            (remaining < kMaxChunkSize) ? iend : chunkStart + kMaxChunkSize;
+        size_t const chunkSize = chunkEnd - chunkStart;
+        size_t newLeftoverSize;
+        size_t const prevSize = sequences->size;
+
+        assert(chunkStart < iend);
+        /* 1. Perform overflow correction if necessary. */
+        if (ZSTD_window_needOverflowCorrection(ldmState->window, chunkEnd)) {
+            U32 const ldmHSize = 1U << params->hashLog;
+            U32 const correction = ZSTD_window_correctOverflow(
+                &ldmState->window, /* cycleLog */ 0, maxDist, chunkStart);
+            ZSTD_ldm_reduceTable(ldmState->hashTable, ldmHSize, correction);
+        }
+        /* 2. We enforce the maximum offset allowed.
+         *
+         * kMaxChunkSize should be small enough that we don't lose too much of
+         * the window through early invalidation.
+         * TODO: * Test the chunk size.
+         *       * Try invalidation after the sequence generation and test the
+         *         the offset against maxDist directly.
+         */
+        ZSTD_window_enforceMaxDist(&ldmState->window, chunkEnd, maxDist, NULL, NULL);
+        /* 3. Generate the sequences for the chunk, and get newLeftoverSize. */
+        newLeftoverSize = ZSTD_ldm_generateSequences_internal(
+            ldmState, sequences, params, chunkStart, chunkSize);
+        if (ZSTD_isError(newLeftoverSize))
+            return newLeftoverSize;
+        /* 4. We add the leftover literals from previous iterations to the first
+         *    newly generated sequence, or add the `newLeftoverSize` if none are
+         *    generated.
+         */
+        /* Prepend the leftover literals from the last call */
+        if (prevSize < sequences->size) {
+            sequences->seq[prevSize].litLength += (U32)leftoverSize;
+            leftoverSize = newLeftoverSize;
+        } else {
+            assert(newLeftoverSize == chunkSize);
+            leftoverSize += chunkSize;
+        }
+    }
+    return 0;
+}
+
+void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch) {
+    while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) {
+        rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos;
+        if (srcSize <= seq->litLength) {
+            /* Skip past srcSize literals */
+            seq->litLength -= (U32)srcSize;
+            return;
+        }
+        srcSize -= seq->litLength;
+        seq->litLength = 0;
+        if (srcSize < seq->matchLength) {
+            /* Skip past the first srcSize of the match */
+            seq->matchLength -= (U32)srcSize;
+            if (seq->matchLength < minMatch) {
+                /* The match is too short, omit it */
+                if (rawSeqStore->pos + 1 < rawSeqStore->size) {
+                    seq[1].litLength += seq[0].matchLength;
+                }
+                rawSeqStore->pos++;
+            }
+            return;
+        }
+        srcSize -= seq->matchLength;
+        seq->matchLength = 0;
+        rawSeqStore->pos++;
+    }
+}
+
+/**
+ * If the sequence length is longer than remaining then the sequence is split
+ * between this block and the next.
+ *
+ * Returns the current sequence to handle, or if the rest of the block should
+ * be literals, it returns a sequence with offset == 0.
+ */
+static rawSeq maybeSplitSequence(rawSeqStore_t* rawSeqStore,
+                                 U32 const remaining, U32 const minMatch)
+{
+    rawSeq sequence = rawSeqStore->seq[rawSeqStore->pos];
+    assert(sequence.offset > 0);
+    /* Likely: No partial sequence */
+    if (remaining >= sequence.litLength + sequence.matchLength) {
+        rawSeqStore->pos++;
+        return sequence;
+    }
+    /* Cut the sequence short (offset == 0 ==> rest is literals). */
+    if (remaining <= sequence.litLength) {
+        sequence.offset = 0;
+    } else if (remaining < sequence.litLength + sequence.matchLength) {
+        sequence.matchLength = remaining - sequence.litLength;
+        if (sequence.matchLength < minMatch) {
+            sequence.offset = 0;
+        }
+    }
+    /* Skip past `remaining` bytes for the future sequences. */
+    ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch);
+    return sequence;
+}
+
+size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
+    ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+    void const* src, size_t srcSize)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    unsigned const minMatch = cParams->minMatch;
+    ZSTD_blockCompressor const blockCompressor =
+        ZSTD_selectBlockCompressor(cParams->strategy, ZSTD_matchState_dictMode(ms));
+    /* Input bounds */
+    BYTE const* const istart = (BYTE const*)src;
+    BYTE const* const iend = istart + srcSize;
+    /* Input positions */
+    BYTE const* ip = istart;
+
+    DEBUGLOG(5, "ZSTD_ldm_blockCompress: srcSize=%zu", srcSize);
+    assert(rawSeqStore->pos <= rawSeqStore->size);
+    assert(rawSeqStore->size <= rawSeqStore->capacity);
+    /* Loop through each sequence and apply the block compressor to the lits */
+    while (rawSeqStore->pos < rawSeqStore->size && ip < iend) {
+        /* maybeSplitSequence updates rawSeqStore->pos */
+        rawSeq const sequence = maybeSplitSequence(rawSeqStore,
+                                                   (U32)(iend - ip), minMatch);
+        int i;
+        /* End signal */
+        if (sequence.offset == 0)
+            break;
+
+        assert(sequence.offset <= (1U << cParams->windowLog));
+        assert(ip + sequence.litLength + sequence.matchLength <= iend);
+
+        /* Fill tables for block compressor */
+        ZSTD_ldm_limitTableUpdate(ms, ip);
+        ZSTD_ldm_fillFastTables(ms, ip);
+        /* Run the block compressor */
+        DEBUGLOG(5, "calling block compressor on segment of size %u", sequence.litLength);
+        {
+            size_t const newLitLength =
+                blockCompressor(ms, seqStore, rep, ip, sequence.litLength);
+            ip += sequence.litLength;
+            /* Update the repcodes */
+            for (i = ZSTD_REP_NUM - 1; i > 0; i--)
+                rep[i] = rep[i-1];
+            rep[0] = sequence.offset;
+            /* Store the sequence */
+            ZSTD_storeSeq(seqStore, newLitLength, ip - newLitLength,
+                          sequence.offset + ZSTD_REP_MOVE,
+                          sequence.matchLength - MINMATCH);
+            ip += sequence.matchLength;
+        }
+    }
+    /* Fill the tables for the block compressor */
+    ZSTD_ldm_limitTableUpdate(ms, ip);
+    ZSTD_ldm_fillFastTables(ms, ip);
+    /* Compress the last literals */
+    return blockCompressor(ms, seqStore, rep, ip, iend - ip);
+}
diff --git a/src/zstd_ldm.h b/src/zstd_ldm.h
new file mode 100644
index 0000000..a478461
--- /dev/null
+++ b/src/zstd_ldm.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ */
+
+#ifndef ZSTD_LDM_H
+#define ZSTD_LDM_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "zstd_compress_internal.h"   /* ldmParams_t, U32 */
+#include "zstd.h"   /* ZSTD_CCtx, size_t */
+
+/*-*************************************
+*  Long distance matching
+***************************************/
+
+#define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_LIMIT_DEFAULT
+
+/**
+ * ZSTD_ldm_generateSequences():
+ *
+ * Generates the sequences using the long distance match finder.
+ * Generates long range matching sequences in `sequences`, which parse a prefix
+ * of the source. `sequences` must be large enough to store every sequence,
+ * which can be checked with `ZSTD_ldm_getMaxNbSeq()`.
+ * @returns 0 or an error code.
+ *
+ * NOTE: The user must have called ZSTD_window_update() for all of the input
+ * they have, even if they pass it to ZSTD_ldm_generateSequences() in chunks.
+ * NOTE: This function returns an error if it runs out of space to store
+ *       sequences.
+ */
+size_t ZSTD_ldm_generateSequences(
+            ldmState_t* ldms, rawSeqStore_t* sequences,
+            ldmParams_t const* params, void const* src, size_t srcSize);
+
+/**
+ * ZSTD_ldm_blockCompress():
+ *
+ * Compresses a block using the predefined sequences, along with a secondary
+ * block compressor. The literals section of every sequence is passed to the
+ * secondary block compressor, and those sequences are interspersed with the
+ * predefined sequences. Returns the length of the last literals.
+ * Updates `rawSeqStore.pos` to indicate how many sequences have been consumed.
+ * `rawSeqStore.seq` may also be updated to split the last sequence between two
+ * blocks.
+ * @return The length of the last literals.
+ *
+ * NOTE: The source must be at most the maximum block size, but the predefined
+ * sequences can be any size, and may be longer than the block. In the case that
+ * they are longer than the block, the last sequences may need to be split into
+ * two. We handle that case correctly, and update `rawSeqStore` appropriately.
+ * NOTE: This function does not return any errors.
+ */
+size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
+            ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+            void const* src, size_t srcSize);
+
+/**
+ * ZSTD_ldm_skipSequences():
+ *
+ * Skip past `srcSize` bytes worth of sequences in `rawSeqStore`.
+ * Avoids emitting matches less than `minMatch` bytes.
+ * Must be called for data with is not passed to ZSTD_ldm_blockCompress().
+ */
+void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize,
+    U32 const minMatch);
+
+
+/** ZSTD_ldm_getTableSize() :
+ *  Estimate the space needed for long distance matching tables or 0 if LDM is
+ *  disabled.
+ */
+size_t ZSTD_ldm_getTableSize(ldmParams_t params);
+
+/** ZSTD_ldm_getSeqSpace() :
+ *  Return an upper bound on the number of sequences that can be produced by
+ *  the long distance matcher, or 0 if LDM is disabled.
+ */
+size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize);
+
+/** ZSTD_ldm_adjustParameters() :
+ *  If the params->hashRateLog is not set, set it to its default value based on
+ *  windowLog and params->hashLog.
+ *
+ *  Ensures that params->bucketSizeLog is <= params->hashLog (setting it to
+ *  params->hashLog if it is not).
+ *
+ *  Ensures that the minMatchLength >= targetLength during optimal parsing.
+ */
+void ZSTD_ldm_adjustParameters(ldmParams_t* params,
+                               ZSTD_compressionParameters const* cParams);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_FAST_H */
diff --git a/src/zstd_legacy.h b/src/zstd_legacy.h
new file mode 100644
index 0000000..0dbd3c7
--- /dev/null
+++ b/src/zstd_legacy.h
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_LEGACY_H
+#define ZSTD_LEGACY_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Includes
+***************************************/
+#include "mem.h"            /* MEM_STATIC */
+#include "error_private.h"  /* ERROR */
+#include "zstd_internal.h"  /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTD_frameSizeInfo */
+
+#if !defined (ZSTD_LEGACY_SUPPORT) || (ZSTD_LEGACY_SUPPORT == 0)
+#  undef ZSTD_LEGACY_SUPPORT
+#  define ZSTD_LEGACY_SUPPORT 8
+#endif
+
+#if (ZSTD_LEGACY_SUPPORT <= 1)
+#  include "zstd_v01.h"
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 2)
+#  include "zstd_v02.h"
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 3)
+#  include "zstd_v03.h"
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 4)
+#  include "zstd_v04.h"
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+#  include "zstd_v05.h"
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+#  include "zstd_v06.h"
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+#  include "zstd_v07.h"
+#endif
+
+/** ZSTD_isLegacy() :
+    @return : > 0 if supported by legacy decoder. 0 otherwise.
+              return value is the version.
+*/
+MEM_STATIC unsigned ZSTD_isLegacy(const void* src, size_t srcSize)
+{
+    U32 magicNumberLE;
+    if (srcSize<4) return 0;
+    magicNumberLE = MEM_readLE32(src);
+    switch(magicNumberLE)
+    {
+#if (ZSTD_LEGACY_SUPPORT <= 1)
+        case ZSTDv01_magicNumberLE:return 1;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 2)
+        case ZSTDv02_magicNumber : return 2;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 3)
+        case ZSTDv03_magicNumber : return 3;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 4)
+        case ZSTDv04_magicNumber : return 4;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+        case ZSTDv05_MAGICNUMBER : return 5;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+        case ZSTDv06_MAGICNUMBER : return 6;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+        case ZSTDv07_MAGICNUMBER : return 7;
+#endif
+        default : return 0;
+    }
+}
+
+
+MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, size_t srcSize)
+{
+    U32 const version = ZSTD_isLegacy(src, srcSize);
+    if (version < 5) return 0;  /* no decompressed size in frame header, or not a legacy format */
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+    if (version==5) {
+        ZSTDv05_parameters fParams;
+        size_t const frResult = ZSTDv05_getFrameParams(&fParams, src, srcSize);
+        if (frResult != 0) return 0;
+        return fParams.srcSize;
+    }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+    if (version==6) {
+        ZSTDv06_frameParams fParams;
+        size_t const frResult = ZSTDv06_getFrameParams(&fParams, src, srcSize);
+        if (frResult != 0) return 0;
+        return fParams.frameContentSize;
+    }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+    if (version==7) {
+        ZSTDv07_frameParams fParams;
+        size_t const frResult = ZSTDv07_getFrameParams(&fParams, src, srcSize);
+        if (frResult != 0) return 0;
+        return fParams.frameContentSize;
+    }
+#endif
+    return 0;   /* should not be possible */
+}
+
+
+MEM_STATIC size_t ZSTD_decompressLegacy(
+                     void* dst, size_t dstCapacity,
+               const void* src, size_t compressedSize,
+               const void* dict,size_t dictSize)
+{
+    U32 const version = ZSTD_isLegacy(src, compressedSize);
+    (void)dst; (void)dstCapacity; (void)dict; (void)dictSize;  /* unused when ZSTD_LEGACY_SUPPORT >= 8 */
+    switch(version)
+    {
+#if (ZSTD_LEGACY_SUPPORT <= 1)
+        case 1 :
+            return ZSTDv01_decompress(dst, dstCapacity, src, compressedSize);
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 2)
+        case 2 :
+            return ZSTDv02_decompress(dst, dstCapacity, src, compressedSize);
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 3)
+        case 3 :
+            return ZSTDv03_decompress(dst, dstCapacity, src, compressedSize);
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 4)
+        case 4 :
+            return ZSTDv04_decompress(dst, dstCapacity, src, compressedSize);
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+        case 5 :
+            {   size_t result;
+                ZSTDv05_DCtx* const zd = ZSTDv05_createDCtx();
+                if (zd==NULL) return ERROR(memory_allocation);
+                result = ZSTDv05_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
+                ZSTDv05_freeDCtx(zd);
+                return result;
+            }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+        case 6 :
+            {   size_t result;
+                ZSTDv06_DCtx* const zd = ZSTDv06_createDCtx();
+                if (zd==NULL) return ERROR(memory_allocation);
+                result = ZSTDv06_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
+                ZSTDv06_freeDCtx(zd);
+                return result;
+            }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+        case 7 :
+            {   size_t result;
+                ZSTDv07_DCtx* const zd = ZSTDv07_createDCtx();
+                if (zd==NULL) return ERROR(memory_allocation);
+                result = ZSTDv07_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
+                ZSTDv07_freeDCtx(zd);
+                return result;
+            }
+#endif
+        default :
+            return ERROR(prefix_unknown);
+    }
+}
+
+MEM_STATIC ZSTD_frameSizeInfo ZSTD_findFrameSizeInfoLegacy(const void *src, size_t srcSize)
+{
+    ZSTD_frameSizeInfo frameSizeInfo;
+    U32 const version = ZSTD_isLegacy(src, srcSize);
+    switch(version)
+    {
+#if (ZSTD_LEGACY_SUPPORT <= 1)
+        case 1 :
+            ZSTDv01_findFrameSizeInfoLegacy(src, srcSize,
+                &frameSizeInfo.compressedSize,
+                &frameSizeInfo.decompressedBound);
+            break;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 2)
+        case 2 :
+            ZSTDv02_findFrameSizeInfoLegacy(src, srcSize,
+                &frameSizeInfo.compressedSize,
+                &frameSizeInfo.decompressedBound);
+            break;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 3)
+        case 3 :
+            ZSTDv03_findFrameSizeInfoLegacy(src, srcSize,
+                &frameSizeInfo.compressedSize,
+                &frameSizeInfo.decompressedBound);
+            break;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 4)
+        case 4 :
+            ZSTDv04_findFrameSizeInfoLegacy(src, srcSize,
+                &frameSizeInfo.compressedSize,
+                &frameSizeInfo.decompressedBound);
+            break;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+        case 5 :
+            ZSTDv05_findFrameSizeInfoLegacy(src, srcSize,
+                &frameSizeInfo.compressedSize,
+                &frameSizeInfo.decompressedBound);
+            break;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+        case 6 :
+            ZSTDv06_findFrameSizeInfoLegacy(src, srcSize,
+                &frameSizeInfo.compressedSize,
+                &frameSizeInfo.decompressedBound);
+            break;
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+        case 7 :
+            ZSTDv07_findFrameSizeInfoLegacy(src, srcSize,
+                &frameSizeInfo.compressedSize,
+                &frameSizeInfo.decompressedBound);
+            break;
+#endif
+        default :
+            frameSizeInfo.compressedSize = ERROR(prefix_unknown);
+            frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
+            break;
+    }
+    if (!ZSTD_isError(frameSizeInfo.compressedSize) && frameSizeInfo.compressedSize > srcSize) {
+        frameSizeInfo.compressedSize = ERROR(srcSize_wrong);
+        frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
+    }
+    return frameSizeInfo;
+}
+
+MEM_STATIC size_t ZSTD_findFrameCompressedSizeLegacy(const void *src, size_t srcSize)
+{
+    ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfoLegacy(src, srcSize);
+    return frameSizeInfo.compressedSize;
+}
+
+MEM_STATIC size_t ZSTD_freeLegacyStreamContext(void* legacyContext, U32 version)
+{
+    switch(version)
+    {
+        default :
+        case 1 :
+        case 2 :
+        case 3 :
+            (void)legacyContext;
+            return ERROR(version_unsupported);
+#if (ZSTD_LEGACY_SUPPORT <= 4)
+        case 4 : return ZBUFFv04_freeDCtx((ZBUFFv04_DCtx*)legacyContext);
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+        case 5 : return ZBUFFv05_freeDCtx((ZBUFFv05_DCtx*)legacyContext);
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+        case 6 : return ZBUFFv06_freeDCtx((ZBUFFv06_DCtx*)legacyContext);
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+        case 7 : return ZBUFFv07_freeDCtx((ZBUFFv07_DCtx*)legacyContext);
+#endif
+    }
+}
+
+
+MEM_STATIC size_t ZSTD_initLegacyStream(void** legacyContext, U32 prevVersion, U32 newVersion,
+                                        const void* dict, size_t dictSize)
+{
+    DEBUGLOG(5, "ZSTD_initLegacyStream for v0.%u", newVersion);
+    if (prevVersion != newVersion) ZSTD_freeLegacyStreamContext(*legacyContext, prevVersion);
+    switch(newVersion)
+    {
+        default :
+        case 1 :
+        case 2 :
+        case 3 :
+            (void)dict; (void)dictSize;
+            return 0;
+#if (ZSTD_LEGACY_SUPPORT <= 4)
+        case 4 :
+        {
+            ZBUFFv04_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv04_createDCtx() : (ZBUFFv04_DCtx*)*legacyContext;
+            if (dctx==NULL) return ERROR(memory_allocation);
+            ZBUFFv04_decompressInit(dctx);
+            ZBUFFv04_decompressWithDictionary(dctx, dict, dictSize);
+            *legacyContext = dctx;
+            return 0;
+        }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+        case 5 :
+        {
+            ZBUFFv05_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv05_createDCtx() : (ZBUFFv05_DCtx*)*legacyContext;
+            if (dctx==NULL) return ERROR(memory_allocation);
+            ZBUFFv05_decompressInitDictionary(dctx, dict, dictSize);
+            *legacyContext = dctx;
+            return 0;
+        }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+        case 6 :
+        {
+            ZBUFFv06_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv06_createDCtx() : (ZBUFFv06_DCtx*)*legacyContext;
+            if (dctx==NULL) return ERROR(memory_allocation);
+            ZBUFFv06_decompressInitDictionary(dctx, dict, dictSize);
+            *legacyContext = dctx;
+            return 0;
+        }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+        case 7 :
+        {
+            ZBUFFv07_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv07_createDCtx() : (ZBUFFv07_DCtx*)*legacyContext;
+            if (dctx==NULL) return ERROR(memory_allocation);
+            ZBUFFv07_decompressInitDictionary(dctx, dict, dictSize);
+            *legacyContext = dctx;
+            return 0;
+        }
+#endif
+    }
+}
+
+
+
+MEM_STATIC size_t ZSTD_decompressLegacyStream(void* legacyContext, U32 version,
+                                              ZSTD_outBuffer* output, ZSTD_inBuffer* input)
+{
+    DEBUGLOG(5, "ZSTD_decompressLegacyStream for v0.%u", version);
+    switch(version)
+    {
+        default :
+        case 1 :
+        case 2 :
+        case 3 :
+            (void)legacyContext; (void)output; (void)input;
+            return ERROR(version_unsupported);
+#if (ZSTD_LEGACY_SUPPORT <= 4)
+        case 4 :
+            {
+                ZBUFFv04_DCtx* dctx = (ZBUFFv04_DCtx*) legacyContext;
+                const void* src = (const char*)input->src + input->pos;
+                size_t readSize = input->size - input->pos;
+                void* dst = (char*)output->dst + output->pos;
+                size_t decodedSize = output->size - output->pos;
+                size_t const hintSize = ZBUFFv04_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
+                output->pos += decodedSize;
+                input->pos += readSize;
+                return hintSize;
+            }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 5)
+        case 5 :
+            {
+                ZBUFFv05_DCtx* dctx = (ZBUFFv05_DCtx*) legacyContext;
+                const void* src = (const char*)input->src + input->pos;
+                size_t readSize = input->size - input->pos;
+                void* dst = (char*)output->dst + output->pos;
+                size_t decodedSize = output->size - output->pos;
+                size_t const hintSize = ZBUFFv05_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
+                output->pos += decodedSize;
+                input->pos += readSize;
+                return hintSize;
+            }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 6)
+        case 6 :
+            {
+                ZBUFFv06_DCtx* dctx = (ZBUFFv06_DCtx*) legacyContext;
+                const void* src = (const char*)input->src + input->pos;
+                size_t readSize = input->size - input->pos;
+                void* dst = (char*)output->dst + output->pos;
+                size_t decodedSize = output->size - output->pos;
+                size_t const hintSize = ZBUFFv06_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
+                output->pos += decodedSize;
+                input->pos += readSize;
+                return hintSize;
+            }
+#endif
+#if (ZSTD_LEGACY_SUPPORT <= 7)
+        case 7 :
+            {
+                ZBUFFv07_DCtx* dctx = (ZBUFFv07_DCtx*) legacyContext;
+                const void* src = (const char*)input->src + input->pos;
+                size_t readSize = input->size - input->pos;
+                void* dst = (char*)output->dst + output->pos;
+                size_t decodedSize = output->size - output->pos;
+                size_t const hintSize = ZBUFFv07_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
+                output->pos += decodedSize;
+                input->pos += readSize;
+                return hintSize;
+            }
+#endif
+    }
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* ZSTD_LEGACY_H */
diff --git a/src/zstd_opt.c b/src/zstd_opt.c
new file mode 100644
index 0000000..2da363f
--- /dev/null
+++ b/src/zstd_opt.c
@@ -0,0 +1,1246 @@
+/*
+ * Copyright (c) 2016-present, Przemyslaw Skibinski, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#include "zstd_compress_internal.h"
+#include "hist.h"
+#include "zstd_opt.h"
+
+
+#define ZSTD_LITFREQ_ADD    2   /* scaling factor for litFreq, so that frequencies adapt faster to new stats */
+#define ZSTD_FREQ_DIV       4   /* log factor when using previous stats to init next stats */
+#define ZSTD_MAX_PRICE     (1<<30)
+
+#define ZSTD_PREDEF_THRESHOLD 1024   /* if srcSize < ZSTD_PREDEF_THRESHOLD, symbols' cost is assumed static, directly determined by pre-defined distributions */
+
+
+/*-*************************************
+*  Price functions for optimal parser
+***************************************/
+
+#if 0    /* approximation at bit level */
+#  define BITCOST_ACCURACY 0
+#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
+#  define WEIGHT(stat)  ((void)opt, ZSTD_bitWeight(stat))
+#elif 0  /* fractional bit accuracy */
+#  define BITCOST_ACCURACY 8
+#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
+#  define WEIGHT(stat,opt) ((void)opt, ZSTD_fracWeight(stat))
+#else    /* opt==approx, ultra==accurate */
+#  define BITCOST_ACCURACY 8
+#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
+#  define WEIGHT(stat,opt) (opt ? ZSTD_fracWeight(stat) : ZSTD_bitWeight(stat))
+#endif
+
+MEM_STATIC U32 ZSTD_bitWeight(U32 stat)
+{
+    return (ZSTD_highbit32(stat+1) * BITCOST_MULTIPLIER);
+}
+
+MEM_STATIC U32 ZSTD_fracWeight(U32 rawStat)
+{
+    U32 const stat = rawStat + 1;
+    U32 const hb = ZSTD_highbit32(stat);
+    U32 const BWeight = hb * BITCOST_MULTIPLIER;
+    U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb;
+    U32 const weight = BWeight + FWeight;
+    assert(hb + BITCOST_ACCURACY < 31);
+    return weight;
+}
+
+#if (DEBUGLEVEL>=2)
+/* debugging function,
+ * @return price in bytes as fractional value
+ * for debug messages only */
+MEM_STATIC double ZSTD_fCost(U32 price)
+{
+    return (double)price / (BITCOST_MULTIPLIER*8);
+}
+#endif
+
+static int ZSTD_compressedLiterals(optState_t const* const optPtr)
+{
+    return optPtr->literalCompressionMode != ZSTD_lcm_uncompressed;
+}
+
+static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel)
+{
+    if (ZSTD_compressedLiterals(optPtr))
+        optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel);
+    optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel);
+    optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel);
+    optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel);
+}
+
+
+/* ZSTD_downscaleStat() :
+ * reduce all elements in table by a factor 2^(ZSTD_FREQ_DIV+malus)
+ * return the resulting sum of elements */
+static U32 ZSTD_downscaleStat(unsigned* table, U32 lastEltIndex, int malus)
+{
+    U32 s, sum=0;
+    DEBUGLOG(5, "ZSTD_downscaleStat (nbElts=%u)", (unsigned)lastEltIndex+1);
+    assert(ZSTD_FREQ_DIV+malus > 0 && ZSTD_FREQ_DIV+malus < 31);
+    for (s=0; s<lastEltIndex+1; s++) {
+        table[s] = 1 + (table[s] >> (ZSTD_FREQ_DIV+malus));
+        sum += table[s];
+    }
+    return sum;
+}
+
+/* ZSTD_rescaleFreqs() :
+ * if first block (detected by optPtr->litLengthSum == 0) : init statistics
+ *    take hints from dictionary if there is one
+ *    or init from zero, using src for literals stats, or flat 1 for match symbols
+ * otherwise downscale existing stats, to be used as seed for next block.
+ */
+static void
+ZSTD_rescaleFreqs(optState_t* const optPtr,
+            const BYTE* const src, size_t const srcSize,
+                  int const optLevel)
+{
+    int const compressedLiterals = ZSTD_compressedLiterals(optPtr);
+    DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize);
+    optPtr->priceType = zop_dynamic;
+
+    if (optPtr->litLengthSum == 0) {  /* first block : init */
+        if (srcSize <= ZSTD_PREDEF_THRESHOLD) {  /* heuristic */
+            DEBUGLOG(5, "(srcSize <= ZSTD_PREDEF_THRESHOLD) => zop_predef");
+            optPtr->priceType = zop_predef;
+        }
+
+        assert(optPtr->symbolCosts != NULL);
+        if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) {
+            /* huffman table presumed generated by dictionary */
+            optPtr->priceType = zop_dynamic;
+
+            if (compressedLiterals) {
+                unsigned lit;
+                assert(optPtr->litFreq != NULL);
+                optPtr->litSum = 0;
+                for (lit=0; lit<=MaxLit; lit++) {
+                    U32 const scaleLog = 11;   /* scale to 2K */
+                    U32 const bitCost = HUF_getNbBits(optPtr->symbolCosts->huf.CTable, lit);
+                    assert(bitCost <= scaleLog);
+                    optPtr->litFreq[lit] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
+                    optPtr->litSum += optPtr->litFreq[lit];
+            }   }
+
+            {   unsigned ll;
+                FSE_CState_t llstate;
+                FSE_initCState(&llstate, optPtr->symbolCosts->fse.litlengthCTable);
+                optPtr->litLengthSum = 0;
+                for (ll=0; ll<=MaxLL; ll++) {
+                    U32 const scaleLog = 10;   /* scale to 1K */
+                    U32 const bitCost = FSE_getMaxNbBits(llstate.symbolTT, ll);
+                    assert(bitCost < scaleLog);
+                    optPtr->litLengthFreq[ll] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
+                    optPtr->litLengthSum += optPtr->litLengthFreq[ll];
+            }   }
+
+            {   unsigned ml;
+                FSE_CState_t mlstate;
+                FSE_initCState(&mlstate, optPtr->symbolCosts->fse.matchlengthCTable);
+                optPtr->matchLengthSum = 0;
+                for (ml=0; ml<=MaxML; ml++) {
+                    U32 const scaleLog = 10;
+                    U32 const bitCost = FSE_getMaxNbBits(mlstate.symbolTT, ml);
+                    assert(bitCost < scaleLog);
+                    optPtr->matchLengthFreq[ml] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
+                    optPtr->matchLengthSum += optPtr->matchLengthFreq[ml];
+            }   }
+
+            {   unsigned of;
+                FSE_CState_t ofstate;
+                FSE_initCState(&ofstate, optPtr->symbolCosts->fse.offcodeCTable);
+                optPtr->offCodeSum = 0;
+                for (of=0; of<=MaxOff; of++) {
+                    U32 const scaleLog = 10;
+                    U32 const bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of);
+                    assert(bitCost < scaleLog);
+                    optPtr->offCodeFreq[of] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
+                    optPtr->offCodeSum += optPtr->offCodeFreq[of];
+            }   }
+
+        } else {  /* not a dictionary */
+
+            assert(optPtr->litFreq != NULL);
+            if (compressedLiterals) {
+                unsigned lit = MaxLit;
+                HIST_count_simple(optPtr->litFreq, &lit, src, srcSize);   /* use raw first block to init statistics */
+                optPtr->litSum = ZSTD_downscaleStat(optPtr->litFreq, MaxLit, 1);
+            }
+
+            {   unsigned ll;
+                for (ll=0; ll<=MaxLL; ll++)
+                    optPtr->litLengthFreq[ll] = 1;
+            }
+            optPtr->litLengthSum = MaxLL+1;
+
+            {   unsigned ml;
+                for (ml=0; ml<=MaxML; ml++)
+                    optPtr->matchLengthFreq[ml] = 1;
+            }
+            optPtr->matchLengthSum = MaxML+1;
+
+            {   unsigned of;
+                for (of=0; of<=MaxOff; of++)
+                    optPtr->offCodeFreq[of] = 1;
+            }
+            optPtr->offCodeSum = MaxOff+1;
+
+        }
+
+    } else {   /* new block : re-use previous statistics, scaled down */
+
+        if (compressedLiterals)
+            optPtr->litSum = ZSTD_downscaleStat(optPtr->litFreq, MaxLit, 1);
+        optPtr->litLengthSum = ZSTD_downscaleStat(optPtr->litLengthFreq, MaxLL, 0);
+        optPtr->matchLengthSum = ZSTD_downscaleStat(optPtr->matchLengthFreq, MaxML, 0);
+        optPtr->offCodeSum = ZSTD_downscaleStat(optPtr->offCodeFreq, MaxOff, 0);
+    }
+
+    ZSTD_setBasePrices(optPtr, optLevel);
+}
+
+/* ZSTD_rawLiteralsCost() :
+ * price of literals (only) in specified segment (which length can be 0).
+ * does not include price of literalLength symbol */
+static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
+                                const optState_t* const optPtr,
+                                int optLevel)
+{
+    if (litLength == 0) return 0;
+
+    if (!ZSTD_compressedLiterals(optPtr))
+        return (litLength << 3) * BITCOST_MULTIPLIER;  /* Uncompressed - 8 bytes per literal. */
+
+    if (optPtr->priceType == zop_predef)
+        return (litLength*6) * BITCOST_MULTIPLIER;  /* 6 bit per literal - no statistic used */
+
+    /* dynamic statistics */
+    {   U32 price = litLength * optPtr->litSumBasePrice;
+        U32 u;
+        for (u=0; u < litLength; u++) {
+            assert(WEIGHT(optPtr->litFreq[literals[u]], optLevel) <= optPtr->litSumBasePrice);   /* literal cost should never be negative */
+            price -= WEIGHT(optPtr->litFreq[literals[u]], optLevel);
+        }
+        return price;
+    }
+}
+
+/* ZSTD_litLengthPrice() :
+ * cost of literalLength symbol */
+static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel)
+{
+    if (optPtr->priceType == zop_predef) return WEIGHT(litLength, optLevel);
+
+    /* dynamic statistics */
+    {   U32 const llCode = ZSTD_LLcode(litLength);
+        return (LL_bits[llCode] * BITCOST_MULTIPLIER)
+             + optPtr->litLengthSumBasePrice
+             - WEIGHT(optPtr->litLengthFreq[llCode], optLevel);
+    }
+}
+
+/* ZSTD_litLengthContribution() :
+ * @return ( cost(litlength) - cost(0) )
+ * this value can then be added to rawLiteralsCost()
+ * to provide a cost which is directly comparable to a match ending at same position */
+static int ZSTD_litLengthContribution(U32 const litLength, const optState_t* const optPtr, int optLevel)
+{
+    if (optPtr->priceType >= zop_predef) return (int)WEIGHT(litLength, optLevel);
+
+    /* dynamic statistics */
+    {   U32 const llCode = ZSTD_LLcode(litLength);
+        int const contribution = (int)(LL_bits[llCode] * BITCOST_MULTIPLIER)
+                               + (int)WEIGHT(optPtr->litLengthFreq[0], optLevel)   /* note: log2litLengthSum cancel out */
+                               - (int)WEIGHT(optPtr->litLengthFreq[llCode], optLevel);
+#if 1
+        return contribution;
+#else
+        return MAX(0, contribution); /* sometimes better, sometimes not ... */
+#endif
+    }
+}
+
+/* ZSTD_literalsContribution() :
+ * creates a fake cost for the literals part of a sequence
+ * which can be compared to the ending cost of a match
+ * should a new match start at this position */
+static int ZSTD_literalsContribution(const BYTE* const literals, U32 const litLength,
+                                     const optState_t* const optPtr,
+                                     int optLevel)
+{
+    int const contribution = (int)ZSTD_rawLiteralsCost(literals, litLength, optPtr, optLevel)
+                           + ZSTD_litLengthContribution(litLength, optPtr, optLevel);
+    return contribution;
+}
+
+/* ZSTD_getMatchPrice() :
+ * Provides the cost of the match part (offset + matchLength) of a sequence
+ * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence.
+ * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
+FORCE_INLINE_TEMPLATE U32
+ZSTD_getMatchPrice(U32 const offset,
+                   U32 const matchLength,
+             const optState_t* const optPtr,
+                   int const optLevel)
+{
+    U32 price;
+    U32 const offCode = ZSTD_highbit32(offset+1);
+    U32 const mlBase = matchLength - MINMATCH;
+    assert(matchLength >= MINMATCH);
+
+    if (optPtr->priceType == zop_predef)  /* fixed scheme, do not use statistics */
+        return WEIGHT(mlBase, optLevel) + ((16 + offCode) * BITCOST_MULTIPLIER);
+
+    /* dynamic statistics */
+    price = (offCode * BITCOST_MULTIPLIER) + (optPtr->offCodeSumBasePrice - WEIGHT(optPtr->offCodeFreq[offCode], optLevel));
+    if ((optLevel<2) /*static*/ && offCode >= 20)
+        price += (offCode-19)*2 * BITCOST_MULTIPLIER; /* handicap for long distance offsets, favor decompression speed */
+
+    /* match Length */
+    {   U32 const mlCode = ZSTD_MLcode(mlBase);
+        price += (ML_bits[mlCode] * BITCOST_MULTIPLIER) + (optPtr->matchLengthSumBasePrice - WEIGHT(optPtr->matchLengthFreq[mlCode], optLevel));
+    }
+
+    price += BITCOST_MULTIPLIER / 5;   /* heuristic : make matches a bit more costly to favor less sequences -> faster decompression speed */
+
+    DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
+    return price;
+}
+
+/* ZSTD_updateStats() :
+ * assumption : literals + litLengtn <= iend */
+static void ZSTD_updateStats(optState_t* const optPtr,
+                             U32 litLength, const BYTE* literals,
+                             U32 offsetCode, U32 matchLength)
+{
+    /* literals */
+    if (ZSTD_compressedLiterals(optPtr)) {
+        U32 u;
+        for (u=0; u < litLength; u++)
+            optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
+        optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
+    }
+
+    /* literal Length */
+    {   U32 const llCode = ZSTD_LLcode(litLength);
+        optPtr->litLengthFreq[llCode]++;
+        optPtr->litLengthSum++;
+    }
+
+    /* match offset code (0-2=>repCode; 3+=>offset+2) */
+    {   U32 const offCode = ZSTD_highbit32(offsetCode+1);
+        assert(offCode <= MaxOff);
+        optPtr->offCodeFreq[offCode]++;
+        optPtr->offCodeSum++;
+    }
+
+    /* match Length */
+    {   U32 const mlBase = matchLength - MINMATCH;
+        U32 const mlCode = ZSTD_MLcode(mlBase);
+        optPtr->matchLengthFreq[mlCode]++;
+        optPtr->matchLengthSum++;
+    }
+}
+
+
+/* ZSTD_readMINMATCH() :
+ * function safe only for comparisons
+ * assumption : memPtr must be at least 4 bytes before end of buffer */
+MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
+{
+    switch (length)
+    {
+    default :
+    case 4 : return MEM_read32(memPtr);
+    case 3 : if (MEM_isLittleEndian())
+                return MEM_read32(memPtr)<<8;
+             else
+                return MEM_read32(memPtr)>>8;
+    }
+}
+
+
+/* Update hashTable3 up to ip (excluded)
+   Assumption : always within prefix (i.e. not within extDict) */
+static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_matchState_t* ms,
+                                              U32* nextToUpdate3,
+                                              const BYTE* const ip)
+{
+    U32* const hashTable3 = ms->hashTable3;
+    U32 const hashLog3 = ms->hashLog3;
+    const BYTE* const base = ms->window.base;
+    U32 idx = *nextToUpdate3;
+    U32 const target = (U32)(ip - base);
+    size_t const hash3 = ZSTD_hash3Ptr(ip, hashLog3);
+    assert(hashLog3 > 0);
+
+    while(idx < target) {
+        hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;
+        idx++;
+    }
+
+    *nextToUpdate3 = target;
+    return hashTable3[hash3];
+}
+
+
+/*-*************************************
+*  Binary Tree search
+***************************************/
+/** ZSTD_insertBt1() : add one or multiple positions to tree.
+ *  ip : assumed <= iend-8 .
+ * @return : nb of positions added */
+static U32 ZSTD_insertBt1(
+                ZSTD_matchState_t* ms,
+                const BYTE* const ip, const BYTE* const iend,
+                U32 const mls, const int extDict)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32*   const hashTable = ms->hashTable;
+    U32    const hashLog = cParams->hashLog;
+    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32*   const bt = ms->chainTable;
+    U32    const btLog  = cParams->chainLog - 1;
+    U32    const btMask = (1 << btLog) - 1;
+    U32 matchIndex = hashTable[h];
+    size_t commonLengthSmaller=0, commonLengthLarger=0;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const U32 dictLimit = ms->window.dictLimit;
+    const BYTE* const dictEnd = dictBase + dictLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    const BYTE* match;
+    const U32 current = (U32)(ip-base);
+    const U32 btLow = btMask >= current ? 0 : current - btMask;
+    U32* smallerPtr = bt + 2*(current&btMask);
+    U32* largerPtr  = smallerPtr + 1;
+    U32 dummy32;   /* to be nullified at the end */
+    U32 const windowLow = ms->window.lowLimit;
+    U32 matchEndIdx = current+8+1;
+    size_t bestLength = 8;
+    U32 nbCompares = 1U << cParams->searchLog;
+#ifdef ZSTD_C_PREDICT
+    U32 predictedSmall = *(bt + 2*((current-1)&btMask) + 0);
+    U32 predictedLarge = *(bt + 2*((current-1)&btMask) + 1);
+    predictedSmall += (predictedSmall>0);
+    predictedLarge += (predictedLarge>0);
+#endif /* ZSTD_C_PREDICT */
+
+    DEBUGLOG(8, "ZSTD_insertBt1 (%u)", current);
+
+    assert(ip <= iend-8);   /* required for h calculation */
+    hashTable[h] = current;   /* Update Hash Table */
+
+    assert(windowLow > 0);
+    while (nbCompares-- && (matchIndex >= windowLow)) {
+        U32* const nextPtr = bt + 2*(matchIndex & btMask);
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+        assert(matchIndex < current);
+
+#ifdef ZSTD_C_PREDICT   /* note : can create issues when hlog small <= 11 */
+        const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */
+        if (matchIndex == predictedSmall) {
+            /* no need to check length, result known */
+            *smallerPtr = matchIndex;
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
+            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+            predictedSmall = predictPtr[1] + (predictPtr[1]>0);
+            continue;
+        }
+        if (matchIndex == predictedLarge) {
+            *largerPtr = matchIndex;
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+            largerPtr = nextPtr;
+            matchIndex = nextPtr[0];
+            predictedLarge = predictPtr[0] + (predictPtr[0]>0);
+            continue;
+        }
+#endif
+
+        if (!extDict || (matchIndex+matchLength >= dictLimit)) {
+            assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if actually extDict */
+            match = base + matchIndex;
+            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
+        } else {
+            match = dictBase + matchIndex;
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
+            if (matchIndex+matchLength >= dictLimit)
+                match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
+        }
+
+        if (matchLength > bestLength) {
+            bestLength = matchLength;
+            if (matchLength > matchEndIdx - matchIndex)
+                matchEndIdx = matchIndex + (U32)matchLength;
+        }
+
+        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
+            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
+        }
+
+        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */
+            /* match is smaller than current */
+            *smallerPtr = matchIndex;             /* update smaller idx */
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
+            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */
+            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */
+        } else {
+            /* match is larger than current */
+            *largerPtr = matchIndex;
+            commonLengthLarger = matchLength;
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
+            largerPtr = nextPtr;
+            matchIndex = nextPtr[0];
+    }   }
+
+    *smallerPtr = *largerPtr = 0;
+    {   U32 positions = 0;
+        if (bestLength > 384) positions = MIN(192, (U32)(bestLength - 384));   /* speed optimization */
+        assert(matchEndIdx > current + 8);
+        return MAX(positions, matchEndIdx - (current + 8));
+    }
+}
+
+FORCE_INLINE_TEMPLATE
+void ZSTD_updateTree_internal(
+                ZSTD_matchState_t* ms,
+                const BYTE* const ip, const BYTE* const iend,
+                const U32 mls, const ZSTD_dictMode_e dictMode)
+{
+    const BYTE* const base = ms->window.base;
+    U32 const target = (U32)(ip - base);
+    U32 idx = ms->nextToUpdate;
+    DEBUGLOG(6, "ZSTD_updateTree_internal, from %u to %u  (dictMode:%u)",
+                idx, target, dictMode);
+
+    while(idx < target) {
+        U32 const forward = ZSTD_insertBt1(ms, base+idx, iend, mls, dictMode == ZSTD_extDict);
+        assert(idx < (U32)(idx + forward));
+        idx += forward;
+    }
+    assert((size_t)(ip - base) <= (size_t)(U32)(-1));
+    assert((size_t)(iend - base) <= (size_t)(U32)(-1));
+    ms->nextToUpdate = target;
+}
+
+void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) {
+    ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict);
+}
+
+FORCE_INLINE_TEMPLATE
+U32 ZSTD_insertBtAndGetAllMatches (
+                    ZSTD_match_t* matches,   /* store result (found matches) in this table (presumed large enough) */
+                    ZSTD_matchState_t* ms,
+                    U32* nextToUpdate3,
+                    const BYTE* const ip, const BYTE* const iLimit, const ZSTD_dictMode_e dictMode,
+                    const U32 rep[ZSTD_REP_NUM],
+                    U32 const ll0,   /* tells if associated literal length is 0 or not. This value must be 0 or 1 */
+                    const U32 lengthToBeat,
+                    U32 const mls /* template */)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
+    const BYTE* const base = ms->window.base;
+    U32 const current = (U32)(ip-base);
+    U32 const hashLog = cParams->hashLog;
+    U32 const minMatch = (mls==3) ? 3 : 4;
+    U32* const hashTable = ms->hashTable;
+    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32 matchIndex  = hashTable[h];
+    U32* const bt   = ms->chainTable;
+    U32 const btLog = cParams->chainLog - 1;
+    U32 const btMask= (1U << btLog) - 1;
+    size_t commonLengthSmaller=0, commonLengthLarger=0;
+    const BYTE* const dictBase = ms->window.dictBase;
+    U32 const dictLimit = ms->window.dictLimit;
+    const BYTE* const dictEnd = dictBase + dictLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    U32 const btLow = (btMask >= current) ? 0 : current - btMask;
+    U32 const windowLow = ZSTD_getLowestMatchIndex(ms, current, cParams->windowLog);
+    U32 const matchLow = windowLow ? windowLow : 1;
+    U32* smallerPtr = bt + 2*(current&btMask);
+    U32* largerPtr  = bt + 2*(current&btMask) + 1;
+    U32 matchEndIdx = current+8+1;   /* farthest referenced position of any match => detects repetitive patterns */
+    U32 dummy32;   /* to be nullified at the end */
+    U32 mnum = 0;
+    U32 nbCompares = 1U << cParams->searchLog;
+
+    const ZSTD_matchState_t* dms    = dictMode == ZSTD_dictMatchState ? ms->dictMatchState : NULL;
+    const ZSTD_compressionParameters* const dmsCParams =
+                                      dictMode == ZSTD_dictMatchState ? &dms->cParams : NULL;
+    const BYTE* const dmsBase       = dictMode == ZSTD_dictMatchState ? dms->window.base : NULL;
+    const BYTE* const dmsEnd        = dictMode == ZSTD_dictMatchState ? dms->window.nextSrc : NULL;
+    U32         const dmsHighLimit  = dictMode == ZSTD_dictMatchState ? (U32)(dmsEnd - dmsBase) : 0;
+    U32         const dmsLowLimit   = dictMode == ZSTD_dictMatchState ? dms->window.lowLimit : 0;
+    U32         const dmsIndexDelta = dictMode == ZSTD_dictMatchState ? windowLow - dmsHighLimit : 0;
+    U32         const dmsHashLog    = dictMode == ZSTD_dictMatchState ? dmsCParams->hashLog : hashLog;
+    U32         const dmsBtLog      = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog;
+    U32         const dmsBtMask     = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0;
+    U32         const dmsBtLow      = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit;
+
+    size_t bestLength = lengthToBeat-1;
+    DEBUGLOG(8, "ZSTD_insertBtAndGetAllMatches: current=%u", current);
+
+    /* check repCode */
+    assert(ll0 <= 1);   /* necessarily 1 or 0 */
+    {   U32 const lastR = ZSTD_REP_NUM + ll0;
+        U32 repCode;
+        for (repCode = ll0; repCode < lastR; repCode++) {
+            U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+            U32 const repIndex = current - repOffset;
+            U32 repLen = 0;
+            assert(current >= dictLimit);
+            if (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit) {  /* equivalent to `current > repIndex >= dictLimit` */
+                if (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch)) {
+                    repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
+                }
+            } else {  /* repIndex < dictLimit || repIndex >= current */
+                const BYTE* const repMatch = dictMode == ZSTD_dictMatchState ?
+                                             dmsBase + repIndex - dmsIndexDelta :
+                                             dictBase + repIndex;
+                assert(current >= windowLow);
+                if ( dictMode == ZSTD_extDict
+                  && ( ((repOffset-1) /*intentional overflow*/ < current - windowLow)  /* equivalent to `current > repIndex >= windowLow` */
+                     & (((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */)
+                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
+                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch;
+                }
+                if (dictMode == ZSTD_dictMatchState
+                  && ( ((repOffset-1) /*intentional overflow*/ < current - (dmsLowLimit + dmsIndexDelta))  /* equivalent to `current > repIndex >= dmsLowLimit` */
+                     & ((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */
+                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
+                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dmsEnd, prefixStart) + minMatch;
+            }   }
+            /* save longer solution */
+            if (repLen > bestLength) {
+                DEBUGLOG(8, "found repCode %u (ll0:%u, offset:%u) of length %u",
+                            repCode, ll0, repOffset, repLen);
+                bestLength = repLen;
+                matches[mnum].off = repCode - ll0;
+                matches[mnum].len = (U32)repLen;
+                mnum++;
+                if ( (repLen > sufficient_len)
+                   | (ip+repLen == iLimit) ) {  /* best possible */
+                    return mnum;
+    }   }   }   }
+
+    /* HC3 match finder */
+    if ((mls == 3) /*static*/ && (bestLength < mls)) {
+        U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3(ms, nextToUpdate3, ip);
+        if ((matchIndex3 >= matchLow)
+          & (current - matchIndex3 < (1<<18)) /*heuristic : longer distance likely too expensive*/ ) {
+            size_t mlen;
+            if ((dictMode == ZSTD_noDict) /*static*/ || (dictMode == ZSTD_dictMatchState) /*static*/ || (matchIndex3 >= dictLimit)) {
+                const BYTE* const match = base + matchIndex3;
+                mlen = ZSTD_count(ip, match, iLimit);
+            } else {
+                const BYTE* const match = dictBase + matchIndex3;
+                mlen = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart);
+            }
+
+            /* save best solution */
+            if (mlen >= mls /* == 3 > bestLength */) {
+                DEBUGLOG(8, "found small match with hlog3, of length %u",
+                            (U32)mlen);
+                bestLength = mlen;
+                assert(current > matchIndex3);
+                assert(mnum==0);  /* no prior solution */
+                matches[0].off = (current - matchIndex3) + ZSTD_REP_MOVE;
+                matches[0].len = (U32)mlen;
+                mnum = 1;
+                if ( (mlen > sufficient_len) |
+                     (ip+mlen == iLimit) ) {  /* best possible length */
+                    ms->nextToUpdate = current+1;  /* skip insertion */
+                    return 1;
+        }   }   }
+        /* no dictMatchState lookup: dicts don't have a populated HC3 table */
+    }
+
+    hashTable[h] = current;   /* Update Hash Table */
+
+    while (nbCompares-- && (matchIndex >= matchLow)) {
+        U32* const nextPtr = bt + 2*(matchIndex & btMask);
+        const BYTE* match;
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+        assert(current > matchIndex);
+
+        if ((dictMode == ZSTD_noDict) || (dictMode == ZSTD_dictMatchState) || (matchIndex+matchLength >= dictLimit)) {
+            assert(matchIndex+matchLength >= dictLimit);  /* ensure the condition is correct when !extDict */
+            match = base + matchIndex;
+            if (matchIndex >= dictLimit) assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */
+            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iLimit);
+        } else {
+            match = dictBase + matchIndex;
+            assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);
+            if (matchIndex+matchLength >= dictLimit)
+                match = base + matchIndex;   /* prepare for match[matchLength] read */
+        }
+
+        if (matchLength > bestLength) {
+            DEBUGLOG(8, "found match of length %u at distance %u (offCode=%u)",
+                    (U32)matchLength, current - matchIndex, current - matchIndex + ZSTD_REP_MOVE);
+            assert(matchEndIdx > matchIndex);
+            if (matchLength > matchEndIdx - matchIndex)
+                matchEndIdx = matchIndex + (U32)matchLength;
+            bestLength = matchLength;
+            matches[mnum].off = (current - matchIndex) + ZSTD_REP_MOVE;
+            matches[mnum].len = (U32)matchLength;
+            mnum++;
+            if ( (matchLength > ZSTD_OPT_NUM)
+               | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
+                if (dictMode == ZSTD_dictMatchState) nbCompares = 0; /* break should also skip searching dms */
+                break; /* drop, to preserve bt consistency (miss a little bit of compression) */
+            }
+        }
+
+        if (match[matchLength] < ip[matchLength]) {
+            /* match smaller than current */
+            *smallerPtr = matchIndex;             /* update smaller idx */
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+            smallerPtr = nextPtr+1;               /* new candidate => larger than match, which was smaller than current */
+            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous, closer to current */
+        } else {
+            *largerPtr = matchIndex;
+            commonLengthLarger = matchLength;
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+            largerPtr = nextPtr;
+            matchIndex = nextPtr[0];
+    }   }
+
+    *smallerPtr = *largerPtr = 0;
+
+    if (dictMode == ZSTD_dictMatchState && nbCompares) {
+        size_t const dmsH = ZSTD_hashPtr(ip, dmsHashLog, mls);
+        U32 dictMatchIndex = dms->hashTable[dmsH];
+        const U32* const dmsBt = dms->chainTable;
+        commonLengthSmaller = commonLengthLarger = 0;
+        while (nbCompares-- && (dictMatchIndex > dmsLowLimit)) {
+            const U32* const nextPtr = dmsBt + 2*(dictMatchIndex & dmsBtMask);
+            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+            const BYTE* match = dmsBase + dictMatchIndex;
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dmsEnd, prefixStart);
+            if (dictMatchIndex+matchLength >= dmsHighLimit)
+                match = base + dictMatchIndex + dmsIndexDelta;   /* to prepare for next usage of match[matchLength] */
+
+            if (matchLength > bestLength) {
+                matchIndex = dictMatchIndex + dmsIndexDelta;
+                DEBUGLOG(8, "found dms match of length %u at distance %u (offCode=%u)",
+                        (U32)matchLength, current - matchIndex, current - matchIndex + ZSTD_REP_MOVE);
+                if (matchLength > matchEndIdx - matchIndex)
+                    matchEndIdx = matchIndex + (U32)matchLength;
+                bestLength = matchLength;
+                matches[mnum].off = (current - matchIndex) + ZSTD_REP_MOVE;
+                matches[mnum].len = (U32)matchLength;
+                mnum++;
+                if ( (matchLength > ZSTD_OPT_NUM)
+                   | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
+                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+                }
+            }
+
+            if (dictMatchIndex <= dmsBtLow) { break; }   /* beyond tree size, stop the search */
+            if (match[matchLength] < ip[matchLength]) {
+                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+                dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+            } else {
+                /* match is larger than current */
+                commonLengthLarger = matchLength;
+                dictMatchIndex = nextPtr[0];
+            }
+        }
+    }
+
+    assert(matchEndIdx > current+8);
+    ms->nextToUpdate = matchEndIdx - 8;  /* skip repetitive patterns */
+    return mnum;
+}
+
+
+FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches (
+                        ZSTD_match_t* matches,   /* store result (match found, increasing size) in this table */
+                        ZSTD_matchState_t* ms,
+                        U32* nextToUpdate3,
+                        const BYTE* ip, const BYTE* const iHighLimit, const ZSTD_dictMode_e dictMode,
+                        const U32 rep[ZSTD_REP_NUM],
+                        U32 const ll0,
+                        U32 const lengthToBeat)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32 const matchLengthSearch = cParams->minMatch;
+    DEBUGLOG(8, "ZSTD_BtGetAllMatches");
+    if (ip < ms->window.base + ms->nextToUpdate) return 0;   /* skipped area */
+    ZSTD_updateTree_internal(ms, ip, iHighLimit, matchLengthSearch, dictMode);
+    switch(matchLengthSearch)
+    {
+    case 3 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 3);
+    default :
+    case 4 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 4);
+    case 5 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 5);
+    case 7 :
+    case 6 : return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, 6);
+    }
+}
+
+
+/*-*******************************
+*  Optimal parser
+*********************************/
+typedef struct repcodes_s {
+    U32 rep[3];
+} repcodes_t;
+
+static repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
+{
+    repcodes_t newReps;
+    if (offset >= ZSTD_REP_NUM) {  /* full offset */
+        newReps.rep[2] = rep[1];
+        newReps.rep[1] = rep[0];
+        newReps.rep[0] = offset - ZSTD_REP_MOVE;
+    } else {   /* repcode */
+        U32 const repCode = offset + ll0;
+        if (repCode > 0) {  /* note : if repCode==0, no change */
+            U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+            newReps.rep[2] = (repCode >= 2) ? rep[1] : rep[2];
+            newReps.rep[1] = rep[0];
+            newReps.rep[0] = currentOffset;
+        } else {   /* repCode == 0 */
+            memcpy(&newReps, rep, sizeof(newReps));
+        }
+    }
+    return newReps;
+}
+
+
+static U32 ZSTD_totalLen(ZSTD_optimal_t sol)
+{
+    return sol.litlen + sol.mlen;
+}
+
+#if 0 /* debug */
+
+static void
+listStats(const U32* table, int lastEltID)
+{
+    int const nbElts = lastEltID + 1;
+    int enb;
+    for (enb=0; enb < nbElts; enb++) {
+        (void)table;
+        //RAWLOG(2, "%3i:%3i,  ", enb, table[enb]);
+        RAWLOG(2, "%4i,", table[enb]);
+    }
+    RAWLOG(2, " \n");
+}
+
+#endif
+
+FORCE_INLINE_TEMPLATE size_t
+ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
+                               seqStore_t* seqStore,
+                               U32 rep[ZSTD_REP_NUM],
+                         const void* src, size_t srcSize,
+                         const int optLevel,
+                         const ZSTD_dictMode_e dictMode)
+{
+    optState_t* const optStatePtr = &ms->opt;
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - 8;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const prefixStart = base + ms->window.dictLimit;
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+
+    U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
+    U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4;
+    U32 nextToUpdate3 = ms->nextToUpdate;
+
+    ZSTD_optimal_t* const opt = optStatePtr->priceTable;
+    ZSTD_match_t* const matches = optStatePtr->matchTable;
+    ZSTD_optimal_t lastSequence;
+
+    /* init */
+    DEBUGLOG(5, "ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u",
+                (U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate);
+    assert(optLevel <= 2);
+    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);
+    ip += (ip==prefixStart);
+
+    /* Match Loop */
+    while (ip < ilimit) {
+        U32 cur, last_pos = 0;
+
+        /* find first match */
+        {   U32 const litlen = (U32)(ip - anchor);
+            U32 const ll0 = !litlen;
+            U32 const nbMatches = ZSTD_BtGetAllMatches(matches, ms, &nextToUpdate3, ip, iend, dictMode, rep, ll0, minMatch);
+            if (!nbMatches) { ip++; continue; }
+
+            /* initialize opt[0] */
+            { U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
+            opt[0].mlen = 0;  /* means is_a_literal */
+            opt[0].litlen = litlen;
+            opt[0].price = ZSTD_literalsContribution(anchor, litlen, optStatePtr, optLevel);
+
+            /* large match -> immediate encoding */
+            {   U32 const maxML = matches[nbMatches-1].len;
+                U32 const maxOffset = matches[nbMatches-1].off;
+                DEBUGLOG(6, "found %u matches of maxLength=%u and maxOffCode=%u at cPos=%u => start new series",
+                            nbMatches, maxML, maxOffset, (U32)(ip-prefixStart));
+
+                if (maxML > sufficient_len) {
+                    lastSequence.litlen = litlen;
+                    lastSequence.mlen = maxML;
+                    lastSequence.off = maxOffset;
+                    DEBUGLOG(6, "large match (%u>%u), immediate encoding",
+                                maxML, sufficient_len);
+                    cur = 0;
+                    last_pos = ZSTD_totalLen(lastSequence);
+                    goto _shortestPath;
+            }   }
+
+            /* set prices for first matches starting position == 0 */
+            {   U32 const literalsPrice = opt[0].price + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
+                U32 pos;
+                U32 matchNb;
+                for (pos = 1; pos < minMatch; pos++) {
+                    opt[pos].price = ZSTD_MAX_PRICE;   /* mlen, litlen and price will be fixed during forward scanning */
+                }
+                for (matchNb = 0; matchNb < nbMatches; matchNb++) {
+                    U32 const offset = matches[matchNb].off;
+                    U32 const end = matches[matchNb].len;
+                    repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
+                    for ( ; pos <= end ; pos++ ) {
+                        U32 const matchPrice = ZSTD_getMatchPrice(offset, pos, optStatePtr, optLevel);
+                        U32 const sequencePrice = literalsPrice + matchPrice;
+                        DEBUGLOG(7, "rPos:%u => set initial price : %.2f",
+                                    pos, ZSTD_fCost(sequencePrice));
+                        opt[pos].mlen = pos;
+                        opt[pos].off = offset;
+                        opt[pos].litlen = litlen;
+                        opt[pos].price = sequencePrice;
+                        ZSTD_STATIC_ASSERT(sizeof(opt[pos].rep) == sizeof(repHistory));
+                        memcpy(opt[pos].rep, &repHistory, sizeof(repHistory));
+                }   }
+                last_pos = pos-1;
+            }
+        }
+
+        /* check further positions */
+        for (cur = 1; cur <= last_pos; cur++) {
+            const BYTE* const inr = ip + cur;
+            assert(cur < ZSTD_OPT_NUM);
+            DEBUGLOG(7, "cPos:%zi==rPos:%u", inr-istart, cur)
+
+            /* Fix current position with one literal if cheaper */
+            {   U32 const litlen = (opt[cur-1].mlen == 0) ? opt[cur-1].litlen + 1 : 1;
+                int const price = opt[cur-1].price
+                                + ZSTD_rawLiteralsCost(ip+cur-1, 1, optStatePtr, optLevel)
+                                + ZSTD_litLengthPrice(litlen, optStatePtr, optLevel)
+                                - ZSTD_litLengthPrice(litlen-1, optStatePtr, optLevel);
+                assert(price < 1000000000); /* overflow check */
+                if (price <= opt[cur].price) {
+                    DEBUGLOG(7, "cPos:%zi==rPos:%u : better price (%.2f<=%.2f) using literal (ll==%u) (hist:%u,%u,%u)",
+                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), litlen,
+                                opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
+                    opt[cur].mlen = 0;
+                    opt[cur].off = 0;
+                    opt[cur].litlen = litlen;
+                    opt[cur].price = price;
+                    memcpy(opt[cur].rep, opt[cur-1].rep, sizeof(opt[cur].rep));
+                } else {
+                    DEBUGLOG(7, "cPos:%zi==rPos:%u : literal would cost more (%.2f>%.2f) (hist:%u,%u,%u)",
+                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price),
+                                opt[cur].rep[0], opt[cur].rep[1], opt[cur].rep[2]);
+                }
+            }
+
+            /* last match must start at a minimum distance of 8 from oend */
+            if (inr > ilimit) continue;
+
+            if (cur == last_pos) break;
+
+            if ( (optLevel==0) /*static_test*/
+              && (opt[cur+1].price <= opt[cur].price + (BITCOST_MULTIPLIER/2)) ) {
+                DEBUGLOG(7, "move to next rPos:%u : price is <=", cur+1);
+                continue;  /* skip unpromising positions; about ~+6% speed, -0.01 ratio */
+            }
+
+            {   U32 const ll0 = (opt[cur].mlen != 0);
+                U32 const litlen = (opt[cur].mlen == 0) ? opt[cur].litlen : 0;
+                U32 const previousPrice = opt[cur].price;
+                U32 const basePrice = previousPrice + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
+                U32 const nbMatches = ZSTD_BtGetAllMatches(matches, ms, &nextToUpdate3, inr, iend, dictMode, opt[cur].rep, ll0, minMatch);
+                U32 matchNb;
+                if (!nbMatches) {
+                    DEBUGLOG(7, "rPos:%u : no match found", cur);
+                    continue;
+                }
+
+                {   U32 const maxML = matches[nbMatches-1].len;
+                    DEBUGLOG(7, "cPos:%zi==rPos:%u, found %u matches, of maxLength=%u",
+                                inr-istart, cur, nbMatches, maxML);
+
+                    if ( (maxML > sufficient_len)
+                      || (cur + maxML >= ZSTD_OPT_NUM) ) {
+                        lastSequence.mlen = maxML;
+                        lastSequence.off = matches[nbMatches-1].off;
+                        lastSequence.litlen = litlen;
+                        cur -= (opt[cur].mlen==0) ? opt[cur].litlen : 0;  /* last sequence is actually only literals, fix cur to last match - note : may underflow, in which case, it's first sequence, and it's okay */
+                        last_pos = cur + ZSTD_totalLen(lastSequence);
+                        if (cur > ZSTD_OPT_NUM) cur = 0;   /* underflow => first match */
+                        goto _shortestPath;
+                }   }
+
+                /* set prices using matches found at position == cur */
+                for (matchNb = 0; matchNb < nbMatches; matchNb++) {
+                    U32 const offset = matches[matchNb].off;
+                    repcodes_t const repHistory = ZSTD_updateRep(opt[cur].rep, offset, ll0);
+                    U32 const lastML = matches[matchNb].len;
+                    U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
+                    U32 mlen;
+
+                    DEBUGLOG(7, "testing match %u => offCode=%4u, mlen=%2u, llen=%2u",
+                                matchNb, matches[matchNb].off, lastML, litlen);
+
+                    for (mlen = lastML; mlen >= startML; mlen--) {  /* scan downward */
+                        U32 const pos = cur + mlen;
+                        int const price = basePrice + ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel);
+
+                        if ((pos > last_pos) || (price < opt[pos].price)) {
+                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new better price (%.2f<%.2f)",
+                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
+                            while (last_pos < pos) { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; }   /* fill empty positions */
+                            opt[pos].mlen = mlen;
+                            opt[pos].off = offset;
+                            opt[pos].litlen = litlen;
+                            opt[pos].price = price;
+                            ZSTD_STATIC_ASSERT(sizeof(opt[pos].rep) == sizeof(repHistory));
+                            memcpy(opt[pos].rep, &repHistory, sizeof(repHistory));
+                        } else {
+                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new price is worse (%.2f>=%.2f)",
+                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
+                            if (optLevel==0) break;  /* early update abort; gets ~+10% speed for about -0.01 ratio loss */
+                        }
+            }   }   }
+        }  /* for (cur = 1; cur <= last_pos; cur++) */
+
+        lastSequence = opt[last_pos];
+        cur = last_pos > ZSTD_totalLen(lastSequence) ? last_pos - ZSTD_totalLen(lastSequence) : 0;  /* single sequence, and it starts before `ip` */
+        assert(cur < ZSTD_OPT_NUM);  /* control overflow*/
+
+_shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
+        assert(opt[0].mlen == 0);
+
+        {   U32 const storeEnd = cur + 1;
+            U32 storeStart = storeEnd;
+            U32 seqPos = cur;
+
+            DEBUGLOG(6, "start reverse traversal (last_pos:%u, cur:%u)",
+                        last_pos, cur); (void)last_pos;
+            assert(storeEnd < ZSTD_OPT_NUM);
+            DEBUGLOG(6, "last sequence copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
+                        storeEnd, lastSequence.litlen, lastSequence.mlen, lastSequence.off);
+            opt[storeEnd] = lastSequence;
+            while (seqPos > 0) {
+                U32 const backDist = ZSTD_totalLen(opt[seqPos]);
+                storeStart--;
+                DEBUGLOG(6, "sequence from rPos=%u copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
+                            seqPos, storeStart, opt[seqPos].litlen, opt[seqPos].mlen, opt[seqPos].off);
+                opt[storeStart] = opt[seqPos];
+                seqPos = (seqPos > backDist) ? seqPos - backDist : 0;
+            }
+
+            /* save sequences */
+            DEBUGLOG(6, "sending selected sequences into seqStore")
+            {   U32 storePos;
+                for (storePos=storeStart; storePos <= storeEnd; storePos++) {
+                    U32 const llen = opt[storePos].litlen;
+                    U32 const mlen = opt[storePos].mlen;
+                    U32 const offCode = opt[storePos].off;
+                    U32 const advance = llen + mlen;
+                    DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u",
+                                anchor - istart, (unsigned)llen, (unsigned)mlen);
+
+                    if (mlen==0) {  /* only literals => must be last "sequence", actually starting a new stream of sequences */
+                        assert(storePos == storeEnd);   /* must be last sequence */
+                        ip = anchor + llen;     /* last "sequence" is a bunch of literals => don't progress anchor */
+                        continue;   /* will finish */
+                    }
+
+                    /* repcodes update : like ZSTD_updateRep(), but update in place */
+                    if (offCode >= ZSTD_REP_NUM) {  /* full offset */
+                        rep[2] = rep[1];
+                        rep[1] = rep[0];
+                        rep[0] = offCode - ZSTD_REP_MOVE;
+                    } else {   /* repcode */
+                        U32 const repCode = offCode + (llen==0);
+                        if (repCode) {  /* note : if repCode==0, no change */
+                            U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+                            if (repCode >= 2) rep[2] = rep[1];
+                            rep[1] = rep[0];
+                            rep[0] = currentOffset;
+                    }   }
+
+                    assert(anchor + llen <= iend);
+                    ZSTD_updateStats(optStatePtr, llen, anchor, offCode, mlen);
+                    ZSTD_storeSeq(seqStore, llen, anchor, offCode, mlen-MINMATCH);
+                    anchor += advance;
+                    ip = anchor;
+            }   }
+            ZSTD_setBasePrices(optStatePtr, optLevel);
+        }
+
+    }   /* while (ip < ilimit) */
+
+    /* Return the last literals size */
+    return (size_t)(iend - anchor);
+}
+
+
+size_t ZSTD_compressBlock_btopt(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        const void* src, size_t srcSize)
+{
+    DEBUGLOG(5, "ZSTD_compressBlock_btopt");
+    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /*optLevel*/, ZSTD_noDict);
+}
+
+
+/* used in 2-pass strategy */
+static U32 ZSTD_upscaleStat(unsigned* table, U32 lastEltIndex, int bonus)
+{
+    U32 s, sum=0;
+    assert(ZSTD_FREQ_DIV+bonus >= 0);
+    for (s=0; s<lastEltIndex+1; s++) {
+        table[s] <<= ZSTD_FREQ_DIV+bonus;
+        table[s]--;
+        sum += table[s];
+    }
+    return sum;
+}
+
+/* used in 2-pass strategy */
+MEM_STATIC void ZSTD_upscaleStats(optState_t* optPtr)
+{
+    if (ZSTD_compressedLiterals(optPtr))
+        optPtr->litSum = ZSTD_upscaleStat(optPtr->litFreq, MaxLit, 0);
+    optPtr->litLengthSum = ZSTD_upscaleStat(optPtr->litLengthFreq, MaxLL, 0);
+    optPtr->matchLengthSum = ZSTD_upscaleStat(optPtr->matchLengthFreq, MaxML, 0);
+    optPtr->offCodeSum = ZSTD_upscaleStat(optPtr->offCodeFreq, MaxOff, 0);
+}
+
+/* ZSTD_initStats_ultra():
+ * make a first compression pass, just to seed stats with more accurate starting values.
+ * only works on first block, with no dictionary and no ldm.
+ * this function cannot error, hence its contract must be respected.
+ */
+static void
+ZSTD_initStats_ultra(ZSTD_matchState_t* ms,
+                     seqStore_t* seqStore,
+                     U32 rep[ZSTD_REP_NUM],
+               const void* src, size_t srcSize)
+{
+    U32 tmpRep[ZSTD_REP_NUM];  /* updated rep codes will sink here */
+    memcpy(tmpRep, rep, sizeof(tmpRep));
+
+    DEBUGLOG(4, "ZSTD_initStats_ultra (srcSize=%zu)", srcSize);
+    assert(ms->opt.litLengthSum == 0);    /* first block */
+    assert(seqStore->sequences == seqStore->sequencesStart);   /* no ldm */
+    assert(ms->window.dictLimit == ms->window.lowLimit);   /* no dictionary */
+    assert(ms->window.dictLimit - ms->nextToUpdate <= 1);  /* no prefix (note: intentional overflow, defined as 2-complement) */
+
+    ZSTD_compressBlock_opt_generic(ms, seqStore, tmpRep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict);   /* generate stats into ms->opt*/
+
+    /* invalidate first scan from history */
+    ZSTD_resetSeqStore(seqStore);
+    ms->window.base -= srcSize;
+    ms->window.dictLimit += (U32)srcSize;
+    ms->window.lowLimit = ms->window.dictLimit;
+    ms->nextToUpdate = ms->window.dictLimit;
+
+    /* re-inforce weight of collected statistics */
+    ZSTD_upscaleStats(&ms->opt);
+}
+
+size_t ZSTD_compressBlock_btultra(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        const void* src, size_t srcSize)
+{
+    DEBUGLOG(5, "ZSTD_compressBlock_btultra (srcSize=%zu)", srcSize);
+    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict);
+}
+
+size_t ZSTD_compressBlock_btultra2(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        const void* src, size_t srcSize)
+{
+    U32 const current = (U32)((const BYTE*)src - ms->window.base);
+    DEBUGLOG(5, "ZSTD_compressBlock_btultra2 (srcSize=%zu)", srcSize);
+
+    /* 2-pass strategy:
+     * this strategy makes a first pass over first block to collect statistics
+     * and seed next round's statistics with it.
+     * After 1st pass, function forgets everything, and starts a new block.
+     * Consequently, this can only work if no data has been previously loaded in tables,
+     * aka, no dictionary, no prefix, no ldm preprocessing.
+     * The compression ratio gain is generally small (~0.5% on first block),
+     * the cost is 2x cpu time on first block. */
+    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
+    if ( (ms->opt.litLengthSum==0)   /* first block */
+      && (seqStore->sequences == seqStore->sequencesStart)  /* no ldm */
+      && (ms->window.dictLimit == ms->window.lowLimit)   /* no dictionary */
+      && (current == ms->window.dictLimit)   /* start of frame, nothing already loaded nor skipped */
+      && (srcSize > ZSTD_PREDEF_THRESHOLD)
+      ) {
+        ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize);
+    }
+
+    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_noDict);
+}
+
+size_t ZSTD_compressBlock_btopt_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        const void* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /*optLevel*/, ZSTD_dictMatchState);
+}
+
+size_t ZSTD_compressBlock_btultra_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        const void* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_dictMatchState);
+}
+
+size_t ZSTD_compressBlock_btopt_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        const void* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /*optLevel*/, ZSTD_extDict);
+}
+
+size_t ZSTD_compressBlock_btultra_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        const void* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /*optLevel*/, ZSTD_extDict);
+}
+
+/* note : no btultra2 variant for extDict nor dictMatchState,
+ * because btultra2 is not meant to work with dictionaries
+ * and is only specific for the first block (no prefix) */
diff --git a/src/zstd_opt.h b/src/zstd_opt.h
new file mode 100644
index 0000000..094f747
--- /dev/null
+++ b/src/zstd_opt.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_OPT_H
+#define ZSTD_OPT_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "zstd_compress_internal.h"
+
+/* used in ZSTD_loadDictionaryContent() */
+void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend);
+
+size_t ZSTD_compressBlock_btopt(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_btultra(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_btultra2(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+
+size_t ZSTD_compressBlock_btopt_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_btultra_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+size_t ZSTD_compressBlock_btopt_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+size_t ZSTD_compressBlock_btultra_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize);
+
+        /* note : no btultra2 variant for extDict nor dictMatchState,
+         * because btultra2 is not meant to work with dictionaries
+         * and is only specific for the first block (no prefix) */
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_OPT_H */
diff --git a/src/zstd_v01.c b/src/zstd_v01.c
new file mode 100644
index 0000000..ae8cba2
--- /dev/null
+++ b/src/zstd_v01.c
@@ -0,0 +1,2152 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/******************************************
+*  Includes
+******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include "zstd_v01.h"
+#include "error_private.h"
+
+
+/******************************************
+*  Static allocation
+******************************************/
+/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+/* You can statically allocate Huff0 DTable as a table of unsigned short using below macro */
+#define HUF_DTABLE_SIZE_U16(maxTableLog)   (1 + (1<<maxTableLog))
+#define HUF_CREATE_STATIC_DTABLE(DTable, maxTableLog) \
+        unsigned short DTable[HUF_DTABLE_SIZE_U16(maxTableLog)] = { maxTableLog }
+
+
+/******************************************
+*  Error Management
+******************************************/
+#define FSE_LIST_ERRORS(ITEM) \
+        ITEM(FSE_OK_NoError) ITEM(FSE_ERROR_GENERIC) \
+        ITEM(FSE_ERROR_tableLog_tooLarge) ITEM(FSE_ERROR_maxSymbolValue_tooLarge) ITEM(FSE_ERROR_maxSymbolValue_tooSmall) \
+        ITEM(FSE_ERROR_dstSize_tooSmall) ITEM(FSE_ERROR_srcSize_wrong)\
+        ITEM(FSE_ERROR_corruptionDetected) \
+        ITEM(FSE_ERROR_maxCode)
+
+#define FSE_GENERATE_ENUM(ENUM) ENUM,
+typedef enum { FSE_LIST_ERRORS(FSE_GENERATE_ENUM) } FSE_errorCodes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
+
+
+/******************************************
+*  FSE symbol compression API
+******************************************/
+/*
+   This API consists of small unitary functions, which highly benefit from being inlined.
+   You will want to enable link-time-optimization to ensure these functions are properly inlined in your binary.
+   Visual seems to do it automatically.
+   For gcc or clang, you'll need to add -flto flag at compilation and linking stages.
+   If none of these solutions is applicable, include "fse.c" directly.
+*/
+
+typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+
+typedef struct
+{
+    size_t bitContainer;
+    int    bitPos;
+    char*  startPtr;
+    char*  ptr;
+    char*  endPtr;
+} FSE_CStream_t;
+
+typedef struct
+{
+    ptrdiff_t   value;
+    const void* stateTable;
+    const void* symbolTT;
+    unsigned    stateLog;
+} FSE_CState_t;
+
+typedef struct
+{
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+} FSE_DStream_t;
+
+typedef struct
+{
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSE_DState_t;
+
+typedef enum { FSE_DStream_unfinished = 0,
+               FSE_DStream_endOfBuffer = 1,
+               FSE_DStream_completed = 2,
+               FSE_DStream_tooFar = 3 } FSE_DStream_status;  /* result of FSE_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... ?! */
+
+
+/****************************************************************
+*  Tuning parameters
+****************************************************************/
+/* MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#define FSE_MAX_MEMORY_USAGE 14
+#define FSE_DEFAULT_MEMORY_USAGE 13
+
+/* FSE_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#define FSE_MAX_SYMBOL_VALUE 255
+
+
+/****************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSE_FUNCTION_TYPE BYTE
+#define FSE_FUNCTION_EXTENSION
+
+
+/****************************************************************
+*  Byte symbol type
+****************************************************************/
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSE_decode_t;   /* size == U32 */
+
+
+
+/****************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  define FORCE_INLINE static __forceinline
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#else
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/****************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+
+#ifndef MEM_ACCESS_MODULE
+#define MEM_ACCESS_MODULE
+/****************************************************************
+*  Basic Types
+*****************************************************************/
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+# include <stdint.h>
+typedef  uint8_t BYTE;
+typedef uint16_t U16;
+typedef  int16_t S16;
+typedef uint32_t U32;
+typedef  int32_t S32;
+typedef uint64_t U64;
+typedef  int64_t S64;
+#else
+typedef unsigned char       BYTE;
+typedef unsigned short      U16;
+typedef   signed short      S16;
+typedef unsigned int        U32;
+typedef   signed int        S32;
+typedef unsigned long long  U64;
+typedef   signed long long  S64;
+#endif
+
+#endif   /* MEM_ACCESS_MODULE */
+
+/****************************************************************
+*  Memory I/O
+*****************************************************************/
+/* FSE_FORCE_MEMORY_ACCESS
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets generating assembly depending on alignment.
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef FSE_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define FSE_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#    define FSE_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+
+static unsigned FSE_32bits(void)
+{
+    return sizeof(void*)==4;
+}
+
+static unsigned FSE_isLittleEndian(void)
+{
+    const union { U32 i; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_FORCE_MEMORY_ACCESS==2)
+
+static U16 FSE_read16(const void* memPtr) { return *(const U16*) memPtr; }
+static U32 FSE_read32(const void* memPtr) { return *(const U32*) memPtr; }
+static U64 FSE_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+#elif defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
+
+static U16 FSE_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
+static U32 FSE_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+static U64 FSE_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+#else
+
+static U16 FSE_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+static U32 FSE_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+static U64 FSE_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+#endif // FSE_FORCE_MEMORY_ACCESS
+
+static U16 FSE_readLE16(const void* memPtr)
+{
+    if (FSE_isLittleEndian())
+        return FSE_read16(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+static U32 FSE_readLE32(const void* memPtr)
+{
+    if (FSE_isLittleEndian())
+        return FSE_read32(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
+    }
+}
+
+
+static U64 FSE_readLE64(const void* memPtr)
+{
+    if (FSE_isLittleEndian())
+        return FSE_read64(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
+    }
+}
+
+static size_t FSE_readLEST(const void* memPtr)
+{
+    if (FSE_32bits())
+        return (size_t)FSE_readLE32(memPtr);
+    else
+        return (size_t)FSE_readLE64(memPtr);
+}
+
+
+
+/****************************************************************
+*  Constants
+*****************************************************************/
+#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
+#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
+#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
+#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
+#define FSE_MIN_TABLELOG 5
+
+#define FSE_TABLELOG_ABSOLUTE_MAX 15
+#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
+#error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+
+/****************************************************************
+*  Error Management
+****************************************************************/
+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/****************************************************************
+*  Complex types
+****************************************************************/
+typedef struct
+{
+    int deltaFindState;
+    U32 deltaNbBits;
+} FSE_symbolCompressionTransform; /* total 8 bytes */
+
+typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
+
+/****************************************************************
+*  Internal functions
+****************************************************************/
+FORCE_INLINE unsigned FSE_highbit32 (U32 val)
+{
+#   if defined(_MSC_VER)   /* Visual */
+    unsigned long r;
+    _BitScanReverse ( &r, val );
+    return (unsigned) r;
+#   elif defined(__GNUC__) && (GCC_VERSION >= 304)   /* GCC Intrinsic */
+    return 31 - __builtin_clz (val);
+#   else   /* Software version */
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+    U32 v = val;
+    unsigned r;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+    return r;
+#   endif
+}
+
+
+/****************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSE_FUNCTION_EXTENSION
+#  error "FSE_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSE_FUNCTION_TYPE
+#  error "FSE_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSE_CAT(X,Y) X##Y
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
+
+
+
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
+
+#define FSE_DECODE_TYPE FSE_decode_t
+
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSE_DTableHeader;   /* sizeof U32 */
+
+static size_t FSE_buildDTable
+(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)(ptr) + 1;   /* because dt is unsigned, 32-bits aligned on 32-bits */
+    const U32 tableSize = 1 << tableLog;
+    const U32 tableMask = tableSize-1;
+    const U32 step = FSE_tableStep(tableSize);
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
+    U32 position = 0;
+    U32 highThreshold = tableSize-1;
+    const S16 largeLimit= (S16)(1 << (tableLog-1));
+    U32 noLarge = 1;
+    U32 s;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return (size_t)-FSE_ERROR_maxSymbolValue_tooLarge;
+    if (tableLog > FSE_MAX_TABLELOG) return (size_t)-FSE_ERROR_tableLog_tooLarge;
+
+    /* Init, lay down lowprob symbols */
+    DTableH[0].tableLog = (U16)tableLog;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        if (normalizedCounter[s]==-1)
+        {
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
+            symbolNext[s] = 1;
+        }
+        else
+        {
+            if (normalizedCounter[s] >= largeLimit) noLarge=0;
+            symbolNext[s] = normalizedCounter[s];
+        }
+    }
+
+    /* Spread symbols */
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        int i;
+        for (i=0; i<normalizedCounter[s]; i++)
+        {
+            tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
+            position = (position + step) & tableMask;
+            while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }
+    }
+
+    if (position!=0) return (size_t)-FSE_ERROR_GENERIC;   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+
+    /* Build Decoding table */
+    {
+        U32 i;
+        for (i=0; i<tableSize; i++)
+        {
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
+            U16 nextState = symbolNext[symbol]++;
+            tableDecode[i].nbBits = (BYTE) (tableLog - FSE_highbit32 ((U32)nextState) );
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
+        }
+    }
+
+    DTableH->fastMode = (U16)noLarge;
+    return 0;
+}
+
+
+/******************************************
+*  FSE byte symbol
+******************************************/
+#ifndef FSE_COMMONDEFS_ONLY
+
+static unsigned FSE_isError(size_t code) { return (code > (size_t)(-FSE_ERROR_maxCode)); }
+
+static short FSE_abs(short a)
+{
+    return a<0? -a : a;
+}
+
+
+/****************************************************************
+*  Header bitstream management
+****************************************************************/
+static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) return (size_t)-FSE_ERROR_srcSize_wrong;
+    bitStream = FSE_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return (size_t)-FSE_ERROR_tableLog_tooLarge;
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) && (charnum<=*maxSVPtr))
+    {
+        if (previous0)
+        {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF)
+            {
+                n0+=24;
+                if (ip < iend-5)
+                {
+                    ip+=2;
+                    bitStream = FSE_readLE32(ip) >> bitCount;
+                }
+                else
+                {
+                    bitStream >>= 16;
+                    bitCount+=16;
+                }
+            }
+            while ((bitStream & 3) == 3)
+            {
+                n0+=3;
+                bitStream>>=2;
+                bitCount+=2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return (size_t)-FSE_ERROR_maxSymbolValue_tooSmall;
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+            {
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = FSE_readLE32(ip) >> bitCount;
+            }
+            else
+                bitStream >>= 2;
+        }
+        {
+            const short max = (short)((2*threshold-1)-remaining);
+            short count;
+
+            if ((bitStream & (threshold-1)) < (U32)max)
+            {
+                count = (short)(bitStream & (threshold-1));
+                bitCount   += nbBits-1;
+            }
+            else
+            {
+                count = (short)(bitStream & (2*threshold-1));
+                if (count >= threshold) count -= max;
+                bitCount   += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= FSE_abs(count);
+            normalizedCounter[charnum++] = count;
+            previous0 = !count;
+            while (remaining < threshold)
+            {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            {
+                if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+                {
+                    ip += bitCount>>3;
+                    bitCount &= 7;
+                }
+                else
+                {
+                    bitCount -= (int)(8 * (iend - 4 - ip));
+                    ip = iend - 4;
+                }
+                bitStream = FSE_readLE32(ip) >> (bitCount & 31);
+            }
+        }
+    }
+    if (remaining != 1) return (size_t)-FSE_ERROR_GENERIC;
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    if ((size_t)(ip-istart) > hbSize) return (size_t)-FSE_ERROR_srcSize_wrong;
+    return ip-istart;
+}
+
+
+/*********************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSymbolValue = tableMask;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return (size_t)-FSE_ERROR_GENERIC;             /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+
+/* FSE_initDStream
+ * Initialize a FSE_DStream_t.
+ * srcBuffer must point at the beginning of an FSE block.
+ * The function result is the size of the FSE_block (== srcSize).
+ * If srcSize is too small, the function will return an errorCode;
+ */
+static size_t FSE_initDStream(FSE_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) return (size_t)-FSE_ERROR_srcSize_wrong;
+
+    if (srcSize >=  sizeof(size_t))
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
+        bitD->bitContainer = FSE_readLEST(bitD->ptr);
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */
+        bitD->bitsConsumed = 8 - FSE_highbit32(contain32);
+    }
+    else
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
+                    /* fallthrough */
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
+                    /* fallthrough */
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
+                    /* fallthrough */
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
+                    /* fallthrough */
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
+                    /* fallthrough */
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
+                    /* fallthrough */
+            default:;
+        }
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */
+        bitD->bitsConsumed = 8 - FSE_highbit32(contain32);
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+
+
+/*!FSE_lookBits
+ * Provides next n bits from the bitContainer.
+ * bitContainer is not modified (bits are still present for next read/look)
+ * On 32-bits, maxNbBits==25
+ * On 64-bits, maxNbBits==57
+ * return : value extracted.
+ */
+static size_t FSE_lookBits(FSE_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
+}
+
+static size_t FSE_lookBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
+}
+
+static void FSE_skipBits(FSE_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+
+/*!FSE_readBits
+ * Read next n bits from the bitContainer.
+ * On 32-bits, don't read more than maxNbBits==25
+ * On 64-bits, don't read more than maxNbBits==57
+ * Use the fast variant *only* if n >= 1.
+ * return : value extracted.
+ */
+static size_t FSE_readBits(FSE_DStream_t* bitD, U32 nbBits)
+{
+    size_t value = FSE_lookBits(bitD, nbBits);
+    FSE_skipBits(bitD, nbBits);
+    return value;
+}
+
+static size_t FSE_readBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */
+{
+    size_t value = FSE_lookBitsFast(bitD, nbBits);
+    FSE_skipBits(bitD, nbBits);
+    return value;
+}
+
+static unsigned FSE_reloadDStream(FSE_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
+        return FSE_DStream_tooFar;
+
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
+    {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = FSE_readLEST(bitD->ptr);
+        return FSE_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start)
+    {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return FSE_DStream_endOfBuffer;
+        return FSE_DStream_completed;
+    }
+    {
+        U32 nbBytes = bitD->bitsConsumed >> 3;
+        U32 result = FSE_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start)
+        {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = FSE_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = FSE_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
+        return result;
+    }
+}
+
+
+static void FSE_initDState(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD, const FSE_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
+    DStatePtr->state = FSE_readBits(bitD, DTableH->tableLog);
+    FSE_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+static BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32  nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = FSE_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+static BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32 nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = FSE_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+/* FSE_endOfDStream
+   Tells if bitD has reached end of bitStream or not */
+
+static unsigned FSE_endOfDStream(const FSE_DStream_t* bitD)
+{
+    return ((bitD->ptr == bitD->start) && (bitD->bitsConsumed == sizeof(bitD->bitContainer)*8));
+}
+
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
+{
+    return DStatePtr->state == 0;
+}
+
+
+FORCE_INLINE size_t FSE_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSE_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    FSE_DStream_t bitD;
+    FSE_DState_t state1;
+    FSE_DState_t state2;
+    size_t errorCode;
+
+    /* Init */
+    errorCode = FSE_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
+    if (FSE_isError(errorCode)) return errorCode;
+
+    FSE_initDState(&state1, &bitD, dt);
+    FSE_initDState(&state2, &bitD, dt);
+
+#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (FSE_reloadDStream(&bitD)==FSE_DStream_unfinished) && (op<olimit) ; op+=4)
+    {
+        op[0] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            FSE_reloadDStream(&bitD);
+
+        op[1] = FSE_GETSYMBOL(&state2);
+
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (FSE_reloadDStream(&bitD) > FSE_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            FSE_reloadDStream(&bitD);
+
+        op[3] = FSE_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : FSE_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly FSE_DStream_completed */
+    while (1)
+    {
+        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state1);
+
+        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state2);
+    }
+
+    /* end ? */
+    if (FSE_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
+        return op-ostart;
+
+    if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall;   /* dst buffer is full, but cSrc unfinished */
+
+    return (size_t)-FSE_ERROR_corruptionDetected;
+}
+
+
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSE_DTable* dt)
+{
+    FSE_DTableHeader DTableH;
+    memcpy(&DTableH, dt, sizeof(DTableH));   /* memcpy() into local variable, to avoid strict aliasing warning */
+
+    /* select fast mode (static) */
+    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSE_MAX_SYMBOL_VALUE+1];
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+    size_t errorCode;
+
+    if (cSrcSize<2) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */
+
+    /* normal FSE decoding mode */
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+    if (FSE_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
+    if (FSE_isError(errorCode)) return errorCode;
+
+    /* always return, even if it is an error code */
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
+}
+
+
+
+/* *******************************************************
+*  Huff0 : Huffman block compression
+*********************************************************/
+#define HUF_MAX_SYMBOL_VALUE 255
+#define HUF_DEFAULT_TABLELOG  12       /* used by default, when not specified */
+#define HUF_MAX_TABLELOG  12           /* max possible tableLog; for allocation purpose; can be modified */
+#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
+#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)
+#  error "HUF_MAX_TABLELOG is too large !"
+#endif
+
+typedef struct HUF_CElt_s {
+  U16  val;
+  BYTE nbBits;
+} HUF_CElt ;
+
+typedef struct nodeElt_s {
+    U32 count;
+    U16 parent;
+    BYTE byte;
+    BYTE nbBits;
+} nodeElt;
+
+
+/* *******************************************************
+*  Huff0 : Huffman block decompression
+*********************************************************/
+typedef struct {
+    BYTE byte;
+    BYTE nbBits;
+} HUF_DElt;
+
+static size_t HUF_readDTable (U16* DTable, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];  /* large enough for values from 0 to 16 */
+    U32 weightTotal;
+    U32 maxBits;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+    U32 n;
+    U32 nextRankStart;
+    void* ptr = DTable+1;
+    HUF_DElt* const dt = (HUF_DElt*)ptr;
+
+    if (!srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
+    iSize = ip[0];
+
+    FSE_STATIC_ASSERT(sizeof(HUF_DElt) == sizeof(U16));   /* if compilation fails here, assertion is false */
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* should not be necessary, but some analyzer complain ... */
+    if (iSize >= 128)  /* special header */
+    {
+        if (iSize >= (242))   /* RLE */
+        {
+            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+            oSize = l[iSize-242];
+            memset(huffWeight, 1, sizeof(huffWeight));
+            iSize = 0;
+        }
+        else   /* Incompressible */
+        {
+            oSize = iSize - 127;
+            iSize = ((oSize+1)/2);
+            if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
+            ip += 1;
+            for (n=0; n<oSize; n+=2)
+            {
+                huffWeight[n]   = ip[n/2] >> 4;
+                huffWeight[n+1] = ip[n/2] & 15;
+            }
+        }
+    }
+    else  /* header compressed with FSE (normal case) */
+    {
+        if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
+        oSize = FSE_decompress(huffWeight, HUF_MAX_SYMBOL_VALUE, ip+1, iSize);   /* max 255 values decoded, last one is implied */
+        if (FSE_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankVal, 0, sizeof(rankVal));
+    weightTotal = 0;
+    for (n=0; n<oSize; n++)
+    {
+        if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return (size_t)-FSE_ERROR_corruptionDetected;
+        rankVal[huffWeight[n]]++;
+        weightTotal += (1 << huffWeight[n]) >> 1;
+    }
+    if (weightTotal == 0) return (size_t)-FSE_ERROR_corruptionDetected;
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    maxBits = FSE_highbit32(weightTotal) + 1;
+    if (maxBits > DTable[0]) return (size_t)-FSE_ERROR_tableLog_tooLarge;   /* DTable is too small */
+    DTable[0] = (U16)maxBits;
+    {
+        U32 total = 1 << maxBits;
+        U32 rest = total - weightTotal;
+        U32 verif = 1 << FSE_highbit32(rest);
+        U32 lastWeight = FSE_highbit32(rest) + 1;
+        if (verif != rest) return (size_t)-FSE_ERROR_corruptionDetected;    /* last value must be a clean power of 2 */
+        huffWeight[oSize] = (BYTE)lastWeight;
+        rankVal[lastWeight]++;
+    }
+
+    /* check tree construction validity */
+    if ((rankVal[1] < 2) || (rankVal[1] & 1)) return (size_t)-FSE_ERROR_corruptionDetected;   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* Prepare ranks */
+    nextRankStart = 0;
+    for (n=1; n<=maxBits; n++)
+    {
+        U32 current = nextRankStart;
+        nextRankStart += (rankVal[n] << (n-1));
+        rankVal[n] = current;
+    }
+
+    /* fill DTable */
+    for (n=0; n<=oSize; n++)
+    {
+        const U32 w = huffWeight[n];
+        const U32 length = (1 << w) >> 1;
+        U32 i;
+        HUF_DElt D;
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(maxBits + 1 - w);
+        for (i = rankVal[w]; i < rankVal[w] + length; i++)
+            dt[i] = D;
+        rankVal[w] += length;
+    }
+
+    return iSize+1;
+}
+
+
+static BYTE HUF_decodeSymbol(FSE_DStream_t* Dstream, const HUF_DElt* dt, const U32 dtLog)
+{
+        const size_t val = FSE_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+        const BYTE c = dt[val].byte;
+        FSE_skipBits(Dstream, dt[val].nbBits);
+        return c;
+}
+
+static size_t HUF_decompress_usingDTable(   /* -3% slower when non static */
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    if (cSrcSize < 6) return (size_t)-FSE_ERROR_srcSize_wrong;
+    {
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* op = ostart;
+        BYTE* const omax = op + maxDstSize;
+        BYTE* const olimit = omax-15;
+
+        const void* ptr = DTable;
+        const HUF_DElt* const dt = (const HUF_DElt*)(ptr)+1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+        U32 reloadStatus;
+
+        /* Init */
+
+        const U16* jumpTable = (const U16*)cSrc;
+        const size_t length1 = FSE_readLE16(jumpTable);
+        const size_t length2 = FSE_readLE16(jumpTable+1);
+        const size_t length3 = FSE_readLE16(jumpTable+2);
+        const size_t length4 = cSrcSize - 6 - length1 - length2 - length3;   // check coherency !!
+        const char* const start1 = (const char*)(cSrc) + 6;
+        const char* const start2 = start1 + length1;
+        const char* const start3 = start2 + length2;
+        const char* const start4 = start3 + length3;
+        FSE_DStream_t bitD1, bitD2, bitD3, bitD4;
+
+        if (length1+length2+length3+6 >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
+
+        errorCode = FSE_initDStream(&bitD1, start1, length1);
+        if (FSE_isError(errorCode)) return errorCode;
+        errorCode = FSE_initDStream(&bitD2, start2, length2);
+        if (FSE_isError(errorCode)) return errorCode;
+        errorCode = FSE_initDStream(&bitD3, start3, length3);
+        if (FSE_isError(errorCode)) return errorCode;
+        errorCode = FSE_initDStream(&bitD4, start4, length4);
+        if (FSE_isError(errorCode)) return errorCode;
+
+        reloadStatus=FSE_reloadDStream(&bitD2);
+
+        /* 16 symbols per loop */
+        for ( ; (reloadStatus<FSE_DStream_completed) && (op<olimit);  /* D2-3-4 are supposed to be synchronized and finish together */
+            op+=16, reloadStatus = FSE_reloadDStream(&bitD2) | FSE_reloadDStream(&bitD3) | FSE_reloadDStream(&bitD4), FSE_reloadDStream(&bitD1))
+        {
+    #define HUF_DECODE_SYMBOL_0(n, Dstream) \
+            op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog);
+
+    #define HUF_DECODE_SYMBOL_1(n, Dstream) \
+            op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \
+            if (FSE_32bits() && (HUF_MAX_TABLELOG>12)) FSE_reloadDStream(&Dstream)
+
+    #define HUF_DECODE_SYMBOL_2(n, Dstream) \
+            op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \
+            if (FSE_32bits()) FSE_reloadDStream(&Dstream)
+
+            HUF_DECODE_SYMBOL_1( 0, bitD1);
+            HUF_DECODE_SYMBOL_1( 1, bitD2);
+            HUF_DECODE_SYMBOL_1( 2, bitD3);
+            HUF_DECODE_SYMBOL_1( 3, bitD4);
+            HUF_DECODE_SYMBOL_2( 4, bitD1);
+            HUF_DECODE_SYMBOL_2( 5, bitD2);
+            HUF_DECODE_SYMBOL_2( 6, bitD3);
+            HUF_DECODE_SYMBOL_2( 7, bitD4);
+            HUF_DECODE_SYMBOL_1( 8, bitD1);
+            HUF_DECODE_SYMBOL_1( 9, bitD2);
+            HUF_DECODE_SYMBOL_1(10, bitD3);
+            HUF_DECODE_SYMBOL_1(11, bitD4);
+            HUF_DECODE_SYMBOL_0(12, bitD1);
+            HUF_DECODE_SYMBOL_0(13, bitD2);
+            HUF_DECODE_SYMBOL_0(14, bitD3);
+            HUF_DECODE_SYMBOL_0(15, bitD4);
+        }
+
+        if (reloadStatus!=FSE_DStream_completed)   /* not complete : some bitStream might be FSE_DStream_unfinished */
+            return (size_t)-FSE_ERROR_corruptionDetected;
+
+        /* tail */
+        {
+            // bitTail = bitD1;   // *much* slower : -20% !??!
+            FSE_DStream_t bitTail;
+            bitTail.ptr = bitD1.ptr;
+            bitTail.bitsConsumed = bitD1.bitsConsumed;
+            bitTail.bitContainer = bitD1.bitContainer;   // required in case of FSE_DStream_endOfBuffer
+            bitTail.start = start1;
+            for ( ; (FSE_reloadDStream(&bitTail) < FSE_DStream_completed) && (op<omax) ; op++)
+            {
+                HUF_DECODE_SYMBOL_0(0, bitTail);
+            }
+
+            if (FSE_endOfDStream(&bitTail))
+                return op-ostart;
+        }
+
+        if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall;   /* dst buffer is full, but cSrc unfinished */
+
+        return (size_t)-FSE_ERROR_corruptionDetected;
+    }
+}
+
+
+static size_t HUF_decompress (void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLE(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+    size_t errorCode;
+
+    errorCode = HUF_readDTable (DTable, cSrc, cSrcSize);
+    if (FSE_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUF_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, DTable);
+}
+
+
+#endif   /* FSE_COMMONDEFS_ONLY */
+
+/*
+    zstd - standard compression library
+    Copyright (C) 2014-2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/****************************************************************
+*  Tuning parameters
+*****************************************************************/
+/* MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect */
+#define ZSTD_MEMORY_USAGE 17
+
+
+/**************************************
+   CPU Feature Detection
+**************************************/
+/*
+ * Automated efficient unaligned memory access detection
+ * Based on known hardware architectures
+ * This list will be updated thanks to feedbacks
+ */
+#if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \
+    || defined(__ARM_FEATURE_UNALIGNED) \
+    || defined(__i386__) || defined(__x86_64__) \
+    || defined(_M_IX86) || defined(_M_X64) \
+    || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__) \
+    || (defined(_M_ARM) && (_M_ARM >= 7))
+#  define ZSTD_UNALIGNED_ACCESS 1
+#else
+#  define ZSTD_UNALIGNED_ACCESS 0
+#endif
+
+
+/********************************************************
+*  Includes
+*********************************************************/
+#include <stdlib.h>      /* calloc */
+#include <string.h>      /* memcpy, memmove */
+#include <stdio.h>       /* debug : printf */
+
+
+/********************************************************
+*  Compiler specifics
+*********************************************************/
+#ifdef __AVX2__
+#  include <immintrin.h>   /* AVX2 intrinsics */
+#endif
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#endif
+
+
+#ifndef MEM_ACCESS_MODULE
+#define MEM_ACCESS_MODULE
+/********************************************************
+*  Basic Types
+*********************************************************/
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+# include <stdint.h>
+typedef  uint8_t BYTE;
+typedef uint16_t U16;
+typedef  int16_t S16;
+typedef uint32_t U32;
+typedef  int32_t S32;
+typedef uint64_t U64;
+#else
+typedef unsigned char       BYTE;
+typedef unsigned short      U16;
+typedef   signed short      S16;
+typedef unsigned int        U32;
+typedef   signed int        S32;
+typedef unsigned long long  U64;
+#endif
+
+#endif   /* MEM_ACCESS_MODULE */
+
+
+/********************************************************
+*  Constants
+*********************************************************/
+static const U32 ZSTD_magicNumber = 0xFD2FB51E;   /* 3rd version : seqNb header */
+
+#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)
+#define HASH_TABLESIZE (1 << HASH_LOG)
+#define HASH_MASK (HASH_TABLESIZE - 1)
+
+#define KNUTH 2654435761
+
+#define BIT7 128
+#define BIT6  64
+#define BIT5  32
+#define BIT4  16
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
+
+#define WORKPLACESIZE (BLOCKSIZE*3)
+#define MINMATCH 4
+#define MLbits   7
+#define LLbits   6
+#define Offbits  5
+#define MaxML  ((1<<MLbits )-1)
+#define MaxLL  ((1<<LLbits )-1)
+#define MaxOff ((1<<Offbits)-1)
+#define LitFSELog  11
+#define MLFSELog   10
+#define LLFSELog   10
+#define OffFSELog   9
+#define MAX(a,b) ((a)<(b)?(b):(a))
+#define MaxSeq MAX(MaxLL, MaxML)
+
+#define LITERAL_NOENTROPY 63
+#define COMMAND_NOENTROPY 7   /* to remove */
+
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+
+static const size_t ZSTD_blockHeaderSize = 3;
+static const size_t ZSTD_frameHeaderSize = 4;
+
+
+/********************************************************
+*  Memory operations
+*********************************************************/
+static unsigned ZSTD_32bits(void) { return sizeof(void*)==4; }
+
+static unsigned ZSTD_isLittleEndian(void)
+{
+    const union { U32 i; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+static U16    ZSTD_read16(const void* p) { U16 r; memcpy(&r, p, sizeof(r)); return r; }
+
+static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+
+#define COPY8(d,s)    { ZSTD_copy8(d,s); d+=8; s+=8; }
+
+static void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length)
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+    while (op < oend) COPY8(op, ip);
+}
+
+static U16 ZSTD_readLE16(const void* memPtr)
+{
+    if (ZSTD_isLittleEndian()) return ZSTD_read16(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)((U16)p[0] + ((U16)p[1]<<8));
+    }
+}
+
+static U32 ZSTD_readLE24(const void* memPtr)
+{
+    return ZSTD_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
+}
+
+static U32 ZSTD_readBE32(const void* memPtr)
+{
+    const BYTE* p = (const BYTE*)memPtr;
+    return (U32)(((U32)p[0]<<24) + ((U32)p[1]<<16) + ((U32)p[2]<<8) + ((U32)p[3]<<0));
+}
+
+
+/**************************************
+*  Local structures
+***************************************/
+typedef struct ZSTD_Cctx_s ZSTD_Cctx;
+
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
+
+typedef struct
+{
+    blockType_t blockType;
+    U32 origSize;
+} blockProperties_t;
+
+typedef struct {
+    void* buffer;
+    U32*  offsetStart;
+    U32*  offset;
+    BYTE* offCodeStart;
+    BYTE* offCode;
+    BYTE* litStart;
+    BYTE* lit;
+    BYTE* litLengthStart;
+    BYTE* litLength;
+    BYTE* matchLengthStart;
+    BYTE* matchLength;
+    BYTE* dumpsStart;
+    BYTE* dumps;
+} seqStore_t;
+
+
+typedef struct ZSTD_Cctx_s
+{
+    const BYTE* base;
+    U32 current;
+    U32 nextUpdate;
+    seqStore_t seqStore;
+#ifdef __AVX2__
+    __m256i hashTable[HASH_TABLESIZE>>3];
+#else
+    U32 hashTable[HASH_TABLESIZE];
+#endif
+    BYTE buffer[WORKPLACESIZE];
+} cctxi_t;
+
+
+
+
+/**************************************
+*  Error Management
+**************************************/
+/* published entry point */
+unsigned ZSTDv01_isError(size_t code) { return ERR_isError(code); }
+
+
+/**************************************
+*  Tool functions
+**************************************/
+#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
+#define ZSTD_VERSION_MINOR    1    /* for new (non-breaking) interface capabilities */
+#define ZSTD_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
+
+/**************************************************************
+*   Decompression code
+**************************************************************/
+
+static size_t ZSTDv01_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
+{
+    const BYTE* const in = (const BYTE* const)src;
+    BYTE headerFlags;
+    U32 cSize;
+
+    if (srcSize < 3) return ERROR(srcSize_wrong);
+
+    headerFlags = *in;
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
+
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
+
+    if (bpPtr->blockType == bt_end) return 0;
+    if (bpPtr->blockType == bt_rle) return 1;
+    return cSize;
+}
+
+
+static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+
+static size_t ZSTD_decompressLiterals(void* ctx,
+                                      void* dst, size_t maxDstSize,
+                                const void* src, size_t srcSize)
+{
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + maxDstSize;
+    const BYTE* ip = (const BYTE*)src;
+    size_t errorCode;
+    size_t litSize;
+
+    /* check : minimum 2, for litSize, +1, for content */
+    if (srcSize <= 3) return ERROR(corruption_detected);
+
+    litSize = ip[1] + (ip[0]<<8);
+    litSize += ((ip[-3] >> 3) & 7) << 16;   // mmmmh....
+    op = oend - litSize;
+
+    (void)ctx;
+    if (litSize > maxDstSize) return ERROR(dstSize_tooSmall);
+    errorCode = HUF_decompress(op, litSize, ip+2, srcSize-2);
+    if (FSE_isError(errorCode)) return ERROR(GENERIC);
+    return litSize;
+}
+
+
+static size_t ZSTDv01_decodeLiteralsBlock(void* ctx,
+                                void* dst, size_t maxDstSize,
+                          const BYTE** litStart, size_t* litSize,
+                          const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* ip = istart;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* const oend = ostart + maxDstSize;
+    blockProperties_t litbp;
+
+    size_t litcSize = ZSTDv01_getcBlockSize(src, srcSize, &litbp);
+    if (ZSTDv01_isError(litcSize)) return litcSize;
+    if (litcSize > srcSize - ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
+    ip += ZSTD_blockHeaderSize;
+
+    switch(litbp.blockType)
+    {
+    case bt_raw:
+        *litStart = ip;
+        ip += litcSize;
+        *litSize = litcSize;
+        break;
+    case bt_rle:
+        {
+            size_t rleSize = litbp.origSize;
+            if (rleSize>maxDstSize) return ERROR(dstSize_tooSmall);
+            if (!srcSize) return ERROR(srcSize_wrong);
+            memset(oend - rleSize, *ip, rleSize);
+            *litStart = oend - rleSize;
+            *litSize = rleSize;
+            ip++;
+            break;
+        }
+    case bt_compressed:
+        {
+            size_t decodedLitSize = ZSTD_decompressLiterals(ctx, dst, maxDstSize, ip, litcSize);
+            if (ZSTDv01_isError(decodedLitSize)) return decodedLitSize;
+            *litStart = oend - decodedLitSize;
+            *litSize = decodedLitSize;
+            ip += litcSize;
+            break;
+        }
+    case bt_end:
+    default:
+        return ERROR(GENERIC);
+    }
+
+    return ip-istart;
+}
+
+
+static size_t ZSTDv01_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
+                         const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* ip = istart;
+    const BYTE* const iend = istart + srcSize;
+    U32 LLtype, Offtype, MLtype;
+    U32 LLlog, Offlog, MLlog;
+    size_t dumpsLength;
+
+    /* check */
+    if (srcSize < 5) return ERROR(srcSize_wrong);
+
+    /* SeqHead */
+    *nbSeq = ZSTD_readLE16(ip); ip+=2;
+    LLtype  = *ip >> 6;
+    Offtype = (*ip >> 4) & 3;
+    MLtype  = (*ip >> 2) & 3;
+    if (*ip & 2)
+    {
+        dumpsLength  = ip[2];
+        dumpsLength += ip[1] << 8;
+        ip += 3;
+    }
+    else
+    {
+        dumpsLength  = ip[1];
+        dumpsLength += (ip[0] & 1) << 8;
+        ip += 2;
+    }
+    *dumpsPtr = ip;
+    ip += dumpsLength;
+    *dumpsLengthPtr = dumpsLength;
+
+    /* check */
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
+
+    /* sequences */
+    {
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */
+        size_t headerSize;
+
+        /* Build DTables */
+        switch(LLtype)
+        {
+        case bt_rle :
+            LLlog = 0;
+            FSE_buildDTable_rle(DTableLL, *ip++); break;
+        case bt_raw :
+            LLlog = LLbits;
+            FSE_buildDTable_raw(DTableLL, LLbits); break;
+        default :
+            {   U32 max = MaxLL;
+                headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (LLlog > LLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableLL, norm, max, LLlog);
+        }   }
+
+        switch(Offtype)
+        {
+        case bt_rle :
+            Offlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableOffb, *ip++); break;
+        case bt_raw :
+            Offlog = Offbits;
+            FSE_buildDTable_raw(DTableOffb, Offbits); break;
+        default :
+            {   U32 max = MaxOff;
+                headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (Offlog > OffFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableOffb, norm, max, Offlog);
+        }   }
+
+        switch(MLtype)
+        {
+        case bt_rle :
+            MLlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableML, *ip++); break;
+        case bt_raw :
+            MLlog = MLbits;
+            FSE_buildDTable_raw(DTableML, MLbits); break;
+        default :
+            {   U32 max = MaxML;
+                headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (MLlog > MLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableML, norm, max, MLlog);
+    }   }   }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t offset;
+    size_t matchLength;
+} seq_t;
+
+typedef struct {
+    FSE_DStream_t DStream;
+    FSE_DState_t stateLL;
+    FSE_DState_t stateOffb;
+    FSE_DState_t stateML;
+    size_t prevOffset;
+    const BYTE* dumps;
+    const BYTE* dumpsEnd;
+} seqState_t;
+
+
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
+{
+    size_t litLength;
+    size_t prevOffset;
+    size_t offset;
+    size_t matchLength;
+    const BYTE* dumps = seqState->dumps;
+    const BYTE* const de = seqState->dumpsEnd;
+
+    /* Literal length */
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
+    prevOffset = litLength ? seq->offset : seqState->prevOffset;
+    seqState->prevOffset = seq->offset;
+    if (litLength == MaxLL)
+    {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) litLength += add;
+        else
+        {
+            if (dumps<=(de-3))
+            {
+                litLength = ZSTD_readLE24(dumps);
+                dumps += 3;
+            }
+        }
+    }
+
+    /* Offset */
+    {
+        U32 offsetCode, nbBits;
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));
+        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream));
+        nbBits = offsetCode - 1;
+        if (offsetCode==0) nbBits = 0;   /* cmove */
+        offset = ((size_t)1 << (nbBits & ((sizeof(offset)*8)-1))) + FSE_readBits(&(seqState->DStream), nbBits);
+        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream));
+        if (offsetCode==0) offset = prevOffset;
+    }
+
+    /* MatchLength */
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
+    if (matchLength == MaxML)
+    {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) matchLength += add;
+        else
+        {
+            if (dumps<=(de-3))
+            {
+                matchLength = ZSTD_readLE24(dumps);
+                dumps += 3;
+            }
+        }
+    }
+    matchLength += MINMATCH;
+
+    /* save result */
+    seq->litLength = litLength;
+    seq->offset = offset;
+    seq->matchLength = matchLength;
+    seqState->dumps = dumps;
+}
+
+
+static size_t ZSTD_execSequence(BYTE* op,
+                                seq_t sequence,
+                                const BYTE** litPtr, const BYTE* const litLimit,
+                                BYTE* const base, BYTE* const oend)
+{
+    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */
+    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* subtracted */
+    const BYTE* const ostart = op;
+    const size_t litLength = sequence.litLength;
+    BYTE* const endMatch = op + litLength + sequence.matchLength;    /* risk : address space overflow (32-bits) */
+    const BYTE* const litEnd = *litPtr + litLength;
+
+    /* check */
+    if (endMatch > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
+    if (litEnd > litLimit) return ERROR(corruption_detected);
+    if (sequence.matchLength > (size_t)(*litPtr-op))  return ERROR(dstSize_tooSmall);    /* overwrite literal segment */
+
+    /* copy Literals */
+    if (((size_t)(*litPtr - op) < 8) || ((size_t)(oend-litEnd) < 8) || (op+litLength > oend-8))
+        memmove(op, *litPtr, litLength);   /* overwrite risk */
+    else
+        ZSTD_wildcopy(op, *litPtr, litLength);
+    op += litLength;
+    *litPtr = litEnd;   /* update for next sequence */
+
+    /* check : last match must be at a minimum distance of 8 from end of dest buffer */
+    if (oend-op < 8) return ERROR(dstSize_tooSmall);
+
+    /* copy Match */
+    {
+        const U32 overlapRisk = (((size_t)(litEnd - endMatch)) < 12);
+        const BYTE* match = op - sequence.offset;            /* possible underflow at op - offset ? */
+        size_t qutt = 12;
+        U64 saved[2];
+
+        /* check */
+        if (match < base) return ERROR(corruption_detected);
+        if (sequence.offset > (size_t)base) return ERROR(corruption_detected);
+
+        /* save beginning of literal sequence, in case of write overlap */
+        if (overlapRisk)
+        {
+            if ((endMatch + qutt) > oend) qutt = oend-endMatch;
+            memcpy(saved, endMatch, qutt);
+        }
+
+        if (sequence.offset < 8)
+        {
+            const int dec64 = dec64table[sequence.offset];
+            op[0] = match[0];
+            op[1] = match[1];
+            op[2] = match[2];
+            op[3] = match[3];
+            match += dec32table[sequence.offset];
+            ZSTD_copy4(op+4, match);
+            match -= dec64;
+        } else { ZSTD_copy8(op, match); }
+        op += 8; match += 8;
+
+        if (endMatch > oend-(16-MINMATCH))
+        {
+            if (op < oend-8)
+            {
+                ZSTD_wildcopy(op, match, (oend-8) - op);
+                match += (oend-8) - op;
+                op = oend-8;
+            }
+            while (op<endMatch) *op++ = *match++;
+        }
+        else
+            ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
+
+        /* restore, in case of overlap */
+        if (overlapRisk) memcpy(endMatch, saved, qutt);
+    }
+
+    return endMatch-ostart;
+}
+
+typedef struct ZSTDv01_Dctx_s
+{
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
+    void* previousDstEnd;
+    void* base;
+    size_t expected;
+    blockType_t bType;
+    U32 phase;
+} dctx_t;
+
+
+static size_t ZSTD_decompressSequences(
+                               void* ctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize,
+                         const BYTE* litStart, size_t litSize)
+{
+    dctx_t* dctx = (dctx_t*)ctx;
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t errorCode, dumpsLength;
+    const BYTE* litPtr = litStart;
+    const BYTE* const litEnd = litStart + litSize;
+    int nbSeq;
+    const BYTE* dumps;
+    U32* DTableLL = dctx->LLTable;
+    U32* DTableML = dctx->MLTable;
+    U32* DTableOffb = dctx->OffTable;
+    BYTE* const base = (BYTE*) (dctx->base);
+
+    /* Build Decoding Tables */
+    errorCode = ZSTDv01_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
+                                      DTableLL, DTableML, DTableOffb,
+                                      ip, iend-ip);
+    if (ZSTDv01_isError(errorCode)) return errorCode;
+    ip += errorCode;
+
+    /* Regen sequences */
+    {
+        seq_t sequence;
+        seqState_t seqState;
+
+        memset(&sequence, 0, sizeof(sequence));
+        seqState.dumps = dumps;
+        seqState.dumpsEnd = dumps + dumpsLength;
+        seqState.prevOffset = 1;
+        errorCode = FSE_initDStream(&(seqState.DStream), ip, iend-ip);
+        if (FSE_isError(errorCode)) return ERROR(corruption_detected);
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
+
+        for ( ; (FSE_reloadDStream(&(seqState.DStream)) <= FSE_DStream_completed) && (nbSeq>0) ; )
+        {
+            size_t oneSeqSize;
+            nbSeq--;
+            ZSTD_decodeSequence(&sequence, &seqState);
+            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend);
+            if (ZSTDv01_isError(oneSeqSize)) return oneSeqSize;
+            op += oneSeqSize;
+        }
+
+        /* check if reached exact end */
+        if ( !FSE_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */
+        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */
+
+        /* last literal segment */
+        {
+            size_t lastLLSize = litEnd - litPtr;
+            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
+            if (op != litPtr) memmove(op, litPtr, lastLLSize);
+            op += lastLLSize;
+        }
+    }
+
+    return op-ostart;
+}
+
+
+static size_t ZSTD_decompressBlock(
+                            void* ctx,
+                            void* dst, size_t maxDstSize,
+                      const void* src, size_t srcSize)
+{
+    /* blockType == blockCompressed, srcSize is trusted */
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* litPtr = NULL;
+    size_t litSize = 0;
+    size_t errorCode;
+
+    /* Decode literals sub-block */
+    errorCode = ZSTDv01_decodeLiteralsBlock(ctx, dst, maxDstSize, &litPtr, &litSize, src, srcSize);
+    if (ZSTDv01_isError(errorCode)) return errorCode;
+    ip += errorCode;
+    srcSize -= errorCode;
+
+    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize, litPtr, litSize);
+}
+
+
+size_t ZSTDv01_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* iend = ip + srcSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t remainingSize = srcSize;
+    U32 magicNumber;
+    size_t errorCode=0;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
+    magicNumber = ZSTD_readBE32(src);
+    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t blockSize = ZSTDv01_getcBlockSize(ip, iend-ip, &blockProperties);
+        if (ZSTDv01_isError(blockSize)) return blockSize;
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (blockSize > remainingSize) return ERROR(srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            errorCode = ZSTD_decompressBlock(ctx, op, oend-op, ip, blockSize);
+            break;
+        case bt_raw :
+            errorCode = ZSTD_copyUncompressedBlock(op, oend-op, ip, blockSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet supported */
+            break;
+        case bt_end :
+            /* end of frame */
+            if (remainingSize) return ERROR(srcSize_wrong);
+            break;
+        default:
+            return ERROR(GENERIC);
+        }
+        if (blockSize == 0) break;   /* bt_end */
+
+        if (ZSTDv01_isError(errorCode)) return errorCode;
+        op += errorCode;
+        ip += blockSize;
+        remainingSize -= blockSize;
+    }
+
+    return op-ostart;
+}
+
+size_t ZSTDv01_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    dctx_t ctx;
+    ctx.base = dst;
+    return ZSTDv01_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);
+}
+
+/* ZSTD_errorFrameSizeInfoLegacy() :
+   assumes `cSize` and `dBound` are _not_ NULL */
+static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
+{
+    *cSize = ret;
+    *dBound = ZSTD_CONTENTSIZE_ERROR;
+}
+
+void ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t remainingSize = srcSize;
+    size_t nbBlocks = 0;
+    U32 magicNumber;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+        return;
+    }
+    magicNumber = ZSTD_readBE32(src);
+    if (magicNumber != ZSTD_magicNumber) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));
+        return;
+    }
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t blockSize = ZSTDv01_getcBlockSize(ip, remainingSize, &blockProperties);
+        if (ZSTDv01_isError(blockSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, blockSize);
+            return;
+        }
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (blockSize > remainingSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+
+        if (blockSize == 0) break;   /* bt_end */
+
+        ip += blockSize;
+        remainingSize -= blockSize;
+        nbBlocks++;
+    }
+
+    *cSize = ip - (const BYTE*)src;
+    *dBound = nbBlocks * BLOCKSIZE;
+}
+
+/*******************************
+*  Streaming Decompression API
+*******************************/
+
+size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx)
+{
+    dctx->expected = ZSTD_frameHeaderSize;
+    dctx->phase = 0;
+    dctx->previousDstEnd = NULL;
+    dctx->base = NULL;
+    return 0;
+}
+
+ZSTDv01_Dctx* ZSTDv01_createDCtx(void)
+{
+    ZSTDv01_Dctx* dctx = (ZSTDv01_Dctx*)malloc(sizeof(ZSTDv01_Dctx));
+    if (dctx==NULL) return NULL;
+    ZSTDv01_resetDCtx(dctx);
+    return dctx;
+}
+
+size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx)
+{
+    free(dctx);
+    return 0;
+}
+
+size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx)
+{
+    return ((dctx_t*)dctx)->expected;
+}
+
+size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    dctx_t* ctx = (dctx_t*)dctx;
+
+    /* Sanity check */
+    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
+    if (dst != ctx->previousDstEnd)  /* not contiguous */
+        ctx->base = dst;
+
+    /* Decompress : frame header */
+    if (ctx->phase == 0)
+    {
+        /* Check frame magic header */
+        U32 magicNumber = ZSTD_readBE32(src);
+        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
+        ctx->phase = 1;
+        ctx->expected = ZSTD_blockHeaderSize;
+        return 0;
+    }
+
+    /* Decompress : block header */
+    if (ctx->phase == 1)
+    {
+        blockProperties_t bp;
+        size_t blockSize = ZSTDv01_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
+        if (ZSTDv01_isError(blockSize)) return blockSize;
+        if (bp.blockType == bt_end)
+        {
+            ctx->expected = 0;
+            ctx->phase = 0;
+        }
+        else
+        {
+            ctx->expected = blockSize;
+            ctx->bType = bp.blockType;
+            ctx->phase = 2;
+        }
+
+        return 0;
+    }
+
+    /* Decompress : block content */
+    {
+        size_t rSize;
+        switch(ctx->bType)
+        {
+        case bt_compressed:
+            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);
+            break;
+        case bt_raw :
+            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet handled */
+            break;
+        case bt_end :   /* should never happen (filtered at phase 1) */
+            rSize = 0;
+            break;
+        default:
+            return ERROR(GENERIC);
+        }
+        ctx->phase = 1;
+        ctx->expected = ZSTD_blockHeaderSize;
+        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);
+        return rSize;
+    }
+
+}
diff --git a/src/zstd_v01.h b/src/zstd_v01.h
new file mode 100644
index 0000000..245f9dd
--- /dev/null
+++ b/src/zstd_v01.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_V01_H_28739879432
+#define ZSTD_V01_H_28739879432
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stddef.h>   /* size_t */
+
+
+/* *************************************
+*  Simple one-step function
+***************************************/
+/**
+ZSTDv01_decompress() : decompress ZSTD frames compliant with v0.1.x format
+    compressedSize : is the exact source size
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
+                      It must be equal or larger than originalSize, otherwise decompression will fail.
+    return : the number of bytes decompressed into destination buffer (originalSize)
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
+*/
+size_t ZSTDv01_decompress( void* dst, size_t maxOriginalSize,
+                     const void* src, size_t compressedSize);
+
+ /**
+ ZSTDv01_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.1.x format
+     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
+     cSize (output parameter)  : the number of bytes that would be read to decompress this frame
+                                 or an error code if it fails (which can be tested using ZSTDv01_isError())
+     dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
+                                 or ZSTD_CONTENTSIZE_ERROR if an error occurs
+
+     note : assumes `cSize` and `dBound` are _not_ NULL.
+ */
+void ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
+                                     size_t* cSize, unsigned long long* dBound);
+
+/**
+ZSTDv01_isError() : tells if the result of ZSTDv01_decompress() is an error
+*/
+unsigned ZSTDv01_isError(size_t code);
+
+
+/* *************************************
+*  Advanced functions
+***************************************/
+typedef struct ZSTDv01_Dctx_s ZSTDv01_Dctx;
+ZSTDv01_Dctx* ZSTDv01_createDCtx(void);
+size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx);
+
+size_t ZSTDv01_decompressDCtx(void* ctx,
+                              void* dst, size_t maxOriginalSize,
+                        const void* src, size_t compressedSize);
+
+/* *************************************
+*  Streaming functions
+***************************************/
+size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx);
+
+size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx);
+size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+/**
+  Use above functions alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
+  Result is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
+*/
+
+/* *************************************
+*  Prefix - version detection
+***************************************/
+#define ZSTDv01_magicNumber   0xFD2FB51E   /* Big Endian version */
+#define ZSTDv01_magicNumberLE 0x1EB52FFD   /* Little Endian version */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_V01_H_28739879432 */
diff --git a/src/zstd_v02.c b/src/zstd_v02.c
new file mode 100644
index 0000000..793df60
--- /dev/null
+++ b/src/zstd_v02.c
@@ -0,0 +1,3513 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include "zstd_v02.h"
+#include "error_private.h"
+
+
+/******************************************
+*  Compiler-specific
+******************************************/
+#if defined(_MSC_VER)   /* Visual Studio */
+#   include <stdlib.h>  /* _byteswap_ulong */
+#   include <intrin.h>  /* _byteswap_* */
+#endif
+
+
+/* ******************************************************************
+   mem.h
+   low-level memory access routines
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef MEM_H_MODULE
+#define MEM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/******************************************
+*  Includes
+******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include <string.h>    /* memcpy */
+
+
+/******************************************
+*  Compiler-specific
+******************************************/
+#if defined(__GNUC__)
+#  define MEM_STATIC static __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define MEM_STATIC static inline
+#elif defined(_MSC_VER)
+#  define MEM_STATIC static __inline
+#else
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/****************************************************************
+*  Basic Types
+*****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+# include <stdint.h>
+  typedef  uint8_t BYTE;
+  typedef uint16_t U16;
+  typedef  int16_t S16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+  typedef  int64_t S64;
+#else
+  typedef unsigned char       BYTE;
+  typedef unsigned short      U16;
+  typedef   signed short      S16;
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+  typedef unsigned long long  U64;
+  typedef   signed long long  S64;
+#endif
+
+
+/****************************************************************
+*  Memory I/O
+*****************************************************************/
+/* MEM_FORCE_MEMORY_ACCESS
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets generating assembly depending on alignment.
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define MEM_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#    define MEM_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
+
+MEM_STATIC unsigned MEM_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
+
+/* violates C standard on structure alignment.
+Only use if no other choice to achieve best performance on target platform */
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
+
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
+
+#else
+
+/* default method, safe and standard.
+   can sometimes prove slower */
+
+MEM_STATIC U16 MEM_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U32 MEM_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U64 MEM_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+#endif // MEM_FORCE_MEMORY_ACCESS
+
+
+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read16(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
+{
+    if (MEM_isLittleEndian())
+    {
+        MEM_write16(memPtr, val);
+    }
+    else
+    {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE)val;
+        p[1] = (BYTE)(val>>8);
+    }
+}
+
+MEM_STATIC U32 MEM_readLE24(const void* memPtr)
+{
+    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
+}
+
+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read32(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
+    }
+}
+
+
+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read64(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
+    }
+}
+
+
+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readLE32(memPtr);
+    else
+        return (size_t)MEM_readLE64(memPtr);
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* MEM_H_MODULE */
+
+
+/* ******************************************************************
+   bitstream
+   Part of NewGen Entropy library
+   header file (to include)
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef BITSTREAM_H_MODULE
+#define BITSTREAM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*
+*  This API consists of small unitary functions, which highly benefit from being inlined.
+*  Since link-time-optimization is not available for all compilers,
+*  these functions are defined into a .h to be included.
+*/
+
+
+/**********************************************
+*  bitStream decompression API (read backward)
+**********************************************/
+typedef struct
+{
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+} BIT_DStream_t;
+
+typedef enum { BIT_DStream_unfinished = 0,
+               BIT_DStream_endOfBuffer = 1,
+               BIT_DStream_completed = 2,
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
+
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
+
+
+/******************************************
+*  unsafe API
+******************************************/
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
+/* faster, but works only if nbBits >= 1 */
+
+
+
+/****************************************************************
+*  Helper functions
+****************************************************************/
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
+{
+#   if defined(_MSC_VER)   /* Visual */
+    unsigned long r=0;
+    _BitScanReverse ( &r, val );
+    return (unsigned) r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+    return 31 - __builtin_clz (val);
+#   else   /* Software version */
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+    U32 v = val;
+    unsigned r;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+    return r;
+#   endif
+}
+
+
+
+/**********************************************************
+* bitStream decoding
+**********************************************************/
+
+/*!BIT_initDStream
+*  Initialize a BIT_DStream_t.
+*  @bitD : a pointer to an already allocated BIT_DStream_t structure
+*  @srcBuffer must point at the beginning of a bitStream
+*  @srcSize must be the exact size of the bitStream
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
+*/
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
+
+    if (srcSize >=  sizeof(size_t))   /* normal case */
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
+    }
+    else
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
+                    /* fallthrough */
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
+                    /* fallthrough */
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
+                    /* fallthrough */
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
+                    /* fallthrough */
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
+                    /* fallthrough */
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
+                    /* fallthrough */
+            default:;
+        }
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+
+MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
+}
+
+/*! BIT_lookBitsFast :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
+}
+
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    size_t value = BIT_lookBits(bitD, nbBits);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*!BIT_readBitsFast :
+*  unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
+{
+    size_t value = BIT_lookBitsFast(bitD, nbBits);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
+        return BIT_DStream_overflow;
+
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
+    {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        return BIT_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start)
+    {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
+        return BIT_DStream_completed;
+    }
+    {
+        U32 nbBytes = bitD->bitsConsumed >> 3;
+        BIT_DStream_status result = BIT_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start)
+        {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = BIT_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
+        return result;
+    }
+}
+
+/*! BIT_endOfDStream
+*   @return Tells if DStream has reached its exact end
+*/
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
+{
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* BITSTREAM_H_MODULE */
+/* ******************************************************************
+   Error codes and messages
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef ERROR_H_MODULE
+#define ERROR_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/******************************************
+*  Compiler-specific
+******************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define ERR_STATIC static inline
+#elif defined(_MSC_VER)
+#  define ERR_STATIC static __inline
+#elif defined(__GNUC__)
+#  define ERR_STATIC static __attribute__((unused))
+#else
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/******************************************
+*  Error Management
+******************************************/
+#define PREFIX(name) ZSTD_error_##name
+
+#define ERROR(name) (size_t)-PREFIX(name)
+
+#define ERROR_LIST(ITEM) \
+        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \
+        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \
+        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \
+        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \
+        ITEM(PREFIX(maxCode))
+
+#define ERROR_GENERATE_ENUM(ENUM) ENUM,
+typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
+
+#define ERROR_CONVERTTOSTRING(STRING) #STRING,
+#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)
+static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) };
+
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
+
+ERR_STATIC const char* ERR_getErrorName(size_t code)
+{
+    static const char* codeError = "Unspecified error code";
+    if (ERR_isError(code)) return ERR_strings[-(int)(code)];
+    return codeError;
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ERROR_H_MODULE */
+/*
+Constructor and Destructor of type FSE_CTable
+    Note that its size depends on 'tableLog' and 'maxSymbolValue' */
+typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+
+
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/******************************************
+*  Static allocation
+******************************************/
+/* FSE buffer bounds */
+#define FSE_NCOUNTBOUND 512
+#define FSE_BLOCKBOUND(size) (size + (size>>7))
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+
+/******************************************
+*  FSE advanced API
+******************************************/
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
+/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
+
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
+/* build a fake FSE_DTable, designed to always generate the same symbolValue */
+
+
+/******************************************
+*  FSE symbol decompression API
+******************************************/
+typedef struct
+{
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSE_DState_t;
+
+
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
+
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
+
+
+/******************************************
+*  FSE unsafe API
+******************************************/
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
+
+
+/******************************************
+*  Implementation of inline functions
+******************************************/
+
+/* decompression */
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSE_DTableHeader;   /* sizeof U32 */
+
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSE_decode_t;   /* size == U32 */
+
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
+{
+    FSE_DTableHeader DTableH;
+    memcpy(&DTableH, dt, sizeof(DTableH));
+    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);
+    BIT_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32  nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BIT_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32 nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BIT_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
+{
+    return DStatePtr->state == 0;
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/******************************************
+*  Static allocation macros
+******************************************/
+/* Huff0 buffer bounds */
+#define HUF_CTABLEBOUND 129
+#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */
+#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* static allocation of Huff0's DTable */
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */
+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+        unsigned short DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUF_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
+
+
+/******************************************
+*  Advanced functions
+******************************************/
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
+static size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* quad-symbols decoder */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+/*
+    zstd - standard compression library
+    Header File
+    Copyright (C) 2014-2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stddef.h>   /* size_t */
+
+
+/* *************************************
+*  Version
+***************************************/
+#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
+#define ZSTD_VERSION_MINOR    2    /* for new (non-breaking) interface capabilities */
+#define ZSTD_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
+
+
+/* *************************************
+*  Advanced functions
+***************************************/
+typedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */
+
+#if defined (__cplusplus)
+}
+#endif
+/*
+    zstd - standard compression library
+    Header File for static linking only
+    Copyright (C) 2014-2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* The objects defined into this file should be considered experimental.
+ * They are not labelled stable, as their prototype may change in the future.
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes.
+ */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Streaming functions
+***************************************/
+
+typedef struct ZSTD_DCtx_s ZSTD_DCtx;
+
+/*
+  Use above functions alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
+  Result is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
+*/
+
+/* *************************************
+*  Prefix - version detection
+***************************************/
+#define ZSTD_magicNumber 0xFD2FB522   /* v0.2 (current)*/
+
+
+#if defined (__cplusplus)
+}
+#endif
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+#ifndef FSE_COMMONDEFS_ONLY
+
+/****************************************************************
+*  Tuning parameters
+****************************************************************/
+/* MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#define FSE_MAX_MEMORY_USAGE 14
+#define FSE_DEFAULT_MEMORY_USAGE 13
+
+/* FSE_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#define FSE_MAX_SYMBOL_VALUE 255
+
+
+/****************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSE_FUNCTION_TYPE BYTE
+#define FSE_FUNCTION_EXTENSION
+
+
+/****************************************************************
+*  Byte symbol type
+****************************************************************/
+#endif   /* !FSE_COMMONDEFS_ONLY */
+
+
+/****************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  define FORCE_INLINE static __forceinline
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#else
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/****************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+/****************************************************************
+*  Constants
+*****************************************************************/
+#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
+#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
+#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
+#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
+#define FSE_MIN_TABLELOG 5
+
+#define FSE_TABLELOG_ABSOLUTE_MAX 15
+#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
+#error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+
+/****************************************************************
+*  Error Management
+****************************************************************/
+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/****************************************************************
+*  Complex types
+****************************************************************/
+typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
+
+
+/****************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSE_FUNCTION_EXTENSION
+#  error "FSE_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSE_FUNCTION_TYPE
+#  error "FSE_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSE_CAT(X,Y) X##Y
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
+
+
+/* Function templates */
+
+#define FSE_DECODE_TYPE FSE_decode_t
+
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
+
+static size_t FSE_buildDTable
+(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    void* ptr = dt+1;
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr;
+    FSE_DTableHeader DTableH;
+    const U32 tableSize = 1 << tableLog;
+    const U32 tableMask = tableSize-1;
+    const U32 step = FSE_tableStep(tableSize);
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
+    U32 position = 0;
+    U32 highThreshold = tableSize-1;
+    const S16 largeLimit= (S16)(1 << (tableLog-1));
+    U32 noLarge = 1;
+    U32 s;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+
+    /* Init, lay down lowprob symbols */
+    DTableH.tableLog = (U16)tableLog;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        if (normalizedCounter[s]==-1)
+        {
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
+            symbolNext[s] = 1;
+        }
+        else
+        {
+            if (normalizedCounter[s] >= largeLimit) noLarge=0;
+            symbolNext[s] = normalizedCounter[s];
+        }
+    }
+
+    /* Spread symbols */
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        int i;
+        for (i=0; i<normalizedCounter[s]; i++)
+        {
+            tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
+            position = (position + step) & tableMask;
+            while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }
+    }
+
+    if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+
+    /* Build Decoding table */
+    {
+        U32 i;
+        for (i=0; i<tableSize; i++)
+        {
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
+            U16 nextState = symbolNext[symbol]++;
+            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
+        }
+    }
+
+    DTableH.fastMode = (U16)noLarge;
+    memcpy(dt, &DTableH, sizeof(DTableH));   /* memcpy(), to avoid strict aliasing warnings */
+    return 0;
+}
+
+
+#ifndef FSE_COMMONDEFS_ONLY
+/******************************************
+*  FSE helper functions
+******************************************/
+static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
+
+
+/****************************************************************
+*  FSE NCount encoding-decoding
+****************************************************************/
+static short FSE_abs(short a)
+{
+    return (short)(a<0 ? -a : a);
+}
+
+static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) return ERROR(srcSize_wrong);
+    bitStream = MEM_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) && (charnum<=*maxSVPtr))
+    {
+        if (previous0)
+        {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF)
+            {
+                n0+=24;
+                if (ip < iend-5)
+                {
+                    ip+=2;
+                    bitStream = MEM_readLE32(ip) >> bitCount;
+                }
+                else
+                {
+                    bitStream >>= 16;
+                    bitCount+=16;
+                }
+            }
+            while ((bitStream & 3) == 3)
+            {
+                n0+=3;
+                bitStream>>=2;
+                bitCount+=2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+            {
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = MEM_readLE32(ip) >> bitCount;
+            }
+            else
+                bitStream >>= 2;
+        }
+        {
+            const short max = (short)((2*threshold-1)-remaining);
+            short count;
+
+            if ((bitStream & (threshold-1)) < (U32)max)
+            {
+                count = (short)(bitStream & (threshold-1));
+                bitCount   += nbBits-1;
+            }
+            else
+            {
+                count = (short)(bitStream & (2*threshold-1));
+                if (count >= threshold) count -= max;
+                bitCount   += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= FSE_abs(count);
+            normalizedCounter[charnum++] = count;
+            previous0 = !count;
+            while (remaining < threshold)
+            {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            {
+                if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+                {
+                    ip += bitCount>>3;
+                    bitCount &= 7;
+                }
+                else
+                {
+                    bitCount -= (int)(8 * (iend - 4 - ip));
+                    ip = iend - 4;
+                }
+                bitStream = MEM_readLE32(ip) >> (bitCount & 31);
+            }
+        }
+    }
+    if (remaining != 1) return ERROR(GENERIC);
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
+    return ip-istart;
+}
+
+
+/*********************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSymbolValue = tableMask;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+FORCE_INLINE size_t FSE_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSE_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    BIT_DStream_t bitD;
+    FSE_DState_t state1;
+    FSE_DState_t state2;
+    size_t errorCode;
+
+    /* Init */
+    errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
+    if (FSE_isError(errorCode)) return errorCode;
+
+    FSE_initDState(&state1, &bitD, dt);
+    FSE_initDState(&state2, &bitD, dt);
+
+#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op<olimit) ; op+=4)
+    {
+        op[0] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[1] = FSE_GETSYMBOL(&state2);
+
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[3] = FSE_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
+    while (1)
+    {
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state1);
+
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state2);
+    }
+
+    /* end ? */
+    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
+        return op-ostart;
+
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
+
+    return ERROR(corruption_detected);
+}
+
+
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSE_DTable* dt)
+{
+    FSE_DTableHeader DTableH;
+    memcpy(&DTableH, dt, sizeof(DTableH));
+
+    /* select fast mode (static) */
+    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSE_MAX_SYMBOL_VALUE+1];
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+    size_t errorCode;
+
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
+
+    /* normal FSE decoding mode */
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+    if (FSE_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
+    if (FSE_isError(errorCode)) return errorCode;
+
+    /* always return, even if it is an error code */
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
+}
+
+
+
+#endif   /* FSE_COMMONDEFS_ONLY */
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/****************************************************************
+*  Compiler specifics
+****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+/* inline is defined */
+#elif defined(_MSC_VER)
+#  define inline __inline
+#else
+#  define inline /* disable inline */
+#endif
+
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#endif
+
+
+/****************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+/****************************************************************
+*  Error Management
+****************************************************************/
+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/******************************************
+*  Helper functions
+******************************************/
+static unsigned HUF_isError(size_t code) { return ERR_isError(code); }
+
+#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
+#define HUF_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
+#define HUF_DEFAULT_TABLELOG  HUF_MAX_TABLELOG   /* tableLog by default, when not specified */
+#define HUF_MAX_SYMBOL_VALUE 255
+#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)
+#  error "HUF_MAX_TABLELOG is too large !"
+#endif
+
+
+
+/*********************************************************
+*  Huff0 : Huffman block decompression
+*********************************************************/
+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */
+
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */
+
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
+
+/*! HUF_readStats
+    Read compact Huffman tree, saved by HUF_writeCTable
+    @huffWeight : destination buffer
+    @return : size read from `src`
+*/
+static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                            U32* nbSymbolsPtr, U32* tableLogPtr,
+                            const void* src, size_t srcSize)
+{
+    U32 weightTotal;
+    U32 tableLog;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+    U32 n;
+
+    if (!srcSize) return ERROR(srcSize_wrong);
+    iSize = ip[0];
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
+
+    if (iSize >= 128)  /* special header */
+    {
+        if (iSize >= (242))   /* RLE */
+        {
+            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+            oSize = l[iSize-242];
+            memset(huffWeight, 1, hwSize);
+            iSize = 0;
+        }
+        else   /* Incompressible */
+        {
+            oSize = iSize - 127;
+            iSize = ((oSize+1)/2);
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+            if (oSize >= hwSize) return ERROR(corruption_detected);
+            ip += 1;
+            for (n=0; n<oSize; n+=2)
+            {
+                huffWeight[n]   = ip[n/2] >> 4;
+                huffWeight[n+1] = ip[n/2] & 15;
+            }
+        }
+    }
+    else  /* header compressed with FSE (normal case) */
+    {
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
+        if (FSE_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
+    weightTotal = 0;
+    for (n=0; n<oSize; n++)
+    {
+        if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+        rankStats[huffWeight[n]]++;
+        weightTotal += (1 << huffWeight[n]) >> 1;
+    }
+    if (weightTotal == 0) return ERROR(corruption_detected);
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    tableLog = BIT_highbit32(weightTotal) + 1;
+    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+    {
+        U32 total = 1 << tableLog;
+        U32 rest = total - weightTotal;
+        U32 verif = 1 << BIT_highbit32(rest);
+        U32 lastWeight = BIT_highbit32(rest) + 1;
+        if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
+        huffWeight[oSize] = (BYTE)lastWeight;
+        rankStats[lastWeight]++;
+    }
+
+    /* check tree construction validity */
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* results */
+    *nbSymbolsPtr = (U32)(oSize+1);
+    *tableLogPtr = tableLog;
+    return iSize+1;
+}
+
+
+/**************************/
+/* single-symbol decoding */
+/**************************/
+
+static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
+    U32 tableLog = 0;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize = ip[0];
+    U32 nbSymbols = 0;
+    U32 n;
+    U32 nextRankStart;
+    void* ptr = DTable+1;
+    HUF_DEltX2* const dt = (HUF_DEltX2*)ptr;
+
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */
+
+    /* Prepare ranks */
+    nextRankStart = 0;
+    for (n=1; n<=tableLog; n++)
+    {
+        U32 current = nextRankStart;
+        nextRankStart += (rankVal[n] << (n-1));
+        rankVal[n] = current;
+    }
+
+    /* fill DTable */
+    for (n=0; n<nbSymbols; n++)
+    {
+        const U32 w = huffWeight[n];
+        const U32 length = (1 << w) >> 1;
+        U32 i;
+        HUF_DEltX2 D;
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
+        for (i = rankVal[w]; i < rankVal[w] + length; i++)
+            dt[i] = D;
+        rankVal[w] += length;
+    }
+
+    return iSize;
+}
+
+static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)
+{
+        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+        const BYTE c = dt[val].byte;
+        BIT_skipBits(Dstream, dt[val].nbBits);
+        return c;
+}
+
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 4 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
+    {
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    /* no more data to retrieve from bitstream, hence no need to reload */
+    while (p < pEnd)
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    return pEnd-pStart;
+}
+
+
+static size_t HUF_decompress4X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+
+        const void* ptr = DTable;
+        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BIT_initDStream(&bitD1, istart1, length1);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD2, istart2, length2);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD3, istart3, length3);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD4, istart4, length4);
+        if (HUF_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
+        {
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+    size_t errorCode;
+
+    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);
+    if (HUF_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/***************************/
+/* double-symbols decoding */
+/***************************/
+
+static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,
+                           const U32* rankValOrigin, const int minWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
+                           U32 nbBitsBaseline, U16 baseSeq)
+{
+    HUF_DEltX4 DElt;
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
+    U32 s;
+
+    /* get pre-calculated rankVal */
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1)
+    {
+        U32 i, skipSize = rankVal[minWeight];
+        MEM_writeLE16(&(DElt.sequence), baseSeq);
+        DElt.nbBits   = (BYTE)(consumed);
+        DElt.length   = 1;
+        for (i = 0; i < skipSize; i++)
+            DTable[i] = DElt;
+    }
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */
+    {
+        const U32 symbol = sortedSymbols[s].symbol;
+        const U32 weight = sortedSymbols[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 length = 1 << (sizeLog-nbBits);
+        const U32 start = rankVal[weight];
+        U32 i = start;
+        const U32 end = start + length;
+
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
+        DElt.nbBits = (BYTE)(nbBits + consumed);
+        DElt.length = 2;
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
+
+        rankVal[weight] += length;
+    }
+}
+
+typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];
+
+static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32 nbBitsBaseline)
+{
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
+    const U32 minBits  = nbBitsBaseline - maxWeight;
+    U32 s;
+
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++)
+    {
+        const U16 symbol = sortedList[s].symbol;
+        const U32 weight = sortedList[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 start = rankVal[weight];
+        const U32 length = 1 << (targetLog-nbBits);
+
+        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */
+        {
+            U32 sortedRank;
+            int minWeight = nbBits + scaleLog;
+            if (minWeight < 1) minWeight = 1;
+            sortedRank = rankStart[minWeight];
+            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
+                           rankValOrigin[nbBits], minWeight,
+                           sortedList+sortedRank, sortedListSize-sortedRank,
+                           nbBitsBaseline, symbol);
+        }
+        else
+        {
+            U32 i;
+            const U32 end = start + length;
+            HUF_DEltX4 DElt;
+
+            MEM_writeLE16(&(DElt.sequence), symbol);
+            DElt.nbBits   = (BYTE)(nbBits);
+            DElt.length   = 1;
+            for (i = start; i < end; i++)
+                DTable[i] = DElt;
+        }
+        rankVal[weight] += length;
+    }
+}
+
+static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
+{
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
+    U32* const rankStart = rankStart0+1;
+    rankVal_t rankVal;
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    const U32 memLog = DTable[0];
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize = ip[0];
+    void* ptr = DTable;
+    HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1;
+
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
+        {if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
+
+    /* Get start index of each weight */
+    {
+        U32 w, nextRankStart = 0;
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {
+        U32 s;
+        for (s=0; s<nbSymbols; s++)
+        {
+            U32 w = weightList[s];
+            U32 r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {
+        const U32 minBits = tableLog+1 - maxW;
+        U32 nextRankVal = 0;
+        U32 w, consumed;
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
+        U32* rankVal0 = rankVal[0];
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankVal;
+            nextRankVal += rankStats[w] << (w+rescale);
+            rankVal0[w] = current;
+        }
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
+        {
+            U32* rankValPtr = rankVal[consumed];
+            for (w = 1; w <= maxW; w++)
+            {
+                rankValPtr[w] = rankVal0[w] >> consumed;
+            }
+        }
+    }
+
+    HUF_fillDTableX4(dt, memLog,
+                   sortedSymbol, sizeOfSort,
+                   rankStart0, rankVal, maxW,
+                   tableLog+1);
+
+    return iSize;
+}
+
+
+static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 2);
+    BIT_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 1);
+    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
+    else
+    {
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
+        {
+            BIT_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+        }
+    }
+    return 1;
+}
+
+
+#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
+    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))
+    {
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
+
+    while (p <= pEnd-2)
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    if (p < pEnd)
+        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+
+
+static size_t HUF_decompress4X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U32* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+
+        const void* ptr = DTable;
+        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BIT_initDStream(&bitD1, istart1, length1);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD2, istart2, length2);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD3, istart3, length3);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD4, istart4, length4);
+        if (HUF_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
+        {
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/**********************************/
+/* quad-symbol decoding           */
+/**********************************/
+typedef struct { BYTE nbBits; BYTE nbBytes; } HUF_DDescX6;
+typedef union { BYTE byte[4]; U32 sequence; } HUF_DSeqX6;
+
+/* recursive, up to level 3; may benefit from <template>-like strategy to nest each level inline */
+static void HUF_fillDTableX6LevelN(HUF_DDescX6* DDescription, HUF_DSeqX6* DSequence, int sizeLog,
+                           const rankVal_t rankValOrigin, const U32 consumed, const int minWeight, const U32 maxWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, const U32* rankStart,
+                           const U32 nbBitsBaseline, HUF_DSeqX6 baseSeq, HUF_DDescX6 DDesc)
+{
+    const int scaleLog = nbBitsBaseline - sizeLog;   /* note : targetLog >= (nbBitsBaseline-1), hence scaleLog <= 1 */
+    const int minBits  = nbBitsBaseline - maxWeight;
+    const U32 level = DDesc.nbBytes;
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
+    U32 symbolStartPos, s;
+
+    /* local rankVal, will be modified */
+    memcpy(rankVal, rankValOrigin[consumed], sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1)
+    {
+        U32 i;
+        const U32 skipSize = rankVal[minWeight];
+        for (i = 0; i < skipSize; i++)
+        {
+            DSequence[i] = baseSeq;
+            DDescription[i] = DDesc;
+        }
+    }
+
+    /* fill DTable */
+    DDesc.nbBytes++;
+    symbolStartPos = rankStart[minWeight];
+    for (s=symbolStartPos; s<sortedListSize; s++)
+    {
+        const BYTE symbol = sortedSymbols[s].symbol;
+        const U32  weight = sortedSymbols[s].weight;   /* >= 1 (sorted) */
+        const int  nbBits = nbBitsBaseline - weight;   /* >= 1 (by construction) */
+        const int  totalBits = consumed+nbBits;
+        const U32  start  = rankVal[weight];
+        const U32  length = 1 << (sizeLog-nbBits);
+        baseSeq.byte[level] = symbol;
+        DDesc.nbBits = (BYTE)totalBits;
+
+        if ((level<3) && (sizeLog-totalBits >= minBits))   /* enough room for another symbol */
+        {
+            int nextMinWeight = totalBits + scaleLog;
+            if (nextMinWeight < 1) nextMinWeight = 1;
+            HUF_fillDTableX6LevelN(DDescription+start, DSequence+start, sizeLog-nbBits,
+                           rankValOrigin, totalBits, nextMinWeight, maxWeight,
+                           sortedSymbols, sortedListSize, rankStart,
+                           nbBitsBaseline, baseSeq, DDesc);   /* recursive (max : level 3) */
+        }
+        else
+        {
+            U32 i;
+            const U32 end = start + length;
+            for (i = start; i < end; i++)
+            {
+                DDescription[i] = DDesc;
+                DSequence[i] = baseSeq;
+            }
+        }
+        rankVal[weight] += length;
+    }
+}
+
+
+/* note : same preparation as X4 */
+static size_t HUF_readDTableX6 (U32* DTable, const void* src, size_t srcSize)
+{
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
+    U32* const rankStart = rankStart0+1;
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    rankVal_t rankVal;
+    const U32 memLog = DTable[0];
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize = ip[0];
+
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable is too small */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
+        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
+
+
+    /* Get start index of each weight */
+    {
+        U32 w, nextRankStart = 0;
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {
+        U32 s;
+        for (s=0; s<nbSymbols; s++)
+        {
+            U32 w = weightList[s];
+            U32 r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {
+        const U32 minBits = tableLog+1 - maxW;
+        U32 nextRankVal = 0;
+        U32 w, consumed;
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
+        U32* rankVal0 = rankVal[0];
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankVal;
+            nextRankVal += rankStats[w] << (w+rescale);
+            rankVal0[w] = current;
+        }
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
+        {
+            U32* rankValPtr = rankVal[consumed];
+            for (w = 1; w <= maxW; w++)
+            {
+                rankValPtr[w] = rankVal0[w] >> consumed;
+            }
+        }
+    }
+
+
+    /* fill tables */
+    {
+        void* ptr = DTable+1;
+        HUF_DDescX6* DDescription = (HUF_DDescX6*)(ptr);
+        void* dSeqStart = DTable + 1 + ((size_t)1<<(memLog-1));
+        HUF_DSeqX6* DSequence = (HUF_DSeqX6*)(dSeqStart);
+        HUF_DSeqX6 DSeq;
+        HUF_DDescX6 DDesc;
+        DSeq.sequence = 0;
+        DDesc.nbBits = 0;
+        DDesc.nbBytes = 0;
+        HUF_fillDTableX6LevelN(DDescription, DSequence, memLog,
+                       (const U32 (*)[HUF_ABSOLUTEMAX_TABLELOG + 1])rankVal, 0, 1, maxW,
+                       sortedSymbol, sizeOfSort, rankStart0,
+                       tableLog+1, DSeq, DDesc);
+    }
+
+    return iSize;
+}
+
+
+static U32 HUF_decodeSymbolX6(void* op, BIT_DStream_t* DStream, const HUF_DDescX6* dd, const HUF_DSeqX6* ds, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, ds+val, sizeof(HUF_DSeqX6));
+    BIT_skipBits(DStream, dd[val].nbBits);
+    return dd[val].nbBytes;
+}
+
+static U32 HUF_decodeLastSymbolsX6(void* op, const U32 maxL, BIT_DStream_t* DStream,
+                                  const HUF_DDescX6* dd, const HUF_DSeqX6* ds, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    U32 length = dd[val].nbBytes;
+    if (length <= maxL)
+    {
+        memcpy(op, ds+val, length);
+        BIT_skipBits(DStream, dd[val].nbBits);
+        return length;
+    }
+    memcpy(op, ds+val, maxL);
+    if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
+    {
+        BIT_skipBits(DStream, dd[val].nbBits);
+        if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+            DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+    }
+    return maxL;
+}
+
+
+#define HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr) \
+    ptr += HUF_decodeSymbolX6(ptr, DStreamPtr, dd, ds, dtLog)
+
+#define HUF_DECODE_SYMBOLX6_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
+        HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr)
+
+#define HUF_DECODE_SYMBOLX6_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr)
+
+static inline size_t HUF_decodeStreamX6(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const U32* DTable, const U32 dtLog)
+{
+    const void* ddPtr = DTable+1;
+    const HUF_DDescX6* dd = (const HUF_DDescX6*)(ddPtr);
+    const void* dsPtr = DTable + 1 + ((size_t)1<<(dtLog-1));
+    const HUF_DSeqX6* ds = (const HUF_DSeqX6*)(dsPtr);
+    BYTE* const pStart = p;
+
+    /* up to 16 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-16))
+    {
+        HUF_DECODE_SYMBOLX6_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX6_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX6_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX6_0(p, bitDPtr);
+    }
+
+    /* closer to the end, up to 4 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
+        HUF_DECODE_SYMBOLX6_0(p, bitDPtr);
+
+    while (p <= pEnd-4)
+        HUF_DECODE_SYMBOLX6_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    while (p < pEnd)
+        p += HUF_decodeLastSymbolsX6(p, (U32)(pEnd-p), bitDPtr, dd, ds, dtLog);
+
+    return p-pStart;
+}
+
+
+
+static size_t HUF_decompress4X6_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U32* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+
+        const U32 dtLog = DTable[0];
+        const void* ddPtr = DTable+1;
+        const HUF_DDescX6* dd = (const HUF_DDescX6*)(ddPtr);
+        const void* dsPtr = DTable + 1 + ((size_t)1<<(dtLog-1));
+        const HUF_DSeqX6* ds = (const HUF_DSeqX6*)(dsPtr);
+        size_t errorCode;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BIT_initDStream(&bitD1, istart1, length1);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD2, istart2, length2);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD3, istart3, length3);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD4, istart4, length4);
+        if (HUF_isError(errorCode)) return errorCode;
+
+        /* 16-64 symbols per loop (4-16 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (op3 <= opStart4) && (endSignal==BIT_DStream_unfinished) && (op4<=(oend-16)) ; )
+        {
+            HUF_DECODE_SYMBOLX6_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX6_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX6_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX6_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX6_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX6_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX6_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX6_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX6_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX6_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX6_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX6_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX6_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX6_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX6_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX6_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX6(op1, &bitD1, opStart2, DTable, dtLog);
+        HUF_decodeStreamX6(op2, &bitD2, opStart3, DTable, dtLog);
+        HUF_decodeStreamX6(op3, &bitD3, opStart4, DTable, dtLog);
+        HUF_decodeStreamX6(op4, &bitD4, oend,     DTable, dtLog);
+
+        /* check */
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+static size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX6(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUF_readDTableX6 (DTable, cSrc, cSrcSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUF_decompress4X6_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/**********************************/
+/* Generic decompression selector */
+/**********************************/
+
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
+{
+    /* single, double, quad */
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
+};
+
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+
+static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, HUF_decompress4X6 };
+    /* estimate decompression time */
+    U32 Q;
+    const U32 D256 = (U32)(dstSize >> 8);
+    U32 Dtime[3];
+    U32 algoNb = 0;
+    int n;
+
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    /* decoder timing evaluation */
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
+    for (n=0; n<3; n++)
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
+
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
+
+    if (Dtime[1] < Dtime[0]) algoNb = 1;
+    if (Dtime[2] < Dtime[algoNb]) algoNb = 2;
+
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
+
+    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
+    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
+    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
+}
+/*
+    zstd - standard compression library
+    Copyright (C) 2014-2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+*  MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*/
+#define ZSTD_MEMORY_USAGE 17
+
+/*!
+ * HEAPMODE :
+ * Select how default compression functions will allocate memory for their hash table,
+ * in memory stack (0, fastest), or in memory heap (1, requires malloc())
+ * Note that compression context is fairly large, as a consequence heap memory is recommended.
+ */
+#ifndef ZSTD_HEAPMODE
+#  define ZSTD_HEAPMODE 1
+#endif /* ZSTD_HEAPMODE */
+
+/*!
+*  LEGACY_SUPPORT :
+*  decompressor can decode older formats (starting from Zstd 0.1+)
+*/
+#ifndef ZSTD_LEGACY_SUPPORT
+#  define ZSTD_LEGACY_SUPPORT 1
+#endif
+
+
+/* *******************************************************
+*  Includes
+*********************************************************/
+#include <stdlib.h>      /* calloc */
+#include <string.h>      /* memcpy, memmove */
+#include <stdio.h>       /* debug : printf */
+
+
+/* *******************************************************
+*  Compiler specifics
+*********************************************************/
+#ifdef __AVX2__
+#  include <immintrin.h>   /* AVX2 intrinsics */
+#endif
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#endif
+
+
+/* *******************************************************
+*  Constants
+*********************************************************/
+#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)
+#define HASH_TABLESIZE (1 << HASH_LOG)
+#define HASH_MASK (HASH_TABLESIZE - 1)
+
+#define KNUTH 2654435761
+
+#define BIT7 128
+#define BIT6  64
+#define BIT5  32
+#define BIT4  16
+#define BIT1   2
+#define BIT0   1
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
+#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
+#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
+#define IS_RAW BIT0
+#define IS_RLE BIT1
+
+#define WORKPLACESIZE (BLOCKSIZE*3)
+#define MINMATCH 4
+#define MLbits   7
+#define LLbits   6
+#define Offbits  5
+#define MaxML  ((1<<MLbits )-1)
+#define MaxLL  ((1<<LLbits )-1)
+#define MaxOff   31
+#define LitFSELog  11
+#define MLFSELog   10
+#define LLFSELog   10
+#define OffFSELog   9
+#define MAX(a,b) ((a)<(b)?(b):(a))
+#define MaxSeq MAX(MaxLL, MaxML)
+
+#define LITERAL_NOENTROPY 63
+#define COMMAND_NOENTROPY 7   /* to remove */
+
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+
+static const size_t ZSTD_blockHeaderSize = 3;
+static const size_t ZSTD_frameHeaderSize = 4;
+
+
+/* *******************************************************
+*  Memory operations
+**********************************************************/
+static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
+
+/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */
+static void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length)
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+    do COPY8(op, ip) while (op < oend);
+}
+
+
+/* **************************************
+*  Local structures
+****************************************/
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
+
+typedef struct
+{
+    blockType_t blockType;
+    U32 origSize;
+} blockProperties_t;
+
+typedef struct {
+    void* buffer;
+    U32*  offsetStart;
+    U32*  offset;
+    BYTE* offCodeStart;
+    BYTE* offCode;
+    BYTE* litStart;
+    BYTE* lit;
+    BYTE* litLengthStart;
+    BYTE* litLength;
+    BYTE* matchLengthStart;
+    BYTE* matchLength;
+    BYTE* dumpsStart;
+    BYTE* dumps;
+} seqStore_t;
+
+
+/* *************************************
+*  Error Management
+***************************************/
+/*! ZSTD_isError
+*   tells if a return value is an error code */
+static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
+
+
+
+/* *************************************************************
+*   Decompression section
+***************************************************************/
+struct ZSTD_DCtx_s
+{
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
+    void* previousDstEnd;
+    void* base;
+    size_t expected;
+    blockType_t bType;
+    U32 phase;
+    const BYTE* litPtr;
+    size_t litSize;
+    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */];
+};   /* typedef'd to ZSTD_Dctx within "zstd_static.h" */
+
+
+static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
+{
+    const BYTE* const in = (const BYTE* const)src;
+    BYTE headerFlags;
+    U32 cSize;
+
+    if (srcSize < 3) return ERROR(srcSize_wrong);
+
+    headerFlags = *in;
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
+
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
+
+    if (bpPtr->blockType == bt_end) return 0;
+    if (bpPtr->blockType == bt_rle) return 1;
+    return cSize;
+}
+
+static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+
+/** ZSTD_decompressLiterals
+    @return : nb of bytes read from src, or an error code*/
+static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,
+                                const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+
+    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+
+    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);
+    if (litCSize + 5 > srcSize) return ERROR(corruption_detected);
+
+    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);
+
+    *maxDstSizePtr = litSize;
+    return litCSize + 5;
+}
+
+
+/** ZSTD_decodeLiteralsBlock
+    @return : nb of bytes read from src (< srcSize )*/
+static size_t ZSTD_decodeLiteralsBlock(void* ctx,
+                          const void* src, size_t srcSize)
+{
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
+    const BYTE* const istart = (const BYTE* const)src;
+
+    /* any compressed block with literals segment must be at least this size */
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
+
+    switch(*istart & 3)
+    {
+    default:
+    case 0:
+        {
+            size_t litSize = BLOCKSIZE;
+            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, 8);
+            return readSize;   /* works if it's an error too */
+        }
+    case IS_RAW:
+        {
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */
+            {
+                if (litSize > srcSize-3) return ERROR(corruption_detected);
+                memcpy(dctx->litBuffer, istart, litSize);
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                memset(dctx->litBuffer + dctx->litSize, 0, 8);
+                return litSize+3;
+            }
+            /* direct reference into compressed stream */
+            dctx->litPtr = istart+3;
+            dctx->litSize = litSize;
+            return litSize+3;
+        }
+    case IS_RLE:
+        {
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
+            memset(dctx->litBuffer, istart[3], litSize + 8);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            return 4;
+        }
+    }
+}
+
+
+static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
+                         const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* ip = istart;
+    const BYTE* const iend = istart + srcSize;
+    U32 LLtype, Offtype, MLtype;
+    U32 LLlog, Offlog, MLlog;
+    size_t dumpsLength;
+
+    /* check */
+    if (srcSize < 5) return ERROR(srcSize_wrong);
+
+    /* SeqHead */
+    *nbSeq = MEM_readLE16(ip); ip+=2;
+    LLtype  = *ip >> 6;
+    Offtype = (*ip >> 4) & 3;
+    MLtype  = (*ip >> 2) & 3;
+    if (*ip & 2)
+    {
+        dumpsLength  = ip[2];
+        dumpsLength += ip[1] << 8;
+        ip += 3;
+    }
+    else
+    {
+        dumpsLength  = ip[1];
+        dumpsLength += (ip[0] & 1) << 8;
+        ip += 2;
+    }
+    *dumpsPtr = ip;
+    ip += dumpsLength;
+    *dumpsLengthPtr = dumpsLength;
+
+    /* check */
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
+
+    /* sequences */
+    {
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */
+        size_t headerSize;
+
+        /* Build DTables */
+        switch(LLtype)
+        {
+        case bt_rle :
+            LLlog = 0;
+            FSE_buildDTable_rle(DTableLL, *ip++); break;
+        case bt_raw :
+            LLlog = LLbits;
+            FSE_buildDTable_raw(DTableLL, LLbits); break;
+        default :
+            {   U32 max = MaxLL;
+                headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (LLlog > LLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableLL, norm, max, LLlog);
+        }   }
+
+        switch(Offtype)
+        {
+        case bt_rle :
+            Offlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
+            break;
+        case bt_raw :
+            Offlog = Offbits;
+            FSE_buildDTable_raw(DTableOffb, Offbits); break;
+        default :
+            {   U32 max = MaxOff;
+                headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (Offlog > OffFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableOffb, norm, max, Offlog);
+        }   }
+
+        switch(MLtype)
+        {
+        case bt_rle :
+            MLlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableML, *ip++); break;
+        case bt_raw :
+            MLlog = MLbits;
+            FSE_buildDTable_raw(DTableML, MLbits); break;
+        default :
+            {   U32 max = MaxML;
+                headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (MLlog > MLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableML, norm, max, MLlog);
+    }   }   }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t offset;
+    size_t matchLength;
+} seq_t;
+
+typedef struct {
+    BIT_DStream_t DStream;
+    FSE_DState_t stateLL;
+    FSE_DState_t stateOffb;
+    FSE_DState_t stateML;
+    size_t prevOffset;
+    const BYTE* dumps;
+    const BYTE* dumpsEnd;
+} seqState_t;
+
+
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
+{
+    size_t litLength;
+    size_t prevOffset;
+    size_t offset;
+    size_t matchLength;
+    const BYTE* dumps = seqState->dumps;
+    const BYTE* const de = seqState->dumpsEnd;
+
+    /* Literal length */
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
+    prevOffset = litLength ? seq->offset : seqState->prevOffset;
+    seqState->prevOffset = seq->offset;
+    if (litLength == MaxLL)
+    {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) litLength += add;
+        else if (dumps + 3 <= de)
+        {
+            litLength = MEM_readLE24(dumps);
+            dumps += 3;
+        }
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+
+    /* Offset */
+    {
+        static const size_t offsetPrefix[MaxOff+1] = {  /* note : size_t faster than U32 */
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
+        U32 offsetCode, nbBits;
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
+        nbBits = offsetCode - 1;
+        if (offsetCode==0) nbBits = 0;   /* cmove */
+        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
+        if (offsetCode==0) offset = prevOffset;   /* cmove */
+    }
+
+    /* MatchLength */
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
+    if (matchLength == MaxML)
+    {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) matchLength += add;
+        else if (dumps + 3 <= de)
+        {
+            matchLength = MEM_readLE24(dumps);
+            dumps += 3;
+        }
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+    matchLength += MINMATCH;
+
+    /* save result */
+    seq->litLength = litLength;
+    seq->offset = offset;
+    seq->matchLength = matchLength;
+    seqState->dumps = dumps;
+}
+
+
+static size_t ZSTD_execSequence(BYTE* op,
+                                seq_t sequence,
+                                const BYTE** litPtr, const BYTE* const litLimit,
+                                BYTE* const base, BYTE* const oend)
+{
+    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */
+    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* subtracted */
+    const BYTE* const ostart = op;
+    BYTE* const oLitEnd = op + sequence.litLength;
+    BYTE* const oMatchEnd = op + sequence.litLength + sequence.matchLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_8 = oend-8;
+    const BYTE* const litEnd = *litPtr + sequence.litLength;
+
+    /* checks */
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
+    if (litEnd > litLimit) return ERROR(corruption_detected);   /* overRead beyond lit buffer */
+
+    /* copy Literals */
+    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
+    op = oLitEnd;
+    *litPtr = litEnd;   /* update for next sequence */
+
+    /* copy Match */
+    {
+        const BYTE* match = op - sequence.offset;
+
+        /* check */
+        if (sequence.offset > (size_t)op) return ERROR(corruption_detected);   /* address space overflow test (this test seems kept by clang optimizer) */
+        //if (match > op) return ERROR(corruption_detected);   /* address space overflow test (is clang optimizer removing this test ?) */
+        if (match < base) return ERROR(corruption_detected);
+
+        /* close range match, overlap */
+        if (sequence.offset < 8)
+        {
+            const int dec64 = dec64table[sequence.offset];
+            op[0] = match[0];
+            op[1] = match[1];
+            op[2] = match[2];
+            op[3] = match[3];
+            match += dec32table[sequence.offset];
+            ZSTD_copy4(op+4, match);
+            match -= dec64;
+        }
+        else
+        {
+            ZSTD_copy8(op, match);
+        }
+        op += 8; match += 8;
+
+        if (oMatchEnd > oend-(16-MINMATCH))
+        {
+            if (op < oend_8)
+            {
+                ZSTD_wildcopy(op, match, oend_8 - op);
+                match += oend_8 - op;
+                op = oend_8;
+            }
+            while (op < oMatchEnd) *op++ = *match++;
+        }
+        else
+        {
+            ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
+        }
+    }
+
+    return oMatchEnd - ostart;
+}
+
+static size_t ZSTD_decompressSequences(
+                               void* ctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize)
+{
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t errorCode, dumpsLength;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    int nbSeq;
+    const BYTE* dumps;
+    U32* DTableLL = dctx->LLTable;
+    U32* DTableML = dctx->MLTable;
+    U32* DTableOffb = dctx->OffTable;
+    BYTE* const base = (BYTE*) (dctx->base);
+
+    /* Build Decoding Tables */
+    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
+                                      DTableLL, DTableML, DTableOffb,
+                                      ip, iend-ip);
+    if (ZSTD_isError(errorCode)) return errorCode;
+    ip += errorCode;
+
+    /* Regen sequences */
+    {
+        seq_t sequence;
+        seqState_t seqState;
+
+        memset(&sequence, 0, sizeof(sequence));
+        seqState.dumps = dumps;
+        seqState.dumpsEnd = dumps + dumpsLength;
+        seqState.prevOffset = 1;
+        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
+
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (nbSeq>0) ; )
+        {
+            size_t oneSeqSize;
+            nbSeq--;
+            ZSTD_decodeSequence(&sequence, &seqState);
+            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend);
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
+            op += oneSeqSize;
+        }
+
+        /* check if reached exact end */
+        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */
+        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */
+
+        /* last literal segment */
+        {
+            size_t lastLLSize = litEnd - litPtr;
+            if (litPtr > litEnd) return ERROR(corruption_detected);
+            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
+            if (op != litPtr) memmove(op, litPtr, lastLLSize);
+            op += lastLLSize;
+        }
+    }
+
+    return op-ostart;
+}
+
+
+static size_t ZSTD_decompressBlock(
+                            void* ctx,
+                            void* dst, size_t maxDstSize,
+                      const void* src, size_t srcSize)
+{
+    /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+
+    /* Decode literals sub-block */
+    size_t litCSize = ZSTD_decodeLiteralsBlock(ctx, src, srcSize);
+    if (ZSTD_isError(litCSize)) return litCSize;
+    ip += litCSize;
+    srcSize -= litCSize;
+
+    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize);
+}
+
+
+static size_t ZSTD_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* iend = ip + srcSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t remainingSize = srcSize;
+    U32 magicNumber;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t decodedSize=0;
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
+        if (ZSTD_isError(cBlockSize)) return cBlockSize;
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            decodedSize = ZSTD_decompressBlock(ctx, op, oend-op, ip, cBlockSize);
+            break;
+        case bt_raw :
+            decodedSize = ZSTD_copyUncompressedBlock(op, oend-op, ip, cBlockSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet supported */
+            break;
+        case bt_end :
+            /* end of frame */
+            if (remainingSize) return ERROR(srcSize_wrong);
+            break;
+        default:
+            return ERROR(GENERIC);   /* impossible */
+        }
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        if (ZSTD_isError(decodedSize)) return decodedSize;
+        op += decodedSize;
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+    }
+
+    return op-ostart;
+}
+
+static size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    ZSTD_DCtx ctx;
+    ctx.base = dst;
+    return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);
+}
+
+/* ZSTD_errorFrameSizeInfoLegacy() :
+   assumes `cSize` and `dBound` are _not_ NULL */
+static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
+{
+    *cSize = ret;
+    *dBound = ZSTD_CONTENTSIZE_ERROR;
+}
+
+void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t remainingSize = srcSize;
+    size_t nbBlocks = 0;
+    U32 magicNumber;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+        return;
+    }
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTD_magicNumber) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));
+        return;
+    }
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
+        if (ZSTD_isError(cBlockSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);
+            return;
+        }
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (cBlockSize > remainingSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+        nbBlocks++;
+    }
+
+    *cSize = ip - (const BYTE*)src;
+    *dBound = nbBlocks * BLOCKSIZE;
+}
+
+/*******************************
+*  Streaming Decompression API
+*******************************/
+
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)
+{
+    dctx->expected = ZSTD_frameHeaderSize;
+    dctx->phase = 0;
+    dctx->previousDstEnd = NULL;
+    dctx->base = NULL;
+    return 0;
+}
+
+static ZSTD_DCtx* ZSTD_createDCtx(void)
+{
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));
+    if (dctx==NULL) return NULL;
+    ZSTD_resetDCtx(dctx);
+    return dctx;
+}
+
+static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
+{
+    free(dctx);
+    return 0;
+}
+
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)
+{
+    return dctx->expected;
+}
+
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    /* Sanity check */
+    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
+    if (dst != ctx->previousDstEnd)  /* not contiguous */
+        ctx->base = dst;
+
+    /* Decompress : frame header */
+    if (ctx->phase == 0)
+    {
+        /* Check frame magic header */
+        U32 magicNumber = MEM_readLE32(src);
+        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
+        ctx->phase = 1;
+        ctx->expected = ZSTD_blockHeaderSize;
+        return 0;
+    }
+
+    /* Decompress : block header */
+    if (ctx->phase == 1)
+    {
+        blockProperties_t bp;
+        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
+        if (ZSTD_isError(blockSize)) return blockSize;
+        if (bp.blockType == bt_end)
+        {
+            ctx->expected = 0;
+            ctx->phase = 0;
+        }
+        else
+        {
+            ctx->expected = blockSize;
+            ctx->bType = bp.blockType;
+            ctx->phase = 2;
+        }
+
+        return 0;
+    }
+
+    /* Decompress : block content */
+    {
+        size_t rSize;
+        switch(ctx->bType)
+        {
+        case bt_compressed:
+            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);
+            break;
+        case bt_raw :
+            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet handled */
+            break;
+        case bt_end :   /* should never happen (filtered at phase 1) */
+            rSize = 0;
+            break;
+        default:
+            return ERROR(GENERIC);
+        }
+        ctx->phase = 1;
+        ctx->expected = ZSTD_blockHeaderSize;
+        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);
+        return rSize;
+    }
+
+}
+
+
+/* wrapper layer */
+
+unsigned ZSTDv02_isError(size_t code)
+{
+    return ZSTD_isError(code);
+}
+
+size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize,
+                     const void* src, size_t compressedSize)
+{
+    return ZSTD_decompress(dst, maxOriginalSize, src, compressedSize);
+}
+
+ZSTDv02_Dctx* ZSTDv02_createDCtx(void)
+{
+    return (ZSTDv02_Dctx*)ZSTD_createDCtx();
+}
+
+size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx)
+{
+    return ZSTD_freeDCtx((ZSTD_DCtx*)dctx);
+}
+
+size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx)
+{
+    return ZSTD_resetDCtx((ZSTD_DCtx*)dctx);
+}
+
+size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx)
+{
+    return ZSTD_nextSrcSizeToDecompress((ZSTD_DCtx*)dctx);
+}
+
+size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTD_decompressContinue((ZSTD_DCtx*)dctx, dst, maxDstSize, src, srcSize);
+}
diff --git a/src/zstd_v02.h b/src/zstd_v02.h
new file mode 100644
index 0000000..9d7d8d9
--- /dev/null
+++ b/src/zstd_v02.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_V02_H_4174539423
+#define ZSTD_V02_H_4174539423
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stddef.h>   /* size_t */
+
+
+/* *************************************
+*  Simple one-step function
+***************************************/
+/**
+ZSTDv02_decompress() : decompress ZSTD frames compliant with v0.2.x format
+    compressedSize : is the exact source size
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
+                      It must be equal or larger than originalSize, otherwise decompression will fail.
+    return : the number of bytes decompressed into destination buffer (originalSize)
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
+*/
+size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize,
+                     const void* src, size_t compressedSize);
+
+ /**
+ ZSTDv02_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.2.x format
+     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
+     cSize (output parameter)  : the number of bytes that would be read to decompress this frame
+                                 or an error code if it fails (which can be tested using ZSTDv01_isError())
+     dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
+                                 or ZSTD_CONTENTSIZE_ERROR if an error occurs
+
+    note : assumes `cSize` and `dBound` are _not_ NULL.
+ */
+void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
+                                     size_t* cSize, unsigned long long* dBound);
+
+/**
+ZSTDv02_isError() : tells if the result of ZSTDv02_decompress() is an error
+*/
+unsigned ZSTDv02_isError(size_t code);
+
+
+/* *************************************
+*  Advanced functions
+***************************************/
+typedef struct ZSTDv02_Dctx_s ZSTDv02_Dctx;
+ZSTDv02_Dctx* ZSTDv02_createDCtx(void);
+size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx);
+
+size_t ZSTDv02_decompressDCtx(void* ctx,
+                              void* dst, size_t maxOriginalSize,
+                        const void* src, size_t compressedSize);
+
+/* *************************************
+*  Streaming functions
+***************************************/
+size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx);
+
+size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx);
+size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+/**
+  Use above functions alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
+  Result is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
+*/
+
+/* *************************************
+*  Prefix - version detection
+***************************************/
+#define ZSTDv02_magicNumber 0xFD2FB522   /* v0.2 */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_V02_H_4174539423 */
diff --git a/src/zstd_v03.c b/src/zstd_v03.c
new file mode 100644
index 0000000..dbc83f1
--- /dev/null
+++ b/src/zstd_v03.c
@@ -0,0 +1,3156 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include "zstd_v03.h"
+#include "error_private.h"
+
+
+/******************************************
+*  Compiler-specific
+******************************************/
+#if defined(_MSC_VER)   /* Visual Studio */
+#   include <stdlib.h>  /* _byteswap_ulong */
+#   include <intrin.h>  /* _byteswap_* */
+#endif
+
+
+
+/* ******************************************************************
+   mem.h
+   low-level memory access routines
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef MEM_H_MODULE
+#define MEM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/******************************************
+*  Includes
+******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include <string.h>    /* memcpy */
+
+
+/******************************************
+*  Compiler-specific
+******************************************/
+#if defined(__GNUC__)
+#  define MEM_STATIC static __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define MEM_STATIC static inline
+#elif defined(_MSC_VER)
+#  define MEM_STATIC static __inline
+#else
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/****************************************************************
+*  Basic Types
+*****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+# include <stdint.h>
+  typedef  uint8_t BYTE;
+  typedef uint16_t U16;
+  typedef  int16_t S16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+  typedef  int64_t S64;
+#else
+  typedef unsigned char       BYTE;
+  typedef unsigned short      U16;
+  typedef   signed short      S16;
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+  typedef unsigned long long  U64;
+  typedef   signed long long  S64;
+#endif
+
+
+/****************************************************************
+*  Memory I/O
+*****************************************************************/
+/* MEM_FORCE_MEMORY_ACCESS
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets generating assembly depending on alignment.
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define MEM_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#    define MEM_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
+
+MEM_STATIC unsigned MEM_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
+
+/* violates C standard on structure alignment.
+Only use if no other choice to achieve best performance on target platform */
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
+
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
+
+#else
+
+/* default method, safe and standard.
+   can sometimes prove slower */
+
+MEM_STATIC U16 MEM_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U32 MEM_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U64 MEM_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+
+#endif // MEM_FORCE_MEMORY_ACCESS
+
+
+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read16(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
+{
+    if (MEM_isLittleEndian())
+    {
+        MEM_write16(memPtr, val);
+    }
+    else
+    {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE)val;
+        p[1] = (BYTE)(val>>8);
+    }
+}
+
+MEM_STATIC U32 MEM_readLE24(const void* memPtr)
+{
+    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
+}
+
+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read32(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
+    }
+}
+
+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read64(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
+    }
+}
+
+
+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readLE32(memPtr);
+    else
+        return (size_t)MEM_readLE64(memPtr);
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* MEM_H_MODULE */
+
+
+/* ******************************************************************
+   bitstream
+   Part of NewGen Entropy library
+   header file (to include)
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef BITSTREAM_H_MODULE
+#define BITSTREAM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*
+*  This API consists of small unitary functions, which highly benefit from being inlined.
+*  Since link-time-optimization is not available for all compilers,
+*  these functions are defined into a .h to be included.
+*/
+
+
+/**********************************************
+*  bitStream decompression API (read backward)
+**********************************************/
+typedef struct
+{
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+} BIT_DStream_t;
+
+typedef enum { BIT_DStream_unfinished = 0,
+               BIT_DStream_endOfBuffer = 1,
+               BIT_DStream_completed = 2,
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
+
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
+
+
+
+/******************************************
+*  unsafe API
+******************************************/
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
+/* faster, but works only if nbBits >= 1 */
+
+
+
+/****************************************************************
+*  Helper functions
+****************************************************************/
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
+{
+#   if defined(_MSC_VER)   /* Visual */
+    unsigned long r=0;
+    _BitScanReverse ( &r, val );
+    return (unsigned) r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+    return 31 - __builtin_clz (val);
+#   else   /* Software version */
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+    U32 v = val;
+    unsigned r;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+    return r;
+#   endif
+}
+
+
+
+/**********************************************************
+* bitStream decoding
+**********************************************************/
+
+/*!BIT_initDStream
+*  Initialize a BIT_DStream_t.
+*  @bitD : a pointer to an already allocated BIT_DStream_t structure
+*  @srcBuffer must point at the beginning of a bitStream
+*  @srcSize must be the exact size of the bitStream
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
+*/
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
+
+    if (srcSize >=  sizeof(size_t))   /* normal case */
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
+    }
+    else
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
+                    /* fallthrough */
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
+                    /* fallthrough */
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
+                    /* fallthrough */
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
+                    /* fallthrough */
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
+                    /* fallthrough */
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
+                    /* fallthrough */
+            default:;
+        }
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
+}
+
+/*! BIT_lookBitsFast :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
+}
+
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    size_t value = BIT_lookBits(bitD, nbBits);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*!BIT_readBitsFast :
+*  unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
+{
+    size_t value = BIT_lookBitsFast(bitD, nbBits);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
+        return BIT_DStream_overflow;
+
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
+    {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        return BIT_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start)
+    {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
+        return BIT_DStream_completed;
+    }
+    {
+        U32 nbBytes = bitD->bitsConsumed >> 3;
+        BIT_DStream_status result = BIT_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start)
+        {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = BIT_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
+        return result;
+    }
+}
+
+/*! BIT_endOfDStream
+*   @return Tells if DStream has reached its exact end
+*/
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
+{
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* BITSTREAM_H_MODULE */
+/* ******************************************************************
+   Error codes and messages
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef ERROR_H_MODULE
+#define ERROR_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/******************************************
+*  Compiler-specific
+******************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define ERR_STATIC static inline
+#elif defined(_MSC_VER)
+#  define ERR_STATIC static __inline
+#elif defined(__GNUC__)
+#  define ERR_STATIC static __attribute__((unused))
+#else
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/******************************************
+*  Error Management
+******************************************/
+#define PREFIX(name) ZSTD_error_##name
+
+#define ERROR(name) (size_t)-PREFIX(name)
+
+#define ERROR_LIST(ITEM) \
+        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \
+        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \
+        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \
+        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \
+        ITEM(PREFIX(maxCode))
+
+#define ERROR_GENERATE_ENUM(ENUM) ENUM,
+typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
+
+#define ERROR_CONVERTTOSTRING(STRING) #STRING,
+#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)
+static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) };
+
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
+
+ERR_STATIC const char* ERR_getErrorName(size_t code)
+{
+    static const char* codeError = "Unspecified error code";
+    if (ERR_isError(code)) return ERR_strings[-(int)(code)];
+    return codeError;
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ERROR_H_MODULE */
+/*
+Constructor and Destructor of type FSE_CTable
+    Note that its size depends on 'tableLog' and 'maxSymbolValue' */
+typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+
+
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/******************************************
+*  Static allocation
+******************************************/
+/* FSE buffer bounds */
+#define FSE_NCOUNTBOUND 512
+#define FSE_BLOCKBOUND(size) (size + (size>>7))
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+
+/******************************************
+*  FSE advanced API
+******************************************/
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
+/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
+
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
+/* build a fake FSE_DTable, designed to always generate the same symbolValue */
+
+
+/******************************************
+*  FSE symbol decompression API
+******************************************/
+typedef struct
+{
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSE_DState_t;
+
+
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
+
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
+
+
+/******************************************
+*  FSE unsafe API
+******************************************/
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
+
+
+/******************************************
+*  Implementation of inline functions
+******************************************/
+
+/* decompression */
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSE_DTableHeader;   /* sizeof U32 */
+
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSE_decode_t;   /* size == U32 */
+
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
+{
+    FSE_DTableHeader DTableH;
+    memcpy(&DTableH, dt, sizeof(DTableH));
+    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);
+    BIT_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32  nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BIT_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32 nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BIT_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
+{
+    return DStatePtr->state == 0;
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/******************************************
+*  Static allocation macros
+******************************************/
+/* Huff0 buffer bounds */
+#define HUF_CTABLEBOUND 129
+#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */
+#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* static allocation of Huff0's DTable */
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */
+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+        unsigned short DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUF_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
+
+
+/******************************************
+*  Advanced functions
+******************************************/
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+/*
+    zstd - standard compression library
+    Header File
+    Copyright (C) 2014-2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stddef.h>   /* size_t */
+
+
+/* *************************************
+*  Version
+***************************************/
+#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
+#define ZSTD_VERSION_MINOR    2    /* for new (non-breaking) interface capabilities */
+#define ZSTD_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
+
+
+/* *************************************
+*  Advanced functions
+***************************************/
+typedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */
+
+#if defined (__cplusplus)
+}
+#endif
+/*
+    zstd - standard compression library
+    Header File for static linking only
+    Copyright (C) 2014-2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* The objects defined into this file should be considered experimental.
+ * They are not labelled stable, as their prototype may change in the future.
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes.
+ */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Streaming functions
+***************************************/
+
+typedef struct ZSTD_DCtx_s ZSTD_DCtx;
+
+/*
+  Use above functions alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
+  Result is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
+*/
+
+/* *************************************
+*  Prefix - version detection
+***************************************/
+#define ZSTD_magicNumber 0xFD2FB523   /* v0.3 */
+
+
+#if defined (__cplusplus)
+}
+#endif
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+#ifndef FSE_COMMONDEFS_ONLY
+
+/****************************************************************
+*  Tuning parameters
+****************************************************************/
+/* MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#define FSE_MAX_MEMORY_USAGE 14
+#define FSE_DEFAULT_MEMORY_USAGE 13
+
+/* FSE_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#define FSE_MAX_SYMBOL_VALUE 255
+
+
+/****************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSE_FUNCTION_TYPE BYTE
+#define FSE_FUNCTION_EXTENSION
+
+
+/****************************************************************
+*  Byte symbol type
+****************************************************************/
+#endif   /* !FSE_COMMONDEFS_ONLY */
+
+
+/****************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  define FORCE_INLINE static __forceinline
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#else
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/****************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+/****************************************************************
+*  Constants
+*****************************************************************/
+#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
+#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
+#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
+#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
+#define FSE_MIN_TABLELOG 5
+
+#define FSE_TABLELOG_ABSOLUTE_MAX 15
+#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
+#error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+
+/****************************************************************
+*  Error Management
+****************************************************************/
+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/****************************************************************
+*  Complex types
+****************************************************************/
+typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
+
+
+/****************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSE_FUNCTION_EXTENSION
+#  error "FSE_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSE_FUNCTION_TYPE
+#  error "FSE_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSE_CAT(X,Y) X##Y
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
+
+
+/* Function templates */
+
+#define FSE_DECODE_TYPE FSE_decode_t
+
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
+
+static size_t FSE_buildDTable
+(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    void* ptr = dt+1;
+    FSE_DTableHeader DTableH;
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr;
+    const U32 tableSize = 1 << tableLog;
+    const U32 tableMask = tableSize-1;
+    const U32 step = FSE_tableStep(tableSize);
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
+    U32 position = 0;
+    U32 highThreshold = tableSize-1;
+    const S16 largeLimit= (S16)(1 << (tableLog-1));
+    U32 noLarge = 1;
+    U32 s;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+
+    /* Init, lay down lowprob symbols */
+    DTableH.tableLog = (U16)tableLog;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        if (normalizedCounter[s]==-1)
+        {
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
+            symbolNext[s] = 1;
+        }
+        else
+        {
+            if (normalizedCounter[s] >= largeLimit) noLarge=0;
+            symbolNext[s] = normalizedCounter[s];
+        }
+    }
+
+    /* Spread symbols */
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        int i;
+        for (i=0; i<normalizedCounter[s]; i++)
+        {
+            tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
+            position = (position + step) & tableMask;
+            while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }
+    }
+
+    if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+
+    /* Build Decoding table */
+    {
+        U32 i;
+        for (i=0; i<tableSize; i++)
+        {
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
+            U16 nextState = symbolNext[symbol]++;
+            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
+        }
+    }
+
+    DTableH.fastMode = (U16)noLarge;
+    memcpy(dt, &DTableH, sizeof(DTableH));
+    return 0;
+}
+
+
+#ifndef FSE_COMMONDEFS_ONLY
+/******************************************
+*  FSE helper functions
+******************************************/
+static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
+
+
+/****************************************************************
+*  FSE NCount encoding-decoding
+****************************************************************/
+static short FSE_abs(short a)
+{
+    return a<0 ? -a : a;
+}
+
+static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) return ERROR(srcSize_wrong);
+    bitStream = MEM_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) && (charnum<=*maxSVPtr))
+    {
+        if (previous0)
+        {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF)
+            {
+                n0+=24;
+                if (ip < iend-5)
+                {
+                    ip+=2;
+                    bitStream = MEM_readLE32(ip) >> bitCount;
+                }
+                else
+                {
+                    bitStream >>= 16;
+                    bitCount+=16;
+                }
+            }
+            while ((bitStream & 3) == 3)
+            {
+                n0+=3;
+                bitStream>>=2;
+                bitCount+=2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+            {
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = MEM_readLE32(ip) >> bitCount;
+            }
+            else
+                bitStream >>= 2;
+        }
+        {
+            const short max = (short)((2*threshold-1)-remaining);
+            short count;
+
+            if ((bitStream & (threshold-1)) < (U32)max)
+            {
+                count = (short)(bitStream & (threshold-1));
+                bitCount   += nbBits-1;
+            }
+            else
+            {
+                count = (short)(bitStream & (2*threshold-1));
+                if (count >= threshold) count -= max;
+                bitCount   += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= FSE_abs(count);
+            normalizedCounter[charnum++] = count;
+            previous0 = !count;
+            while (remaining < threshold)
+            {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            {
+                if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+                {
+                    ip += bitCount>>3;
+                    bitCount &= 7;
+                }
+                else
+                {
+                    bitCount -= (int)(8 * (iend - 4 - ip));
+                    ip = iend - 4;
+                }
+                bitStream = MEM_readLE32(ip) >> (bitCount & 31);
+            }
+        }
+    }
+    if (remaining != 1) return ERROR(GENERIC);
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
+    return ip-istart;
+}
+
+
+/*********************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSymbolValue = tableMask;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+FORCE_INLINE size_t FSE_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSE_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    BIT_DStream_t bitD;
+    FSE_DState_t state1;
+    FSE_DState_t state2;
+    size_t errorCode;
+
+    /* Init */
+    errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
+    if (FSE_isError(errorCode)) return errorCode;
+
+    FSE_initDState(&state1, &bitD, dt);
+    FSE_initDState(&state2, &bitD, dt);
+
+#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op<olimit) ; op+=4)
+    {
+        op[0] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[1] = FSE_GETSYMBOL(&state2);
+
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[3] = FSE_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
+    while (1)
+    {
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state1);
+
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state2);
+    }
+
+    /* end ? */
+    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
+        return op-ostart;
+
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
+
+    return ERROR(corruption_detected);
+}
+
+
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSE_DTable* dt)
+{
+    FSE_DTableHeader DTableH;
+    memcpy(&DTableH, dt, sizeof(DTableH));
+
+    /* select fast mode (static) */
+    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSE_MAX_SYMBOL_VALUE+1];
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+    size_t errorCode;
+
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
+
+    /* normal FSE decoding mode */
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+    if (FSE_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
+    if (FSE_isError(errorCode)) return errorCode;
+
+    /* always return, even if it is an error code */
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
+}
+
+
+
+#endif   /* FSE_COMMONDEFS_ONLY */
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/****************************************************************
+*  Compiler specifics
+****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+/* inline is defined */
+#elif defined(_MSC_VER)
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  define inline __inline
+#else
+#  define inline /* disable inline */
+#endif
+
+
+/****************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+/****************************************************************
+*  Error Management
+****************************************************************/
+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/******************************************
+*  Helper functions
+******************************************/
+static unsigned HUF_isError(size_t code) { return ERR_isError(code); }
+
+#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
+#define HUF_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
+#define HUF_DEFAULT_TABLELOG  HUF_MAX_TABLELOG   /* tableLog by default, when not specified */
+#define HUF_MAX_SYMBOL_VALUE 255
+#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)
+#  error "HUF_MAX_TABLELOG is too large !"
+#endif
+
+
+
+/*********************************************************
+*  Huff0 : Huffman block decompression
+*********************************************************/
+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */
+
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */
+
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
+
+/*! HUF_readStats
+    Read compact Huffman tree, saved by HUF_writeCTable
+    @huffWeight : destination buffer
+    @return : size read from `src`
+*/
+static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                            U32* nbSymbolsPtr, U32* tableLogPtr,
+                            const void* src, size_t srcSize)
+{
+    U32 weightTotal;
+    U32 tableLog;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+    U32 n;
+
+    if (!srcSize) return ERROR(srcSize_wrong);
+    iSize = ip[0];
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
+
+    if (iSize >= 128)  /* special header */
+    {
+        if (iSize >= (242))   /* RLE */
+        {
+            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+            oSize = l[iSize-242];
+            memset(huffWeight, 1, hwSize);
+            iSize = 0;
+        }
+        else   /* Incompressible */
+        {
+            oSize = iSize - 127;
+            iSize = ((oSize+1)/2);
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+            if (oSize >= hwSize) return ERROR(corruption_detected);
+            ip += 1;
+            for (n=0; n<oSize; n+=2)
+            {
+                huffWeight[n]   = ip[n/2] >> 4;
+                huffWeight[n+1] = ip[n/2] & 15;
+            }
+        }
+    }
+    else  /* header compressed with FSE (normal case) */
+    {
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
+        if (FSE_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
+    weightTotal = 0;
+    for (n=0; n<oSize; n++)
+    {
+        if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+        rankStats[huffWeight[n]]++;
+        weightTotal += (1 << huffWeight[n]) >> 1;
+    }
+    if (weightTotal == 0) return ERROR(corruption_detected);
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    tableLog = BIT_highbit32(weightTotal) + 1;
+    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+    {
+        U32 total = 1 << tableLog;
+        U32 rest = total - weightTotal;
+        U32 verif = 1 << BIT_highbit32(rest);
+        U32 lastWeight = BIT_highbit32(rest) + 1;
+        if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
+        huffWeight[oSize] = (BYTE)lastWeight;
+        rankStats[lastWeight]++;
+    }
+
+    /* check tree construction validity */
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* results */
+    *nbSymbolsPtr = (U32)(oSize+1);
+    *tableLogPtr = tableLog;
+    return iSize+1;
+}
+
+
+/**************************/
+/* single-symbol decoding */
+/**************************/
+
+static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
+    U32 tableLog = 0;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize = ip[0];
+    U32 nbSymbols = 0;
+    U32 n;
+    U32 nextRankStart;
+    void* ptr = DTable+1;
+    HUF_DEltX2* const dt = (HUF_DEltX2*)(ptr);
+
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */
+
+    /* Prepare ranks */
+    nextRankStart = 0;
+    for (n=1; n<=tableLog; n++)
+    {
+        U32 current = nextRankStart;
+        nextRankStart += (rankVal[n] << (n-1));
+        rankVal[n] = current;
+    }
+
+    /* fill DTable */
+    for (n=0; n<nbSymbols; n++)
+    {
+        const U32 w = huffWeight[n];
+        const U32 length = (1 << w) >> 1;
+        U32 i;
+        HUF_DEltX2 D;
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
+        for (i = rankVal[w]; i < rankVal[w] + length; i++)
+            dt[i] = D;
+        rankVal[w] += length;
+    }
+
+    return iSize;
+}
+
+static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)
+{
+        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+        const BYTE c = dt[val].byte;
+        BIT_skipBits(Dstream, dt[val].nbBits);
+        return c;
+}
+
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 4 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
+    {
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    /* no more data to retrieve from bitstream, hence no need to reload */
+    while (p < pEnd)
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    return pEnd-pStart;
+}
+
+
+static size_t HUF_decompress4X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+
+        const void* ptr = DTable;
+        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BIT_initDStream(&bitD1, istart1, length1);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD2, istart2, length2);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD3, istart3, length3);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD4, istart4, length4);
+        if (HUF_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
+        {
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+    size_t errorCode;
+
+    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);
+    if (HUF_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/***************************/
+/* double-symbols decoding */
+/***************************/
+
+static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,
+                           const U32* rankValOrigin, const int minWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
+                           U32 nbBitsBaseline, U16 baseSeq)
+{
+    HUF_DEltX4 DElt;
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
+    U32 s;
+
+    /* get pre-calculated rankVal */
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1)
+    {
+        U32 i, skipSize = rankVal[minWeight];
+        MEM_writeLE16(&(DElt.sequence), baseSeq);
+        DElt.nbBits   = (BYTE)(consumed);
+        DElt.length   = 1;
+        for (i = 0; i < skipSize; i++)
+            DTable[i] = DElt;
+    }
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */
+    {
+        const U32 symbol = sortedSymbols[s].symbol;
+        const U32 weight = sortedSymbols[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 length = 1 << (sizeLog-nbBits);
+        const U32 start = rankVal[weight];
+        U32 i = start;
+        const U32 end = start + length;
+
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
+        DElt.nbBits = (BYTE)(nbBits + consumed);
+        DElt.length = 2;
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
+
+        rankVal[weight] += length;
+    }
+}
+
+typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];
+
+static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32 nbBitsBaseline)
+{
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
+    const U32 minBits  = nbBitsBaseline - maxWeight;
+    U32 s;
+
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++)
+    {
+        const U16 symbol = sortedList[s].symbol;
+        const U32 weight = sortedList[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 start = rankVal[weight];
+        const U32 length = 1 << (targetLog-nbBits);
+
+        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */
+        {
+            U32 sortedRank;
+            int minWeight = nbBits + scaleLog;
+            if (minWeight < 1) minWeight = 1;
+            sortedRank = rankStart[minWeight];
+            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
+                           rankValOrigin[nbBits], minWeight,
+                           sortedList+sortedRank, sortedListSize-sortedRank,
+                           nbBitsBaseline, symbol);
+        }
+        else
+        {
+            U32 i;
+            const U32 end = start + length;
+            HUF_DEltX4 DElt;
+
+            MEM_writeLE16(&(DElt.sequence), symbol);
+            DElt.nbBits   = (BYTE)(nbBits);
+            DElt.length   = 1;
+            for (i = start; i < end; i++)
+                DTable[i] = DElt;
+        }
+        rankVal[weight] += length;
+    }
+}
+
+static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
+{
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
+    U32* const rankStart = rankStart0+1;
+    rankVal_t rankVal;
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    const U32 memLog = DTable[0];
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize = ip[0];
+    void* ptr = DTable;
+    HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1;
+
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
+        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
+
+    /* Get start index of each weight */
+    {
+        U32 w, nextRankStart = 0;
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {
+        U32 s;
+        for (s=0; s<nbSymbols; s++)
+        {
+            U32 w = weightList[s];
+            U32 r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {
+        const U32 minBits = tableLog+1 - maxW;
+        U32 nextRankVal = 0;
+        U32 w, consumed;
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
+        U32* rankVal0 = rankVal[0];
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankVal;
+            nextRankVal += rankStats[w] << (w+rescale);
+            rankVal0[w] = current;
+        }
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
+        {
+            U32* rankValPtr = rankVal[consumed];
+            for (w = 1; w <= maxW; w++)
+            {
+                rankValPtr[w] = rankVal0[w] >> consumed;
+            }
+        }
+    }
+
+    HUF_fillDTableX4(dt, memLog,
+                   sortedSymbol, sizeOfSort,
+                   rankStart0, rankVal, maxW,
+                   tableLog+1);
+
+    return iSize;
+}
+
+
+static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 2);
+    BIT_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 1);
+    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
+    else
+    {
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
+        {
+            BIT_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+        }
+    }
+    return 1;
+}
+
+
+#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
+    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))
+    {
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
+
+    while (p <= pEnd-2)
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    if (p < pEnd)
+        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+
+
+static size_t HUF_decompress4X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U32* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+
+        const void* ptr = DTable;
+        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BIT_initDStream(&bitD1, istart1, length1);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD2, istart2, length2);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD3, istart3, length3);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD4, istart4, length4);
+        if (HUF_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
+        {
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/**********************************/
+/* Generic decompression selector */
+/**********************************/
+
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
+{
+    /* single, double, quad */
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
+};
+
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+
+static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, NULL };
+    /* estimate decompression time */
+    U32 Q;
+    const U32 D256 = (U32)(dstSize >> 8);
+    U32 Dtime[3];
+    U32 algoNb = 0;
+    int n;
+
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    /* decoder timing evaluation */
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
+    for (n=0; n<3; n++)
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
+
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
+
+    if (Dtime[1] < Dtime[0]) algoNb = 1;
+
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
+
+    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
+    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
+    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
+}
+/*
+    zstd - standard compression library
+    Copyright (C) 2014-2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+*  MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*/
+#define ZSTD_MEMORY_USAGE 17
+
+/*!
+ * HEAPMODE :
+ * Select how default compression functions will allocate memory for their hash table,
+ * in memory stack (0, fastest), or in memory heap (1, requires malloc())
+ * Note that compression context is fairly large, as a consequence heap memory is recommended.
+ */
+#ifndef ZSTD_HEAPMODE
+#  define ZSTD_HEAPMODE 1
+#endif /* ZSTD_HEAPMODE */
+
+/*!
+*  LEGACY_SUPPORT :
+*  decompressor can decode older formats (starting from Zstd 0.1+)
+*/
+#ifndef ZSTD_LEGACY_SUPPORT
+#  define ZSTD_LEGACY_SUPPORT 1
+#endif
+
+
+/* *******************************************************
+*  Includes
+*********************************************************/
+#include <stdlib.h>      /* calloc */
+#include <string.h>      /* memcpy, memmove */
+#include <stdio.h>       /* debug : printf */
+
+
+/* *******************************************************
+*  Compiler specifics
+*********************************************************/
+#ifdef __AVX2__
+#  include <immintrin.h>   /* AVX2 intrinsics */
+#endif
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#else
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#endif
+
+
+/* *******************************************************
+*  Constants
+*********************************************************/
+#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)
+#define HASH_TABLESIZE (1 << HASH_LOG)
+#define HASH_MASK (HASH_TABLESIZE - 1)
+
+#define KNUTH 2654435761
+
+#define BIT7 128
+#define BIT6  64
+#define BIT5  32
+#define BIT4  16
+#define BIT1   2
+#define BIT0   1
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
+#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
+#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
+#define IS_RAW BIT0
+#define IS_RLE BIT1
+
+#define WORKPLACESIZE (BLOCKSIZE*3)
+#define MINMATCH 4
+#define MLbits   7
+#define LLbits   6
+#define Offbits  5
+#define MaxML  ((1<<MLbits )-1)
+#define MaxLL  ((1<<LLbits )-1)
+#define MaxOff   31
+#define LitFSELog  11
+#define MLFSELog   10
+#define LLFSELog   10
+#define OffFSELog   9
+#define MAX(a,b) ((a)<(b)?(b):(a))
+#define MaxSeq MAX(MaxLL, MaxML)
+
+#define LITERAL_NOENTROPY 63
+#define COMMAND_NOENTROPY 7   /* to remove */
+
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+
+static const size_t ZSTD_blockHeaderSize = 3;
+static const size_t ZSTD_frameHeaderSize = 4;
+
+
+/* *******************************************************
+*  Memory operations
+**********************************************************/
+static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
+
+/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */
+static void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length)
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+    do COPY8(op, ip) while (op < oend);
+}
+
+
+/* **************************************
+*  Local structures
+****************************************/
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
+
+typedef struct
+{
+    blockType_t blockType;
+    U32 origSize;
+} blockProperties_t;
+
+typedef struct {
+    void* buffer;
+    U32*  offsetStart;
+    U32*  offset;
+    BYTE* offCodeStart;
+    BYTE* offCode;
+    BYTE* litStart;
+    BYTE* lit;
+    BYTE* litLengthStart;
+    BYTE* litLength;
+    BYTE* matchLengthStart;
+    BYTE* matchLength;
+    BYTE* dumpsStart;
+    BYTE* dumps;
+} seqStore_t;
+
+
+/* *************************************
+*  Error Management
+***************************************/
+/*! ZSTD_isError
+*   tells if a return value is an error code */
+static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
+
+
+
+/* *************************************************************
+*   Decompression section
+***************************************************************/
+struct ZSTD_DCtx_s
+{
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
+    void* previousDstEnd;
+    void* base;
+    size_t expected;
+    blockType_t bType;
+    U32 phase;
+    const BYTE* litPtr;
+    size_t litSize;
+    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */];
+};   /* typedef'd to ZSTD_Dctx within "zstd_static.h" */
+
+
+static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
+{
+    const BYTE* const in = (const BYTE* const)src;
+    BYTE headerFlags;
+    U32 cSize;
+
+    if (srcSize < 3) return ERROR(srcSize_wrong);
+
+    headerFlags = *in;
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
+
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
+
+    if (bpPtr->blockType == bt_end) return 0;
+    if (bpPtr->blockType == bt_rle) return 1;
+    return cSize;
+}
+
+static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+
+/** ZSTD_decompressLiterals
+    @return : nb of bytes read from src, or an error code*/
+static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,
+                                const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+
+    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+
+    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);
+    if (litCSize + 5 > srcSize) return ERROR(corruption_detected);
+
+    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);
+
+    *maxDstSizePtr = litSize;
+    return litCSize + 5;
+}
+
+
+/** ZSTD_decodeLiteralsBlock
+    @return : nb of bytes read from src (< srcSize )*/
+static size_t ZSTD_decodeLiteralsBlock(void* ctx,
+                          const void* src, size_t srcSize)
+{
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
+    const BYTE* const istart = (const BYTE* const)src;
+
+    /* any compressed block with literals segment must be at least this size */
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
+
+    switch(*istart & 3)
+    {
+    default:
+    case 0:
+        {
+            size_t litSize = BLOCKSIZE;
+            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, 8);
+            return readSize;   /* works if it's an error too */
+        }
+    case IS_RAW:
+        {
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */
+            {
+                if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
+                if (litSize > srcSize-3) return ERROR(corruption_detected);
+                memcpy(dctx->litBuffer, istart, litSize);
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                memset(dctx->litBuffer + dctx->litSize, 0, 8);
+                return litSize+3;
+            }
+            /* direct reference into compressed stream */
+            dctx->litPtr = istart+3;
+            dctx->litSize = litSize;
+            return litSize+3;
+        }
+    case IS_RLE:
+        {
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
+            memset(dctx->litBuffer, istart[3], litSize + 8);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            return 4;
+        }
+    }
+}
+
+
+static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
+                         const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* ip = istart;
+    const BYTE* const iend = istart + srcSize;
+    U32 LLtype, Offtype, MLtype;
+    U32 LLlog, Offlog, MLlog;
+    size_t dumpsLength;
+
+    /* check */
+    if (srcSize < 5) return ERROR(srcSize_wrong);
+
+    /* SeqHead */
+    *nbSeq = MEM_readLE16(ip); ip+=2;
+    LLtype  = *ip >> 6;
+    Offtype = (*ip >> 4) & 3;
+    MLtype  = (*ip >> 2) & 3;
+    if (*ip & 2)
+    {
+        dumpsLength  = ip[2];
+        dumpsLength += ip[1] << 8;
+        ip += 3;
+    }
+    else
+    {
+        dumpsLength  = ip[1];
+        dumpsLength += (ip[0] & 1) << 8;
+        ip += 2;
+    }
+    *dumpsPtr = ip;
+    ip += dumpsLength;
+    *dumpsLengthPtr = dumpsLength;
+
+    /* check */
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
+
+    /* sequences */
+    {
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */
+        size_t headerSize;
+
+        /* Build DTables */
+        switch(LLtype)
+        {
+        case bt_rle :
+            LLlog = 0;
+            FSE_buildDTable_rle(DTableLL, *ip++); break;
+        case bt_raw :
+            LLlog = LLbits;
+            FSE_buildDTable_raw(DTableLL, LLbits); break;
+        default :
+            {   U32 max = MaxLL;
+                headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (LLlog > LLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableLL, norm, max, LLlog);
+        }   }
+
+        switch(Offtype)
+        {
+        case bt_rle :
+            Offlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
+            break;
+        case bt_raw :
+            Offlog = Offbits;
+            FSE_buildDTable_raw(DTableOffb, Offbits); break;
+        default :
+            {   U32 max = MaxOff;
+                headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (Offlog > OffFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableOffb, norm, max, Offlog);
+        }   }
+
+        switch(MLtype)
+        {
+        case bt_rle :
+            MLlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableML, *ip++); break;
+        case bt_raw :
+            MLlog = MLbits;
+            FSE_buildDTable_raw(DTableML, MLbits); break;
+        default :
+            {   U32 max = MaxML;
+                headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (MLlog > MLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableML, norm, max, MLlog);
+    }   }   }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t offset;
+    size_t matchLength;
+} seq_t;
+
+typedef struct {
+    BIT_DStream_t DStream;
+    FSE_DState_t stateLL;
+    FSE_DState_t stateOffb;
+    FSE_DState_t stateML;
+    size_t prevOffset;
+    const BYTE* dumps;
+    const BYTE* dumpsEnd;
+} seqState_t;
+
+
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
+{
+    size_t litLength;
+    size_t prevOffset;
+    size_t offset;
+    size_t matchLength;
+    const BYTE* dumps = seqState->dumps;
+    const BYTE* const de = seqState->dumpsEnd;
+
+    /* Literal length */
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
+    prevOffset = litLength ? seq->offset : seqState->prevOffset;
+    seqState->prevOffset = seq->offset;
+    if (litLength == MaxLL)
+    {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) litLength += add;
+        else if (dumps + 3 <= de)
+        {
+            litLength = MEM_readLE24(dumps);
+            dumps += 3;
+        }
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+
+    /* Offset */
+    {
+        static const size_t offsetPrefix[MaxOff+1] = {  /* note : size_t faster than U32 */
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
+        U32 offsetCode, nbBits;
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
+        nbBits = offsetCode - 1;
+        if (offsetCode==0) nbBits = 0;   /* cmove */
+        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
+        if (offsetCode==0) offset = prevOffset;   /* cmove */
+    }
+
+    /* MatchLength */
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
+    if (matchLength == MaxML)
+    {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) matchLength += add;
+        else if (dumps + 3 <= de)
+        {
+            matchLength = MEM_readLE24(dumps);
+            dumps += 3;
+        }
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+    matchLength += MINMATCH;
+
+    /* save result */
+    seq->litLength = litLength;
+    seq->offset = offset;
+    seq->matchLength = matchLength;
+    seqState->dumps = dumps;
+}
+
+
+static size_t ZSTD_execSequence(BYTE* op,
+                                seq_t sequence,
+                                const BYTE** litPtr, const BYTE* const litLimit,
+                                BYTE* const base, BYTE* const oend)
+{
+    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */
+    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* subtracted */
+    const BYTE* const ostart = op;
+    BYTE* const oLitEnd = op + sequence.litLength;
+    BYTE* const oMatchEnd = op + sequence.litLength + sequence.matchLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_8 = oend-8;
+    const BYTE* const litEnd = *litPtr + sequence.litLength;
+
+    /* checks */
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
+    if (litEnd > litLimit) return ERROR(corruption_detected);   /* overRead beyond lit buffer */
+
+    /* copy Literals */
+    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
+    op = oLitEnd;
+    *litPtr = litEnd;   /* update for next sequence */
+
+    /* copy Match */
+    {
+        const BYTE* match = op - sequence.offset;
+
+        /* check */
+        if (sequence.offset > (size_t)op) return ERROR(corruption_detected);   /* address space overflow test (this test seems kept by clang optimizer) */
+        //if (match > op) return ERROR(corruption_detected);   /* address space overflow test (is clang optimizer removing this test ?) */
+        if (match < base) return ERROR(corruption_detected);
+
+        /* close range match, overlap */
+        if (sequence.offset < 8)
+        {
+            const int dec64 = dec64table[sequence.offset];
+            op[0] = match[0];
+            op[1] = match[1];
+            op[2] = match[2];
+            op[3] = match[3];
+            match += dec32table[sequence.offset];
+            ZSTD_copy4(op+4, match);
+            match -= dec64;
+        }
+        else
+        {
+            ZSTD_copy8(op, match);
+        }
+        op += 8; match += 8;
+
+        if (oMatchEnd > oend-(16-MINMATCH))
+        {
+            if (op < oend_8)
+            {
+                ZSTD_wildcopy(op, match, oend_8 - op);
+                match += oend_8 - op;
+                op = oend_8;
+            }
+            while (op < oMatchEnd) *op++ = *match++;
+        }
+        else
+        {
+            ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
+        }
+    }
+
+    return oMatchEnd - ostart;
+}
+
+static size_t ZSTD_decompressSequences(
+                               void* ctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize)
+{
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t errorCode, dumpsLength;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    int nbSeq;
+    const BYTE* dumps;
+    U32* DTableLL = dctx->LLTable;
+    U32* DTableML = dctx->MLTable;
+    U32* DTableOffb = dctx->OffTable;
+    BYTE* const base = (BYTE*) (dctx->base);
+
+    /* Build Decoding Tables */
+    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
+                                      DTableLL, DTableML, DTableOffb,
+                                      ip, iend-ip);
+    if (ZSTD_isError(errorCode)) return errorCode;
+    ip += errorCode;
+
+    /* Regen sequences */
+    {
+        seq_t sequence;
+        seqState_t seqState;
+
+        memset(&sequence, 0, sizeof(sequence));
+        seqState.dumps = dumps;
+        seqState.dumpsEnd = dumps + dumpsLength;
+        seqState.prevOffset = sequence.offset = 4;
+        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
+
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (nbSeq>0) ; )
+        {
+            size_t oneSeqSize;
+            nbSeq--;
+            ZSTD_decodeSequence(&sequence, &seqState);
+            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend);
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
+            op += oneSeqSize;
+        }
+
+        /* check if reached exact end */
+        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */
+        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */
+
+        /* last literal segment */
+        {
+            size_t lastLLSize = litEnd - litPtr;
+            if (litPtr > litEnd) return ERROR(corruption_detected);
+            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
+            if (op != litPtr) memmove(op, litPtr, lastLLSize);
+            op += lastLLSize;
+        }
+    }
+
+    return op-ostart;
+}
+
+
+static size_t ZSTD_decompressBlock(
+                            void* ctx,
+                            void* dst, size_t maxDstSize,
+                      const void* src, size_t srcSize)
+{
+    /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+
+    /* Decode literals sub-block */
+    size_t litCSize = ZSTD_decodeLiteralsBlock(ctx, src, srcSize);
+    if (ZSTD_isError(litCSize)) return litCSize;
+    ip += litCSize;
+    srcSize -= litCSize;
+
+    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize);
+}
+
+
+static size_t ZSTD_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* iend = ip + srcSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t remainingSize = srcSize;
+    U32 magicNumber;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t decodedSize=0;
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
+        if (ZSTD_isError(cBlockSize)) return cBlockSize;
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            decodedSize = ZSTD_decompressBlock(ctx, op, oend-op, ip, cBlockSize);
+            break;
+        case bt_raw :
+            decodedSize = ZSTD_copyUncompressedBlock(op, oend-op, ip, cBlockSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet supported */
+            break;
+        case bt_end :
+            /* end of frame */
+            if (remainingSize) return ERROR(srcSize_wrong);
+            break;
+        default:
+            return ERROR(GENERIC);   /* impossible */
+        }
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        if (ZSTD_isError(decodedSize)) return decodedSize;
+        op += decodedSize;
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+    }
+
+    return op-ostart;
+}
+
+static size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    ZSTD_DCtx ctx;
+    ctx.base = dst;
+    return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);
+}
+
+/* ZSTD_errorFrameSizeInfoLegacy() :
+   assumes `cSize` and `dBound` are _not_ NULL */
+MEM_STATIC void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
+{
+    *cSize = ret;
+    *dBound = ZSTD_CONTENTSIZE_ERROR;
+}
+
+void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t remainingSize = srcSize;
+    size_t nbBlocks = 0;
+    U32 magicNumber;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+        return;
+    }
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTD_magicNumber) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));
+        return;
+    }
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
+        if (ZSTD_isError(cBlockSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);
+            return;
+        }
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (cBlockSize > remainingSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+        nbBlocks++;
+    }
+
+    *cSize = ip - (const BYTE*)src;
+    *dBound = nbBlocks * BLOCKSIZE;
+}
+
+
+/*******************************
+*  Streaming Decompression API
+*******************************/
+
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)
+{
+    dctx->expected = ZSTD_frameHeaderSize;
+    dctx->phase = 0;
+    dctx->previousDstEnd = NULL;
+    dctx->base = NULL;
+    return 0;
+}
+
+static ZSTD_DCtx* ZSTD_createDCtx(void)
+{
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));
+    if (dctx==NULL) return NULL;
+    ZSTD_resetDCtx(dctx);
+    return dctx;
+}
+
+static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
+{
+    free(dctx);
+    return 0;
+}
+
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)
+{
+    return dctx->expected;
+}
+
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    /* Sanity check */
+    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
+    if (dst != ctx->previousDstEnd)  /* not contiguous */
+        ctx->base = dst;
+
+    /* Decompress : frame header */
+    if (ctx->phase == 0)
+    {
+        /* Check frame magic header */
+        U32 magicNumber = MEM_readLE32(src);
+        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
+        ctx->phase = 1;
+        ctx->expected = ZSTD_blockHeaderSize;
+        return 0;
+    }
+
+    /* Decompress : block header */
+    if (ctx->phase == 1)
+    {
+        blockProperties_t bp;
+        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
+        if (ZSTD_isError(blockSize)) return blockSize;
+        if (bp.blockType == bt_end)
+        {
+            ctx->expected = 0;
+            ctx->phase = 0;
+        }
+        else
+        {
+            ctx->expected = blockSize;
+            ctx->bType = bp.blockType;
+            ctx->phase = 2;
+        }
+
+        return 0;
+    }
+
+    /* Decompress : block content */
+    {
+        size_t rSize;
+        switch(ctx->bType)
+        {
+        case bt_compressed:
+            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);
+            break;
+        case bt_raw :
+            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet handled */
+            break;
+        case bt_end :   /* should never happen (filtered at phase 1) */
+            rSize = 0;
+            break;
+        default:
+            return ERROR(GENERIC);
+        }
+        ctx->phase = 1;
+        ctx->expected = ZSTD_blockHeaderSize;
+        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);
+        return rSize;
+    }
+
+}
+
+
+/* wrapper layer */
+
+unsigned ZSTDv03_isError(size_t code)
+{
+    return ZSTD_isError(code);
+}
+
+size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,
+                     const void* src, size_t compressedSize)
+{
+    return ZSTD_decompress(dst, maxOriginalSize, src, compressedSize);
+}
+
+ZSTDv03_Dctx* ZSTDv03_createDCtx(void)
+{
+    return (ZSTDv03_Dctx*)ZSTD_createDCtx();
+}
+
+size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx)
+{
+    return ZSTD_freeDCtx((ZSTD_DCtx*)dctx);
+}
+
+size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx)
+{
+    return ZSTD_resetDCtx((ZSTD_DCtx*)dctx);
+}
+
+size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx)
+{
+    return ZSTD_nextSrcSizeToDecompress((ZSTD_DCtx*)dctx);
+}
+
+size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTD_decompressContinue((ZSTD_DCtx*)dctx, dst, maxDstSize, src, srcSize);
+}
diff --git a/src/zstd_v03.h b/src/zstd_v03.h
new file mode 100644
index 0000000..efd8c2b
--- /dev/null
+++ b/src/zstd_v03.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_V03_H_298734209782
+#define ZSTD_V03_H_298734209782
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stddef.h>   /* size_t */
+
+
+/* *************************************
+*  Simple one-step function
+***************************************/
+/**
+ZSTDv03_decompress() : decompress ZSTD frames compliant with v0.3.x format
+    compressedSize : is the exact source size
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
+                      It must be equal or larger than originalSize, otherwise decompression will fail.
+    return : the number of bytes decompressed into destination buffer (originalSize)
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
+*/
+size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,
+                     const void* src, size_t compressedSize);
+
+ /**
+ ZSTDv03_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.3.x format
+     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
+     cSize (output parameter)  : the number of bytes that would be read to decompress this frame
+                                 or an error code if it fails (which can be tested using ZSTDv01_isError())
+     dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
+                                 or ZSTD_CONTENTSIZE_ERROR if an error occurs
+
+    note : assumes `cSize` and `dBound` are _not_ NULL.
+ */
+ void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
+                                      size_t* cSize, unsigned long long* dBound);
+
+    /**
+ZSTDv03_isError() : tells if the result of ZSTDv03_decompress() is an error
+*/
+unsigned ZSTDv03_isError(size_t code);
+
+
+/* *************************************
+*  Advanced functions
+***************************************/
+typedef struct ZSTDv03_Dctx_s ZSTDv03_Dctx;
+ZSTDv03_Dctx* ZSTDv03_createDCtx(void);
+size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx);
+
+size_t ZSTDv03_decompressDCtx(void* ctx,
+                              void* dst, size_t maxOriginalSize,
+                        const void* src, size_t compressedSize);
+
+/* *************************************
+*  Streaming functions
+***************************************/
+size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx);
+
+size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx);
+size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+/**
+  Use above functions alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
+  Result is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
+*/
+
+/* *************************************
+*  Prefix - version detection
+***************************************/
+#define ZSTDv03_magicNumber 0xFD2FB523   /* v0.3 */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_V03_H_298734209782 */
diff --git a/src/zstd_v04.c b/src/zstd_v04.c
new file mode 100644
index 0000000..645a6e3
--- /dev/null
+++ b/src/zstd_v04.c
@@ -0,0 +1,3637 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+ /******************************************
+ *  Includes
+ ******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include <string.h>    /* memcpy */
+
+#include "zstd_v04.h"
+#include "error_private.h"
+
+
+/* ******************************************************************
+ *   mem.h
+ *******************************************************************/
+#ifndef MEM_H_MODULE
+#define MEM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/******************************************
+*  Compiler-specific
+******************************************/
+#if defined(_MSC_VER)   /* Visual Studio */
+#   include <stdlib.h>  /* _byteswap_ulong */
+#   include <intrin.h>  /* _byteswap_* */
+#endif
+#if defined(__GNUC__)
+#  define MEM_STATIC static __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define MEM_STATIC static inline
+#elif defined(_MSC_VER)
+#  define MEM_STATIC static __inline
+#else
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/****************************************************************
+*  Basic Types
+*****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+# include <stdint.h>
+  typedef  uint8_t BYTE;
+  typedef uint16_t U16;
+  typedef  int16_t S16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+  typedef  int64_t S64;
+#else
+  typedef unsigned char       BYTE;
+  typedef unsigned short      U16;
+  typedef   signed short      S16;
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+  typedef unsigned long long  U64;
+  typedef   signed long long  S64;
+#endif
+
+
+/*-*************************************
+*  Debug
+***************************************/
+#include "debug.h"
+#ifndef assert
+#  define assert(condition) ((void)0)
+#endif
+
+
+/****************************************************************
+*  Memory I/O
+*****************************************************************/
+/* MEM_FORCE_MEMORY_ACCESS
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets generating assembly depending on alignment.
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define MEM_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#    define MEM_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
+
+MEM_STATIC unsigned MEM_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
+
+/* violates C standard on structure alignment.
+Only use if no other choice to achieve best performance on target platform */
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
+
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
+
+#else
+
+/* default method, safe and standard.
+   can sometimes prove slower */
+
+MEM_STATIC U16 MEM_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U32 MEM_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U64 MEM_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+#endif // MEM_FORCE_MEMORY_ACCESS
+
+
+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read16(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
+{
+    if (MEM_isLittleEndian())
+    {
+        MEM_write16(memPtr, val);
+    }
+    else
+    {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE)val;
+        p[1] = (BYTE)(val>>8);
+    }
+}
+
+MEM_STATIC U32 MEM_readLE24(const void* memPtr)
+{
+    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
+}
+
+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read32(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
+    }
+}
+
+
+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read64(memPtr);
+    else
+    {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
+    }
+}
+
+
+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readLE32(memPtr);
+    else
+        return (size_t)MEM_readLE64(memPtr);
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* MEM_H_MODULE */
+
+/*
+    zstd - standard compression library
+    Header File for static linking only
+*/
+#ifndef ZSTD_STATIC_H
+#define ZSTD_STATIC_H
+
+
+/* *************************************
+*  Types
+***************************************/
+#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11
+
+/** from faster to stronger */
+typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2 } ZSTD_strategy;
+
+typedef struct
+{
+    U64 srcSize;       /* optional : tells how much bytes are present in the frame. Use 0 if not known. */
+    U32 windowLog;     /* largest match distance : larger == more compression, more memory needed during decompression */
+    U32 contentLog;    /* full search segment : larger == more compression, slower, more memory (useless for fast) */
+    U32 hashLog;       /* dispatch table : larger == more memory, faster */
+    U32 searchLog;     /* nb of searches : larger == more compression, slower */
+    U32 searchLength;  /* size of matches : larger == faster decompression, sometimes less compression */
+    ZSTD_strategy strategy;
+} ZSTD_parameters;
+
+typedef ZSTDv04_Dctx ZSTD_DCtx;
+
+/* *************************************
+*  Advanced functions
+***************************************/
+/** ZSTD_decompress_usingDict
+*   Same as ZSTD_decompressDCtx, using a Dictionary content as prefix
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */
+static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,
+                                             void* dst, size_t maxDstSize,
+                                       const void* src, size_t srcSize,
+                                       const void* dict,size_t dictSize);
+
+
+/* **************************************
+*  Streaming functions (direct mode)
+****************************************/
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx);
+static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize);
+static void   ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* src, size_t srcSize);
+
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+
+/**
+  Streaming decompression, bufferless mode
+
+  A ZSTD_DCtx object is required to track streaming operations.
+  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
+  A ZSTD_DCtx object can be re-used multiple times. Use ZSTD_resetDCtx() to return to fresh status.
+
+  First operation is to retrieve frame parameters, using ZSTD_getFrameParams().
+  This function doesn't consume its input. It needs enough input data to properly decode the frame header.
+  Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding.
+  Result : 0 when successful, it means the ZSTD_parameters structure has been filled.
+           >0 : means there is not enough data into src. Provides the expected size to successfully decode header.
+           errorCode, which can be tested using ZSTD_isError() (For example, if it's not a ZSTD header)
+
+  Then, you can optionally insert a dictionary.
+  This operation must mimic the compressor behavior, otherwise decompression will fail or be corrupted.
+
+  Then it's possible to start decompression.
+  Use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() requires this exact amount of bytes, or it will fail.
+  ZSTD_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog).
+  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible.
+
+  @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
+
+  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
+  Context can then be reset to start a new decompression.
+*/
+
+
+
+
+#endif  /* ZSTD_STATIC_H */
+
+
+/*
+    zstd_internal - common functions to include
+    Header File for include
+*/
+#ifndef ZSTD_CCOMMON_H_MODULE
+#define ZSTD_CCOMMON_H_MODULE
+
+/* *************************************
+*  Common macros
+***************************************/
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
+
+
+/* *************************************
+*  Common constants
+***************************************/
+#define ZSTD_MAGICNUMBER 0xFD2FB524   /* v0.4 */
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
+
+static const size_t ZSTD_blockHeaderSize = 3;
+static const size_t ZSTD_frameHeaderSize_min = 5;
+#define ZSTD_frameHeaderSize_max 5         /* define, for static allocation */
+
+#define BIT7 128
+#define BIT6  64
+#define BIT5  32
+#define BIT4  16
+#define BIT1   2
+#define BIT0   1
+
+#define IS_RAW BIT0
+#define IS_RLE BIT1
+
+#define MINMATCH 4
+#define REPCODE_STARTVALUE 4
+
+#define MLbits   7
+#define LLbits   6
+#define Offbits  5
+#define MaxML  ((1<<MLbits) - 1)
+#define MaxLL  ((1<<LLbits) - 1)
+#define MaxOff ((1<<Offbits)- 1)
+#define MLFSELog   10
+#define LLFSELog   10
+#define OffFSELog   9
+#define MaxSeq MAX(MaxLL, MaxML)
+
+#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
+#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
+
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
+
+
+/* ******************************************
+*  Shared functions to include for inlining
+********************************************/
+static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
+
+/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */
+static void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length)
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+    do
+        COPY8(op, ip)
+    while (op < oend);
+}
+
+
+
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   header file
+****************************************************************** */
+#ifndef FSE_H
+#define FSE_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* *****************************************
+*  Includes
+******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+
+
+/* *****************************************
+*  FSE simple functions
+******************************************/
+static size_t FSE_decompress(void* dst,  size_t maxDstSize,
+                const void* cSrc, size_t cSrcSize);
+/*!
+FSE_decompress():
+    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'maxDstSize'.
+    return : size of regenerated data (<= maxDstSize)
+             or an error code, which can be tested using FSE_isError()
+
+    ** Important ** : FSE_decompress() doesn't decompress non-compressible nor RLE data !!!
+    Why ? : making this distinction requires a header.
+    Header management is intentionally delegated to the user layer, which can better manage special cases.
+*/
+
+
+/* *****************************************
+*  Tool functions
+******************************************/
+/* Error Management */
+static unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */
+
+
+
+/* *****************************************
+*  FSE detailed API
+******************************************/
+/*!
+FSE_compress() does the following:
+1. count symbol occurrence from source[] into table count[]
+2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
+3. save normalized counters to memory buffer using writeNCount()
+4. build encoding table 'CTable' from normalized counters
+5. encode the data stream using encoding table 'CTable'
+
+FSE_decompress() does the following:
+1. read normalized counters with readNCount()
+2. build decoding table 'DTable' from normalized counters
+3. decode the data stream using decoding table 'DTable'
+
+The following API allows targeting specific sub-functions for advanced tasks.
+For example, it's possible to compress several blocks using the same 'CTable',
+or to save and provide normalized distribution using external method.
+*/
+
+
+/* *** DECOMPRESSION *** */
+
+/*!
+FSE_readNCount():
+   Read compactly saved 'normalizedCounter' from 'rBuffer'.
+   return : size read from 'rBuffer'
+            or an errorCode, which can be tested using FSE_isError()
+            maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
+static  size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
+
+/*!
+Constructor and Destructor of type FSE_DTable
+    Note that its size depends on 'tableLog' */
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+
+/*!
+FSE_buildDTable():
+   Builds 'dt', which must be already allocated, using FSE_createDTable()
+   return : 0,
+            or an errorCode, which can be tested using FSE_isError() */
+static size_t FSE_buildDTable ( FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
+
+/*!
+FSE_decompress_usingDTable():
+   Decompress compressed source 'cSrc' of size 'cSrcSize' using 'dt'
+   into 'dst' which must be already allocated.
+   return : size of regenerated data (necessarily <= maxDstSize)
+            or an errorCode, which can be tested using FSE_isError() */
+static  size_t FSE_decompress_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);
+
+/*!
+Tutorial :
+----------
+(Note : these functions only decompress FSE-compressed blocks.
+ If block is uncompressed, use memcpy() instead
+ If block is a single repeated byte, use memset() instead )
+
+The first step is to obtain the normalized frequencies of symbols.
+This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
+In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
+or size the table to handle worst case situations (typically 256).
+FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
+The result of FSE_readNCount() is the number of bytes read from 'rBuffer'.
+Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
+If there is an error, the function will return an error code, which can be tested using FSE_isError().
+
+The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.
+This is performed by the function FSE_buildDTable().
+The space required by 'FSE_DTable' must be already allocated using FSE_createDTable().
+If there is an error, the function will return an error code, which can be tested using FSE_isError().
+
+'FSE_DTable' can then be used to decompress 'cSrc', with FSE_decompress_usingDTable().
+'cSrcSize' must be strictly correct, otherwise decompression will fail.
+FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=maxDstSize).
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
+*/
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* FSE_H */
+
+
+/* ******************************************************************
+   bitstream
+   Part of NewGen Entropy library
+   header file (to include)
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef BITSTREAM_H_MODULE
+#define BITSTREAM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*
+*  This API consists of small unitary functions, which highly benefit from being inlined.
+*  Since link-time-optimization is not available for all compilers,
+*  these functions are defined into a .h to be included.
+*/
+
+/**********************************************
+*  bitStream decompression API (read backward)
+**********************************************/
+typedef struct
+{
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+} BIT_DStream_t;
+
+typedef enum { BIT_DStream_unfinished = 0,
+               BIT_DStream_endOfBuffer = 1,
+               BIT_DStream_completed = 2,
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
+
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
+
+
+
+
+/******************************************
+*  unsafe API
+******************************************/
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
+/* faster, but works only if nbBits >= 1 */
+
+
+
+/****************************************************************
+*  Helper functions
+****************************************************************/
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
+{
+#   if defined(_MSC_VER)   /* Visual */
+    unsigned long r=0;
+    _BitScanReverse ( &r, val );
+    return (unsigned) r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+    return 31 - __builtin_clz (val);
+#   else   /* Software version */
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+    U32 v = val;
+    unsigned r;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+    return r;
+#   endif
+}
+
+
+/**********************************************************
+* bitStream decoding
+**********************************************************/
+
+/*!BIT_initDStream
+*  Initialize a BIT_DStream_t.
+*  @bitD : a pointer to an already allocated BIT_DStream_t structure
+*  @srcBuffer must point at the beginning of a bitStream
+*  @srcSize must be the exact size of the bitStream
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
+*/
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
+
+    if (srcSize >=  sizeof(size_t))   /* normal case */
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
+    }
+    else
+    {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);/* fall-through */
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);/* fall-through */
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);/* fall-through */
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; /* fall-through */
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; /* fall-through */
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; /* fall-through */
+            default: break;
+        }
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+
+MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
+}
+
+/*! BIT_lookBitsFast :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
+}
+
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
+{
+    size_t value = BIT_lookBits(bitD, nbBits);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*!BIT_readBitsFast :
+*  unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
+{
+    size_t value = BIT_lookBitsFast(bitD, nbBits);
+    BIT_skipBits(bitD, nbBits);
+    return value;
+}
+
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
+        return BIT_DStream_overflow;
+
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
+    {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        return BIT_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start)
+    {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
+        return BIT_DStream_completed;
+    }
+    {
+        U32 nbBytes = bitD->bitsConsumed >> 3;
+        BIT_DStream_status result = BIT_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start)
+        {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = BIT_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
+        return result;
+    }
+}
+
+/*! BIT_endOfDStream
+*   @return Tells if DStream has reached its exact end
+*/
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
+{
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* BITSTREAM_H_MODULE */
+
+
+
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef FSE_STATIC_H
+#define FSE_STATIC_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* *****************************************
+*  Static allocation
+*******************************************/
+/* FSE buffer bounds */
+#define FSE_NCOUNTBOUND 512
+#define FSE_BLOCKBOUND(size) (size + (size>>7))
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+
+/* *****************************************
+*  FSE advanced API
+*******************************************/
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
+/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
+
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
+/* build a fake FSE_DTable, designed to always generate the same symbolValue */
+
+
+
+/* *****************************************
+*  FSE symbol decompression API
+*******************************************/
+typedef struct
+{
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSE_DState_t;
+
+
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
+
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
+
+
+/* *****************************************
+*  FSE unsafe API
+*******************************************/
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
+
+
+/* *****************************************
+*  Implementation of inlined functions
+*******************************************/
+/* decompression */
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSE_DTableHeader;   /* sizeof U32 */
+
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSE_decode_t;   /* size == U32 */
+
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
+{
+    FSE_DTableHeader DTableH;
+    memcpy(&DTableH, dt, sizeof(DTableH));
+    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);
+    BIT_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32  nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BIT_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
+{
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32 nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BIT_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
+{
+    return DStatePtr->state == 0;
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* FSE_STATIC_H */
+
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+#ifndef FSE_COMMONDEFS_ONLY
+
+/* **************************************************************
+*  Tuning parameters
+****************************************************************/
+/*!MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#define FSE_MAX_MEMORY_USAGE 14
+#define FSE_DEFAULT_MEMORY_USAGE 13
+
+/*!FSE_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#define FSE_MAX_SYMBOL_VALUE 255
+
+
+/* **************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSE_FUNCTION_TYPE BYTE
+#define FSE_FUNCTION_EXTENSION
+#define FSE_DECODE_TYPE FSE_decode_t
+
+
+#endif   /* !FSE_COMMONDEFS_ONLY */
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  define FORCE_INLINE static __forceinline
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#else
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/* **************************************************************
+*  Dependencies
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+
+/* ***************************************************************
+*  Constants
+*****************************************************************/
+#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
+#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
+#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
+#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
+#define FSE_MIN_TABLELOG 5
+
+#define FSE_TABLELOG_ABSOLUTE_MAX 15
+#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
+#error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/* **************************************************************
+*  Complex types
+****************************************************************/
+typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
+
+
+/*-**************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSE_FUNCTION_EXTENSION
+#  error "FSE_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSE_FUNCTION_TYPE
+#  error "FSE_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSE_CAT(X,Y) X##Y
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
+
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
+
+
+static size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    FSE_DTableHeader DTableH;
+    void* const tdPtr = dt+1;   /* because dt is unsigned, 32-bits aligned on 32-bits */
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
+    const U32 tableSize = 1 << tableLog;
+    const U32 tableMask = tableSize-1;
+    const U32 step = FSE_tableStep(tableSize);
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
+    U32 position = 0;
+    U32 highThreshold = tableSize-1;
+    const S16 largeLimit= (S16)(1 << (tableLog-1));
+    U32 noLarge = 1;
+    U32 s;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+
+    /* Init, lay down lowprob symbols */
+    memset(tableDecode, 0, sizeof(FSE_DECODE_TYPE) * (maxSymbolValue+1) );   /* useless init, but keep static analyzer happy, and we don't need to performance optimize legacy decoders */
+    DTableH.tableLog = (U16)tableLog;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        if (normalizedCounter[s]==-1)
+        {
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
+            symbolNext[s] = 1;
+        }
+        else
+        {
+            if (normalizedCounter[s] >= largeLimit) noLarge=0;
+            symbolNext[s] = normalizedCounter[s];
+        }
+    }
+
+    /* Spread symbols */
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        int i;
+        for (i=0; i<normalizedCounter[s]; i++)
+        {
+            tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
+            position = (position + step) & tableMask;
+            while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }
+    }
+
+    if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+
+    /* Build Decoding table */
+    {
+        U32 i;
+        for (i=0; i<tableSize; i++)
+        {
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
+            U16 nextState = symbolNext[symbol]++;
+            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
+        }
+    }
+
+    DTableH.fastMode = (U16)noLarge;
+    memcpy(dt, &DTableH, sizeof(DTableH));
+    return 0;
+}
+
+
+#ifndef FSE_COMMONDEFS_ONLY
+/******************************************
+*  FSE helper functions
+******************************************/
+static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
+
+
+/****************************************************************
+*  FSE NCount encoding-decoding
+****************************************************************/
+static short FSE_abs(short a)
+{
+    return a<0 ? -a : a;
+}
+
+static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) return ERROR(srcSize_wrong);
+    bitStream = MEM_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) && (charnum<=*maxSVPtr))
+    {
+        if (previous0)
+        {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF)
+            {
+                n0+=24;
+                if (ip < iend-5)
+                {
+                    ip+=2;
+                    bitStream = MEM_readLE32(ip) >> bitCount;
+                }
+                else
+                {
+                    bitStream >>= 16;
+                    bitCount+=16;
+                }
+            }
+            while ((bitStream & 3) == 3)
+            {
+                n0+=3;
+                bitStream>>=2;
+                bitCount+=2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+            {
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = MEM_readLE32(ip) >> bitCount;
+            }
+            else
+                bitStream >>= 2;
+        }
+        {
+            const short max = (short)((2*threshold-1)-remaining);
+            short count;
+
+            if ((bitStream & (threshold-1)) < (U32)max)
+            {
+                count = (short)(bitStream & (threshold-1));
+                bitCount   += nbBits-1;
+            }
+            else
+            {
+                count = (short)(bitStream & (2*threshold-1));
+                if (count >= threshold) count -= max;
+                bitCount   += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= FSE_abs(count);
+            normalizedCounter[charnum++] = count;
+            previous0 = !count;
+            while (remaining < threshold)
+            {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            {
+                if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
+                {
+                    ip += bitCount>>3;
+                    bitCount &= 7;
+                }
+                else
+                {
+                    bitCount -= (int)(8 * (iend - 4 - ip));
+                    ip = iend - 4;
+                }
+                bitStream = MEM_readLE32(ip) >> (bitCount & 31);
+            }
+        }
+    }
+    if (remaining != 1) return ERROR(GENERIC);
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
+    return ip-istart;
+}
+
+
+/*********************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSE_decode_t* const cell = (FSE_decode_t*)dPtr;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSymbolValue = tableMask;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<=maxSymbolValue; s++)
+    {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+FORCE_INLINE size_t FSE_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSE_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    BIT_DStream_t bitD;
+    FSE_DState_t state1;
+    FSE_DState_t state2;
+    size_t errorCode;
+
+    /* Init */
+    errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
+    if (FSE_isError(errorCode)) return errorCode;
+
+    FSE_initDState(&state1, &bitD, dt);
+    FSE_initDState(&state2, &bitD, dt);
+
+#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op<olimit) ; op+=4)
+    {
+        op[0] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[1] = FSE_GETSYMBOL(&state2);
+
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSE_GETSYMBOL(&state1);
+
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BIT_reloadDStream(&bitD);
+
+        op[3] = FSE_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
+    while (1)
+    {
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state1);
+
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
+            break;
+
+        *op++ = FSE_GETSYMBOL(&state2);
+    }
+
+    /* end ? */
+    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
+        return op-ostart;
+
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
+
+    return ERROR(corruption_detected);
+}
+
+
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSE_DTable* dt)
+{
+    FSE_DTableHeader DTableH;
+    U32 fastMode;
+
+    memcpy(&DTableH, dt, sizeof(DTableH));
+    fastMode = DTableH.fastMode;
+
+    /* select fast mode (static) */
+    if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSE_MAX_SYMBOL_VALUE+1];
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+    size_t errorCode;
+
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
+
+    /* normal FSE decoding mode */
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+    if (FSE_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
+    if (FSE_isError(errorCode)) return errorCode;
+
+    /* always return, even if it is an error code */
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
+}
+
+
+
+#endif   /* FSE_COMMONDEFS_ONLY */
+
+
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   header file
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef HUFF0_H
+#define HUFF0_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* ****************************************
+*  Dependency
+******************************************/
+#include <stddef.h>    /* size_t */
+
+
+/* ****************************************
+*  Huff0 simple functions
+******************************************/
+static size_t HUF_decompress(void* dst,  size_t dstSize,
+                const void* cSrc, size_t cSrcSize);
+/*!
+HUF_decompress():
+    Decompress Huff0 data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'dstSize'.
+    'dstSize' must be the exact size of original (uncompressed) data.
+    Note : in contrast with FSE, HUF_decompress can regenerate RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data, because it knows size to regenerate.
+    @return : size of regenerated data (== dstSize)
+              or an error code, which can be tested using HUF_isError()
+*/
+
+
+/* ****************************************
+*  Tool functions
+******************************************/
+/* Error Management */
+static unsigned    HUF_isError(size_t code);        /* tells if a return value is an error code */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* HUFF0_H */
+
+
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef HUFF0_STATIC_H
+#define HUFF0_STATIC_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/* ****************************************
+*  Static allocation macros
+******************************************/
+/* static allocation of Huff0's DTable */
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */
+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+        unsigned short DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUF_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
+
+
+/* ****************************************
+*  Advanced decompression functions
+******************************************/
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
+
+
+/* ****************************************
+*  Huff0 detailed API
+******************************************/
+/*!
+HUF_decompress() does the following:
+1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics
+2. build Huffman table from save, using HUF_readDTableXn()
+3. decode 1 or 4 segments in parallel using HUF_decompressSXn_usingDTable
+
+*/
+static size_t HUF_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize);
+static size_t HUF_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize);
+
+static size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
+static size_t HUF_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* HUFF0_STATIC_H */
+
+
+
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+/* inline is defined */
+#elif defined(_MSC_VER)
+#  define inline __inline
+#else
+#  define inline /* disable inline */
+#endif
+
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#endif
+
+
+/* **************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+
+/* **************************************************************
+*  Constants
+****************************************************************/
+#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
+#define HUF_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
+#define HUF_DEFAULT_TABLELOG  HUF_MAX_TABLELOG   /* tableLog by default, when not specified */
+#define HUF_MAX_SYMBOL_VALUE 255
+#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)
+#  error "HUF_MAX_TABLELOG is too large !"
+#endif
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+static unsigned HUF_isError(size_t code) { return ERR_isError(code); }
+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+
+/*-*******************************************************
+*  Huff0 : Huffman block decompression
+*********************************************************/
+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */
+
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */
+
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
+
+/*! HUF_readStats
+    Read compact Huffman tree, saved by HUF_writeCTable
+    @huffWeight : destination buffer
+    @return : size read from `src`
+*/
+static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                            U32* nbSymbolsPtr, U32* tableLogPtr,
+                            const void* src, size_t srcSize)
+{
+    U32 weightTotal;
+    U32 tableLog;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+    U32 n;
+
+    if (!srcSize) return ERROR(srcSize_wrong);
+    iSize = ip[0];
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
+
+    if (iSize >= 128)  /* special header */
+    {
+        if (iSize >= (242))   /* RLE */
+        {
+            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+            oSize = l[iSize-242];
+            memset(huffWeight, 1, hwSize);
+            iSize = 0;
+        }
+        else   /* Incompressible */
+        {
+            oSize = iSize - 127;
+            iSize = ((oSize+1)/2);
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+            if (oSize >= hwSize) return ERROR(corruption_detected);
+            ip += 1;
+            for (n=0; n<oSize; n+=2)
+            {
+                huffWeight[n]   = ip[n/2] >> 4;
+                huffWeight[n+1] = ip[n/2] & 15;
+            }
+        }
+    }
+    else  /* header compressed with FSE (normal case) */
+    {
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
+        if (FSE_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
+    weightTotal = 0;
+    for (n=0; n<oSize; n++)
+    {
+        if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+        rankStats[huffWeight[n]]++;
+        weightTotal += (1 << huffWeight[n]) >> 1;
+    }
+    if (weightTotal == 0) return ERROR(corruption_detected);
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    tableLog = BIT_highbit32(weightTotal) + 1;
+    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+    {
+        U32 total = 1 << tableLog;
+        U32 rest = total - weightTotal;
+        U32 verif = 1 << BIT_highbit32(rest);
+        U32 lastWeight = BIT_highbit32(rest) + 1;
+        if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
+        huffWeight[oSize] = (BYTE)lastWeight;
+        rankStats[lastWeight]++;
+    }
+
+    /* check tree construction validity */
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* results */
+    *nbSymbolsPtr = (U32)(oSize+1);
+    *tableLogPtr = tableLog;
+    return iSize+1;
+}
+
+
+/**************************/
+/* single-symbol decoding */
+/**************************/
+
+static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
+    U32 tableLog = 0;
+    size_t iSize;
+    U32 nbSymbols = 0;
+    U32 n;
+    U32 nextRankStart;
+    void* const dtPtr = DTable + 1;
+    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
+
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */
+
+    /* Prepare ranks */
+    nextRankStart = 0;
+    for (n=1; n<=tableLog; n++)
+    {
+        U32 current = nextRankStart;
+        nextRankStart += (rankVal[n] << (n-1));
+        rankVal[n] = current;
+    }
+
+    /* fill DTable */
+    for (n=0; n<nbSymbols; n++)
+    {
+        const U32 w = huffWeight[n];
+        const U32 length = (1 << w) >> 1;
+        U32 i;
+        HUF_DEltX2 D;
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
+        for (i = rankVal[w]; i < rankVal[w] + length; i++)
+            dt[i] = D;
+        rankVal[w] += length;
+    }
+
+    return iSize;
+}
+
+static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)
+{
+        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+        const BYTE c = dt[val].byte;
+        BIT_skipBits(Dstream, dt[val].nbBits);
+        return c;
+}
+
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 4 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
+    {
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    /* no more data to retrieve from bitstream, hence no need to reload */
+    while (p < pEnd)
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    return pEnd-pStart;
+}
+
+
+static size_t HUF_decompress4X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable;
+        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)dtPtr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BIT_initDStream(&bitD1, istart1, length1);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD2, istart2, length2);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD3, istart3, length3);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD4, istart4, length4);
+        if (HUF_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
+        {
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+    size_t errorCode;
+
+    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);
+    if (HUF_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/***************************/
+/* double-symbols decoding */
+/***************************/
+
+static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,
+                           const U32* rankValOrigin, const int minWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
+                           U32 nbBitsBaseline, U16 baseSeq)
+{
+    HUF_DEltX4 DElt;
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
+    U32 s;
+
+    /* get pre-calculated rankVal */
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1)
+    {
+        U32 i, skipSize = rankVal[minWeight];
+        MEM_writeLE16(&(DElt.sequence), baseSeq);
+        DElt.nbBits   = (BYTE)(consumed);
+        DElt.length   = 1;
+        for (i = 0; i < skipSize; i++)
+            DTable[i] = DElt;
+    }
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */
+    {
+        const U32 symbol = sortedSymbols[s].symbol;
+        const U32 weight = sortedSymbols[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 length = 1 << (sizeLog-nbBits);
+        const U32 start = rankVal[weight];
+        U32 i = start;
+        const U32 end = start + length;
+
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
+        DElt.nbBits = (BYTE)(nbBits + consumed);
+        DElt.length = 2;
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
+
+        rankVal[weight] += length;
+    }
+}
+
+typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];
+
+static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32 nbBitsBaseline)
+{
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
+    const U32 minBits  = nbBitsBaseline - maxWeight;
+    U32 s;
+
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++)
+    {
+        const U16 symbol = sortedList[s].symbol;
+        const U32 weight = sortedList[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 start = rankVal[weight];
+        const U32 length = 1 << (targetLog-nbBits);
+
+        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */
+        {
+            U32 sortedRank;
+            int minWeight = nbBits + scaleLog;
+            if (minWeight < 1) minWeight = 1;
+            sortedRank = rankStart[minWeight];
+            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
+                           rankValOrigin[nbBits], minWeight,
+                           sortedList+sortedRank, sortedListSize-sortedRank,
+                           nbBitsBaseline, symbol);
+        }
+        else
+        {
+            U32 i;
+            const U32 end = start + length;
+            HUF_DEltX4 DElt;
+
+            MEM_writeLE16(&(DElt.sequence), symbol);
+            DElt.nbBits   = (BYTE)(nbBits);
+            DElt.length   = 1;
+            for (i = start; i < end; i++)
+                DTable[i] = DElt;
+        }
+        rankVal[weight] += length;
+    }
+}
+
+static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
+{
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
+    U32* const rankStart = rankStart0+1;
+    rankVal_t rankVal;
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    const U32 memLog = DTable[0];
+    size_t iSize;
+    void* dtPtr = DTable;
+    HUF_DEltX4* const dt = ((HUF_DEltX4*)dtPtr) + 1;
+
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUF_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
+        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
+
+    /* Get start index of each weight */
+    {
+        U32 w, nextRankStart = 0;
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {
+        U32 s;
+        for (s=0; s<nbSymbols; s++)
+        {
+            U32 w = weightList[s];
+            U32 r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {
+        const U32 minBits = tableLog+1 - maxW;
+        U32 nextRankVal = 0;
+        U32 w, consumed;
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
+        U32* rankVal0 = rankVal[0];
+        for (w=1; w<=maxW; w++)
+        {
+            U32 current = nextRankVal;
+            nextRankVal += rankStats[w] << (w+rescale);
+            rankVal0[w] = current;
+        }
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
+        {
+            U32* rankValPtr = rankVal[consumed];
+            for (w = 1; w <= maxW; w++)
+            {
+                rankValPtr[w] = rankVal0[w] >> consumed;
+            }
+        }
+    }
+
+    HUF_fillDTableX4(dt, memLog,
+                   sortedSymbol, sizeOfSort,
+                   rankStart0, rankVal, maxW,
+                   tableLog+1);
+
+    return iSize;
+}
+
+
+static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 2);
+    BIT_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 1);
+    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
+    else
+    {
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
+        {
+            BIT_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+        }
+    }
+    return 1;
+}
+
+
+#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
+    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))
+    {
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_1(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
+
+    while (p <= pEnd-2)
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    if (p < pEnd)
+        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+static size_t HUF_decompress4X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U32* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable;
+        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)dtPtr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BIT_initDStream(&bitD1, istart1, length1);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD2, istart2, length2);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD3, istart3, length3);
+        if (HUF_isError(errorCode)) return errorCode;
+        errorCode = BIT_initDStream(&bitD4, istart4, length4);
+        if (HUF_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
+        {
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_1(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_1(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_1(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_1(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUF_DECODE_SYMBOLX4_0(op1, &bitD1);
+            HUF_DECODE_SYMBOLX4_0(op2, &bitD2);
+            HUF_DECODE_SYMBOLX4_0(op3, &bitD3);
+            HUF_DECODE_SYMBOLX4_0(op4, &bitD4);
+
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);
+    if (HUF_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/**********************************/
+/* Generic decompression selector */
+/**********************************/
+
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
+{
+    /* single, double, quad */
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
+};
+
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+
+static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, NULL };
+    /* estimate decompression time */
+    U32 Q;
+    const U32 D256 = (U32)(dstSize >> 8);
+    U32 Dtime[3];
+    U32 algoNb = 0;
+    int n;
+
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    /* decoder timing evaluation */
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
+    for (n=0; n<3; n++)
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
+
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
+
+    if (Dtime[1] < Dtime[0]) algoNb = 1;
+
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
+
+    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
+    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
+    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
+}
+
+
+
+#endif   /* ZSTD_CCOMMON_H_MODULE */
+
+
+/*
+    zstd - decompression module fo v0.4 legacy format
+    Copyright (C) 2015-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+ * HEAPMODE :
+ * Select how default decompression function ZSTD_decompress() will allocate memory,
+ * in memory stack (0), or in memory heap (1, requires malloc())
+ */
+#ifndef ZSTD_HEAPMODE
+#  define ZSTD_HEAPMODE 1
+#endif
+
+
+/* *******************************************************
+*  Includes
+*********************************************************/
+#include <stdlib.h>      /* calloc */
+#include <string.h>      /* memcpy, memmove */
+#include <stdio.h>       /* debug : printf */
+
+
+/* *******************************************************
+*  Compiler specifics
+*********************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#endif
+
+
+/* *************************************
+*  Local types
+***************************************/
+typedef struct
+{
+    blockType_t blockType;
+    U32 origSize;
+} blockProperties_t;
+
+
+/* *******************************************************
+*  Memory operations
+**********************************************************/
+static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+
+/* *************************************
+*  Error Management
+***************************************/
+
+/*! ZSTD_isError
+*   tells if a return value is an error code */
+static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
+
+
+/* *************************************************************
+*   Context management
+***************************************************************/
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTD_dStage;
+
+struct ZSTDv04_Dctx_s
+{
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
+    const void* previousDstEnd;
+    const void* base;
+    const void* vBase;
+    const void* dictEnd;
+    size_t expected;
+    size_t headerSize;
+    ZSTD_parameters params;
+    blockType_t bType;
+    ZSTD_dStage stage;
+    const BYTE* litPtr;
+    size_t litSize;
+    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */];
+    BYTE headerBuffer[ZSTD_frameHeaderSize_max];
+};  /* typedef'd to ZSTD_DCtx within "zstd_static.h" */
+
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)
+{
+    dctx->expected = ZSTD_frameHeaderSize_min;
+    dctx->stage = ZSTDds_getFrameHeaderSize;
+    dctx->previousDstEnd = NULL;
+    dctx->base = NULL;
+    dctx->vBase = NULL;
+    dctx->dictEnd = NULL;
+    return 0;
+}
+
+static ZSTD_DCtx* ZSTD_createDCtx(void)
+{
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));
+    if (dctx==NULL) return NULL;
+    ZSTD_resetDCtx(dctx);
+    return dctx;
+}
+
+static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
+{
+    free(dctx);
+    return 0;
+}
+
+
+/* *************************************************************
+*   Decompression section
+***************************************************************/
+/** ZSTD_decodeFrameHeader_Part1
+*   decode the 1st part of the Frame Header, which tells Frame Header size.
+*   srcSize must be == ZSTD_frameHeaderSize_min
+*   @return : the full size of the Frame Header */
+static size_t ZSTD_decodeFrameHeader_Part1(ZSTD_DCtx* zc, const void* src, size_t srcSize)
+{
+    U32 magicNumber;
+    if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);
+    zc->headerSize = ZSTD_frameHeaderSize_min;
+    return zc->headerSize;
+}
+
+
+static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize)
+{
+    U32 magicNumber;
+    if (srcSize < ZSTD_frameHeaderSize_min) return ZSTD_frameHeaderSize_max;
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);
+    memset(params, 0, sizeof(*params));
+    params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
+    if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported);   /* reserved bits */
+    return 0;
+}
+
+/** ZSTD_decodeFrameHeader_Part2
+*   decode the full Frame Header
+*   srcSize must be the size provided by ZSTD_decodeFrameHeader_Part1
+*   @return : 0, or an error code, which can be tested using ZSTD_isError() */
+static size_t ZSTD_decodeFrameHeader_Part2(ZSTD_DCtx* zc, const void* src, size_t srcSize)
+{
+    size_t result;
+    if (srcSize != zc->headerSize) return ERROR(srcSize_wrong);
+    result = ZSTD_getFrameParams(&(zc->params), src, srcSize);
+    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupported);
+    return result;
+}
+
+
+static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
+{
+    const BYTE* const in = (const BYTE* const)src;
+    BYTE headerFlags;
+    U32 cSize;
+
+    if (srcSize < 3) return ERROR(srcSize_wrong);
+
+    headerFlags = *in;
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
+
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
+
+    if (bpPtr->blockType == bt_end) return 0;
+    if (bpPtr->blockType == bt_rle) return 1;
+    return cSize;
+}
+
+static size_t ZSTD_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+
+/** ZSTD_decompressLiterals
+    @return : nb of bytes read from src, or an error code*/
+static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,
+                                const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+
+    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+
+    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);
+    if (litCSize + 5 > srcSize) return ERROR(corruption_detected);
+
+    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);
+
+    *maxDstSizePtr = litSize;
+    return litCSize + 5;
+}
+
+
+/** ZSTD_decodeLiteralsBlock
+    @return : nb of bytes read from src (< srcSize ) */
+static size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
+{
+    const BYTE* const istart = (const BYTE*) src;
+
+    /* any compressed block with literals segment must be at least this size */
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
+
+    switch(*istart & 3)
+    {
+    /* compressed */
+    case 0:
+        {
+            size_t litSize = BLOCKSIZE;
+            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, 8);
+            return readSize;   /* works if it's an error too */
+        }
+    case IS_RAW:
+        {
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */
+            {
+                if (litSize > srcSize-3) return ERROR(corruption_detected);
+                memcpy(dctx->litBuffer, istart, litSize);
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                memset(dctx->litBuffer + dctx->litSize, 0, 8);
+                return litSize+3;
+            }
+            /* direct reference into compressed stream */
+            dctx->litPtr = istart+3;
+            dctx->litSize = litSize;
+            return litSize+3;        }
+    case IS_RLE:
+        {
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
+            memset(dctx->litBuffer, istart[3], litSize + 8);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            return 4;
+        }
+    default:
+        return ERROR(corruption_detected);   /* forbidden nominal case */
+    }
+}
+
+
+static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
+                         const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* ip = istart;
+    const BYTE* const iend = istart + srcSize;
+    U32 LLtype, Offtype, MLtype;
+    U32 LLlog, Offlog, MLlog;
+    size_t dumpsLength;
+
+    /* check */
+    if (srcSize < 5) return ERROR(srcSize_wrong);
+
+    /* SeqHead */
+    *nbSeq = MEM_readLE16(ip); ip+=2;
+    LLtype  = *ip >> 6;
+    Offtype = (*ip >> 4) & 3;
+    MLtype  = (*ip >> 2) & 3;
+    if (*ip & 2)
+    {
+        dumpsLength  = ip[2];
+        dumpsLength += ip[1] << 8;
+        ip += 3;
+    }
+    else
+    {
+        dumpsLength  = ip[1];
+        dumpsLength += (ip[0] & 1) << 8;
+        ip += 2;
+    }
+    *dumpsPtr = ip;
+    ip += dumpsLength;
+    *dumpsLengthPtr = dumpsLength;
+
+    /* check */
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
+
+    /* sequences */
+    {
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL >= MaxOff */
+        size_t headerSize;
+
+        /* Build DTables */
+        switch(LLtype)
+        {
+        case bt_rle :
+            LLlog = 0;
+            FSE_buildDTable_rle(DTableLL, *ip++); break;
+        case bt_raw :
+            LLlog = LLbits;
+            FSE_buildDTable_raw(DTableLL, LLbits); break;
+        default :
+            {   U32 max = MaxLL;
+                headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (LLlog > LLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableLL, norm, max, LLlog);
+        }   }
+
+        switch(Offtype)
+        {
+        case bt_rle :
+            Offlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
+            break;
+        case bt_raw :
+            Offlog = Offbits;
+            FSE_buildDTable_raw(DTableOffb, Offbits); break;
+        default :
+            {   U32 max = MaxOff;
+                headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (Offlog > OffFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableOffb, norm, max, Offlog);
+        }   }
+
+        switch(MLtype)
+        {
+        case bt_rle :
+            MLlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
+            FSE_buildDTable_rle(DTableML, *ip++); break;
+        case bt_raw :
+            MLlog = MLbits;
+            FSE_buildDTable_raw(DTableML, MLbits); break;
+        default :
+            {   U32 max = MaxML;
+                headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
+                if (FSE_isError(headerSize)) return ERROR(GENERIC);
+                if (MLlog > MLFSELog) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSE_buildDTable(DTableML, norm, max, MLlog);
+    }   }   }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t offset;
+    size_t matchLength;
+} seq_t;
+
+typedef struct {
+    BIT_DStream_t DStream;
+    FSE_DState_t stateLL;
+    FSE_DState_t stateOffb;
+    FSE_DState_t stateML;
+    size_t prevOffset;
+    const BYTE* dumps;
+    const BYTE* dumpsEnd;
+} seqState_t;
+
+
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
+{
+    size_t litLength;
+    size_t prevOffset;
+    size_t offset;
+    size_t matchLength;
+    const BYTE* dumps = seqState->dumps;
+    const BYTE* const de = seqState->dumpsEnd;
+
+    /* Literal length */
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
+    prevOffset = litLength ? seq->offset : seqState->prevOffset;
+    if (litLength == MaxLL) {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) litLength += add;
+        else if (dumps + 3 <= de) {
+            litLength = MEM_readLE24(dumps);
+            dumps += 3;
+        }
+        if (dumps >= de) { dumps = de-1; }  /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+
+    /* Offset */
+    {   static const U32 offsetPrefix[MaxOff+1] = {
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
+        U32 offsetCode, nbBits;
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
+        nbBits = offsetCode - 1;
+        if (offsetCode==0) nbBits = 0;   /* cmove */
+        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
+        if (offsetCode==0) offset = prevOffset;   /* cmove */
+        if (offsetCode | !litLength) seqState->prevOffset = seq->offset;   /* cmove */
+    }
+
+    /* MatchLength */
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
+    if (matchLength == MaxML) {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) matchLength += add;
+        else if (dumps + 3 <= de){
+            matchLength = MEM_readLE24(dumps);
+            dumps += 3;
+        }
+        if (dumps >= de) { dumps = de-1; }  /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+    matchLength += MINMATCH;
+
+    /* save result */
+    seq->litLength = litLength;
+    seq->offset = offset;
+    seq->matchLength = matchLength;
+    seqState->dumps = dumps;
+}
+
+
+static size_t ZSTD_execSequence(BYTE* op,
+                                BYTE* const oend, seq_t sequence,
+                                const BYTE** litPtr, const BYTE* const litLimit,
+                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
+{
+    static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+    static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */
+    BYTE* const oLitEnd = op + sequence.litLength;
+    const size_t sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_8 = oend-8;
+    const BYTE* const litEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
+
+    /* check */
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
+    if (litEnd > litLimit) return ERROR(corruption_detected);   /* risk read beyond lit buffer */
+
+    /* copy Literals */
+    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
+    op = oLitEnd;
+    *litPtr = litEnd;   /* update for next sequence */
+
+    /* copy Match */
+    if (sequence.offset > (size_t)(oLitEnd - base))
+    {
+        /* offset beyond prefix */
+        if (sequence.offset > (size_t)(oLitEnd - vBase))
+            return ERROR(corruption_detected);
+        match = dictEnd - (base-match);
+        if (match + sequence.matchLength <= dictEnd)
+        {
+            memmove(oLitEnd, match, sequence.matchLength);
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {
+            size_t length1 = dictEnd - match;
+            memmove(oLitEnd, match, length1);
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = base;
+            if (op > oend_8 || sequence.matchLength < MINMATCH) {
+              while (op < oMatchEnd) *op++ = *match++;
+              return sequenceLength;
+            }
+        }
+    }
+    /* Requirement: op <= oend_8 */
+
+    /* match within prefix */
+    if (sequence.offset < 8) {
+        /* close range match, overlap */
+        const int sub2 = dec64table[sequence.offset];
+        op[0] = match[0];
+        op[1] = match[1];
+        op[2] = match[2];
+        op[3] = match[3];
+        match += dec32table[sequence.offset];
+        ZSTD_copy4(op+4, match);
+        match -= sub2;
+    } else {
+        ZSTD_copy8(op, match);
+    }
+    op += 8; match += 8;
+
+    if (oMatchEnd > oend-(16-MINMATCH))
+    {
+        if (op < oend_8)
+        {
+            ZSTD_wildcopy(op, match, oend_8 - op);
+            match += oend_8 - op;
+            op = oend_8;
+        }
+        while (op < oMatchEnd) *op++ = *match++;
+    }
+    else
+    {
+        ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8, but must be signed */
+    }
+    return sequenceLength;
+}
+
+
+static size_t ZSTD_decompressSequences(
+                               ZSTD_DCtx* dctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize)
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t errorCode, dumpsLength;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    int nbSeq;
+    const BYTE* dumps;
+    U32* DTableLL = dctx->LLTable;
+    U32* DTableML = dctx->MLTable;
+    U32* DTableOffb = dctx->OffTable;
+    const BYTE* const base = (const BYTE*) (dctx->base);
+    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
+
+    /* Build Decoding Tables */
+    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
+                                      DTableLL, DTableML, DTableOffb,
+                                      ip, iend-ip);
+    if (ZSTD_isError(errorCode)) return errorCode;
+    ip += errorCode;
+
+    /* Regen sequences */
+    {
+        seq_t sequence;
+        seqState_t seqState;
+
+        memset(&sequence, 0, sizeof(sequence));
+        sequence.offset = 4;
+        seqState.dumps = dumps;
+        seqState.dumpsEnd = dumps + dumpsLength;
+        seqState.prevOffset = 4;
+        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
+
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; )
+        {
+            size_t oneSeqSize;
+            nbSeq--;
+            ZSTD_decodeSequence(&sequence, &seqState);
+            oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
+            op += oneSeqSize;
+        }
+
+        /* check if reached exact end */
+        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* DStream should be entirely and exactly consumed; otherwise data is corrupted */
+
+        /* last literal segment */
+        {
+            size_t lastLLSize = litEnd - litPtr;
+            if (litPtr > litEnd) return ERROR(corruption_detected);
+            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
+            if (op != litPtr) memcpy(op, litPtr, lastLLSize);
+            op += lastLLSize;
+        }
+    }
+
+    return op-ostart;
+}
+
+
+static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)
+{
+    if (dst != dctx->previousDstEnd)   /* not contiguous */
+    {
+        dctx->dictEnd = dctx->previousDstEnd;
+        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
+        dctx->base = dst;
+        dctx->previousDstEnd = dst;
+    }
+}
+
+
+static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
+                            void* dst, size_t maxDstSize,
+                      const void* src, size_t srcSize)
+{
+    /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+
+    /* Decode literals sub-block */
+    size_t litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
+    if (ZSTD_isError(litCSize)) return litCSize;
+    ip += litCSize;
+    srcSize -= litCSize;
+
+    return ZSTD_decompressSequences(dctx, dst, maxDstSize, ip, srcSize);
+}
+
+
+static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,
+                                 void* dst, size_t maxDstSize,
+                                 const void* src, size_t srcSize,
+                                 const void* dict, size_t dictSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* iend = ip + srcSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t remainingSize = srcSize;
+    blockProperties_t blockProperties;
+
+    /* init */
+    ZSTD_resetDCtx(ctx);
+    if (dict)
+    {
+        ZSTD_decompress_insertDictionary(ctx, dict, dictSize);
+        ctx->dictEnd = ctx->previousDstEnd;
+        ctx->vBase = (const char*)dst - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));
+        ctx->base = dst;
+    }
+    else
+    {
+        ctx->vBase = ctx->base = ctx->dictEnd = dst;
+    }
+
+    /* Frame Header */
+    {
+        size_t frameHeaderSize;
+        if (srcSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
+        frameHeaderSize = ZSTD_decodeFrameHeader_Part1(ctx, src, ZSTD_frameHeaderSize_min);
+        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
+        if (srcSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
+        frameHeaderSize = ZSTD_decodeFrameHeader_Part2(ctx, src, frameHeaderSize);
+        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
+    }
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t decodedSize=0;
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
+        if (ZSTD_isError(cBlockSize)) return cBlockSize;
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            decodedSize = ZSTD_decompressBlock_internal(ctx, op, oend-op, ip, cBlockSize);
+            break;
+        case bt_raw :
+            decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet supported */
+            break;
+        case bt_end :
+            /* end of frame */
+            if (remainingSize) return ERROR(srcSize_wrong);
+            break;
+        default:
+            return ERROR(GENERIC);   /* impossible */
+        }
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        if (ZSTD_isError(decodedSize)) return decodedSize;
+        op += decodedSize;
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+    }
+
+    return op-ostart;
+}
+
+/* ZSTD_errorFrameSizeInfoLegacy() :
+   assumes `cSize` and `dBound` are _not_ NULL */
+static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
+{
+    *cSize = ret;
+    *dBound = ZSTD_CONTENTSIZE_ERROR;
+}
+
+void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t remainingSize = srcSize;
+    size_t nbBlocks = 0;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTD_frameHeaderSize_min) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+        return;
+    }
+    if (MEM_readLE32(src) != ZSTD_MAGICNUMBER) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));
+        return;
+    }
+    ip += ZSTD_frameHeaderSize_min; remainingSize -= ZSTD_frameHeaderSize_min;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
+        if (ZSTD_isError(cBlockSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);
+            return;
+        }
+
+        ip += ZSTD_blockHeaderSize;
+        remainingSize -= ZSTD_blockHeaderSize;
+        if (cBlockSize > remainingSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+        nbBlocks++;
+    }
+
+    *cSize = ip - (const BYTE*)src;
+    *dBound = nbBlocks * BLOCKSIZE;
+}
+
+/* ******************************
+*  Streaming Decompression API
+********************************/
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)
+{
+    return dctx->expected;
+}
+
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    /* Sanity check */
+    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
+    ZSTD_checkContinuity(ctx, dst);
+
+    /* Decompress : frame header; part 1 */
+    switch (ctx->stage)
+    {
+    case ZSTDds_getFrameHeaderSize :
+        /* get frame header size */
+        if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
+        ctx->headerSize = ZSTD_decodeFrameHeader_Part1(ctx, src, ZSTD_frameHeaderSize_min);
+        if (ZSTD_isError(ctx->headerSize)) return ctx->headerSize;
+        memcpy(ctx->headerBuffer, src, ZSTD_frameHeaderSize_min);
+        if (ctx->headerSize > ZSTD_frameHeaderSize_min) return ERROR(GENERIC);   /* impossible */
+        ctx->expected = 0;   /* not necessary to copy more */
+        /* fallthrough */
+    case ZSTDds_decodeFrameHeader:
+        /* get frame header */
+        {   size_t const result = ZSTD_decodeFrameHeader_Part2(ctx, ctx->headerBuffer, ctx->headerSize);
+            if (ZSTD_isError(result)) return result;
+            ctx->expected = ZSTD_blockHeaderSize;
+            ctx->stage = ZSTDds_decodeBlockHeader;
+            return 0;
+        }
+    case ZSTDds_decodeBlockHeader:
+        /* Decode block header */
+        {   blockProperties_t bp;
+            size_t const blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
+            if (ZSTD_isError(blockSize)) return blockSize;
+            if (bp.blockType == bt_end)
+            {
+                ctx->expected = 0;
+                ctx->stage = ZSTDds_getFrameHeaderSize;
+            }
+            else
+            {
+                ctx->expected = blockSize;
+                ctx->bType = bp.blockType;
+                ctx->stage = ZSTDds_decompressBlock;
+            }
+            return 0;
+        }
+    case ZSTDds_decompressBlock:
+        {
+            /* Decompress : block content */
+            size_t rSize;
+            switch(ctx->bType)
+            {
+            case bt_compressed:
+                rSize = ZSTD_decompressBlock_internal(ctx, dst, maxDstSize, src, srcSize);
+                break;
+            case bt_raw :
+                rSize = ZSTD_copyRawBlock(dst, maxDstSize, src, srcSize);
+                break;
+            case bt_rle :
+                return ERROR(GENERIC);   /* not yet handled */
+                break;
+            case bt_end :   /* should never happen (filtered at phase 1) */
+                rSize = 0;
+                break;
+            default:
+                return ERROR(GENERIC);
+            }
+            ctx->stage = ZSTDds_decodeBlockHeader;
+            ctx->expected = ZSTD_blockHeaderSize;
+            ctx->previousDstEnd = (char*)dst + rSize;
+            return rSize;
+        }
+    default:
+        return ERROR(GENERIC);   /* impossible */
+    }
+}
+
+
+static void ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* dict, size_t dictSize)
+{
+    ctx->dictEnd = ctx->previousDstEnd;
+    ctx->vBase = (const char*)dict - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));
+    ctx->base = dict;
+    ctx->previousDstEnd = (const char*)dict + dictSize;
+}
+
+
+
+/*
+    Buffered version of Zstd compression library
+    Copyright (C) 2015, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* The objects defined into this file should be considered experimental.
+ * They are not labelled stable, as their prototype may change in the future.
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes.
+ */
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stdlib.h>
+
+
+/** ************************************************
+*  Streaming decompression
+*
+*  A ZBUFF_DCtx object is required to track streaming operation.
+*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
+*  Use ZBUFF_decompressInit() to start a new decompression operation.
+*  ZBUFF_DCtx objects can be reused multiple times.
+*
+*  Use ZBUFF_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *maxDstSizePtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.
+*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst .
+*  return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
+*            or 0 when a frame is completely decoded
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory)
+*  output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded.
+*  input : just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* **************************************************/
+
+typedef enum { ZBUFFds_init, ZBUFFds_readHeader, ZBUFFds_loadHeader, ZBUFFds_decodeHeader,
+               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFF_dStage;
+
+/* *** Resource management *** */
+
+#define ZSTD_frameHeaderSize_max 5   /* too magical, should come from reference */
+struct ZBUFFv04_DCtx_s {
+    ZSTD_DCtx* zc;
+    ZSTD_parameters params;
+    char* inBuff;
+    size_t inBuffSize;
+    size_t inPos;
+    char* outBuff;
+    size_t outBuffSize;
+    size_t outStart;
+    size_t outEnd;
+    size_t hPos;
+    const char* dict;
+    size_t dictSize;
+    ZBUFF_dStage stage;
+    unsigned char headerBuffer[ZSTD_frameHeaderSize_max];
+};   /* typedef'd to ZBUFF_DCtx within "zstd_buffered.h" */
+
+typedef ZBUFFv04_DCtx ZBUFF_DCtx;
+
+
+static ZBUFF_DCtx* ZBUFF_createDCtx(void)
+{
+    ZBUFF_DCtx* zbc = (ZBUFF_DCtx*)malloc(sizeof(ZBUFF_DCtx));
+    if (zbc==NULL) return NULL;
+    memset(zbc, 0, sizeof(*zbc));
+    zbc->zc = ZSTD_createDCtx();
+    zbc->stage = ZBUFFds_init;
+    return zbc;
+}
+
+static size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbc)
+{
+    if (zbc==NULL) return 0;   /* support free on null */
+    ZSTD_freeDCtx(zbc->zc);
+    free(zbc->inBuff);
+    free(zbc->outBuff);
+    free(zbc);
+    return 0;
+}
+
+
+/* *** Initialization *** */
+
+static size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbc)
+{
+    zbc->stage = ZBUFFds_readHeader;
+    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = zbc->dictSize = 0;
+    return ZSTD_resetDCtx(zbc->zc);
+}
+
+
+static size_t ZBUFF_decompressWithDictionary(ZBUFF_DCtx* zbc, const void* src, size_t srcSize)
+{
+    zbc->dict = (const char*)src;
+    zbc->dictSize = srcSize;
+    return 0;
+}
+
+static size_t ZBUFF_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    size_t length = MIN(maxDstSize, srcSize);
+    memcpy(dst, src, length);
+    return length;
+}
+
+/* *** Decompression *** */
+
+static size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)
+{
+    const char* const istart = (const char*)src;
+    const char* ip = istart;
+    const char* const iend = istart + *srcSizePtr;
+    char* const ostart = (char*)dst;
+    char* op = ostart;
+    char* const oend = ostart + *maxDstSizePtr;
+    U32 notDone = 1;
+
+    DEBUGLOG(5, "ZBUFF_decompressContinue");
+    while (notDone)
+    {
+        switch(zbc->stage)
+        {
+
+        case ZBUFFds_init :
+            DEBUGLOG(5, "ZBUFF_decompressContinue: stage==ZBUFFds_init => ERROR(init_missing)");
+            return ERROR(init_missing);
+
+        case ZBUFFds_readHeader :
+            /* read header from src */
+            {   size_t const headerSize = ZSTD_getFrameParams(&(zbc->params), src, *srcSizePtr);
+                if (ZSTD_isError(headerSize)) return headerSize;
+                if (headerSize) {
+                    /* not enough input to decode header : tell how many bytes would be necessary */
+                    memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr);
+                    zbc->hPos += *srcSizePtr;
+                    *maxDstSizePtr = 0;
+                    zbc->stage = ZBUFFds_loadHeader;
+                    return headerSize - zbc->hPos;
+                }
+                zbc->stage = ZBUFFds_decodeHeader;
+                break;
+            }
+
+        case ZBUFFds_loadHeader:
+            /* complete header from src */
+            {   size_t headerSize = ZBUFF_limitCopy(
+                    zbc->headerBuffer + zbc->hPos, ZSTD_frameHeaderSize_max - zbc->hPos,
+                    src, *srcSizePtr);
+                zbc->hPos += headerSize;
+                ip += headerSize;
+                headerSize = ZSTD_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos);
+                if (ZSTD_isError(headerSize)) return headerSize;
+                if (headerSize) {
+                    /* not enough input to decode header : tell how many bytes would be necessary */
+                    *maxDstSizePtr = 0;
+                    return headerSize - zbc->hPos;
+            }   }
+            /* intentional fallthrough */
+
+        case ZBUFFds_decodeHeader:
+                /* apply header to create / resize buffers */
+                {   size_t const neededOutSize = (size_t)1 << zbc->params.windowLog;
+                    size_t const neededInSize = BLOCKSIZE;   /* a block is never > BLOCKSIZE */
+                    if (zbc->inBuffSize < neededInSize) {
+                        free(zbc->inBuff);
+                        zbc->inBuffSize = neededInSize;
+                        zbc->inBuff = (char*)malloc(neededInSize);
+                        if (zbc->inBuff == NULL) return ERROR(memory_allocation);
+                    }
+                    if (zbc->outBuffSize < neededOutSize) {
+                        free(zbc->outBuff);
+                        zbc->outBuffSize = neededOutSize;
+                        zbc->outBuff = (char*)malloc(neededOutSize);
+                        if (zbc->outBuff == NULL) return ERROR(memory_allocation);
+                }   }
+                if (zbc->dictSize)
+                    ZSTD_decompress_insertDictionary(zbc->zc, zbc->dict, zbc->dictSize);
+                if (zbc->hPos) {
+                    /* some data already loaded into headerBuffer : transfer into inBuff */
+                    memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos);
+                    zbc->inPos = zbc->hPos;
+                    zbc->hPos = 0;
+                    zbc->stage = ZBUFFds_load;
+                    break;
+                }
+                zbc->stage = ZBUFFds_read;
+		/* fall-through */
+        case ZBUFFds_read:
+            {
+                size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
+                if (neededInSize==0)   /* end of frame */
+                {
+                    zbc->stage = ZBUFFds_init;
+                    notDone = 0;
+                    break;
+                }
+                if ((size_t)(iend-ip) >= neededInSize)
+                {
+                    /* directly decode from src */
+                    size_t decodedSize = ZSTD_decompressContinue(zbc->zc,
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
+                        ip, neededInSize);
+                    if (ZSTD_isError(decodedSize)) return decodedSize;
+                    ip += neededInSize;
+                    if (!decodedSize) break;   /* this was just a header */
+                    zbc->outEnd = zbc->outStart +  decodedSize;
+                    zbc->stage = ZBUFFds_flush;
+                    break;
+                }
+                if (ip==iend) { notDone = 0; break; }   /* no more input */
+                zbc->stage = ZBUFFds_load;
+            }
+	    /* fall-through */
+        case ZBUFFds_load:
+            {
+                size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
+                size_t toLoad = neededInSize - zbc->inPos;   /* should always be <= remaining space within inBuff */
+                size_t loadedSize;
+                if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected);   /* should never happen */
+                loadedSize = ZBUFF_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip);
+                ip += loadedSize;
+                zbc->inPos += loadedSize;
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
+                {
+                    size_t decodedSize = ZSTD_decompressContinue(zbc->zc,
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
+                        zbc->inBuff, neededInSize);
+                    if (ZSTD_isError(decodedSize)) return decodedSize;
+                    zbc->inPos = 0;   /* input is consumed */
+                    if (!decodedSize) { zbc->stage = ZBUFFds_read; break; }   /* this was just a header */
+                    zbc->outEnd = zbc->outStart +  decodedSize;
+                    zbc->stage = ZBUFFds_flush;
+                    /* ZBUFFds_flush follows */
+                }
+            }
+	    /* fall-through */
+        case ZBUFFds_flush:
+            {
+                size_t toFlushSize = zbc->outEnd - zbc->outStart;
+                size_t flushedSize = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize);
+                op += flushedSize;
+                zbc->outStart += flushedSize;
+                if (flushedSize == toFlushSize)
+                {
+                    zbc->stage = ZBUFFds_read;
+                    if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize)
+                        zbc->outStart = zbc->outEnd = 0;
+                    break;
+                }
+                /* cannot flush everything */
+                notDone = 0;
+                break;
+            }
+        default: return ERROR(GENERIC);   /* impossible */
+        }
+    }
+
+    *srcSizePtr = ip-istart;
+    *maxDstSizePtr = op-ostart;
+
+    {
+        size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zbc->zc);
+        if (nextSrcSizeHint > 3) nextSrcSizeHint+= 3;   /* get the next block header while at it */
+        nextSrcSizeHint -= zbc->inPos;   /* already loaded*/
+        return nextSrcSizeHint;
+    }
+}
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+unsigned ZBUFFv04_isError(size_t errorCode) { return ERR_isError(errorCode); }
+const char* ZBUFFv04_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
+
+size_t ZBUFFv04_recommendedDInSize()  { return BLOCKSIZE + 3; }
+size_t ZBUFFv04_recommendedDOutSize() { return BLOCKSIZE; }
+
+
+
+/*- ========================================================================= -*/
+
+/* final wrapping stage */
+
+size_t ZSTDv04_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTD_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0);
+}
+
+size_t ZSTDv04_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE==1)
+    size_t regenSize;
+    ZSTD_DCtx* dctx = ZSTD_createDCtx();
+    if (dctx==NULL) return ERROR(memory_allocation);
+    regenSize = ZSTDv04_decompressDCtx(dctx, dst, maxDstSize, src, srcSize);
+    ZSTD_freeDCtx(dctx);
+    return regenSize;
+#else
+    ZSTD_DCtx dctx;
+    return ZSTDv04_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);
+#endif
+}
+
+size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx) { return ZSTD_resetDCtx(dctx); }
+
+size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx)
+{
+    return ZSTD_nextSrcSizeToDecompress(dctx);
+}
+
+size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTD_decompressContinue(dctx, dst, maxDstSize, src, srcSize);
+}
+
+
+
+ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void) { return ZBUFF_createDCtx(); }
+size_t ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx) { return ZBUFF_freeDCtx(dctx); }
+
+size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx) { return ZBUFF_decompressInit(dctx); }
+size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* src, size_t srcSize)
+{ return ZBUFF_decompressWithDictionary(dctx, src, srcSize); }
+
+size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)
+{
+    DEBUGLOG(5, "ZBUFFv04_decompressContinue");
+    return ZBUFF_decompressContinue(dctx, dst, maxDstSizePtr, src, srcSizePtr);
+}
+
+ZSTD_DCtx* ZSTDv04_createDCtx(void) { return ZSTD_createDCtx(); }
+size_t ZSTDv04_freeDCtx(ZSTD_DCtx* dctx) { return ZSTD_freeDCtx(dctx); }
diff --git a/src/zstd_v04.h b/src/zstd_v04.h
new file mode 100644
index 0000000..bb5f3b7
--- /dev/null
+++ b/src/zstd_v04.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_V04_H_91868324769238
+#define ZSTD_V04_H_91868324769238
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stddef.h>   /* size_t */
+
+
+/* *************************************
+*  Simple one-step function
+***************************************/
+/**
+ZSTDv04_decompress() : decompress ZSTD frames compliant with v0.4.x format
+    compressedSize : is the exact source size
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
+                      It must be equal or larger than originalSize, otherwise decompression will fail.
+    return : the number of bytes decompressed into destination buffer (originalSize)
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
+*/
+size_t ZSTDv04_decompress( void* dst, size_t maxOriginalSize,
+                     const void* src, size_t compressedSize);
+
+ /**
+ ZSTDv04_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.4.x format
+     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
+     cSize (output parameter)  : the number of bytes that would be read to decompress this frame
+                                 or an error code if it fails (which can be tested using ZSTDv01_isError())
+     dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
+                                 or ZSTD_CONTENTSIZE_ERROR if an error occurs
+
+    note : assumes `cSize` and `dBound` are _not_ NULL.
+ */
+ void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
+                                      size_t* cSize, unsigned long long* dBound);
+
+/**
+ZSTDv04_isError() : tells if the result of ZSTDv04_decompress() is an error
+*/
+unsigned ZSTDv04_isError(size_t code);
+
+
+/* *************************************
+*  Advanced functions
+***************************************/
+typedef struct ZSTDv04_Dctx_s ZSTDv04_Dctx;
+ZSTDv04_Dctx* ZSTDv04_createDCtx(void);
+size_t ZSTDv04_freeDCtx(ZSTDv04_Dctx* dctx);
+
+size_t ZSTDv04_decompressDCtx(ZSTDv04_Dctx* dctx,
+                              void* dst, size_t maxOriginalSize,
+                        const void* src, size_t compressedSize);
+
+
+/* *************************************
+*  Direct Streaming
+***************************************/
+size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx);
+
+size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx);
+size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+/**
+  Use above functions alternatively.
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
+  Result is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
+*/
+
+
+/* *************************************
+*  Buffered Streaming
+***************************************/
+typedef struct ZBUFFv04_DCtx_s ZBUFFv04_DCtx;
+ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void);
+size_t         ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx);
+
+size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx);
+size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* dict, size_t dictSize);
+
+size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);
+
+/** ************************************************
+*  Streaming decompression
+*
+*  A ZBUFF_DCtx object is required to track streaming operation.
+*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
+*  Use ZBUFF_decompressInit() to start a new decompression operation.
+*  ZBUFF_DCtx objects can be reused multiple times.
+*
+*  Optionally, a reference to a static dictionary can be set, using ZBUFF_decompressWithDictionary()
+*  It must be the same content as the one set during compression phase.
+*  Dictionary content must remain accessible during the decompression process.
+*
+*  Use ZBUFF_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *maxDstSizePtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
+*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst.
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
+*            or 0 when a frame is completely decoded
+*            or an error code, which can be tested using ZBUFF_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize / ZBUFF_recommendedDOutSize
+*  output : ZBUFF_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded.
+*  input : ZBUFF_recommendedDInSize==128Kb+3; just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* **************************************************/
+unsigned ZBUFFv04_isError(size_t errorCode);
+const char* ZBUFFv04_getErrorName(size_t errorCode);
+
+
+/** The below functions provide recommended buffer sizes for Compression or Decompression operations.
+*   These sizes are not compulsory, they just tend to offer better latency */
+size_t ZBUFFv04_recommendedDInSize(void);
+size_t ZBUFFv04_recommendedDOutSize(void);
+
+
+/* *************************************
+*  Prefix - version detection
+***************************************/
+#define ZSTDv04_magicNumber 0xFD2FB524   /* v0.4 */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_V04_H_91868324769238 */
diff --git a/src/zstd_v05.c b/src/zstd_v05.c
new file mode 100644
index 0000000..e347b00
--- /dev/null
+++ b/src/zstd_v05.c
@@ -0,0 +1,4046 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/*- Dependencies -*/
+#include "zstd_v05.h"
+#include "error_private.h"
+
+
+/* ******************************************************************
+   mem.h
+   low-level memory access routines
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef MEM_H_MODULE
+#define MEM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*-****************************************
+*  Dependencies
+******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include <string.h>    /* memcpy */
+
+
+/*-****************************************
+*  Compiler specifics
+******************************************/
+#if defined(__GNUC__)
+#  define MEM_STATIC static __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define MEM_STATIC static inline
+#elif defined(_MSC_VER)
+#  define MEM_STATIC static __inline
+#else
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/*-**************************************************************
+*  Basic Types
+*****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+# include <stdint.h>
+  typedef  uint8_t BYTE;
+  typedef uint16_t U16;
+  typedef  int16_t S16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+  typedef  int64_t S64;
+#else
+  typedef unsigned char       BYTE;
+  typedef unsigned short      U16;
+  typedef   signed short      S16;
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+  typedef unsigned long long  U64;
+  typedef   signed long long  S64;
+#endif
+
+
+/*-**************************************************************
+*  Memory I/O
+*****************************************************************/
+/* MEM_FORCE_MEMORY_ACCESS :
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets depending on alignment.
+ *            In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define MEM_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#    define MEM_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
+
+MEM_STATIC unsigned MEM_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
+
+/* violates C standard, by lying on structure alignment.
+Only use if no other choice to achieve best performance on target platform */
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
+
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;
+
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }
+
+#else
+
+/* default method, safe and standard.
+   can sometimes prove slower */
+
+MEM_STATIC U16 MEM_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U32 MEM_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U64 MEM_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+MEM_STATIC void MEM_write32(void* memPtr, U32 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+MEM_STATIC void MEM_write64(void* memPtr, U64 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+#endif /* MEM_FORCE_MEMORY_ACCESS */
+
+
+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read16(memPtr);
+    else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
+{
+    if (MEM_isLittleEndian()) {
+        MEM_write16(memPtr, val);
+    } else {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE)val;
+        p[1] = (BYTE)(val>>8);
+    }
+}
+
+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read32(memPtr);
+    else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
+    }
+}
+
+
+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read64(memPtr);
+    else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
+    }
+}
+
+
+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readLE32(memPtr);
+    else
+        return (size_t)MEM_readLE64(memPtr);
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* MEM_H_MODULE */
+
+/*
+    zstd - standard compression library
+    Header File for static linking only
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net
+*/
+#ifndef ZSTD_STATIC_H
+#define ZSTD_STATIC_H
+
+/* The prototypes defined within this file are considered experimental.
+ * They should not be used in the context DLL as they may change in the future.
+ * Prefer static linking if you need them, to control breaking version changes issues.
+ */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/*-*************************************
+*  Types
+***************************************/
+#define ZSTDv05_WINDOWLOG_ABSOLUTEMIN 11
+
+
+/*-*************************************
+*  Advanced functions
+***************************************/
+/*- Advanced Decompression functions -*/
+
+/*! ZSTDv05_decompress_usingPreparedDCtx() :
+*   Same as ZSTDv05_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded.
+*   It avoids reloading the dictionary each time.
+*   `preparedDCtx` must have been properly initialized using ZSTDv05_decompressBegin_usingDict().
+*   Requires 2 contexts : 1 for reference, which will not be modified, and 1 to run the decompression operation */
+size_t ZSTDv05_decompress_usingPreparedDCtx(
+                                             ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* preparedDCtx,
+                                             void* dst, size_t dstCapacity,
+                                       const void* src, size_t srcSize);
+
+
+/* **************************************
+*  Streaming functions (direct mode)
+****************************************/
+size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx);
+
+/*
+  Streaming decompression, direct mode (bufferless)
+
+  A ZSTDv05_DCtx object is required to track streaming operations.
+  Use ZSTDv05_createDCtx() / ZSTDv05_freeDCtx() to manage it.
+  A ZSTDv05_DCtx object can be re-used multiple times.
+
+  First typical operation is to retrieve frame parameters, using ZSTDv05_getFrameParams().
+  This operation is independent, and just needs enough input data to properly decode the frame header.
+  Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding.
+  Result : 0 when successful, it means the ZSTDv05_parameters structure has been filled.
+           >0 : means there is not enough data into src. Provides the expected size to successfully decode header.
+           errorCode, which can be tested using ZSTDv05_isError()
+
+  Start decompression, with ZSTDv05_decompressBegin() or ZSTDv05_decompressBegin_usingDict()
+  Alternatively, you can copy a prepared context, using ZSTDv05_copyDCtx()
+
+  Then use ZSTDv05_nextSrcSizeToDecompress() and ZSTDv05_decompressContinue() alternatively.
+  ZSTDv05_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv05_decompressContinue().
+  ZSTDv05_decompressContinue() requires this exact amount of bytes, or it will fail.
+  ZSTDv05_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog).
+  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible.
+
+  @result of ZSTDv05_decompressContinue() is the number of bytes regenerated within 'dst'.
+  It can be zero, which is not an error; it just means ZSTDv05_decompressContinue() has decoded some header.
+
+  A frame is fully decoded when ZSTDv05_nextSrcSizeToDecompress() returns zero.
+  Context can then be reset to start a new decompression.
+*/
+
+
+/* **************************************
+*  Block functions
+****************************************/
+/*! Block functions produce and decode raw zstd blocks, without frame metadata.
+    User will have to take in charge required information to regenerate data, such as block sizes.
+
+    A few rules to respect :
+    - Uncompressed block size must be <= 128 KB
+    - Compressing or decompressing requires a context structure
+      + Use ZSTDv05_createCCtx() and ZSTDv05_createDCtx()
+    - It is necessary to init context before starting
+      + compression : ZSTDv05_compressBegin()
+      + decompression : ZSTDv05_decompressBegin()
+      + variants _usingDict() are also allowed
+      + copyCCtx() and copyDCtx() work too
+    - When a block is considered not compressible enough, ZSTDv05_compressBlock() result will be zero.
+      In which case, nothing is produced into `dst`.
+      + User must test for such outcome and deal directly with uncompressed data
+      + ZSTDv05_decompressBlock() doesn't accept uncompressed data as input !!
+*/
+
+size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* ZSTDv05_STATIC_H */
+
+
+/*
+    zstd_internal - common functions to include
+    Header File for include
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+*/
+#ifndef ZSTD_CCOMMON_H_MODULE
+#define ZSTD_CCOMMON_H_MODULE
+
+
+
+/*-*************************************
+*  Common macros
+***************************************/
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
+
+
+/*-*************************************
+*  Common constants
+***************************************/
+#define ZSTDv05_DICT_MAGIC  0xEC30A435
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
+
+static const size_t ZSTDv05_blockHeaderSize = 3;
+static const size_t ZSTDv05_frameHeaderSize_min = 5;
+#define ZSTDv05_frameHeaderSize_max 5         /* define, for static allocation */
+
+#define BITv057 128
+#define BITv056  64
+#define BITv055  32
+#define BITv054  16
+#define BITv051   2
+#define BITv050   1
+
+#define IS_HUFv05 0
+#define IS_PCH 1
+#define IS_RAW 2
+#define IS_RLE 3
+
+#define MINMATCH 4
+#define REPCODE_STARTVALUE 1
+
+#define Litbits  8
+#define MLbits   7
+#define LLbits   6
+#define Offbits  5
+#define MaxLit ((1<<Litbits) - 1)
+#define MaxML  ((1<<MLbits) - 1)
+#define MaxLL  ((1<<LLbits) - 1)
+#define MaxOff ((1<<Offbits)- 1)
+#define MLFSEv05Log   10
+#define LLFSEv05Log   10
+#define OffFSEv05Log   9
+#define MaxSeq MAX(MaxLL, MaxML)
+
+#define FSEv05_ENCODING_RAW     0
+#define FSEv05_ENCODING_RLE     1
+#define FSEv05_ENCODING_STATIC  2
+#define FSEv05_ENCODING_DYNAMIC 3
+
+
+#define HufLog 12
+
+#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
+#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */
+
+#define WILDCOPY_OVERLENGTH 8
+
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
+
+
+/*-*******************************************
+*  Shared functions to include for inlining
+*********************************************/
+static void ZSTDv05_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+
+#define COPY8(d,s) { ZSTDv05_copy8(d,s); d+=8; s+=8; }
+
+/*! ZSTDv05_wildcopy() :
+*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
+MEM_STATIC void ZSTDv05_wildcopy(void* dst, const void* src, ptrdiff_t length)
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+    do
+        COPY8(op, ip)
+    while (op < oend);
+}
+
+
+/*-*******************************************
+*  Private interfaces
+*********************************************/
+typedef struct {
+    void* buffer;
+    U32*  offsetStart;
+    U32*  offset;
+    BYTE* offCodeStart;
+    BYTE* offCode;
+    BYTE* litStart;
+    BYTE* lit;
+    BYTE* litLengthStart;
+    BYTE* litLength;
+    BYTE* matchLengthStart;
+    BYTE* matchLength;
+    BYTE* dumpsStart;
+    BYTE* dumps;
+    /* opt */
+    U32* matchLengthFreq;
+    U32* litLengthFreq;
+    U32* litFreq;
+    U32* offCodeFreq;
+    U32  matchLengthSum;
+    U32  litLengthSum;
+    U32  litSum;
+    U32  offCodeSum;
+} seqStore_t;
+
+
+
+#endif   /* ZSTDv05_CCOMMON_H_MODULE */
+/* ******************************************************************
+   FSEv05 : Finite State Entropy coder
+   header file
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef FSEv05_H
+#define FSEv05_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* *****************************************
+*  Includes
+******************************************/
+#include <stddef.h>    /* size_t, ptrdiff_t */
+
+
+/*-****************************************
+*  FSEv05 simple functions
+******************************************/
+size_t FSEv05_decompress(void* dst,  size_t maxDstSize,
+                const void* cSrc, size_t cSrcSize);
+/*!
+FSEv05_decompress():
+    Decompress FSEv05 data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'maxDstSize'.
+    return : size of regenerated data (<= maxDstSize)
+             or an error code, which can be tested using FSEv05_isError()
+
+    ** Important ** : FSEv05_decompress() doesn't decompress non-compressible nor RLE data !!!
+    Why ? : making this distinction requires a header.
+    Header management is intentionally delegated to the user layer, which can better manage special cases.
+*/
+
+
+/* *****************************************
+*  Tool functions
+******************************************/
+/* Error Management */
+unsigned    FSEv05_isError(size_t code);        /* tells if a return value is an error code */
+const char* FSEv05_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
+
+
+
+
+/* *****************************************
+*  FSEv05 detailed API
+******************************************/
+/* *** DECOMPRESSION *** */
+
+/*!
+FSEv05_readNCount():
+   Read compactly saved 'normalizedCounter' from 'rBuffer'.
+   return : size read from 'rBuffer'
+            or an errorCode, which can be tested using FSEv05_isError()
+            maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
+size_t FSEv05_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
+
+/*!
+Constructor and Destructor of type FSEv05_DTable
+    Note that its size depends on 'tableLog' */
+typedef unsigned FSEv05_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+FSEv05_DTable* FSEv05_createDTable(unsigned tableLog);
+void        FSEv05_freeDTable(FSEv05_DTable* dt);
+
+/*!
+FSEv05_buildDTable():
+   Builds 'dt', which must be already allocated, using FSEv05_createDTable()
+   @return : 0,
+             or an errorCode, which can be tested using FSEv05_isError() */
+size_t FSEv05_buildDTable (FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
+
+/*!
+FSEv05_decompress_usingDTable():
+   Decompress compressed source @cSrc of size @cSrcSize using `dt`
+   into `dst` which must be already allocated.
+   @return : size of regenerated data (necessarily <= @dstCapacity)
+             or an errorCode, which can be tested using FSEv05_isError() */
+size_t FSEv05_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv05_DTable* dt);
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* FSEv05_H */
+/* ******************************************************************
+   bitstream
+   Part of FSEv05 library
+   header file (to include)
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef BITv05STREAM_H_MODULE
+#define BITv05STREAM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*
+*  This API consists of small unitary functions, which highly benefit from being inlined.
+*  Since link-time-optimization is not available for all compilers,
+*  these functions are defined into a .h to be included.
+*/
+
+
+
+/*-********************************************
+*  bitStream decoding API (read backward)
+**********************************************/
+typedef struct
+{
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+} BITv05_DStream_t;
+
+typedef enum { BITv05_DStream_unfinished = 0,
+               BITv05_DStream_endOfBuffer = 1,
+               BITv05_DStream_completed = 2,
+               BITv05_DStream_overflow = 3 } BITv05_DStream_status;  /* result of BITv05_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
+
+MEM_STATIC size_t   BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
+MEM_STATIC size_t   BITv05_readBits(BITv05_DStream_t* bitD, unsigned nbBits);
+MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD);
+MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* bitD);
+
+
+/*-****************************************
+*  unsafe API
+******************************************/
+MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits);
+/* faster, but works only if nbBits >= 1 */
+
+
+
+/*-**************************************************************
+*  Helper functions
+****************************************************************/
+MEM_STATIC unsigned BITv05_highbit32 (U32 val)
+{
+#   if defined(_MSC_VER)   /* Visual */
+    unsigned long r=0;
+    _BitScanReverse ( &r, val );
+    return (unsigned) r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+    return 31 - __builtin_clz (val);
+#   else   /* Software version */
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+    U32 v = val;
+    unsigned r;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+    return r;
+#   endif
+}
+
+
+
+/*-********************************************************
+* bitStream decoding
+**********************************************************/
+/*!BITv05_initDStream
+*  Initialize a BITv05_DStream_t.
+*  @bitD : a pointer to an already allocated BITv05_DStream_t structure
+*  @srcBuffer must point at the beginning of a bitStream
+*  @srcSize must be the exact size of the bitStream
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
+*/
+MEM_STATIC size_t BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
+
+    if (srcSize >=  sizeof(size_t)) {  /* normal case */
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BITv05_highbit32(contain32);
+    } else {
+        U32 contain32;
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);/* fall-through */
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);/* fall-through */
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);/* fall-through */
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; /* fall-through */
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; /* fall-through */
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; /* fall-through */
+            default: break;
+        }
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
+        bitD->bitsConsumed = 8 - BITv05_highbit32(contain32);
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+
+MEM_STATIC size_t BITv05_lookBits(BITv05_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
+}
+
+/*! BITv05_lookBitsFast :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BITv05_lookBitsFast(BITv05_DStream_t* bitD, U32 nbBits)
+{
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
+}
+
+MEM_STATIC void BITv05_skipBits(BITv05_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+MEM_STATIC size_t BITv05_readBits(BITv05_DStream_t* bitD, unsigned nbBits)
+{
+    size_t value = BITv05_lookBits(bitD, nbBits);
+    BITv05_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*!BITv05_readBitsFast :
+*  unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits)
+{
+    size_t value = BITv05_lookBitsFast(bitD, nbBits);
+    BITv05_skipBits(bitD, nbBits);
+    return value;
+}
+
+MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
+        return BITv05_DStream_overflow;
+
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        return BITv05_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start) {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv05_DStream_endOfBuffer;
+        return BITv05_DStream_completed;
+    }
+    {
+        U32 nbBytes = bitD->bitsConsumed >> 3;
+        BITv05_DStream_status result = BITv05_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start) {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = BITv05_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
+        return result;
+    }
+}
+
+/*! BITv05_endOfDStream
+*   @return Tells if DStream has reached its exact end
+*/
+MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* DStream)
+{
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* BITv05STREAM_H_MODULE */
+/* ******************************************************************
+   FSEv05 : Finite State Entropy coder
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef FSEv05_STATIC_H
+#define FSEv05_STATIC_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/* *****************************************
+*  Static allocation
+*******************************************/
+/* It is possible to statically allocate FSEv05 CTable/DTable as a table of unsigned using below macros */
+#define FSEv05_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+
+/* *****************************************
+*  FSEv05 advanced API
+*******************************************/
+size_t FSEv05_buildDTable_raw (FSEv05_DTable* dt, unsigned nbBits);
+/* build a fake FSEv05_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
+
+size_t FSEv05_buildDTable_rle (FSEv05_DTable* dt, unsigned char symbolValue);
+/* build a fake FSEv05_DTable, designed to always generate the same symbolValue */
+
+
+
+/* *****************************************
+*  FSEv05 symbol decompression API
+*******************************************/
+typedef struct
+{
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSEv05_DState_t;
+
+
+static void     FSEv05_initDState(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD, const FSEv05_DTable* dt);
+
+static unsigned char FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD);
+
+static unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr);
+
+
+
+/* *****************************************
+*  FSEv05 unsafe API
+*******************************************/
+static unsigned char FSEv05_decodeSymbolFast(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD);
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
+
+
+/* *****************************************
+*  Implementation of inlined functions
+*******************************************/
+/* decompression */
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSEv05_DTableHeader;   /* sizeof U32 */
+
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSEv05_decode_t;   /* size == U32 */
+
+MEM_STATIC void FSEv05_initDState(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD, const FSEv05_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSEv05_DTableHeader* const DTableH = (const FSEv05_DTableHeader*)ptr;
+    DStatePtr->state = BITv05_readBits(bitD, DTableH->tableLog);
+    BITv05_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+MEM_STATIC BYTE FSEv05_peakSymbol(FSEv05_DState_t* DStatePtr)
+{
+    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    return DInfo.symbol;
+}
+
+MEM_STATIC BYTE FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD)
+{
+    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32  nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BITv05_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC BYTE FSEv05_decodeSymbolFast(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD)
+{
+    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    const U32 nbBits = DInfo.nbBits;
+    BYTE symbol = DInfo.symbol;
+    size_t lowBits = BITv05_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+MEM_STATIC unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr)
+{
+    return DStatePtr->state == 0;
+}
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* FSEv05_STATIC_H */
+/* ******************************************************************
+   FSEv05 : Finite State Entropy coder
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+#ifndef FSEv05_COMMONDEFS_ONLY
+
+/* **************************************************************
+*  Tuning parameters
+****************************************************************/
+/*!MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#define FSEv05_MAX_MEMORY_USAGE 14
+#define FSEv05_DEFAULT_MEMORY_USAGE 13
+
+/*!FSEv05_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#define FSEv05_MAX_SYMBOL_VALUE 255
+
+
+/* **************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSEv05_FUNCTION_TYPE BYTE
+#define FSEv05_FUNCTION_EXTENSION
+#define FSEv05_DECODE_TYPE FSEv05_decode_t
+
+
+#endif   /* !FSEv05_COMMONDEFS_ONLY */
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  define FORCE_INLINE static __forceinline
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#else
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/* **************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+
+
+/* ***************************************************************
+*  Constants
+*****************************************************************/
+#define FSEv05_MAX_TABLELOG  (FSEv05_MAX_MEMORY_USAGE-2)
+#define FSEv05_MAX_TABLESIZE (1U<<FSEv05_MAX_TABLELOG)
+#define FSEv05_MAXTABLESIZE_MASK (FSEv05_MAX_TABLESIZE-1)
+#define FSEv05_DEFAULT_TABLELOG (FSEv05_DEFAULT_MEMORY_USAGE-2)
+#define FSEv05_MIN_TABLELOG 5
+
+#define FSEv05_TABLELOG_ABSOLUTE_MAX 15
+#if FSEv05_MAX_TABLELOG > FSEv05_TABLELOG_ABSOLUTE_MAX
+#error "FSEv05_MAX_TABLELOG > FSEv05_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define FSEv05_STATIC_ASSERT(c) { enum { FSEv05_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/* **************************************************************
+*  Complex types
+****************************************************************/
+typedef unsigned DTable_max_t[FSEv05_DTABLE_SIZE_U32(FSEv05_MAX_TABLELOG)];
+
+
+/* **************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSEv05_FUNCTION_EXTENSION
+#  error "FSEv05_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSEv05_FUNCTION_TYPE
+#  error "FSEv05_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSEv05_CAT(X,Y) X##Y
+#define FSEv05_FUNCTION_NAME(X,Y) FSEv05_CAT(X,Y)
+#define FSEv05_TYPE_NAME(X,Y) FSEv05_CAT(X,Y)
+
+
+/* Function templates */
+static U32 FSEv05_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
+
+
+
+FSEv05_DTable* FSEv05_createDTable (unsigned tableLog)
+{
+    if (tableLog > FSEv05_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv05_TABLELOG_ABSOLUTE_MAX;
+    return (FSEv05_DTable*)malloc( FSEv05_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
+}
+
+void FSEv05_freeDTable (FSEv05_DTable* dt)
+{
+    free(dt);
+}
+
+size_t FSEv05_buildDTable(FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    FSEv05_DTableHeader DTableH;
+    void* const tdPtr = dt+1;   /* because dt is unsigned, 32-bits aligned on 32-bits */
+    FSEv05_DECODE_TYPE* const tableDecode = (FSEv05_DECODE_TYPE*) (tdPtr);
+    const U32 tableSize = 1 << tableLog;
+    const U32 tableMask = tableSize-1;
+    const U32 step = FSEv05_tableStep(tableSize);
+    U16 symbolNext[FSEv05_MAX_SYMBOL_VALUE+1];
+    U32 position = 0;
+    U32 highThreshold = tableSize-1;
+    const S16 largeLimit= (S16)(1 << (tableLog-1));
+    U32 noLarge = 1;
+    U32 s;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSEv05_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
+    if (tableLog > FSEv05_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+
+    /* Init, lay down lowprob symbols */
+    memset(tableDecode, 0, sizeof(FSEv05_FUNCTION_TYPE) * (maxSymbolValue+1) );   /* useless init, but keep static analyzer happy, and we don't need to performance optimize legacy decoders */
+    DTableH.tableLog = (U16)tableLog;
+    for (s=0; s<=maxSymbolValue; s++) {
+        if (normalizedCounter[s]==-1) {
+            tableDecode[highThreshold--].symbol = (FSEv05_FUNCTION_TYPE)s;
+            symbolNext[s] = 1;
+        } else {
+            if (normalizedCounter[s] >= largeLimit) noLarge=0;
+            symbolNext[s] = normalizedCounter[s];
+    }   }
+
+    /* Spread symbols */
+    for (s=0; s<=maxSymbolValue; s++) {
+        int i;
+        for (i=0; i<normalizedCounter[s]; i++) {
+            tableDecode[position].symbol = (FSEv05_FUNCTION_TYPE)s;
+            position = (position + step) & tableMask;
+            while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+    }   }
+
+    if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+
+    /* Build Decoding table */
+    {
+        U32 i;
+        for (i=0; i<tableSize; i++) {
+            FSEv05_FUNCTION_TYPE symbol = (FSEv05_FUNCTION_TYPE)(tableDecode[i].symbol);
+            U16 nextState = symbolNext[symbol]++;
+            tableDecode[i].nbBits = (BYTE) (tableLog - BITv05_highbit32 ((U32)nextState) );
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
+    }   }
+
+    DTableH.fastMode = (U16)noLarge;
+    memcpy(dt, &DTableH, sizeof(DTableH));
+    return 0;
+}
+
+
+#ifndef FSEv05_COMMONDEFS_ONLY
+/*-****************************************
+*  FSEv05 helper functions
+******************************************/
+unsigned FSEv05_isError(size_t code) { return ERR_isError(code); }
+
+const char* FSEv05_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+/*-**************************************************************
+*  FSEv05 NCount encoding-decoding
+****************************************************************/
+static short FSEv05_abs(short a) { return a<0 ? -a : a; }
+
+
+size_t FSEv05_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) return ERROR(srcSize_wrong);
+    bitStream = MEM_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSEv05_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSEv05_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) && (charnum<=*maxSVPtr)) {
+        if (previous0) {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF) {
+                n0+=24;
+                if (ip < iend-5) {
+                    ip+=2;
+                    bitStream = MEM_readLE32(ip) >> bitCount;
+                } else {
+                    bitStream >>= 16;
+                    bitCount+=16;
+            }   }
+            while ((bitStream & 3) == 3) {
+                n0+=3;
+                bitStream>>=2;
+                bitCount+=2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = MEM_readLE32(ip) >> bitCount;
+            }
+            else
+                bitStream >>= 2;
+        }
+        {
+            const short max = (short)((2*threshold-1)-remaining);
+            short count;
+
+            if ((bitStream & (threshold-1)) < (U32)max) {
+                count = (short)(bitStream & (threshold-1));
+                bitCount   += nbBits-1;
+            } else {
+                count = (short)(bitStream & (2*threshold-1));
+                if (count >= threshold) count -= max;
+                bitCount   += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= FSEv05_abs(count);
+            normalizedCounter[charnum++] = count;
+            previous0 = !count;
+            while (remaining < threshold) {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                ip += bitCount>>3;
+                bitCount &= 7;
+            } else {
+                bitCount -= (int)(8 * (iend - 4 - ip));
+                ip = iend - 4;
+            }
+            bitStream = MEM_readLE32(ip) >> (bitCount & 31);
+    }   }
+    if (remaining != 1) return ERROR(GENERIC);
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
+    return ip-istart;
+}
+
+
+
+/*-*******************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+size_t FSEv05_buildDTable_rle (FSEv05_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSEv05_decode_t* const cell = (FSEv05_decode_t*)dPtr;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+size_t FSEv05_buildDTable_raw (FSEv05_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSEv05_decode_t* const dinfo = (FSEv05_decode_t*)dPtr;
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSymbolValue = tableMask;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<=maxSymbolValue; s++) {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+FORCE_INLINE size_t FSEv05_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSEv05_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    BITv05_DStream_t bitD;
+    FSEv05_DState_t state1;
+    FSEv05_DState_t state2;
+    size_t errorCode;
+
+    /* Init */
+    errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
+    if (FSEv05_isError(errorCode)) return errorCode;
+
+    FSEv05_initDState(&state1, &bitD, dt);
+    FSEv05_initDState(&state2, &bitD, dt);
+
+#define FSEv05_GETSYMBOL(statePtr) fast ? FSEv05_decodeSymbolFast(statePtr, &bitD) : FSEv05_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (BITv05_reloadDStream(&bitD)==BITv05_DStream_unfinished) && (op<olimit) ; op+=4) {
+        op[0] = FSEv05_GETSYMBOL(&state1);
+
+        if (FSEv05_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BITv05_reloadDStream(&bitD);
+
+        op[1] = FSEv05_GETSYMBOL(&state2);
+
+        if (FSEv05_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (BITv05_reloadDStream(&bitD) > BITv05_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSEv05_GETSYMBOL(&state1);
+
+        if (FSEv05_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BITv05_reloadDStream(&bitD);
+
+        op[3] = FSEv05_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : BITv05_reloadDStream(&bitD) >= FSEv05_DStream_partiallyFilled; Ends at exactly BITv05_DStream_completed */
+    while (1) {
+        if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state1))) )
+            break;
+
+        *op++ = FSEv05_GETSYMBOL(&state1);
+
+        if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state2))) )
+            break;
+
+        *op++ = FSEv05_GETSYMBOL(&state2);
+    }
+
+    /* end ? */
+    if (BITv05_endOfDStream(&bitD) && FSEv05_endOfDState(&state1) && FSEv05_endOfDState(&state2))
+        return op-ostart;
+
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
+
+    return ERROR(corruption_detected);
+}
+
+
+size_t FSEv05_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSEv05_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSEv05_DTableHeader* DTableH = (const FSEv05_DTableHeader*)ptr;
+    const U32 fastMode = DTableH->fastMode;
+
+    /* select fast mode (static) */
+    if (fastMode) return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+size_t FSEv05_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSEv05_MAX_SYMBOL_VALUE+1];
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSEv05_MAX_SYMBOL_VALUE;
+    size_t errorCode;
+
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
+
+    /* normal FSEv05 decoding mode */
+    errorCode = FSEv05_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+    if (FSEv05_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    errorCode = FSEv05_buildDTable (dt, counting, maxSymbolValue, tableLog);
+    if (FSEv05_isError(errorCode)) return errorCode;
+
+    /* always return, even if it is an error code */
+    return FSEv05_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
+}
+
+
+
+#endif   /* FSEv05_COMMONDEFS_ONLY */
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   header file
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef HUFF0_H
+#define HUFF0_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/* ****************************************
+*  Huff0 simple functions
+******************************************/
+size_t HUFv05_decompress(void* dst,  size_t dstSize,
+                const void* cSrc, size_t cSrcSize);
+/*!
+HUFv05_decompress():
+    Decompress Huff0 data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'dstSize'.
+    @dstSize : must be the **exact** size of original (uncompressed) data.
+    Note : in contrast with FSEv05, HUFv05_decompress can regenerate
+           RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
+           because it knows size to regenerate.
+    @return : size of regenerated data (== dstSize)
+              or an error code, which can be tested using HUFv05_isError()
+*/
+
+
+/* ****************************************
+*  Tool functions
+******************************************/
+/* Error Management */
+unsigned    HUFv05_isError(size_t code);        /* tells if a return value is an error code */
+const char* HUFv05_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* HUF0_H */
+/* ******************************************************************
+   Huff0 : Huffman codec, part of New Generation Entropy library
+   header file, for static linking only
+   Copyright (C) 2013-2016, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef HUF0_STATIC_H
+#define HUF0_STATIC_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/* ****************************************
+*  Static allocation
+******************************************/
+/* static allocation of Huff0's DTable */
+#define HUFv05_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))
+#define HUFv05_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+        unsigned short DTable[HUFv05_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUFv05_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
+        unsigned int DTable[HUFv05_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUFv05_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
+        unsigned int DTable[HUFv05_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
+
+
+/* ****************************************
+*  Advanced decompression functions
+******************************************/
+size_t HUFv05_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+size_t HUFv05_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
+
+
+/* ****************************************
+*  Huff0 detailed API
+******************************************/
+/*!
+HUFv05_decompress() does the following:
+1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics
+2. build Huffman table from save, using HUFv05_readDTableXn()
+3. decode 1 or 4 segments in parallel using HUFv05_decompressSXn_usingDTable
+*/
+size_t HUFv05_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize);
+size_t HUFv05_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize);
+
+size_t HUFv05_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
+size_t HUFv05_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
+
+
+/* single stream variants */
+
+size_t HUFv05_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+size_t HUFv05_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
+
+size_t HUFv05_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
+size_t HUFv05_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* HUF0_STATIC_H */
+/* ******************************************************************
+   Huff0 : Huffman coder, part of New Generation Entropy library
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSEv05+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+/* inline is defined */
+#elif defined(_MSC_VER)
+#  define inline __inline
+#else
+#  define inline /* disable inline */
+#endif
+
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#endif
+
+
+/* **************************************************************
+*  Includes
+****************************************************************/
+#include <stdlib.h>     /* malloc, free, qsort */
+#include <string.h>     /* memcpy, memset */
+#include <stdio.h>      /* printf (debug) */
+
+
+/* **************************************************************
+*  Constants
+****************************************************************/
+#define HUFv05_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUFv05_MAX_TABLELOG. Beyond that value, code does not work */
+#define HUFv05_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUFv05_ABSOLUTEMAX_TABLELOG */
+#define HUFv05_DEFAULT_TABLELOG  HUFv05_MAX_TABLELOG   /* tableLog by default, when not specified */
+#define HUFv05_MAX_SYMBOL_VALUE 255
+#if (HUFv05_MAX_TABLELOG > HUFv05_ABSOLUTEMAX_TABLELOG)
+#  error "HUFv05_MAX_TABLELOG is too large !"
+#endif
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+unsigned HUFv05_isError(size_t code) { return ERR_isError(code); }
+const char* HUFv05_getErrorName(size_t code) { return ERR_getErrorName(code); }
+#define HUFv05_STATIC_ASSERT(c) { enum { HUFv05_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/* *******************************************************
+*  Huff0 : Huffman block decompression
+*********************************************************/
+typedef struct { BYTE byte; BYTE nbBits; } HUFv05_DEltX2;   /* single-symbol decoding */
+
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv05_DEltX4;  /* double-symbols decoding */
+
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
+
+/*! HUFv05_readStats
+    Read compact Huffman tree, saved by HUFv05_writeCTable
+    @huffWeight : destination buffer
+    @return : size read from `src`
+*/
+static size_t HUFv05_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                            U32* nbSymbolsPtr, U32* tableLogPtr,
+                            const void* src, size_t srcSize)
+{
+    U32 weightTotal;
+    U32 tableLog;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+    U32 n;
+
+    if (!srcSize) return ERROR(srcSize_wrong);
+    iSize = ip[0];
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
+
+    if (iSize >= 128)  { /* special header */
+        if (iSize >= (242)) {  /* RLE */
+            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+            oSize = l[iSize-242];
+            memset(huffWeight, 1, hwSize);
+            iSize = 0;
+        }
+        else {   /* Incompressible */
+            oSize = iSize - 127;
+            iSize = ((oSize+1)/2);
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+            if (oSize >= hwSize) return ERROR(corruption_detected);
+            ip += 1;
+            for (n=0; n<oSize; n+=2) {
+                huffWeight[n]   = ip[n/2] >> 4;
+                huffWeight[n+1] = ip[n/2] & 15;
+    }   }   }
+    else  {   /* header compressed with FSEv05 (normal case) */
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        oSize = FSEv05_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
+        if (FSEv05_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankStats, 0, (HUFv05_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
+    weightTotal = 0;
+    for (n=0; n<oSize; n++) {
+        if (huffWeight[n] >= HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+        rankStats[huffWeight[n]]++;
+        weightTotal += (1 << huffWeight[n]) >> 1;
+    }
+    if (weightTotal == 0) return ERROR(corruption_detected);
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    tableLog = BITv05_highbit32(weightTotal) + 1;
+    if (tableLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+    {   /* determine last weight */
+        U32 total = 1 << tableLog;
+        U32 rest = total - weightTotal;
+        U32 verif = 1 << BITv05_highbit32(rest);
+        U32 lastWeight = BITv05_highbit32(rest) + 1;
+        if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
+        huffWeight[oSize] = (BYTE)lastWeight;
+        rankStats[lastWeight]++;
+    }
+
+    /* check tree construction validity */
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* results */
+    *nbSymbolsPtr = (U32)(oSize+1);
+    *tableLogPtr = tableLog;
+    return iSize+1;
+}
+
+
+/*-***************************/
+/*  single-symbol decoding   */
+/*-***************************/
+
+size_t HUFv05_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUFv05_MAX_SYMBOL_VALUE + 1];
+    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
+    U32 tableLog = 0;
+    size_t iSize;
+    U32 nbSymbols = 0;
+    U32 n;
+    U32 nextRankStart;
+    void* const dtPtr = DTable + 1;
+    HUFv05_DEltX2* const dt = (HUFv05_DEltX2*)dtPtr;
+
+    HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUFv05_readStats(huffWeight, HUFv05_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
+    if (HUFv05_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof allocated DTable, from used size of DTable, in case of re-use */
+
+    /* Prepare ranks */
+    nextRankStart = 0;
+    for (n=1; n<=tableLog; n++) {
+        U32 current = nextRankStart;
+        nextRankStart += (rankVal[n] << (n-1));
+        rankVal[n] = current;
+    }
+
+    /* fill DTable */
+    for (n=0; n<nbSymbols; n++) {
+        const U32 w = huffWeight[n];
+        const U32 length = (1 << w) >> 1;
+        U32 i;
+        HUFv05_DEltX2 D;
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
+        for (i = rankVal[w]; i < rankVal[w] + length; i++)
+            dt[i] = D;
+        rankVal[w] += length;
+    }
+
+    return iSize;
+}
+
+static BYTE HUFv05_decodeSymbolX2(BITv05_DStream_t* Dstream, const HUFv05_DEltX2* dt, const U32 dtLog)
+{
+        const size_t val = BITv05_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+        const BYTE c = dt[val].byte;
+        BITv05_skipBits(Dstream, dt[val].nbBits);
+        return c;
+}
+
+#define HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    *ptr++ = HUFv05_decodeSymbolX2(DStreamPtr, dt, dtLog)
+
+#define HUFv05_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \
+        HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+#define HUFv05_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+static inline size_t HUFv05_decodeStreamX2(BYTE* p, BITv05_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv05_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 4 symbols at a time */
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-4)) {
+        HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUFv05_DECODE_SYMBOLX2_1(p, bitDPtr);
+        HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd))
+        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    /* no more data to retrieve from bitstream, hence no need to reload */
+    while (p < pEnd)
+        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    return pEnd-pStart;
+}
+
+size_t HUFv05_decompress1X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + dstSize;
+    const U32 dtLog = DTable[0];
+    const void* dtPtr = DTable;
+    const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr)+1;
+    BITv05_DStream_t bitD;
+
+    if (dstSize <= cSrcSize) return ERROR(dstSize_tooSmall);
+    { size_t const errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize);
+      if (HUFv05_isError(errorCode)) return errorCode; }
+
+    HUFv05_decodeStreamX2(op, &bitD, oend, dt, dtLog);
+
+    /* check */
+    if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    return dstSize;
+}
+
+size_t HUFv05_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+    size_t errorCode;
+
+    errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize);
+    if (HUFv05_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUFv05_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+size_t HUFv05_decompress4X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    /* Check */
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable;
+        const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BITv05_DStream_t bitD1;
+        BITv05_DStream_t bitD2;
+        BITv05_DStream_t bitD3;
+        BITv05_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BITv05_initDStream(&bitD1, istart1, length1);
+        if (HUFv05_isError(errorCode)) return errorCode;
+        errorCode = BITv05_initDStream(&bitD2, istart2, length2);
+        if (HUFv05_isError(errorCode)) return errorCode;
+        errorCode = BITv05_initDStream(&bitD3, istart3, length3);
+        if (HUFv05_isError(errorCode)) return errorCode;
+        errorCode = BITv05_initDStream(&bitD4, istart4, length4);
+        if (HUFv05_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
+        for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) {
+            HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUFv05_DECODE_SYMBOLX2_1(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX2_1(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX2_1(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX2_1(op4, &bitD4);
+            HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUFv05_DECODE_SYMBOLX2_0(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX2_0(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX2_0(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX2_0(op4, &bitD4);
+            endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUFv05_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUFv05_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUFv05_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUFv05_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+size_t HUFv05_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+    size_t errorCode;
+
+    errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize);
+    if (HUFv05_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUFv05_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/* *************************/
+/* double-symbols decoding */
+/* *************************/
+
+static void HUFv05_fillDTableX4Level2(HUFv05_DEltX4* DTable, U32 sizeLog, const U32 consumed,
+                           const U32* rankValOrigin, const int minWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
+                           U32 nbBitsBaseline, U16 baseSeq)
+{
+    HUFv05_DEltX4 DElt;
+    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];
+    U32 s;
+
+    /* get pre-calculated rankVal */
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1) {
+        U32 i, skipSize = rankVal[minWeight];
+        MEM_writeLE16(&(DElt.sequence), baseSeq);
+        DElt.nbBits   = (BYTE)(consumed);
+        DElt.length   = 1;
+        for (i = 0; i < skipSize; i++)
+            DTable[i] = DElt;
+    }
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++) {   /* note : sortedSymbols already skipped */
+        const U32 symbol = sortedSymbols[s].symbol;
+        const U32 weight = sortedSymbols[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 length = 1 << (sizeLog-nbBits);
+        const U32 start = rankVal[weight];
+        U32 i = start;
+        const U32 end = start + length;
+
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
+        DElt.nbBits = (BYTE)(nbBits + consumed);
+        DElt.length = 2;
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
+
+        rankVal[weight] += length;
+    }
+}
+
+typedef U32 rankVal_t[HUFv05_ABSOLUTEMAX_TABLELOG][HUFv05_ABSOLUTEMAX_TABLELOG + 1];
+
+static void HUFv05_fillDTableX4(HUFv05_DEltX4* DTable, const U32 targetLog,
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32 nbBitsBaseline)
+{
+    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
+    const U32 minBits  = nbBitsBaseline - maxWeight;
+    U32 s;
+
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++) {
+        const U16 symbol = sortedList[s].symbol;
+        const U32 weight = sortedList[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 start = rankVal[weight];
+        const U32 length = 1 << (targetLog-nbBits);
+
+        if (targetLog-nbBits >= minBits) {   /* enough room for a second symbol */
+            U32 sortedRank;
+            int minWeight = nbBits + scaleLog;
+            if (minWeight < 1) minWeight = 1;
+            sortedRank = rankStart[minWeight];
+            HUFv05_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
+                           rankValOrigin[nbBits], minWeight,
+                           sortedList+sortedRank, sortedListSize-sortedRank,
+                           nbBitsBaseline, symbol);
+        } else {
+            U32 i;
+            const U32 end = start + length;
+            HUFv05_DEltX4 DElt;
+
+            MEM_writeLE16(&(DElt.sequence), symbol);
+            DElt.nbBits   = (BYTE)(nbBits);
+            DElt.length   = 1;
+            for (i = start; i < end; i++)
+                DTable[i] = DElt;
+        }
+        rankVal[weight] += length;
+    }
+}
+
+size_t HUFv05_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize)
+{
+    BYTE weightList[HUFv05_MAX_SYMBOL_VALUE + 1];
+    sortedSymbol_t sortedSymbol[HUFv05_MAX_SYMBOL_VALUE + 1];
+    U32 rankStats[HUFv05_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
+    U32 rankStart0[HUFv05_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
+    U32* const rankStart = rankStart0+1;
+    rankVal_t rankVal;
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    const U32 memLog = DTable[0];
+    size_t iSize;
+    void* dtPtr = DTable;
+    HUFv05_DEltX4* const dt = ((HUFv05_DEltX4*)dtPtr) + 1;
+
+    HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX4) == sizeof(unsigned));   /* if compilation fails here, assertion is false */
+    if (memLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUFv05_readStats(weightList, HUFv05_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUFv05_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
+
+    /* Get start index of each weight */
+    {
+        U32 w, nextRankStart = 0;
+        for (w=1; w<=maxW; w++) {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {
+        U32 s;
+        for (s=0; s<nbSymbols; s++) {
+            U32 w = weightList[s];
+            U32 r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {
+        const U32 minBits = tableLog+1 - maxW;
+        U32 nextRankVal = 0;
+        U32 w, consumed;
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
+        U32* rankVal0 = rankVal[0];
+        for (w=1; w<=maxW; w++) {
+            U32 current = nextRankVal;
+            nextRankVal += rankStats[w] << (w+rescale);
+            rankVal0[w] = current;
+        }
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++) {
+            U32* rankValPtr = rankVal[consumed];
+            for (w = 1; w <= maxW; w++) {
+                rankValPtr[w] = rankVal0[w] >> consumed;
+    }   }   }
+
+    HUFv05_fillDTableX4(dt, memLog,
+                   sortedSymbol, sizeOfSort,
+                   rankStart0, rankVal, maxW,
+                   tableLog+1);
+
+    return iSize;
+}
+
+
+static U32 HUFv05_decodeSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BITv05_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 2);
+    BITv05_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+static U32 HUFv05_decodeLastSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BITv05_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 1);
+    if (dt[val].length==1) BITv05_skipBits(DStream, dt[val].nbBits);
+    else {
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
+            BITv05_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+    }   }
+    return 1;
+}
+
+
+#define HUFv05_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
+    ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUFv05_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \
+        ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUFv05_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+static inline size_t HUFv05_decodeStreamX4(BYTE* p, BITv05_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv05_DEltX4* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd-7)) {
+        HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUFv05_DECODE_SYMBOLX4_1(p, bitDPtr);
+        HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-2))
+        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);
+
+    while (p <= pEnd-2)
+        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    if (p < pEnd)
+        p += HUFv05_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+
+size_t HUFv05_decompress1X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const unsigned* DTable)
+{
+    const BYTE* const istart = (const BYTE*) cSrc;
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* const oend = ostart + dstSize;
+
+    const U32 dtLog = DTable[0];
+    const void* const dtPtr = DTable;
+    const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1;
+    size_t errorCode;
+
+    /* Init */
+    BITv05_DStream_t bitD;
+    errorCode = BITv05_initDStream(&bitD, istart, cSrcSize);
+    if (HUFv05_isError(errorCode)) return errorCode;
+
+    /* finish bitStreams one by one */
+    HUFv05_decodeStreamX4(ostart, &bitD, oend,     dt, dtLog);
+
+    /* check */
+    if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    /* decoded size */
+    return dstSize;
+}
+
+size_t HUFv05_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize);
+    if (HUFv05_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUFv05_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+size_t HUFv05_decompress4X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const unsigned* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {
+        const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable;
+        const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BITv05_DStream_t bitD1;
+        BITv05_DStream_t bitD2;
+        BITv05_DStream_t bitD3;
+        BITv05_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BITv05_initDStream(&bitD1, istart1, length1);
+        if (HUFv05_isError(errorCode)) return errorCode;
+        errorCode = BITv05_initDStream(&bitD2, istart2, length2);
+        if (HUFv05_isError(errorCode)) return errorCode;
+        errorCode = BITv05_initDStream(&bitD3, istart3, length3);
+        if (HUFv05_isError(errorCode)) return errorCode;
+        errorCode = BITv05_initDStream(&bitD4, istart4, length4);
+        if (HUFv05_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
+        for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) {
+            HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUFv05_DECODE_SYMBOLX4_1(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX4_1(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX4_1(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX4_1(op4, &bitD4);
+            HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUFv05_DECODE_SYMBOLX4_0(op1, &bitD1);
+            HUFv05_DECODE_SYMBOLX4_0(op2, &bitD2);
+            HUFv05_DECODE_SYMBOLX4_0(op3, &bitD3);
+            HUFv05_DECODE_SYMBOLX4_0(op4, &bitD4);
+
+            endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUFv05_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
+        HUFv05_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
+        HUFv05_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
+        HUFv05_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+size_t HUFv05_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize);
+    if (HUFv05_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUFv05_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/* ********************************/
+/* Generic decompression selector */
+/* ********************************/
+
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
+{
+    /* single, double, quad */
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
+};
+
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+
+size_t HUFv05_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    static const decompressionAlgo decompress[3] = { HUFv05_decompress4X2, HUFv05_decompress4X4, NULL };
+    /* estimate decompression time */
+    U32 Q;
+    const U32 D256 = (U32)(dstSize >> 8);
+    U32 Dtime[3];
+    U32 algoNb = 0;
+    int n;
+
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize >= dstSize) return ERROR(corruption_detected);   /* invalid, or not compressed, but not compressed already dealt with */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    /* decoder timing evaluation */
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
+    for (n=0; n<3; n++)
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
+
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
+
+    if (Dtime[1] < Dtime[0]) algoNb = 1;
+
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
+
+    //return HUFv05_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
+    //return HUFv05_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
+    //return HUFv05_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
+}
+/*
+    zstd - standard compression library
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+*/
+
+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+ * HEAPMODE :
+ * Select how default decompression function ZSTDv05_decompress() will allocate memory,
+ * in memory stack (0), or in memory heap (1, requires malloc())
+ */
+#ifndef ZSTDv05_HEAPMODE
+#  define ZSTDv05_HEAPMODE 1
+#endif
+
+
+/*-*******************************************************
+*  Dependencies
+*********************************************************/
+#include <stdlib.h>      /* calloc */
+#include <string.h>      /* memcpy, memmove */
+#include <stdio.h>       /* debug only : printf */
+
+
+/*-*******************************************************
+*  Compiler specifics
+*********************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#endif
+
+
+/*-*************************************
+*  Local types
+***************************************/
+typedef struct
+{
+    blockType_t blockType;
+    U32 origSize;
+} blockProperties_t;
+
+
+/* *******************************************************
+*  Memory operations
+**********************************************************/
+static void ZSTDv05_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+
+/* *************************************
+*  Error Management
+***************************************/
+/*! ZSTDv05_isError() :
+*   tells if a return value is an error code */
+unsigned ZSTDv05_isError(size_t code) { return ERR_isError(code); }
+
+
+/*! ZSTDv05_getErrorName() :
+*   provides error code string (useful for debugging) */
+const char* ZSTDv05_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+/* *************************************************************
+*   Context management
+***************************************************************/
+typedef enum { ZSTDv05ds_getFrameHeaderSize, ZSTDv05ds_decodeFrameHeader,
+               ZSTDv05ds_decodeBlockHeader, ZSTDv05ds_decompressBlock } ZSTDv05_dStage;
+
+struct ZSTDv05_DCtx_s
+{
+    FSEv05_DTable LLTable[FSEv05_DTABLE_SIZE_U32(LLFSEv05Log)];
+    FSEv05_DTable OffTable[FSEv05_DTABLE_SIZE_U32(OffFSEv05Log)];
+    FSEv05_DTable MLTable[FSEv05_DTABLE_SIZE_U32(MLFSEv05Log)];
+    unsigned   hufTableX4[HUFv05_DTABLE_SIZE(HufLog)];
+    const void* previousDstEnd;
+    const void* base;
+    const void* vBase;
+    const void* dictEnd;
+    size_t expected;
+    size_t headerSize;
+    ZSTDv05_parameters params;
+    blockType_t bType;   /* used in ZSTDv05_decompressContinue(), to transfer blockType between header decoding and block decoding stages */
+    ZSTDv05_dStage stage;
+    U32 flagStaticTables;
+    const BYTE* litPtr;
+    size_t litSize;
+    BYTE litBuffer[BLOCKSIZE + WILDCOPY_OVERLENGTH];
+    BYTE headerBuffer[ZSTDv05_frameHeaderSize_max];
+};  /* typedef'd to ZSTDv05_DCtx within "zstd_static.h" */
+
+size_t ZSTDv05_sizeofDCtx (void); /* Hidden declaration */
+size_t ZSTDv05_sizeofDCtx (void) { return sizeof(ZSTDv05_DCtx); }
+
+size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx)
+{
+    dctx->expected = ZSTDv05_frameHeaderSize_min;
+    dctx->stage = ZSTDv05ds_getFrameHeaderSize;
+    dctx->previousDstEnd = NULL;
+    dctx->base = NULL;
+    dctx->vBase = NULL;
+    dctx->dictEnd = NULL;
+    dctx->hufTableX4[0] = HufLog;
+    dctx->flagStaticTables = 0;
+    return 0;
+}
+
+ZSTDv05_DCtx* ZSTDv05_createDCtx(void)
+{
+    ZSTDv05_DCtx* dctx = (ZSTDv05_DCtx*)malloc(sizeof(ZSTDv05_DCtx));
+    if (dctx==NULL) return NULL;
+    ZSTDv05_decompressBegin(dctx);
+    return dctx;
+}
+
+size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx)
+{
+    free(dctx);
+    return 0;   /* reserved as a potential error code in the future */
+}
+
+void ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx)
+{
+    memcpy(dstDCtx, srcDCtx,
+           sizeof(ZSTDv05_DCtx) - (BLOCKSIZE+WILDCOPY_OVERLENGTH + ZSTDv05_frameHeaderSize_max));  /* no need to copy workspace */
+}
+
+
+/* *************************************************************
+*   Decompression section
+***************************************************************/
+
+/* Frame format description
+   Frame Header -  [ Block Header - Block ] - Frame End
+   1) Frame Header
+      - 4 bytes - Magic Number : ZSTDv05_MAGICNUMBER (defined within zstd_internal.h)
+      - 1 byte  - Window Descriptor
+   2) Block Header
+      - 3 bytes, starting with a 2-bits descriptor
+                 Uncompressed, Compressed, Frame End, unused
+   3) Block
+      See Block Format Description
+   4) Frame End
+      - 3 bytes, compatible with Block Header
+*/
+
+/* Block format description
+
+   Block = Literal Section - Sequences Section
+   Prerequisite : size of (compressed) block, maximum size of regenerated data
+
+   1) Literal Section
+
+   1.1) Header : 1-5 bytes
+        flags: 2 bits
+            00 compressed by Huff0
+            01 unused
+            10 is Raw (uncompressed)
+            11 is Rle
+            Note : using 01 => Huff0 with precomputed table ?
+            Note : delta map ? => compressed ?
+
+   1.1.1) Huff0-compressed literal block : 3-5 bytes
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
+            srcSize < 1 KB => 3 bytes (2-2-10-10)
+            srcSize < 16KB => 4 bytes (2-2-14-14)
+            else           => 5 bytes (2-2-18-18)
+            big endian convention
+
+   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes
+        size :  5 bits: (IS_RAW<<6) + (0<<4) + size
+               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)
+                        size&255
+               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)
+                        size>>8&255
+                        size&255
+
+   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes
+        size :  5 bits: (IS_RLE<<6) + (0<<4) + size
+               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)
+                        size&255
+               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)
+                        size>>8&255
+                        size&255
+
+   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
+            srcSize < 1 KB => 3 bytes (2-2-10-10)
+            srcSize < 16KB => 4 bytes (2-2-14-14)
+            else           => 5 bytes (2-2-18-18)
+            big endian convention
+
+        1- CTable available (stored into workspace ?)
+        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)
+
+
+   1.2) Literal block content
+
+   1.2.1) Huff0 block, using sizes from header
+        See Huff0 format
+
+   1.2.2) Huff0 block, using prepared table
+
+   1.2.3) Raw content
+
+   1.2.4) single byte
+
+
+   2) Sequences section
+      TO DO
+*/
+
+
+/** ZSTDv05_decodeFrameHeader_Part1() :
+*   decode the 1st part of the Frame Header, which tells Frame Header size.
+*   srcSize must be == ZSTDv05_frameHeaderSize_min.
+*   @return : the full size of the Frame Header */
+static size_t ZSTDv05_decodeFrameHeader_Part1(ZSTDv05_DCtx* zc, const void* src, size_t srcSize)
+{
+    U32 magicNumber;
+    if (srcSize != ZSTDv05_frameHeaderSize_min)
+        return ERROR(srcSize_wrong);
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown);
+    zc->headerSize = ZSTDv05_frameHeaderSize_min;
+    return zc->headerSize;
+}
+
+
+size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize)
+{
+    U32 magicNumber;
+    if (srcSize < ZSTDv05_frameHeaderSize_min) return ZSTDv05_frameHeaderSize_max;
+    magicNumber = MEM_readLE32(src);
+    if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown);
+    memset(params, 0, sizeof(*params));
+    params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTDv05_WINDOWLOG_ABSOLUTEMIN;
+    if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported);   /* reserved bits */
+    return 0;
+}
+
+/** ZSTDv05_decodeFrameHeader_Part2() :
+*   decode the full Frame Header.
+*   srcSize must be the size provided by ZSTDv05_decodeFrameHeader_Part1().
+*   @return : 0, or an error code, which can be tested using ZSTDv05_isError() */
+static size_t ZSTDv05_decodeFrameHeader_Part2(ZSTDv05_DCtx* zc, const void* src, size_t srcSize)
+{
+    size_t result;
+    if (srcSize != zc->headerSize)
+        return ERROR(srcSize_wrong);
+    result = ZSTDv05_getFrameParams(&(zc->params), src, srcSize);
+    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupported);
+    return result;
+}
+
+
+static size_t ZSTDv05_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
+{
+    const BYTE* const in = (const BYTE* const)src;
+    BYTE headerFlags;
+    U32 cSize;
+
+    if (srcSize < 3)
+        return ERROR(srcSize_wrong);
+
+    headerFlags = *in;
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
+
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
+
+    if (bpPtr->blockType == bt_end) return 0;
+    if (bpPtr->blockType == bt_rle) return 1;
+    return cSize;
+}
+
+
+static size_t ZSTDv05_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    if (dst==NULL) return ERROR(dstSize_tooSmall);
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+
+/*! ZSTDv05_decodeLiteralsBlock() :
+    @return : nb of bytes read from src (< srcSize ) */
+static size_t ZSTDv05_decodeLiteralsBlock(ZSTDv05_DCtx* dctx,
+                                    const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
+{
+    const BYTE* const istart = (const BYTE*) src;
+
+    /* any compressed block with literals segment must be at least this size */
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
+
+    switch(istart[0]>> 6)
+    {
+    case IS_HUFv05:
+        {
+            size_t litSize, litCSize, singleStream=0;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            if (srcSize < 5) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3 */
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                /* 2 - 2 - 10 - 10 */
+                lhSize=3;
+                singleStream = istart[0] & 16;
+                litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
+                litCSize = ((istart[1] &  3) << 8) + istart[2];
+                break;
+            case 2:
+                /* 2 - 2 - 14 - 14 */
+                lhSize=4;
+                litSize  = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);
+                litCSize = ((istart[2] & 63) <<  8) + istart[3];
+                break;
+            case 3:
+                /* 2 - 2 - 18 - 18 */
+                lhSize=5;
+                litSize  = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);
+                litCSize = ((istart[2] &  3) << 16) + (istart[3] << 8) + istart[4];
+                break;
+            }
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
+
+            if (HUFv05_isError(singleStream ?
+                            HUFv05_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) :
+                            HUFv05_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
+                return ERROR(corruption_detected);
+
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+            return litCSize + lhSize;
+        }
+    case IS_PCH:
+        {
+            size_t errorCode;
+            size_t litSize, litCSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            if (lhSize != 1)  /* only case supported for now : small litSize, single stream */
+                return ERROR(corruption_detected);
+            if (!dctx->flagStaticTables)
+                return ERROR(dictionary_corrupted);
+
+            /* 2 - 2 - 10 - 10 */
+            lhSize=3;
+            litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
+            litCSize = ((istart[1] &  3) << 8) + istart[2];
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
+
+            errorCode = HUFv05_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4);
+            if (HUFv05_isError(errorCode)) return ERROR(corruption_detected);
+
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+            return litCSize + lhSize;
+        }
+    case IS_RAW:
+        {
+            size_t litSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                lhSize=1;
+                litSize = istart[0] & 31;
+                break;
+            case 2:
+                litSize = ((istart[0] & 15) << 8) + istart[1];
+                break;
+            case 3:
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
+                break;
+            }
+
+            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
+                if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
+                memcpy(dctx->litBuffer, istart+lhSize, litSize);
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+                return lhSize+litSize;
+            }
+            /* direct reference into compressed stream */
+            dctx->litPtr = istart+lhSize;
+            dctx->litSize = litSize;
+            return lhSize+litSize;
+        }
+    case IS_RLE:
+        {
+            size_t litSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                lhSize = 1;
+                litSize = istart[0] & 31;
+                break;
+            case 2:
+                litSize = ((istart[0] & 15) << 8) + istart[1];
+                break;
+            case 3:
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
+                if (srcSize<4) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
+                break;
+            }
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
+            memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            return lhSize+1;
+        }
+    default:
+        return ERROR(corruption_detected);   /* impossible */
+    }
+}
+
+
+static size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
+                         FSEv05_DTable* DTableLL, FSEv05_DTable* DTableML, FSEv05_DTable* DTableOffb,
+                         const void* src, size_t srcSize, U32 flagStaticTable)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* ip = istart;
+    const BYTE* const iend = istart + srcSize;
+    U32 LLtype, Offtype, MLtype;
+    unsigned LLlog, Offlog, MLlog;
+    size_t dumpsLength;
+
+    /* check */
+    if (srcSize < MIN_SEQUENCES_SIZE)
+        return ERROR(srcSize_wrong);
+
+    /* SeqHead */
+    *nbSeq = *ip++;
+    if (*nbSeq==0) return 1;
+    if (*nbSeq >= 128) {
+        if (ip >= iend) return ERROR(srcSize_wrong);
+        *nbSeq = ((nbSeq[0]-128)<<8) + *ip++;
+    }
+
+    if (ip >= iend) return ERROR(srcSize_wrong);
+    LLtype  = *ip >> 6;
+    Offtype = (*ip >> 4) & 3;
+    MLtype  = (*ip >> 2) & 3;
+    if (*ip & 2) {
+        if (ip+3 > iend) return ERROR(srcSize_wrong);
+        dumpsLength  = ip[2];
+        dumpsLength += ip[1] << 8;
+        ip += 3;
+    } else {
+        if (ip+2 > iend) return ERROR(srcSize_wrong);
+        dumpsLength  = ip[1];
+        dumpsLength += (ip[0] & 1) << 8;
+        ip += 2;
+    }
+    *dumpsPtr = ip;
+    ip += dumpsLength;
+    *dumpsLengthPtr = dumpsLength;
+
+    /* check */
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
+
+    /* sequences */
+    {
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL >= MaxOff */
+        size_t headerSize;
+
+        /* Build DTables */
+        switch(LLtype)
+        {
+        case FSEv05_ENCODING_RLE :
+            LLlog = 0;
+            FSEv05_buildDTable_rle(DTableLL, *ip++);
+            break;
+        case FSEv05_ENCODING_RAW :
+            LLlog = LLbits;
+            FSEv05_buildDTable_raw(DTableLL, LLbits);
+            break;
+        case FSEv05_ENCODING_STATIC:
+            if (!flagStaticTable) return ERROR(corruption_detected);
+            break;
+        case FSEv05_ENCODING_DYNAMIC :
+        default :   /* impossible */
+            {   unsigned max = MaxLL;
+                headerSize = FSEv05_readNCount(norm, &max, &LLlog, ip, iend-ip);
+                if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
+                if (LLlog > LLFSEv05Log) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSEv05_buildDTable(DTableLL, norm, max, LLlog);
+        }   }
+
+        switch(Offtype)
+        {
+        case FSEv05_ENCODING_RLE :
+            Offlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
+            FSEv05_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
+            break;
+        case FSEv05_ENCODING_RAW :
+            Offlog = Offbits;
+            FSEv05_buildDTable_raw(DTableOffb, Offbits);
+            break;
+        case FSEv05_ENCODING_STATIC:
+            if (!flagStaticTable) return ERROR(corruption_detected);
+            break;
+        case FSEv05_ENCODING_DYNAMIC :
+        default :   /* impossible */
+            {   unsigned max = MaxOff;
+                headerSize = FSEv05_readNCount(norm, &max, &Offlog, ip, iend-ip);
+                if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
+                if (Offlog > OffFSEv05Log) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSEv05_buildDTable(DTableOffb, norm, max, Offlog);
+        }   }
+
+        switch(MLtype)
+        {
+        case FSEv05_ENCODING_RLE :
+            MLlog = 0;
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
+            FSEv05_buildDTable_rle(DTableML, *ip++);
+            break;
+        case FSEv05_ENCODING_RAW :
+            MLlog = MLbits;
+            FSEv05_buildDTable_raw(DTableML, MLbits);
+            break;
+        case FSEv05_ENCODING_STATIC:
+            if (!flagStaticTable) return ERROR(corruption_detected);
+            break;
+        case FSEv05_ENCODING_DYNAMIC :
+        default :   /* impossible */
+            {   unsigned max = MaxML;
+                headerSize = FSEv05_readNCount(norm, &max, &MLlog, ip, iend-ip);
+                if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
+                if (MLlog > MLFSEv05Log) return ERROR(corruption_detected);
+                ip += headerSize;
+                FSEv05_buildDTable(DTableML, norm, max, MLlog);
+    }   }   }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t matchLength;
+    size_t offset;
+} seq_t;
+
+typedef struct {
+    BITv05_DStream_t DStream;
+    FSEv05_DState_t stateLL;
+    FSEv05_DState_t stateOffb;
+    FSEv05_DState_t stateML;
+    size_t prevOffset;
+    const BYTE* dumps;
+    const BYTE* dumpsEnd;
+} seqState_t;
+
+
+
+static void ZSTDv05_decodeSequence(seq_t* seq, seqState_t* seqState)
+{
+    size_t litLength;
+    size_t prevOffset;
+    size_t offset;
+    size_t matchLength;
+    const BYTE* dumps = seqState->dumps;
+    const BYTE* const de = seqState->dumpsEnd;
+
+    /* Literal length */
+    litLength = FSEv05_peakSymbol(&(seqState->stateLL));
+    prevOffset = litLength ? seq->offset : seqState->prevOffset;
+    if (litLength == MaxLL) {
+        const U32 add = *dumps++;
+        if (add < 255) litLength += add;
+        else if (dumps + 2 <= de) {
+            litLength = MEM_readLE16(dumps);
+            dumps += 2;
+            if ((litLength & 1) && dumps < de) {
+                litLength += *dumps << 16;
+                dumps += 1;
+            }
+            litLength>>=1;
+        }
+        if (dumps >= de) { dumps = de-1; }  /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+
+    /* Offset */
+    {
+        static const U32 offsetPrefix[MaxOff+1] = {
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
+        U32 offsetCode = FSEv05_peakSymbol(&(seqState->stateOffb));   /* <= maxOff, by table construction */
+        U32 nbBits = offsetCode - 1;
+        if (offsetCode==0) nbBits = 0;   /* cmove */
+        offset = offsetPrefix[offsetCode] + BITv05_readBits(&(seqState->DStream), nbBits);
+        if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream));
+        if (offsetCode==0) offset = prevOffset;   /* repcode, cmove */
+        if (offsetCode | !litLength) seqState->prevOffset = seq->offset;   /* cmove */
+        FSEv05_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));    /* update */
+    }
+
+    /* Literal length update */
+    FSEv05_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));   /* update */
+    if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream));
+
+    /* MatchLength */
+    matchLength = FSEv05_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
+    if (matchLength == MaxML) {
+        const U32 add = dumps<de ? *dumps++ : 0;
+        if (add < 255) matchLength += add;
+        else if (dumps + 2 <= de) {
+            matchLength = MEM_readLE16(dumps);
+            dumps += 2;
+            if ((matchLength & 1) && dumps < de) {
+                matchLength += *dumps << 16;
+                dumps += 1;
+            }
+            matchLength >>= 1;
+        }
+        if (dumps >= de) { dumps = de-1; }  /* late correction, to avoid read overflow (data is now corrupted anyway) */
+    }
+    matchLength += MINMATCH;
+
+    /* save result */
+    seq->litLength = litLength;
+    seq->offset = offset;
+    seq->matchLength = matchLength;
+    seqState->dumps = dumps;
+
+#if 0   /* debug */
+    {
+        static U64 totalDecoded = 0;
+        printf("pos %6u : %3u literals & match %3u bytes at distance %6u \n",
+           (U32)(totalDecoded), (U32)litLength, (U32)matchLength, (U32)offset);
+        totalDecoded += litLength + matchLength;
+    }
+#endif
+}
+
+
+static size_t ZSTDv05_execSequence(BYTE* op,
+                                BYTE* const oend, seq_t sequence,
+                                const BYTE** litPtr, const BYTE* const litLimit,
+                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
+{
+    static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+    static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */
+    BYTE* const oLitEnd = op + sequence.litLength;
+    const size_t sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_8 = oend-8;
+    const BYTE* const litEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
+
+    /* check */
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
+    if (litEnd > litLimit) return ERROR(corruption_detected);   /* risk read beyond lit buffer */
+
+    /* copy Literals */
+    ZSTDv05_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
+    op = oLitEnd;
+    *litPtr = litEnd;   /* update for next sequence */
+
+    /* copy Match */
+    if (sequence.offset > (size_t)(oLitEnd - base)) {
+        /* offset beyond prefix */
+        if (sequence.offset > (size_t)(oLitEnd - vBase))
+            return ERROR(corruption_detected);
+        match = dictEnd - (base-match);
+        if (match + sequence.matchLength <= dictEnd) {
+            memmove(oLitEnd, match, sequence.matchLength);
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {
+            size_t length1 = dictEnd - match;
+            memmove(oLitEnd, match, length1);
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = base;
+            if (op > oend_8 || sequence.matchLength < MINMATCH) {
+              while (op < oMatchEnd) *op++ = *match++;
+              return sequenceLength;
+            }
+    }   }
+    /* Requirement: op <= oend_8 */
+
+    /* match within prefix */
+    if (sequence.offset < 8) {
+        /* close range match, overlap */
+        const int sub2 = dec64table[sequence.offset];
+        op[0] = match[0];
+        op[1] = match[1];
+        op[2] = match[2];
+        op[3] = match[3];
+        match += dec32table[sequence.offset];
+        ZSTDv05_copy4(op+4, match);
+        match -= sub2;
+    } else {
+        ZSTDv05_copy8(op, match);
+    }
+    op += 8; match += 8;
+
+    if (oMatchEnd > oend-(16-MINMATCH)) {
+        if (op < oend_8) {
+            ZSTDv05_wildcopy(op, match, oend_8 - op);
+            match += oend_8 - op;
+            op = oend_8;
+        }
+        while (op < oMatchEnd)
+            *op++ = *match++;
+    } else {
+        ZSTDv05_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
+    }
+    return sequenceLength;
+}
+
+
+static size_t ZSTDv05_decompressSequences(
+                               ZSTDv05_DCtx* dctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize)
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t errorCode, dumpsLength=0;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    int nbSeq=0;
+    const BYTE* dumps = NULL;
+    unsigned* DTableLL = dctx->LLTable;
+    unsigned* DTableML = dctx->MLTable;
+    unsigned* DTableOffb = dctx->OffTable;
+    const BYTE* const base = (const BYTE*) (dctx->base);
+    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
+
+    /* Build Decoding Tables */
+    errorCode = ZSTDv05_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
+                                      DTableLL, DTableML, DTableOffb,
+                                      ip, seqSize, dctx->flagStaticTables);
+    if (ZSTDv05_isError(errorCode)) return errorCode;
+    ip += errorCode;
+
+    /* Regen sequences */
+    if (nbSeq) {
+        seq_t sequence;
+        seqState_t seqState;
+
+        memset(&sequence, 0, sizeof(sequence));
+        sequence.offset = REPCODE_STARTVALUE;
+        seqState.dumps = dumps;
+        seqState.dumpsEnd = dumps + dumpsLength;
+        seqState.prevOffset = REPCODE_STARTVALUE;
+        errorCode = BITv05_initDStream(&(seqState.DStream), ip, iend-ip);
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
+        FSEv05_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
+        FSEv05_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
+        FSEv05_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
+
+        for ( ; (BITv05_reloadDStream(&(seqState.DStream)) <= BITv05_DStream_completed) && nbSeq ; ) {
+            size_t oneSeqSize;
+            nbSeq--;
+            ZSTDv05_decodeSequence(&sequence, &seqState);
+            oneSeqSize = ZSTDv05_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);
+            if (ZSTDv05_isError(oneSeqSize)) return oneSeqSize;
+            op += oneSeqSize;
+        }
+
+        /* check if reached exact end */
+        if (nbSeq) return ERROR(corruption_detected);
+    }
+
+    /* last literal segment */
+    {
+        size_t lastLLSize = litEnd - litPtr;
+        if (litPtr > litEnd) return ERROR(corruption_detected);   /* too many literals already used */
+        if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
+        memcpy(op, litPtr, lastLLSize);
+        op += lastLLSize;
+    }
+
+    return op-ostart;
+}
+
+
+static void ZSTDv05_checkContinuity(ZSTDv05_DCtx* dctx, const void* dst)
+{
+    if (dst != dctx->previousDstEnd) {   /* not contiguous */
+        dctx->dictEnd = dctx->previousDstEnd;
+        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
+        dctx->base = dst;
+        dctx->previousDstEnd = dst;
+    }
+}
+
+
+static size_t ZSTDv05_decompressBlock_internal(ZSTDv05_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{   /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+    size_t litCSize;
+
+    if (srcSize >= BLOCKSIZE) return ERROR(srcSize_wrong);
+
+    /* Decode literals sub-block */
+    litCSize = ZSTDv05_decodeLiteralsBlock(dctx, src, srcSize);
+    if (ZSTDv05_isError(litCSize)) return litCSize;
+    ip += litCSize;
+    srcSize -= litCSize;
+
+    return ZSTDv05_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
+}
+
+
+size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{
+    ZSTDv05_checkContinuity(dctx, dst);
+    return ZSTDv05_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
+}
+
+
+/*! ZSTDv05_decompress_continueDCtx
+*   dctx must have been properly initialized */
+static size_t ZSTDv05_decompress_continueDCtx(ZSTDv05_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                                 const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* iend = ip + srcSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + maxDstSize;
+    size_t remainingSize = srcSize;
+    blockProperties_t blockProperties;
+    memset(&blockProperties, 0, sizeof(blockProperties));
+
+    /* Frame Header */
+    {   size_t frameHeaderSize;
+        if (srcSize < ZSTDv05_frameHeaderSize_min+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong);
+        frameHeaderSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src, ZSTDv05_frameHeaderSize_min);
+        if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize;
+        if (srcSize < frameHeaderSize+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong);
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
+        frameHeaderSize = ZSTDv05_decodeFrameHeader_Part2(dctx, src, frameHeaderSize);
+        if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize;
+    }
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t decodedSize=0;
+        size_t cBlockSize = ZSTDv05_getcBlockSize(ip, iend-ip, &blockProperties);
+        if (ZSTDv05_isError(cBlockSize)) return cBlockSize;
+
+        ip += ZSTDv05_blockHeaderSize;
+        remainingSize -= ZSTDv05_blockHeaderSize;
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            decodedSize = ZSTDv05_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
+            break;
+        case bt_raw :
+            decodedSize = ZSTDv05_copyRawBlock(op, oend-op, ip, cBlockSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet supported */
+            break;
+        case bt_end :
+            /* end of frame */
+            if (remainingSize) return ERROR(srcSize_wrong);
+            break;
+        default:
+            return ERROR(GENERIC);   /* impossible */
+        }
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        if (ZSTDv05_isError(decodedSize)) return decodedSize;
+        op += decodedSize;
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+    }
+
+    return op-ostart;
+}
+
+
+size_t ZSTDv05_decompress_usingPreparedDCtx(ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* refDCtx,
+                                         void* dst, size_t maxDstSize,
+                                   const void* src, size_t srcSize)
+{
+    ZSTDv05_copyDCtx(dctx, refDCtx);
+    ZSTDv05_checkContinuity(dctx, dst);
+    return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize);
+}
+
+
+size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                                 const void* src, size_t srcSize,
+                                 const void* dict, size_t dictSize)
+{
+    ZSTDv05_decompressBegin_usingDict(dctx, dict, dictSize);
+    ZSTDv05_checkContinuity(dctx, dst);
+    return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize);
+}
+
+
+size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTDv05_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0);
+}
+
+size_t ZSTDv05_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+#if defined(ZSTDv05_HEAPMODE) && (ZSTDv05_HEAPMODE==1)
+    size_t regenSize;
+    ZSTDv05_DCtx* dctx = ZSTDv05_createDCtx();
+    if (dctx==NULL) return ERROR(memory_allocation);
+    regenSize = ZSTDv05_decompressDCtx(dctx, dst, maxDstSize, src, srcSize);
+    ZSTDv05_freeDCtx(dctx);
+    return regenSize;
+#else
+    ZSTDv05_DCtx dctx;
+    return ZSTDv05_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);
+#endif
+}
+
+/* ZSTD_errorFrameSizeInfoLegacy() :
+   assumes `cSize` and `dBound` are _not_ NULL */
+static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
+{
+    *cSize = ret;
+    *dBound = ZSTD_CONTENTSIZE_ERROR;
+}
+
+void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t remainingSize = srcSize;
+    size_t nbBlocks = 0;
+    blockProperties_t blockProperties;
+
+    /* Frame Header */
+    if (srcSize < ZSTDv05_frameHeaderSize_min) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+        return;
+    }
+    if (MEM_readLE32(src) != ZSTDv05_MAGICNUMBER) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));
+        return;
+    }
+    ip += ZSTDv05_frameHeaderSize_min; remainingSize -= ZSTDv05_frameHeaderSize_min;
+
+    /* Loop on each block */
+    while (1)
+    {
+        size_t cBlockSize = ZSTDv05_getcBlockSize(ip, remainingSize, &blockProperties);
+        if (ZSTDv05_isError(cBlockSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);
+            return;
+        }
+
+        ip += ZSTDv05_blockHeaderSize;
+        remainingSize -= ZSTDv05_blockHeaderSize;
+        if (cBlockSize > remainingSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+        nbBlocks++;
+    }
+
+    *cSize = ip - (const BYTE*)src;
+    *dBound = nbBlocks * BLOCKSIZE;
+}
+
+/* ******************************
+*  Streaming Decompression API
+********************************/
+size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx)
+{
+    return dctx->expected;
+}
+
+size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    /* Sanity check */
+    if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
+    ZSTDv05_checkContinuity(dctx, dst);
+
+    /* Decompress : frame header; part 1 */
+    switch (dctx->stage)
+    {
+    case ZSTDv05ds_getFrameHeaderSize :
+        /* get frame header size */
+        if (srcSize != ZSTDv05_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
+        dctx->headerSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src, ZSTDv05_frameHeaderSize_min);
+        if (ZSTDv05_isError(dctx->headerSize)) return dctx->headerSize;
+        memcpy(dctx->headerBuffer, src, ZSTDv05_frameHeaderSize_min);
+        if (dctx->headerSize > ZSTDv05_frameHeaderSize_min) return ERROR(GENERIC); /* should never happen */
+        dctx->expected = 0;   /* not necessary to copy more */
+        /* fallthrough */
+    case ZSTDv05ds_decodeFrameHeader:
+        /* get frame header */
+        {   size_t const result = ZSTDv05_decodeFrameHeader_Part2(dctx, dctx->headerBuffer, dctx->headerSize);
+            if (ZSTDv05_isError(result)) return result;
+            dctx->expected = ZSTDv05_blockHeaderSize;
+            dctx->stage = ZSTDv05ds_decodeBlockHeader;
+            return 0;
+        }
+    case ZSTDv05ds_decodeBlockHeader:
+        {
+            /* Decode block header */
+            blockProperties_t bp;
+            size_t blockSize = ZSTDv05_getcBlockSize(src, ZSTDv05_blockHeaderSize, &bp);
+            if (ZSTDv05_isError(blockSize)) return blockSize;
+            if (bp.blockType == bt_end) {
+                dctx->expected = 0;
+                dctx->stage = ZSTDv05ds_getFrameHeaderSize;
+            }
+            else {
+                dctx->expected = blockSize;
+                dctx->bType = bp.blockType;
+                dctx->stage = ZSTDv05ds_decompressBlock;
+            }
+            return 0;
+        }
+    case ZSTDv05ds_decompressBlock:
+        {
+            /* Decompress : block content */
+            size_t rSize;
+            switch(dctx->bType)
+            {
+            case bt_compressed:
+                rSize = ZSTDv05_decompressBlock_internal(dctx, dst, maxDstSize, src, srcSize);
+                break;
+            case bt_raw :
+                rSize = ZSTDv05_copyRawBlock(dst, maxDstSize, src, srcSize);
+                break;
+            case bt_rle :
+                return ERROR(GENERIC);   /* not yet handled */
+                break;
+            case bt_end :   /* should never happen (filtered at phase 1) */
+                rSize = 0;
+                break;
+            default:
+                return ERROR(GENERIC);   /* impossible */
+            }
+            dctx->stage = ZSTDv05ds_decodeBlockHeader;
+            dctx->expected = ZSTDv05_blockHeaderSize;
+            dctx->previousDstEnd = (char*)dst + rSize;
+            return rSize;
+        }
+    default:
+        return ERROR(GENERIC);   /* impossible */
+    }
+}
+
+
+static void ZSTDv05_refDictContent(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    dctx->dictEnd = dctx->previousDstEnd;
+    dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
+    dctx->base = dict;
+    dctx->previousDstEnd = (const char*)dict + dictSize;
+}
+
+static size_t ZSTDv05_loadEntropy(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, errorCode, litlengthHeaderSize;
+    short offcodeNCount[MaxOff+1];
+    unsigned offcodeMaxValue=MaxOff, offcodeLog;
+    short matchlengthNCount[MaxML+1];
+    unsigned matchlengthMaxValue = MaxML, matchlengthLog;
+    short litlengthNCount[MaxLL+1];
+    unsigned litlengthMaxValue = MaxLL, litlengthLog;
+
+    hSize = HUFv05_readDTableX4(dctx->hufTableX4, dict, dictSize);
+    if (HUFv05_isError(hSize)) return ERROR(dictionary_corrupted);
+    dict = (const char*)dict + hSize;
+    dictSize -= hSize;
+
+    offcodeHeaderSize = FSEv05_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);
+    if (FSEv05_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
+    if (offcodeLog > OffFSEv05Log) return ERROR(dictionary_corrupted);
+    errorCode = FSEv05_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);
+    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);
+    dict = (const char*)dict + offcodeHeaderSize;
+    dictSize -= offcodeHeaderSize;
+
+    matchlengthHeaderSize = FSEv05_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);
+    if (FSEv05_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
+    if (matchlengthLog > MLFSEv05Log) return ERROR(dictionary_corrupted);
+    errorCode = FSEv05_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
+    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);
+    dict = (const char*)dict + matchlengthHeaderSize;
+    dictSize -= matchlengthHeaderSize;
+
+    litlengthHeaderSize = FSEv05_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);
+    if (litlengthLog > LLFSEv05Log) return ERROR(dictionary_corrupted);
+    if (FSEv05_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
+    errorCode = FSEv05_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
+    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);
+
+    dctx->flagStaticTables = 1;
+    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;
+}
+
+static size_t ZSTDv05_decompress_insertDictionary(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    size_t eSize;
+    U32 magic = MEM_readLE32(dict);
+    if (magic != ZSTDv05_DICT_MAGIC) {
+        /* pure content mode */
+        ZSTDv05_refDictContent(dctx, dict, dictSize);
+        return 0;
+    }
+    /* load entropy tables */
+    dict = (const char*)dict + 4;
+    dictSize -= 4;
+    eSize = ZSTDv05_loadEntropy(dctx, dict, dictSize);
+    if (ZSTDv05_isError(eSize)) return ERROR(dictionary_corrupted);
+
+    /* reference dictionary content */
+    dict = (const char*)dict + eSize;
+    dictSize -= eSize;
+    ZSTDv05_refDictContent(dctx, dict, dictSize);
+
+    return 0;
+}
+
+
+size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    size_t errorCode;
+    errorCode = ZSTDv05_decompressBegin(dctx);
+    if (ZSTDv05_isError(errorCode)) return errorCode;
+
+    if (dict && dictSize) {
+        errorCode = ZSTDv05_decompress_insertDictionary(dctx, dict, dictSize);
+        if (ZSTDv05_isError(errorCode)) return ERROR(dictionary_corrupted);
+    }
+
+    return 0;
+}
+
+/*
+    Buffered version of Zstd compression library
+    Copyright (C) 2015-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* The objects defined into this file should be considered experimental.
+ * They are not labelled stable, as their prototype may change in the future.
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes.
+ */
+
+
+
+/* *************************************
+*  Constants
+***************************************/
+static size_t ZBUFFv05_blockHeaderSize = 3;
+
+
+
+/* *** Compression *** */
+
+static size_t ZBUFFv05_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    size_t length = MIN(maxDstSize, srcSize);
+    memcpy(dst, src, length);
+    return length;
+}
+
+
+
+
+/** ************************************************
+*  Streaming decompression
+*
+*  A ZBUFFv05_DCtx object is required to track streaming operation.
+*  Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources.
+*  Use ZBUFFv05_decompressInit() to start a new decompression operation.
+*  ZBUFFv05_DCtx objects can be reused multiple times.
+*
+*  Use ZBUFFv05_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *maxDstSizePtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.
+*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst .
+*  return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
+*            or 0 when a frame is completely decoded
+*            or an error code, which can be tested using ZBUFFv05_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory)
+*  output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded.
+*  input : just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* **************************************************/
+
+typedef enum { ZBUFFv05ds_init, ZBUFFv05ds_readHeader, ZBUFFv05ds_loadHeader, ZBUFFv05ds_decodeHeader,
+               ZBUFFv05ds_read, ZBUFFv05ds_load, ZBUFFv05ds_flush } ZBUFFv05_dStage;
+
+/* *** Resource management *** */
+
+#define ZSTDv05_frameHeaderSize_max 5   /* too magical, should come from reference */
+struct ZBUFFv05_DCtx_s {
+    ZSTDv05_DCtx* zc;
+    ZSTDv05_parameters params;
+    char* inBuff;
+    size_t inBuffSize;
+    size_t inPos;
+    char* outBuff;
+    size_t outBuffSize;
+    size_t outStart;
+    size_t outEnd;
+    size_t hPos;
+    ZBUFFv05_dStage stage;
+    unsigned char headerBuffer[ZSTDv05_frameHeaderSize_max];
+};   /* typedef'd to ZBUFFv05_DCtx within "zstd_buffered.h" */
+
+
+ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void)
+{
+    ZBUFFv05_DCtx* zbc = (ZBUFFv05_DCtx*)malloc(sizeof(ZBUFFv05_DCtx));
+    if (zbc==NULL) return NULL;
+    memset(zbc, 0, sizeof(*zbc));
+    zbc->zc = ZSTDv05_createDCtx();
+    zbc->stage = ZBUFFv05ds_init;
+    return zbc;
+}
+
+size_t ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* zbc)
+{
+    if (zbc==NULL) return 0;   /* support free on null */
+    ZSTDv05_freeDCtx(zbc->zc);
+    free(zbc->inBuff);
+    free(zbc->outBuff);
+    free(zbc);
+    return 0;
+}
+
+
+/* *** Initialization *** */
+
+size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* zbc, const void* dict, size_t dictSize)
+{
+    zbc->stage = ZBUFFv05ds_readHeader;
+    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = 0;
+    return ZSTDv05_decompressBegin_usingDict(zbc->zc, dict, dictSize);
+}
+
+size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* zbc)
+{
+    return ZBUFFv05_decompressInitDictionary(zbc, NULL, 0);
+}
+
+
+/* *** Decompression *** */
+
+size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)
+{
+    const char* const istart = (const char*)src;
+    const char* ip = istart;
+    const char* const iend = istart + *srcSizePtr;
+    char* const ostart = (char*)dst;
+    char* op = ostart;
+    char* const oend = ostart + *maxDstSizePtr;
+    U32 notDone = 1;
+
+    while (notDone) {
+        switch(zbc->stage)
+        {
+        case ZBUFFv05ds_init :
+            return ERROR(init_missing);
+
+        case ZBUFFv05ds_readHeader :
+            /* read header from src */
+            {
+                size_t headerSize = ZSTDv05_getFrameParams(&(zbc->params), src, *srcSizePtr);
+                if (ZSTDv05_isError(headerSize)) return headerSize;
+                if (headerSize) {
+                    /* not enough input to decode header : tell how many bytes would be necessary */
+                    memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr);
+                    zbc->hPos += *srcSizePtr;
+                    *maxDstSizePtr = 0;
+                    zbc->stage = ZBUFFv05ds_loadHeader;
+                    return headerSize - zbc->hPos;
+                }
+                zbc->stage = ZBUFFv05ds_decodeHeader;
+                break;
+            }
+	    /* fall-through */
+        case ZBUFFv05ds_loadHeader:
+            /* complete header from src */
+            {
+                size_t headerSize = ZBUFFv05_limitCopy(
+                    zbc->headerBuffer + zbc->hPos, ZSTDv05_frameHeaderSize_max - zbc->hPos,
+                    src, *srcSizePtr);
+                zbc->hPos += headerSize;
+                ip += headerSize;
+                headerSize = ZSTDv05_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos);
+                if (ZSTDv05_isError(headerSize)) return headerSize;
+                if (headerSize) {
+                    /* not enough input to decode header : tell how many bytes would be necessary */
+                    *maxDstSizePtr = 0;
+                    return headerSize - zbc->hPos;
+                }
+                // zbc->stage = ZBUFFv05ds_decodeHeader; break;   /* useless : stage follows */
+            }
+	    /* fall-through */
+        case ZBUFFv05ds_decodeHeader:
+                /* apply header to create / resize buffers */
+                {
+                    size_t neededOutSize = (size_t)1 << zbc->params.windowLog;
+                    size_t neededInSize = BLOCKSIZE;   /* a block is never > BLOCKSIZE */
+                    if (zbc->inBuffSize < neededInSize) {
+                        free(zbc->inBuff);
+                        zbc->inBuffSize = neededInSize;
+                        zbc->inBuff = (char*)malloc(neededInSize);
+                        if (zbc->inBuff == NULL) return ERROR(memory_allocation);
+                    }
+                    if (zbc->outBuffSize < neededOutSize) {
+                        free(zbc->outBuff);
+                        zbc->outBuffSize = neededOutSize;
+                        zbc->outBuff = (char*)malloc(neededOutSize);
+                        if (zbc->outBuff == NULL) return ERROR(memory_allocation);
+                }   }
+                if (zbc->hPos) {
+                    /* some data already loaded into headerBuffer : transfer into inBuff */
+                    memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos);
+                    zbc->inPos = zbc->hPos;
+                    zbc->hPos = 0;
+                    zbc->stage = ZBUFFv05ds_load;
+                    break;
+                }
+                zbc->stage = ZBUFFv05ds_read;
+		/* fall-through */
+        case ZBUFFv05ds_read:
+            {
+                size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);
+                if (neededInSize==0) {  /* end of frame */
+                    zbc->stage = ZBUFFv05ds_init;
+                    notDone = 0;
+                    break;
+                }
+                if ((size_t)(iend-ip) >= neededInSize) {
+                    /* directly decode from src */
+                    size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc,
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
+                        ip, neededInSize);
+                    if (ZSTDv05_isError(decodedSize)) return decodedSize;
+                    ip += neededInSize;
+                    if (!decodedSize) break;   /* this was just a header */
+                    zbc->outEnd = zbc->outStart +  decodedSize;
+                    zbc->stage = ZBUFFv05ds_flush;
+                    break;
+                }
+                if (ip==iend) { notDone = 0; break; }   /* no more input */
+                zbc->stage = ZBUFFv05ds_load;
+            }
+	    /* fall-through */
+        case ZBUFFv05ds_load:
+            {
+                size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);
+                size_t toLoad = neededInSize - zbc->inPos;   /* should always be <= remaining space within inBuff */
+                size_t loadedSize;
+                if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected);   /* should never happen */
+                loadedSize = ZBUFFv05_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip);
+                ip += loadedSize;
+                zbc->inPos += loadedSize;
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
+                {
+                    size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc,
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
+                        zbc->inBuff, neededInSize);
+                    if (ZSTDv05_isError(decodedSize)) return decodedSize;
+                    zbc->inPos = 0;   /* input is consumed */
+                    if (!decodedSize) { zbc->stage = ZBUFFv05ds_read; break; }   /* this was just a header */
+                    zbc->outEnd = zbc->outStart +  decodedSize;
+                    zbc->stage = ZBUFFv05ds_flush;
+                    // break; /* ZBUFFv05ds_flush follows */
+                }
+	    }
+	    /* fall-through */
+        case ZBUFFv05ds_flush:
+            {
+                size_t toFlushSize = zbc->outEnd - zbc->outStart;
+                size_t flushedSize = ZBUFFv05_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize);
+                op += flushedSize;
+                zbc->outStart += flushedSize;
+                if (flushedSize == toFlushSize) {
+                    zbc->stage = ZBUFFv05ds_read;
+                    if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize)
+                        zbc->outStart = zbc->outEnd = 0;
+                    break;
+                }
+                /* cannot flush everything */
+                notDone = 0;
+                break;
+            }
+        default: return ERROR(GENERIC);   /* impossible */
+    }   }
+
+    *srcSizePtr = ip-istart;
+    *maxDstSizePtr = op-ostart;
+
+    {   size_t nextSrcSizeHint = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);
+        if (nextSrcSizeHint > ZBUFFv05_blockHeaderSize) nextSrcSizeHint+= ZBUFFv05_blockHeaderSize;   /* get next block header too */
+        nextSrcSizeHint -= zbc->inPos;   /* already loaded*/
+        return nextSrcSizeHint;
+    }
+}
+
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+unsigned ZBUFFv05_isError(size_t errorCode) { return ERR_isError(errorCode); }
+const char* ZBUFFv05_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
+
+size_t ZBUFFv05_recommendedDInSize(void)  { return BLOCKSIZE + ZBUFFv05_blockHeaderSize /* block header size*/ ; }
+size_t ZBUFFv05_recommendedDOutSize(void) { return BLOCKSIZE; }
diff --git a/src/zstd_v05.h b/src/zstd_v05.h
new file mode 100644
index 0000000..4a97985
--- /dev/null
+++ b/src/zstd_v05.h
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTDv05_H
+#define ZSTDv05_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*-*************************************
+*  Dependencies
+***************************************/
+#include <stddef.h>   /* size_t */
+#include "mem.h"      /* U64, U32 */
+
+
+/* *************************************
+*  Simple functions
+***************************************/
+/*! ZSTDv05_decompress() :
+    `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail.
+    `dstCapacity` must be large enough, equal or larger than originalSize.
+    @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
+              or an errorCode if it fails (which can be tested using ZSTDv05_isError()) */
+size_t ZSTDv05_decompress( void* dst, size_t dstCapacity,
+                     const void* src, size_t compressedSize);
+
+ /**
+ ZSTDv05_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.5.x format
+     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
+     cSize (output parameter)  : the number of bytes that would be read to decompress this frame
+                                 or an error code if it fails (which can be tested using ZSTDv01_isError())
+     dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
+                                 or ZSTD_CONTENTSIZE_ERROR if an error occurs
+
+    note : assumes `cSize` and `dBound` are _not_ NULL.
+ */
+void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
+                                     size_t* cSize, unsigned long long* dBound);
+
+/* *************************************
+*  Helper functions
+***************************************/
+/* Error Management */
+unsigned    ZSTDv05_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
+const char* ZSTDv05_getErrorName(size_t code);     /*!< provides readable string for an error code */
+
+
+/* *************************************
+*  Explicit memory management
+***************************************/
+/** Decompression context */
+typedef struct ZSTDv05_DCtx_s ZSTDv05_DCtx;
+ZSTDv05_DCtx* ZSTDv05_createDCtx(void);
+size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx);      /*!< @return : errorCode */
+
+/** ZSTDv05_decompressDCtx() :
+*   Same as ZSTDv05_decompress(), but requires an already allocated ZSTDv05_DCtx (see ZSTDv05_createDCtx()) */
+size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+/*-***********************
+*  Simple Dictionary API
+*************************/
+/*! ZSTDv05_decompress_usingDict() :
+*   Decompression using a pre-defined Dictionary content (see dictBuilder).
+*   Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted.
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTDv05_decompressDCtx() */
+size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx,
+                                            void* dst, size_t dstCapacity,
+                                      const void* src, size_t srcSize,
+                                      const void* dict,size_t dictSize);
+
+/*-************************
+*  Advanced Streaming API
+***************************/
+typedef enum { ZSTDv05_fast, ZSTDv05_greedy, ZSTDv05_lazy, ZSTDv05_lazy2, ZSTDv05_btlazy2, ZSTDv05_opt, ZSTDv05_btopt } ZSTDv05_strategy;
+typedef struct {
+    U64 srcSize;
+    U32 windowLog;     /* the only useful information to retrieve */
+    U32 contentLog; U32 hashLog; U32 searchLog; U32 searchLength; U32 targetLength; ZSTDv05_strategy strategy;
+} ZSTDv05_parameters;
+size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize);
+
+size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize);
+void   ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx);
+size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx);
+size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+/*-***********************
+*  ZBUFF API
+*************************/
+typedef struct ZBUFFv05_DCtx_s ZBUFFv05_DCtx;
+ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void);
+size_t         ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* dctx);
+
+size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* dctx);
+size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* dctx, const void* dict, size_t dictSize);
+
+size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* dctx,
+                                            void* dst, size_t* dstCapacityPtr,
+                                      const void* src, size_t* srcSizePtr);
+
+/*-***************************************************************************
+*  Streaming decompression
+*
+*  A ZBUFFv05_DCtx object is required to track streaming operations.
+*  Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources.
+*  Use ZBUFFv05_decompressInit() to start a new decompression operation,
+*   or ZBUFFv05_decompressInitDictionary() if decompression requires a dictionary.
+*  Note that ZBUFFv05_DCtx objects can be reused multiple times.
+*
+*  Use ZBUFFv05_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
+*  The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change @dst.
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency)
+*            or 0 when a frame is completely decoded
+*            or an error code, which can be tested using ZBUFFv05_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv05_recommendedDInSize() / ZBUFFv05_recommendedDOutSize()
+*  output : ZBUFFv05_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
+*  input  : ZBUFFv05_recommendedDInSize==128Kb+3; just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* *******************************************************************************/
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+unsigned ZBUFFv05_isError(size_t errorCode);
+const char* ZBUFFv05_getErrorName(size_t errorCode);
+
+/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
+*   These sizes are just hints, and tend to offer better latency */
+size_t ZBUFFv05_recommendedDInSize(void);
+size_t ZBUFFv05_recommendedDOutSize(void);
+
+
+
+/*-*************************************
+*  Constants
+***************************************/
+#define ZSTDv05_MAGICNUMBER 0xFD2FB525   /* v0.5 */
+
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* ZSTDv0505_H */
diff --git a/src/zstd_v06.c b/src/zstd_v06.c
new file mode 100644
index 0000000..f907a3a
--- /dev/null
+++ b/src/zstd_v06.c
@@ -0,0 +1,4150 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/*- Dependencies -*/
+#include "zstd_v06.h"
+#include <stddef.h>    /* size_t, ptrdiff_t */
+#include <string.h>    /* memcpy */
+#include <stdlib.h>    /* malloc, free, qsort */
+#include "error_private.h"
+
+
+
+/* ******************************************************************
+   mem.h
+   low-level memory access routines
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef MEM_H_MODULE
+#define MEM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*-****************************************
+*  Compiler specifics
+******************************************/
+#if defined(_MSC_VER)   /* Visual Studio */
+#   include <stdlib.h>  /* _byteswap_ulong */
+#   include <intrin.h>  /* _byteswap_* */
+#endif
+#if defined(__GNUC__)
+#  define MEM_STATIC static __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define MEM_STATIC static inline
+#elif defined(_MSC_VER)
+#  define MEM_STATIC static __inline
+#else
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/*-**************************************************************
+*  Basic Types
+*****************************************************************/
+#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+# include <stdint.h>
+  typedef  uint8_t BYTE;
+  typedef uint16_t U16;
+  typedef  int16_t S16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+  typedef  int64_t S64;
+#else
+  typedef unsigned char       BYTE;
+  typedef unsigned short      U16;
+  typedef   signed short      S16;
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+  typedef unsigned long long  U64;
+  typedef   signed long long  S64;
+#endif
+
+
+/*-**************************************************************
+*  Memory I/O
+*****************************************************************/
+/* MEM_FORCE_MEMORY_ACCESS :
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets depending on alignment.
+ *            In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define MEM_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#    define MEM_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
+
+MEM_STATIC unsigned MEM_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
+
+/* violates C standard, by lying on structure alignment.
+Only use if no other choice to achieve best performance on target platform */
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;
+
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
+
+#else
+
+/* default method, safe and standard.
+   can sometimes prove slower */
+
+MEM_STATIC U16 MEM_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U32 MEM_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U64 MEM_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+
+#endif /* MEM_FORCE_MEMORY_ACCESS */
+
+MEM_STATIC U32 MEM_swap32(U32 in)
+{
+#if defined(_MSC_VER)     /* Visual Studio */
+    return _byteswap_ulong(in);
+#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
+    return __builtin_bswap32(in);
+#else
+    return  ((in << 24) & 0xff000000 ) |
+            ((in <<  8) & 0x00ff0000 ) |
+            ((in >>  8) & 0x0000ff00 ) |
+            ((in >> 24) & 0x000000ff );
+#endif
+}
+
+MEM_STATIC U64 MEM_swap64(U64 in)
+{
+#if defined(_MSC_VER)     /* Visual Studio */
+    return _byteswap_uint64(in);
+#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
+    return __builtin_bswap64(in);
+#else
+    return  ((in << 56) & 0xff00000000000000ULL) |
+            ((in << 40) & 0x00ff000000000000ULL) |
+            ((in << 24) & 0x0000ff0000000000ULL) |
+            ((in << 8)  & 0x000000ff00000000ULL) |
+            ((in >> 8)  & 0x00000000ff000000ULL) |
+            ((in >> 24) & 0x0000000000ff0000ULL) |
+            ((in >> 40) & 0x000000000000ff00ULL) |
+            ((in >> 56) & 0x00000000000000ffULL);
+#endif
+}
+
+
+/*=== Little endian r/w ===*/
+
+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read16(memPtr);
+    else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
+{
+    if (MEM_isLittleEndian()) {
+        MEM_write16(memPtr, val);
+    } else {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE)val;
+        p[1] = (BYTE)(val>>8);
+    }
+}
+
+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read32(memPtr);
+    else
+        return MEM_swap32(MEM_read32(memPtr));
+}
+
+
+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read64(memPtr);
+    else
+        return MEM_swap64(MEM_read64(memPtr));
+}
+
+
+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readLE32(memPtr);
+    else
+        return (size_t)MEM_readLE64(memPtr);
+}
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* MEM_H_MODULE */
+
+/*
+    zstd - standard compression library
+    Header File for static linking only
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net
+*/
+#ifndef ZSTDv06_STATIC_H
+#define ZSTDv06_STATIC_H
+
+/* The prototypes defined within this file are considered experimental.
+ * They should not be used in the context DLL as they may change in the future.
+ * Prefer static linking if you need them, to control breaking version changes issues.
+ */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/*- Advanced Decompression functions -*/
+
+/*! ZSTDv06_decompress_usingPreparedDCtx() :
+*   Same as ZSTDv06_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded.
+*   It avoids reloading the dictionary each time.
+*   `preparedDCtx` must have been properly initialized using ZSTDv06_decompressBegin_usingDict().
+*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */
+ZSTDLIBv06_API size_t ZSTDv06_decompress_usingPreparedDCtx(
+                                           ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx,
+                                           void* dst, size_t dstCapacity,
+                                     const void* src, size_t srcSize);
+
+
+
+#define ZSTDv06_FRAMEHEADERSIZE_MAX 13    /* for static allocation */
+static const size_t ZSTDv06_frameHeaderSize_min = 5;
+static const size_t ZSTDv06_frameHeaderSize_max = ZSTDv06_FRAMEHEADERSIZE_MAX;
+
+ZSTDLIBv06_API size_t ZSTDv06_decompressBegin(ZSTDv06_DCtx* dctx);
+
+/*
+  Streaming decompression, direct mode (bufferless)
+
+  A ZSTDv06_DCtx object is required to track streaming operations.
+  Use ZSTDv06_createDCtx() / ZSTDv06_freeDCtx() to manage it.
+  A ZSTDv06_DCtx object can be re-used multiple times.
+
+  First optional operation is to retrieve frame parameters, using ZSTDv06_getFrameParams(), which doesn't consume the input.
+  It can provide the minimum size of rolling buffer required to properly decompress data,
+  and optionally the final size of uncompressed content.
+  (Note : content size is an optional info that may not be present. 0 means : content size unknown)
+  Frame parameters are extracted from the beginning of compressed frame.
+  The amount of data to read is variable, from ZSTDv06_frameHeaderSize_min to ZSTDv06_frameHeaderSize_max (so if `srcSize` >= ZSTDv06_frameHeaderSize_max, it will always work)
+  If `srcSize` is too small for operation to succeed, function will return the minimum size it requires to produce a result.
+  Result : 0 when successful, it means the ZSTDv06_frameParams structure has been filled.
+          >0 : means there is not enough data into `src`. Provides the expected size to successfully decode header.
+           errorCode, which can be tested using ZSTDv06_isError()
+
+  Start decompression, with ZSTDv06_decompressBegin() or ZSTDv06_decompressBegin_usingDict().
+  Alternatively, you can copy a prepared context, using ZSTDv06_copyDCtx().
+
+  Then use ZSTDv06_nextSrcSizeToDecompress() and ZSTDv06_decompressContinue() alternatively.
+  ZSTDv06_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv06_decompressContinue().
+  ZSTDv06_decompressContinue() requires this exact amount of bytes, or it will fail.
+  ZSTDv06_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog).
+  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible.
+
+  @result of ZSTDv06_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity)
+  It can be zero, which is not an error; it just means ZSTDv06_decompressContinue() has decoded some header.
+
+  A frame is fully decoded when ZSTDv06_nextSrcSizeToDecompress() returns zero.
+  Context can then be reset to start a new decompression.
+*/
+
+
+/* **************************************
+*  Block functions
+****************************************/
+/*! Block functions produce and decode raw zstd blocks, without frame metadata.
+    User will have to take in charge required information to regenerate data, such as compressed and content sizes.
+
+    A few rules to respect :
+    - Uncompressed block size must be <= ZSTDv06_BLOCKSIZE_MAX (128 KB)
+    - Compressing or decompressing requires a context structure
+      + Use ZSTDv06_createCCtx() and ZSTDv06_createDCtx()
+    - It is necessary to init context before starting
+      + compression : ZSTDv06_compressBegin()
+      + decompression : ZSTDv06_decompressBegin()
+      + variants _usingDict() are also allowed
+      + copyCCtx() and copyDCtx() work too
+    - When a block is considered not compressible enough, ZSTDv06_compressBlock() result will be zero.
+      In which case, nothing is produced into `dst`.
+      + User must test for such outcome and deal directly with uncompressed data
+      + ZSTDv06_decompressBlock() doesn't accept uncompressed data as input !!
+*/
+
+#define ZSTDv06_BLOCKSIZE_MAX (128 * 1024)   /* define, for static allocation */
+ZSTDLIBv06_API size_t ZSTDv06_decompressBlock(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* ZSTDv06_STATIC_H */
+/*
+    zstd_internal - common functions to include
+    Header File for include
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : https://www.zstd.net
+*/
+#ifndef ZSTDv06_CCOMMON_H_MODULE
+#define ZSTDv06_CCOMMON_H_MODULE
+
+
+/*-*************************************
+*  Common macros
+***************************************/
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
+
+
+/*-*************************************
+*  Common constants
+***************************************/
+#define ZSTDv06_DICT_MAGIC  0xEC30A436
+
+#define ZSTDv06_REP_NUM    3
+#define ZSTDv06_REP_INIT   ZSTDv06_REP_NUM
+#define ZSTDv06_REP_MOVE   (ZSTDv06_REP_NUM-1)
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BIT7 128
+#define BIT6  64
+#define BIT5  32
+#define BIT4  16
+#define BIT1   2
+#define BIT0   1
+
+#define ZSTDv06_WINDOWLOG_ABSOLUTEMIN 12
+static const size_t ZSTDv06_fcs_fieldSize[4] = { 0, 1, 2, 8 };
+
+#define ZSTDv06_BLOCKHEADERSIZE 3   /* because C standard does not allow a static const value to be defined using another static const value .... :( */
+static const size_t ZSTDv06_blockHeaderSize = ZSTDv06_BLOCKHEADERSIZE;
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
+
+#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
+#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */
+
+#define HufLog 12
+
+#define IS_HUF 0
+#define IS_PCH 1
+#define IS_RAW 2
+#define IS_RLE 3
+
+#define LONGNBSEQ 0x7F00
+
+#define MINMATCH 3
+#define EQUAL_READ32 4
+#define REPCODE_STARTVALUE 1
+
+#define Litbits  8
+#define MaxLit ((1<<Litbits) - 1)
+#define MaxML  52
+#define MaxLL  35
+#define MaxOff 28
+#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */
+#define MLFSELog    9
+#define LLFSELog    9
+#define OffFSELog   8
+
+#define FSEv06_ENCODING_RAW     0
+#define FSEv06_ENCODING_RLE     1
+#define FSEv06_ENCODING_STATIC  2
+#define FSEv06_ENCODING_DYNAMIC 3
+
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+
+static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9,10,11,12,
+                                     13,14,15,16 };
+static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
+                                             2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
+                                            -1,-1,-1,-1 };
+static const U32 LL_defaultNormLog = 6;
+
+static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9,10,11,
+                                     12,13,14,15,16 };
+static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,
+                                            -1,-1,-1,-1,-1 };
+static const U32 ML_defaultNormLog = 6;
+
+static const S16 OF_defaultNorm[MaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
+                                              1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1 };
+static const U32 OF_defaultNormLog = 5;
+
+
+/*-*******************************************
+*  Shared functions to include for inlining
+*********************************************/
+static void ZSTDv06_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+#define COPY8(d,s) { ZSTDv06_copy8(d,s); d+=8; s+=8; }
+
+/*! ZSTDv06_wildcopy() :
+*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
+#define WILDCOPY_OVERLENGTH 8
+MEM_STATIC void ZSTDv06_wildcopy(void* dst, const void* src, ptrdiff_t length)
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+    do
+        COPY8(op, ip)
+    while (op < oend);
+}
+
+
+
+/*-*******************************************
+*  Private interfaces
+*********************************************/
+typedef struct {
+    U32 off;
+    U32 len;
+} ZSTDv06_match_t;
+
+typedef struct {
+    U32 price;
+    U32 off;
+    U32 mlen;
+    U32 litlen;
+    U32 rep[ZSTDv06_REP_INIT];
+} ZSTDv06_optimal_t;
+
+typedef struct { U32  unused; } ZSTDv06_stats_t;
+
+typedef struct {
+    void* buffer;
+    U32*  offsetStart;
+    U32*  offset;
+    BYTE* offCodeStart;
+    BYTE* litStart;
+    BYTE* lit;
+    U16*  litLengthStart;
+    U16*  litLength;
+    BYTE* llCodeStart;
+    U16*  matchLengthStart;
+    U16*  matchLength;
+    BYTE* mlCodeStart;
+    U32   longLengthID;   /* 0 == no longLength; 1 == Lit.longLength; 2 == Match.longLength; */
+    U32   longLengthPos;
+    /* opt */
+    ZSTDv06_optimal_t* priceTable;
+    ZSTDv06_match_t* matchTable;
+    U32* matchLengthFreq;
+    U32* litLengthFreq;
+    U32* litFreq;
+    U32* offCodeFreq;
+    U32  matchLengthSum;
+    U32  matchSum;
+    U32  litLengthSum;
+    U32  litSum;
+    U32  offCodeSum;
+    U32  log2matchLengthSum;
+    U32  log2matchSum;
+    U32  log2litLengthSum;
+    U32  log2litSum;
+    U32  log2offCodeSum;
+    U32  factor;
+    U32  cachedPrice;
+    U32  cachedLitLength;
+    const BYTE* cachedLiterals;
+    ZSTDv06_stats_t stats;
+} seqStore_t;
+
+void ZSTDv06_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq);
+
+
+#endif   /* ZSTDv06_CCOMMON_H_MODULE */
+/* ******************************************************************
+   FSE : Finite State Entropy codec
+   Public Prototypes declaration
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef FSEv06_H
+#define FSEv06_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/*-****************************************
+*  FSE simple functions
+******************************************/
+/*! FSEv06_decompress():
+    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'dstCapacity'.
+    @return : size of regenerated data (<= maxDstSize),
+              or an error code, which can be tested using FSEv06_isError() .
+
+    ** Important ** : FSEv06_decompress() does not decompress non-compressible nor RLE data !!!
+    Why ? : making this distinction requires a header.
+    Header management is intentionally delegated to the user layer, which can better manage special cases.
+*/
+size_t FSEv06_decompress(void* dst,  size_t dstCapacity,
+                const void* cSrc, size_t cSrcSize);
+
+
+/*-*****************************************
+*  Tool functions
+******************************************/
+size_t FSEv06_compressBound(size_t size);       /* maximum compressed size */
+
+/* Error Management */
+unsigned    FSEv06_isError(size_t code);        /* tells if a return value is an error code */
+const char* FSEv06_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
+
+
+
+/*-*****************************************
+*  FSE detailed API
+******************************************/
+/*!
+
+FSEv06_decompress() does the following:
+1. read normalized counters with readNCount()
+2. build decoding table 'DTable' from normalized counters
+3. decode the data stream using decoding table 'DTable'
+
+The following API allows targeting specific sub-functions for advanced tasks.
+For example, it's possible to compress several blocks using the same 'CTable',
+or to save and provide normalized distribution using external method.
+*/
+
+
+/* *** DECOMPRESSION *** */
+
+/*! FSEv06_readNCount():
+    Read compactly saved 'normalizedCounter' from 'rBuffer'.
+    @return : size read from 'rBuffer',
+              or an errorCode, which can be tested using FSEv06_isError().
+              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
+size_t FSEv06_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
+
+/*! Constructor and Destructor of FSEv06_DTable.
+    Note that its size depends on 'tableLog' */
+typedef unsigned FSEv06_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+FSEv06_DTable* FSEv06_createDTable(unsigned tableLog);
+void        FSEv06_freeDTable(FSEv06_DTable* dt);
+
+/*! FSEv06_buildDTable():
+    Builds 'dt', which must be already allocated, using FSEv06_createDTable().
+    return : 0, or an errorCode, which can be tested using FSEv06_isError() */
+size_t FSEv06_buildDTable (FSEv06_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
+
+/*! FSEv06_decompress_usingDTable():
+    Decompress compressed source `cSrc` of size `cSrcSize` using `dt`
+    into `dst` which must be already allocated.
+    @return : size of regenerated data (necessarily <= `dstCapacity`),
+              or an errorCode, which can be tested using FSEv06_isError() */
+size_t FSEv06_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv06_DTable* dt);
+
+/*!
+Tutorial :
+----------
+(Note : these functions only decompress FSE-compressed blocks.
+ If block is uncompressed, use memcpy() instead
+ If block is a single repeated byte, use memset() instead )
+
+The first step is to obtain the normalized frequencies of symbols.
+This can be performed by FSEv06_readNCount() if it was saved using FSEv06_writeNCount().
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
+In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
+or size the table to handle worst case situations (typically 256).
+FSEv06_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
+The result of FSEv06_readNCount() is the number of bytes read from 'rBuffer'.
+Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
+If there is an error, the function will return an error code, which can be tested using FSEv06_isError().
+
+The next step is to build the decompression tables 'FSEv06_DTable' from 'normalizedCounter'.
+This is performed by the function FSEv06_buildDTable().
+The space required by 'FSEv06_DTable' must be already allocated using FSEv06_createDTable().
+If there is an error, the function will return an error code, which can be tested using FSEv06_isError().
+
+`FSEv06_DTable` can then be used to decompress `cSrc`, with FSEv06_decompress_usingDTable().
+`cSrcSize` must be strictly correct, otherwise decompression will fail.
+FSEv06_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).
+If there is an error, the function will return an error code, which can be tested using FSEv06_isError(). (ex: dst buffer too small)
+*/
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* FSEv06_H */
+/* ******************************************************************
+   bitstream
+   Part of FSE library
+   header file (to include)
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef BITSTREAM_H_MODULE
+#define BITSTREAM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*
+*  This API consists of small unitary functions, which must be inlined for best performance.
+*  Since link-time-optimization is not available for all compilers,
+*  these functions are defined into a .h to be included.
+*/
+
+
+/*=========================================
+*  Target specific
+=========================================*/
+#if defined(__BMI__) && defined(__GNUC__)
+#  include <immintrin.h>   /* support for bextr (experimental) */
+#endif
+
+
+
+/*-********************************************
+*  bitStream decoding API (read backward)
+**********************************************/
+typedef struct
+{
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+} BITv06_DStream_t;
+
+typedef enum { BITv06_DStream_unfinished = 0,
+               BITv06_DStream_endOfBuffer = 1,
+               BITv06_DStream_completed = 2,
+               BITv06_DStream_overflow = 3 } BITv06_DStream_status;  /* result of BITv06_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
+
+MEM_STATIC size_t   BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
+MEM_STATIC size_t   BITv06_readBits(BITv06_DStream_t* bitD, unsigned nbBits);
+MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD);
+MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_DStream_t* bitD);
+
+
+
+/*-****************************************
+*  unsafe API
+******************************************/
+MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, unsigned nbBits);
+/* faster, but works only if nbBits >= 1 */
+
+
+
+/*-**************************************************************
+*  Internal functions
+****************************************************************/
+MEM_STATIC unsigned BITv06_highbit32 ( U32 val)
+{
+#   if defined(_MSC_VER)   /* Visual */
+    unsigned long r=0;
+    _BitScanReverse ( &r, val );
+    return (unsigned) r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+    return 31 - __builtin_clz (val);
+#   else   /* Software version */
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+    U32 v = val;
+    unsigned r;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+    return r;
+#   endif
+}
+
+
+
+/*-********************************************************
+* bitStream decoding
+**********************************************************/
+/*! BITv06_initDStream() :
+*   Initialize a BITv06_DStream_t.
+*   `bitD` : a pointer to an already allocated BITv06_DStream_t structure.
+*   `srcSize` must be the *exact* size of the bitStream, in bytes.
+*   @return : size of stream (== srcSize) or an errorCode if a problem is detected
+*/
+MEM_STATIC size_t BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
+
+    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+          if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */
+          bitD->bitsConsumed = 8 - BITv06_highbit32(lastByte); }
+    } else {
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);/* fall-through */
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);/* fall-through */
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);/* fall-through */
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; /* fall-through */
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8; /* fall-through */
+            default: break;
+        }
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+          if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */
+          bitD->bitsConsumed = 8 - BITv06_highbit32(lastByte); }
+        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+
+
+ MEM_STATIC size_t BITv06_lookBits(const BITv06_DStream_t* bitD, U32 nbBits)
+{
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
+}
+
+/*! BITv06_lookBitsFast() :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BITv06_lookBitsFast(const BITv06_DStream_t* bitD, U32 nbBits)
+{
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
+}
+
+MEM_STATIC void BITv06_skipBits(BITv06_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+MEM_STATIC size_t BITv06_readBits(BITv06_DStream_t* bitD, U32 nbBits)
+{
+    size_t const value = BITv06_lookBits(bitD, nbBits);
+    BITv06_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*! BITv06_readBitsFast() :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, U32 nbBits)
+{
+    size_t const value = BITv06_lookBitsFast(bitD, nbBits);
+    BITv06_skipBits(bitD, nbBits);
+    return value;
+}
+
+MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
+        return BITv06_DStream_overflow;
+
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        return BITv06_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start) {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv06_DStream_endOfBuffer;
+        return BITv06_DStream_completed;
+    }
+    {   U32 nbBytes = bitD->bitsConsumed >> 3;
+        BITv06_DStream_status result = BITv06_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start) {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = BITv06_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
+        return result;
+    }
+}
+
+/*! BITv06_endOfDStream() :
+*   @return Tells if DStream has exactly reached its end (all bits consumed).
+*/
+MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_DStream_t* DStream)
+{
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* BITSTREAM_H_MODULE */
+/* ******************************************************************
+   FSE : Finite State Entropy coder
+   header file for static linking (only)
+   Copyright (C) 2013-2015, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef FSEv06_STATIC_H
+#define FSEv06_STATIC_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* *****************************************
+*  Static allocation
+*******************************************/
+/* FSE buffer bounds */
+#define FSEv06_NCOUNTBOUND 512
+#define FSEv06_BLOCKBOUND(size) (size + (size>>7))
+#define FSEv06_COMPRESSBOUND(size) (FSEv06_NCOUNTBOUND + FSEv06_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */
+#define FSEv06_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+
+/* *****************************************
+*  FSE advanced API
+*******************************************/
+size_t FSEv06_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize);
+/* same as FSEv06_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */
+
+size_t FSEv06_buildDTable_raw (FSEv06_DTable* dt, unsigned nbBits);
+/* build a fake FSEv06_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
+
+size_t FSEv06_buildDTable_rle (FSEv06_DTable* dt, unsigned char symbolValue);
+/* build a fake FSEv06_DTable, designed to always generate the same symbolValue */
+
+
+/* *****************************************
+*  FSE symbol decompression API
+*******************************************/
+typedef struct
+{
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSEv06_DState_t;
+
+
+static void     FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD, const FSEv06_DTable* dt);
+
+static unsigned char FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD);
+
+
+/* *****************************************
+*  FSE unsafe API
+*******************************************/
+static unsigned char FSEv06_decodeSymbolFast(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD);
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
+
+
+/* *****************************************
+*  Implementation of inlined functions
+*******************************************/
+
+
+/* ======    Decompression    ====== */
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSEv06_DTableHeader;   /* sizeof U32 */
+
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSEv06_decode_t;   /* size == U32 */
+
+MEM_STATIC void FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD, const FSEv06_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSEv06_DTableHeader* const DTableH = (const FSEv06_DTableHeader*)ptr;
+    DStatePtr->state = BITv06_readBits(bitD, DTableH->tableLog);
+    BITv06_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+MEM_STATIC BYTE FSEv06_peekSymbol(const FSEv06_DState_t* DStatePtr)
+{
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    return DInfo.symbol;
+}
+
+MEM_STATIC void FSEv06_updateState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)
+{
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    size_t const lowBits = BITv06_readBits(bitD, nbBits);
+    DStatePtr->state = DInfo.newState + lowBits;
+}
+
+MEM_STATIC BYTE FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)
+{
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    BYTE const symbol = DInfo.symbol;
+    size_t const lowBits = BITv06_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+/*! FSEv06_decodeSymbolFast() :
+    unsafe, only works if no symbol has a probability > 50% */
+MEM_STATIC BYTE FSEv06_decodeSymbolFast(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)
+{
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    BYTE const symbol = DInfo.symbol;
+    size_t const lowBits = BITv06_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+
+
+#ifndef FSEv06_COMMONDEFS_ONLY
+
+/* **************************************************************
+*  Tuning parameters
+****************************************************************/
+/*!MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#define FSEv06_MAX_MEMORY_USAGE 14
+#define FSEv06_DEFAULT_MEMORY_USAGE 13
+
+/*!FSEv06_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#define FSEv06_MAX_SYMBOL_VALUE 255
+
+
+/* **************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSEv06_FUNCTION_TYPE BYTE
+#define FSEv06_FUNCTION_EXTENSION
+#define FSEv06_DECODE_TYPE FSEv06_decode_t
+
+
+#endif   /* !FSEv06_COMMONDEFS_ONLY */
+
+
+/* ***************************************************************
+*  Constants
+*****************************************************************/
+#define FSEv06_MAX_TABLELOG  (FSEv06_MAX_MEMORY_USAGE-2)
+#define FSEv06_MAX_TABLESIZE (1U<<FSEv06_MAX_TABLELOG)
+#define FSEv06_MAXTABLESIZE_MASK (FSEv06_MAX_TABLESIZE-1)
+#define FSEv06_DEFAULT_TABLELOG (FSEv06_DEFAULT_MEMORY_USAGE-2)
+#define FSEv06_MIN_TABLELOG 5
+
+#define FSEv06_TABLELOG_ABSOLUTE_MAX 15
+#if FSEv06_MAX_TABLELOG > FSEv06_TABLELOG_ABSOLUTE_MAX
+#error "FSEv06_MAX_TABLELOG > FSEv06_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+#define FSEv06_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* FSEv06_STATIC_H */
+/*
+   Common functions of New Generation Entropy library
+   Copyright (C) 2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+*************************************************************************** */
+
+
+/*-****************************************
+*  FSE Error Management
+******************************************/
+unsigned FSEv06_isError(size_t code) { return ERR_isError(code); }
+
+const char* FSEv06_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+/* **************************************************************
+*  HUF Error Management
+****************************************************************/
+static unsigned HUFv06_isError(size_t code) { return ERR_isError(code); }
+
+
+/*-**************************************************************
+*  FSE NCount encoding-decoding
+****************************************************************/
+static short FSEv06_abs(short a) { return a<0 ? -a : a; }
+
+size_t FSEv06_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) return ERROR(srcSize_wrong);
+    bitStream = MEM_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSEv06_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSEv06_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) && (charnum<=*maxSVPtr)) {
+        if (previous0) {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF) {
+                n0+=24;
+                if (ip < iend-5) {
+                    ip+=2;
+                    bitStream = MEM_readLE32(ip) >> bitCount;
+                } else {
+                    bitStream >>= 16;
+                    bitCount+=16;
+            }   }
+            while ((bitStream & 3) == 3) {
+                n0+=3;
+                bitStream>>=2;
+                bitCount+=2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = MEM_readLE32(ip) >> bitCount;
+            }
+            else
+                bitStream >>= 2;
+        }
+        {   short const max = (short)((2*threshold-1)-remaining);
+            short count;
+
+            if ((bitStream & (threshold-1)) < (U32)max) {
+                count = (short)(bitStream & (threshold-1));
+                bitCount   += nbBits-1;
+            } else {
+                count = (short)(bitStream & (2*threshold-1));
+                if (count >= threshold) count -= max;
+                bitCount   += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= FSEv06_abs(count);
+            normalizedCounter[charnum++] = count;
+            previous0 = !count;
+            while (remaining < threshold) {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                ip += bitCount>>3;
+                bitCount &= 7;
+            } else {
+                bitCount -= (int)(8 * (iend - 4 - ip));
+                ip = iend - 4;
+            }
+            bitStream = MEM_readLE32(ip) >> (bitCount & 31);
+    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */
+    if (remaining != 1) return ERROR(GENERIC);
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
+    return ip-istart;
+}
+/* ******************************************************************
+   FSE : Finite State Entropy decoder
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  define FORCE_INLINE static __forceinline
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#else
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define FSEv06_isError ERR_isError
+#define FSEv06_STATIC_ASSERT(c) { enum { FSEv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/* **************************************************************
+*  Complex types
+****************************************************************/
+typedef U32 DTable_max_t[FSEv06_DTABLE_SIZE_U32(FSEv06_MAX_TABLELOG)];
+
+
+/* **************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSEv06_FUNCTION_EXTENSION
+#  error "FSEv06_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSEv06_FUNCTION_TYPE
+#  error "FSEv06_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSEv06_CAT(X,Y) X##Y
+#define FSEv06_FUNCTION_NAME(X,Y) FSEv06_CAT(X,Y)
+#define FSEv06_TYPE_NAME(X,Y) FSEv06_CAT(X,Y)
+
+
+/* Function templates */
+FSEv06_DTable* FSEv06_createDTable (unsigned tableLog)
+{
+    if (tableLog > FSEv06_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv06_TABLELOG_ABSOLUTE_MAX;
+    return (FSEv06_DTable*)malloc( FSEv06_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
+}
+
+void FSEv06_freeDTable (FSEv06_DTable* dt)
+{
+    free(dt);
+}
+
+size_t FSEv06_buildDTable(FSEv06_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
+    FSEv06_DECODE_TYPE* const tableDecode = (FSEv06_DECODE_TYPE*) (tdPtr);
+    U16 symbolNext[FSEv06_MAX_SYMBOL_VALUE+1];
+
+    U32 const maxSV1 = maxSymbolValue + 1;
+    U32 const tableSize = 1 << tableLog;
+    U32 highThreshold = tableSize-1;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSEv06_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
+    if (tableLog > FSEv06_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+
+    /* Init, lay down lowprob symbols */
+    {   FSEv06_DTableHeader DTableH;
+        DTableH.tableLog = (U16)tableLog;
+        DTableH.fastMode = 1;
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
+            U32 s;
+            for (s=0; s<maxSV1; s++) {
+                if (normalizedCounter[s]==-1) {
+                    tableDecode[highThreshold--].symbol = (FSEv06_FUNCTION_TYPE)s;
+                    symbolNext[s] = 1;
+                } else {
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
+                    symbolNext[s] = normalizedCounter[s];
+        }   }   }
+        memcpy(dt, &DTableH, sizeof(DTableH));
+    }
+
+    /* Spread symbols */
+    {   U32 const tableMask = tableSize-1;
+        U32 const step = FSEv06_TABLESTEP(tableSize);
+        U32 s, position = 0;
+        for (s=0; s<maxSV1; s++) {
+            int i;
+            for (i=0; i<normalizedCounter[s]; i++) {
+                tableDecode[position].symbol = (FSEv06_FUNCTION_TYPE)s;
+                position = (position + step) & tableMask;
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }   }
+
+        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+    }
+
+    /* Build Decoding table */
+    {   U32 u;
+        for (u=0; u<tableSize; u++) {
+            FSEv06_FUNCTION_TYPE const symbol = (FSEv06_FUNCTION_TYPE)(tableDecode[u].symbol);
+            U16 nextState = symbolNext[symbol]++;
+            tableDecode[u].nbBits = (BYTE) (tableLog - BITv06_highbit32 ((U32)nextState) );
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
+    }   }
+
+    return 0;
+}
+
+
+
+#ifndef FSEv06_COMMONDEFS_ONLY
+
+/*-*******************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+size_t FSEv06_buildDTable_rle (FSEv06_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSEv06_DTableHeader* const DTableH = (FSEv06_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSEv06_decode_t* const cell = (FSEv06_decode_t*)dPtr;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+size_t FSEv06_buildDTable_raw (FSEv06_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSEv06_DTableHeader* const DTableH = (FSEv06_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSEv06_decode_t* const dinfo = (FSEv06_decode_t*)dPtr;
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSV1 = tableMask+1;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<maxSV1; s++) {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+FORCE_INLINE size_t FSEv06_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSEv06_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    BITv06_DStream_t bitD;
+    FSEv06_DState_t state1;
+    FSEv06_DState_t state2;
+
+    /* Init */
+    { size_t const errorCode = BITv06_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
+      if (FSEv06_isError(errorCode)) return errorCode; }
+
+    FSEv06_initDState(&state1, &bitD, dt);
+    FSEv06_initDState(&state2, &bitD, dt);
+
+#define FSEv06_GETSYMBOL(statePtr) fast ? FSEv06_decodeSymbolFast(statePtr, &bitD) : FSEv06_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (BITv06_reloadDStream(&bitD)==BITv06_DStream_unfinished) && (op<olimit) ; op+=4) {
+        op[0] = FSEv06_GETSYMBOL(&state1);
+
+        if (FSEv06_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BITv06_reloadDStream(&bitD);
+
+        op[1] = FSEv06_GETSYMBOL(&state2);
+
+        if (FSEv06_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (BITv06_reloadDStream(&bitD) > BITv06_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSEv06_GETSYMBOL(&state1);
+
+        if (FSEv06_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BITv06_reloadDStream(&bitD);
+
+        op[3] = FSEv06_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : BITv06_reloadDStream(&bitD) >= FSEv06_DStream_partiallyFilled; Ends at exactly BITv06_DStream_completed */
+    while (1) {
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
+
+        *op++ = FSEv06_GETSYMBOL(&state1);
+
+        if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) {
+            *op++ = FSEv06_GETSYMBOL(&state2);
+            break;
+        }
+
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
+
+        *op++ = FSEv06_GETSYMBOL(&state2);
+
+        if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) {
+            *op++ = FSEv06_GETSYMBOL(&state1);
+            break;
+    }   }
+
+    return op-ostart;
+}
+
+
+size_t FSEv06_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSEv06_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSEv06_DTableHeader* DTableH = (const FSEv06_DTableHeader*)ptr;
+    const U32 fastMode = DTableH->fastMode;
+
+    /* select fast mode (static) */
+    if (fastMode) return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+size_t FSEv06_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSEv06_MAX_SYMBOL_VALUE+1];
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSEv06_MAX_SYMBOL_VALUE;
+
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
+
+    /* normal FSE decoding mode */
+    {   size_t const NCountLength = FSEv06_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+        if (FSEv06_isError(NCountLength)) return NCountLength;
+        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
+        ip += NCountLength;
+        cSrcSize -= NCountLength;
+    }
+
+    { size_t const errorCode = FSEv06_buildDTable (dt, counting, maxSymbolValue, tableLog);
+      if (FSEv06_isError(errorCode)) return errorCode; }
+
+    return FSEv06_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */
+}
+
+
+
+#endif   /* FSEv06_COMMONDEFS_ONLY */
+/* ******************************************************************
+   Huffman coder, part of New Generation Entropy library
+   header file
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef HUFv06_H
+#define HUFv06_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* ****************************************
+*  HUF simple functions
+******************************************/
+size_t HUFv06_decompress(void* dst,  size_t dstSize,
+                const void* cSrc, size_t cSrcSize);
+/*
+HUFv06_decompress() :
+    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'dstSize'.
+    `dstSize` : must be the **exact** size of original (uncompressed) data.
+    Note : in contrast with FSE, HUFv06_decompress can regenerate
+           RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
+           because it knows size to regenerate.
+    @return : size of regenerated data (== dstSize)
+              or an error code, which can be tested using HUFv06_isError()
+*/
+
+
+/* ****************************************
+*  Tool functions
+******************************************/
+size_t HUFv06_compressBound(size_t size);       /**< maximum compressed size */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* HUFv06_H */
+/* ******************************************************************
+   Huffman codec, part of New Generation Entropy library
+   header file, for static linking only
+   Copyright (C) 2013-2016, Yann Collet
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef HUFv06_STATIC_H
+#define HUFv06_STATIC_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* ****************************************
+*  Static allocation
+******************************************/
+/* HUF buffer bounds */
+#define HUFv06_CTABLEBOUND 129
+#define HUFv06_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */
+#define HUFv06_COMPRESSBOUND(size) (HUFv06_CTABLEBOUND + HUFv06_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
+
+/* static allocation of HUF's DTable */
+#define HUFv06_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))
+#define HUFv06_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+        unsigned short DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUFv06_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
+        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
+#define HUFv06_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
+        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
+
+
+/* ****************************************
+*  Advanced decompression functions
+******************************************/
+size_t HUFv06_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+size_t HUFv06_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
+
+
+
+/*!
+HUFv06_decompress() does the following:
+1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics
+2. build Huffman table from save, using HUFv06_readDTableXn()
+3. decode 1 or 4 segments in parallel using HUFv06_decompressSXn_usingDTable
+*/
+size_t HUFv06_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize);
+size_t HUFv06_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize);
+
+size_t HUFv06_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
+size_t HUFv06_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
+
+
+/* single stream variants */
+size_t HUFv06_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+size_t HUFv06_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
+
+size_t HUFv06_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
+size_t HUFv06_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
+
+
+
+/* **************************************************************
+*  Constants
+****************************************************************/
+#define HUFv06_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUFv06_MAX_TABLELOG. Beyond that value, code does not work */
+#define HUFv06_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUFv06_ABSOLUTEMAX_TABLELOG */
+#define HUFv06_DEFAULT_TABLELOG  HUFv06_MAX_TABLELOG   /* tableLog by default, when not specified */
+#define HUFv06_MAX_SYMBOL_VALUE 255
+#if (HUFv06_MAX_TABLELOG > HUFv06_ABSOLUTEMAX_TABLELOG)
+#  error "HUFv06_MAX_TABLELOG is too large !"
+#endif
+
+
+
+/*! HUFv06_readStats() :
+    Read compact Huffman tree, saved by HUFv06_writeCTable().
+    `huffWeight` is destination buffer.
+    @return : size read from `src`
+*/
+MEM_STATIC size_t HUFv06_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                            U32* nbSymbolsPtr, U32* tableLogPtr,
+                            const void* src, size_t srcSize)
+{
+    U32 weightTotal;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+
+    if (!srcSize) return ERROR(srcSize_wrong);
+    iSize = ip[0];
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
+
+    if (iSize >= 128)  { /* special header */
+        if (iSize >= (242)) {  /* RLE */
+            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+            oSize = l[iSize-242];
+            memset(huffWeight, 1, hwSize);
+            iSize = 0;
+        }
+        else {   /* Incompressible */
+            oSize = iSize - 127;
+            iSize = ((oSize+1)/2);
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+            if (oSize >= hwSize) return ERROR(corruption_detected);
+            ip += 1;
+            {   U32 n;
+                for (n=0; n<oSize; n+=2) {
+                    huffWeight[n]   = ip[n/2] >> 4;
+                    huffWeight[n+1] = ip[n/2] & 15;
+    }   }   }   }
+    else  {   /* header compressed with FSE (normal case) */
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        oSize = FSEv06_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
+        if (FSEv06_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankStats, 0, (HUFv06_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
+    weightTotal = 0;
+    {   U32 n; for (n=0; n<oSize; n++) {
+            if (huffWeight[n] >= HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+            rankStats[huffWeight[n]]++;
+            weightTotal += (1 << huffWeight[n]) >> 1;
+    }   }
+    if (weightTotal == 0) return ERROR(corruption_detected);
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    {   U32 const tableLog = BITv06_highbit32(weightTotal) + 1;
+        if (tableLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
+        *tableLogPtr = tableLog;
+        /* determine last weight */
+        {   U32 const total = 1 << tableLog;
+            U32 const rest = total - weightTotal;
+            U32 const verif = 1 << BITv06_highbit32(rest);
+            U32 const lastWeight = BITv06_highbit32(rest) + 1;
+            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
+            huffWeight[oSize] = (BYTE)lastWeight;
+            rankStats[lastWeight]++;
+    }   }
+
+    /* check tree construction validity */
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* results */
+    *nbSymbolsPtr = (U32)(oSize+1);
+    return iSize+1;
+}
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* HUFv06_STATIC_H */
+/* ******************************************************************
+   Huffman decoder, part of New Generation Entropy library
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+/* inline is defined */
+#elif defined(_MSC_VER)
+#  define inline __inline
+#else
+#  define inline /* disable inline */
+#endif
+
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#endif
+
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define HUFv06_STATIC_ASSERT(c) { enum { HUFv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+
+/* *******************************************************
+*  HUF : Huffman block decompression
+*********************************************************/
+typedef struct { BYTE byte; BYTE nbBits; } HUFv06_DEltX2;   /* single-symbol decoding */
+
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv06_DEltX4;  /* double-symbols decoding */
+
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
+
+
+
+/*-***************************/
+/*  single-symbol decoding   */
+/*-***************************/
+
+size_t HUFv06_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUFv06_MAX_SYMBOL_VALUE + 1];
+    U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
+    U32 tableLog = 0;
+    size_t iSize;
+    U32 nbSymbols = 0;
+    U32 n;
+    U32 nextRankStart;
+    void* const dtPtr = DTable + 1;
+    HUFv06_DEltX2* const dt = (HUFv06_DEltX2*)dtPtr;
+
+    HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUFv06_readStats(huffWeight, HUFv06_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
+    if (HUFv06_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof allocated DTable, from used size of DTable, in case of re-use */
+
+    /* Prepare ranks */
+    nextRankStart = 0;
+    for (n=1; n<tableLog+1; n++) {
+        U32 current = nextRankStart;
+        nextRankStart += (rankVal[n] << (n-1));
+        rankVal[n] = current;
+    }
+
+    /* fill DTable */
+    for (n=0; n<nbSymbols; n++) {
+        const U32 w = huffWeight[n];
+        const U32 length = (1 << w) >> 1;
+        U32 i;
+        HUFv06_DEltX2 D;
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
+        for (i = rankVal[w]; i < rankVal[w] + length; i++)
+            dt[i] = D;
+        rankVal[w] += length;
+    }
+
+    return iSize;
+}
+
+
+static BYTE HUFv06_decodeSymbolX2(BITv06_DStream_t* Dstream, const HUFv06_DEltX2* dt, const U32 dtLog)
+{
+    const size_t val = BITv06_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+    const BYTE c = dt[val].byte;
+    BITv06_skipBits(Dstream, dt[val].nbBits);
+    return c;
+}
+
+#define HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    *ptr++ = HUFv06_decodeSymbolX2(DStreamPtr, dt, dtLog)
+
+#define HUFv06_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \
+        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+#define HUFv06_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+static inline size_t HUFv06_decodeStreamX2(BYTE* p, BITv06_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv06_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 4 symbols at a time */
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-4)) {
+        HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUFv06_DECODE_SYMBOLX2_1(p, bitDPtr);
+        HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd))
+        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    /* no more data to retrieve from bitstream, hence no need to reload */
+    while (p < pEnd)
+        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    return pEnd-pStart;
+}
+
+size_t HUFv06_decompress1X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + dstSize;
+    const U32 dtLog = DTable[0];
+    const void* dtPtr = DTable;
+    const HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr)+1;
+    BITv06_DStream_t bitD;
+
+    { size_t const errorCode = BITv06_initDStream(&bitD, cSrc, cSrcSize);
+      if (HUFv06_isError(errorCode)) return errorCode; }
+
+    HUFv06_decodeStreamX2(op, &bitD, oend, dt, dtLog);
+
+    /* check */
+    if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    return dstSize;
+}
+
+size_t HUFv06_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize);
+    if (HUFv06_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUFv06_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+size_t HUFv06_decompress4X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U16* DTable)
+{
+    /* Check */
+    if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */
+
+    {   const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable;
+        const HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BITv06_DStream_t bitD1;
+        BITv06_DStream_t bitD2;
+        BITv06_DStream_t bitD3;
+        BITv06_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BITv06_initDStream(&bitD1, istart1, length1);
+        if (HUFv06_isError(errorCode)) return errorCode;
+        errorCode = BITv06_initDStream(&bitD2, istart2, length2);
+        if (HUFv06_isError(errorCode)) return errorCode;
+        errorCode = BITv06_initDStream(&bitD3, istart3, length3);
+        if (HUFv06_isError(errorCode)) return errorCode;
+        errorCode = BITv06_initDStream(&bitD4, istart4, length4);
+        if (HUFv06_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);
+        for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) {
+            HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUFv06_DECODE_SYMBOLX2_1(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX2_1(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX2_1(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX2_1(op4, &bitD4);
+            HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUFv06_DECODE_SYMBOLX2_0(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX2_0(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX2_0(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX2_0(op4, &bitD4);
+            endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUFv06_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUFv06_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUFv06_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUFv06_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+size_t HUFv06_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize);
+    if (HUFv06_isError(errorCode)) return errorCode;
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += errorCode;
+    cSrcSize -= errorCode;
+
+    return HUFv06_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+/* *************************/
+/* double-symbols decoding */
+/* *************************/
+
+static void HUFv06_fillDTableX4Level2(HUFv06_DEltX4* DTable, U32 sizeLog, const U32 consumed,
+                           const U32* rankValOrigin, const int minWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
+                           U32 nbBitsBaseline, U16 baseSeq)
+{
+    HUFv06_DEltX4 DElt;
+    U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1];
+
+    /* get pre-calculated rankVal */
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1) {
+        U32 i, skipSize = rankVal[minWeight];
+        MEM_writeLE16(&(DElt.sequence), baseSeq);
+        DElt.nbBits   = (BYTE)(consumed);
+        DElt.length   = 1;
+        for (i = 0; i < skipSize; i++)
+            DTable[i] = DElt;
+    }
+
+    /* fill DTable */
+    { U32 s; for (s=0; s<sortedListSize; s++) {   /* note : sortedSymbols already skipped */
+        const U32 symbol = sortedSymbols[s].symbol;
+        const U32 weight = sortedSymbols[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 length = 1 << (sizeLog-nbBits);
+        const U32 start = rankVal[weight];
+        U32 i = start;
+        const U32 end = start + length;
+
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
+        DElt.nbBits = (BYTE)(nbBits + consumed);
+        DElt.length = 2;
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
+
+        rankVal[weight] += length;
+    }}
+}
+
+typedef U32 rankVal_t[HUFv06_ABSOLUTEMAX_TABLELOG][HUFv06_ABSOLUTEMAX_TABLELOG + 1];
+
+static void HUFv06_fillDTableX4(HUFv06_DEltX4* DTable, const U32 targetLog,
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32 nbBitsBaseline)
+{
+    U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1];
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
+    const U32 minBits  = nbBitsBaseline - maxWeight;
+    U32 s;
+
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++) {
+        const U16 symbol = sortedList[s].symbol;
+        const U32 weight = sortedList[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 start = rankVal[weight];
+        const U32 length = 1 << (targetLog-nbBits);
+
+        if (targetLog-nbBits >= minBits) {   /* enough room for a second symbol */
+            U32 sortedRank;
+            int minWeight = nbBits + scaleLog;
+            if (minWeight < 1) minWeight = 1;
+            sortedRank = rankStart[minWeight];
+            HUFv06_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
+                           rankValOrigin[nbBits], minWeight,
+                           sortedList+sortedRank, sortedListSize-sortedRank,
+                           nbBitsBaseline, symbol);
+        } else {
+            HUFv06_DEltX4 DElt;
+            MEM_writeLE16(&(DElt.sequence), symbol);
+            DElt.nbBits = (BYTE)(nbBits);
+            DElt.length = 1;
+            {   U32 u;
+                const U32 end = start + length;
+                for (u = start; u < end; u++) DTable[u] = DElt;
+        }   }
+        rankVal[weight] += length;
+    }
+}
+
+size_t HUFv06_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
+{
+    BYTE weightList[HUFv06_MAX_SYMBOL_VALUE + 1];
+    sortedSymbol_t sortedSymbol[HUFv06_MAX_SYMBOL_VALUE + 1];
+    U32 rankStats[HUFv06_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
+    U32 rankStart0[HUFv06_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
+    U32* const rankStart = rankStart0+1;
+    rankVal_t rankVal;
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    const U32 memLog = DTable[0];
+    size_t iSize;
+    void* dtPtr = DTable;
+    HUFv06_DEltX4* const dt = ((HUFv06_DEltX4*)dtPtr) + 1;
+
+    HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
+    if (memLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUFv06_readStats(weightList, HUFv06_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUFv06_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
+
+    /* Get start index of each weight */
+    {   U32 w, nextRankStart = 0;
+        for (w=1; w<maxW+1; w++) {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {   U32 s;
+        for (s=0; s<nbSymbols; s++) {
+            U32 const w = weightList[s];
+            U32 const r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {   U32* const rankVal0 = rankVal[0];
+        {   int const rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
+            U32 nextRankVal = 0;
+            U32 w;
+            for (w=1; w<maxW+1; w++) {
+                U32 current = nextRankVal;
+                nextRankVal += rankStats[w] << (w+rescale);
+                rankVal0[w] = current;
+        }   }
+        {   U32 const minBits = tableLog+1 - maxW;
+            U32 consumed;
+            for (consumed = minBits; consumed < memLog - minBits + 1; consumed++) {
+                U32* const rankValPtr = rankVal[consumed];
+                U32 w;
+                for (w = 1; w < maxW+1; w++) {
+                    rankValPtr[w] = rankVal0[w] >> consumed;
+    }   }   }   }
+
+    HUFv06_fillDTableX4(dt, memLog,
+                   sortedSymbol, sizeOfSort,
+                   rankStart0, rankVal, maxW,
+                   tableLog+1);
+
+    return iSize;
+}
+
+
+static U32 HUFv06_decodeSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BITv06_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 2);
+    BITv06_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+static U32 HUFv06_decodeLastSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BITv06_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 1);
+    if (dt[val].length==1) BITv06_skipBits(DStream, dt[val].nbBits);
+    else {
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
+            BITv06_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+    }   }
+    return 1;
+}
+
+
+#define HUFv06_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
+    ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUFv06_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \
+        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUFv06_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+static inline size_t HUFv06_decodeStreamX4(BYTE* p, BITv06_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv06_DEltX4* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd-7)) {
+        HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUFv06_DECODE_SYMBOLX4_1(p, bitDPtr);
+        HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-2))
+        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);
+
+    while (p <= pEnd-2)
+        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    if (p < pEnd)
+        p += HUFv06_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+
+size_t HUFv06_decompress1X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U32* DTable)
+{
+    const BYTE* const istart = (const BYTE*) cSrc;
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* const oend = ostart + dstSize;
+
+    const U32 dtLog = DTable[0];
+    const void* const dtPtr = DTable;
+    const HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1;
+
+    /* Init */
+    BITv06_DStream_t bitD;
+    { size_t const errorCode = BITv06_initDStream(&bitD, istart, cSrcSize);
+      if (HUFv06_isError(errorCode)) return errorCode; }
+
+    /* decode */
+    HUFv06_decodeStreamX4(ostart, &bitD, oend, dt, dtLog);
+
+    /* check */
+    if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    /* decoded size */
+    return dstSize;
+}
+
+size_t HUFv06_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize);
+    if (HUFv06_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUFv06_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+size_t HUFv06_decompress4X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const U32* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {   const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable;
+        const HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1;
+        const U32 dtLog = DTable[0];
+        size_t errorCode;
+
+        /* Init */
+        BITv06_DStream_t bitD1;
+        BITv06_DStream_t bitD2;
+        BITv06_DStream_t bitD3;
+        BITv06_DStream_t bitD4;
+        const size_t length1 = MEM_readLE16(istart);
+        const size_t length2 = MEM_readLE16(istart+2);
+        const size_t length3 = MEM_readLE16(istart+4);
+        size_t length4;
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+
+        length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        errorCode = BITv06_initDStream(&bitD1, istart1, length1);
+        if (HUFv06_isError(errorCode)) return errorCode;
+        errorCode = BITv06_initDStream(&bitD2, istart2, length2);
+        if (HUFv06_isError(errorCode)) return errorCode;
+        errorCode = BITv06_initDStream(&bitD3, istart3, length3);
+        if (HUFv06_isError(errorCode)) return errorCode;
+        errorCode = BITv06_initDStream(&bitD4, istart4, length4);
+        if (HUFv06_isError(errorCode)) return errorCode;
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);
+        for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) {
+            HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUFv06_DECODE_SYMBOLX4_1(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX4_1(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX4_1(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX4_1(op4, &bitD4);
+            HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUFv06_DECODE_SYMBOLX4_0(op1, &bitD1);
+            HUFv06_DECODE_SYMBOLX4_0(op2, &bitD2);
+            HUFv06_DECODE_SYMBOLX4_0(op3, &bitD3);
+            HUFv06_DECODE_SYMBOLX4_0(op4, &bitD4);
+
+            endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUFv06_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
+        HUFv06_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
+        HUFv06_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
+        HUFv06_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+size_t HUFv06_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG);
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize);
+    if (HUFv06_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize;
+    cSrcSize -= hSize;
+
+    return HUFv06_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
+}
+
+
+
+
+/* ********************************/
+/* Generic decompression selector */
+/* ********************************/
+
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
+{
+    /* single, double, quad */
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
+};
+
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+
+size_t HUFv06_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    static const decompressionAlgo decompress[3] = { HUFv06_decompress4X2, HUFv06_decompress4X4, NULL };
+    U32 Dtime[3];   /* decompression time estimation */
+
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    /* decoder timing evaluation */
+    {   U32 const Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
+        U32 const D256 = (U32)(dstSize >> 8);
+        U32 n; for (n=0; n<3; n++)
+            Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
+    }
+
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
+
+    {   U32 algoNb = 0;
+        if (Dtime[1] < Dtime[0]) algoNb = 1;
+        // if (Dtime[2] < Dtime[algoNb]) algoNb = 2;   /* current speed of HUFv06_decompress4X6 is not good */
+        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
+    }
+
+    //return HUFv06_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
+    //return HUFv06_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
+    //return HUFv06_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
+}
+/*
+    Common functions of Zstd compression library
+    Copyright (C) 2015-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net/
+*/
+
+
+/*-****************************************
+*  Version
+******************************************/
+
+/*-****************************************
+*  ZSTD Error Management
+******************************************/
+/*! ZSTDv06_isError() :
+*   tells if a return value is an error code */
+unsigned ZSTDv06_isError(size_t code) { return ERR_isError(code); }
+
+/*! ZSTDv06_getErrorName() :
+*   provides error code string from function result (useful for debugging) */
+const char* ZSTDv06_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+/* **************************************************************
+*  ZBUFF Error Management
+****************************************************************/
+unsigned ZBUFFv06_isError(size_t errorCode) { return ERR_isError(errorCode); }
+
+const char* ZBUFFv06_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
+/*
+    zstd - standard compression library
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net
+*/
+
+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+ * HEAPMODE :
+ * Select how default decompression function ZSTDv06_decompress() will allocate memory,
+ * in memory stack (0), or in memory heap (1, requires malloc())
+ */
+#ifndef ZSTDv06_HEAPMODE
+#  define ZSTDv06_HEAPMODE 1
+#endif
+
+
+
+/*-*******************************************************
+*  Compiler specifics
+*********************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#endif
+
+
+/*-*************************************
+*  Macros
+***************************************/
+#define ZSTDv06_isError ERR_isError   /* for inlining */
+#define FSEv06_isError  ERR_isError
+#define HUFv06_isError  ERR_isError
+
+
+/*_*******************************************************
+*  Memory operations
+**********************************************************/
+static void ZSTDv06_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+
+/*-*************************************************************
+*   Context management
+***************************************************************/
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTDv06_dStage;
+
+struct ZSTDv06_DCtx_s
+{
+    FSEv06_DTable LLTable[FSEv06_DTABLE_SIZE_U32(LLFSELog)];
+    FSEv06_DTable OffTable[FSEv06_DTABLE_SIZE_U32(OffFSELog)];
+    FSEv06_DTable MLTable[FSEv06_DTABLE_SIZE_U32(MLFSELog)];
+    unsigned   hufTableX4[HUFv06_DTABLE_SIZE(HufLog)];
+    const void* previousDstEnd;
+    const void* base;
+    const void* vBase;
+    const void* dictEnd;
+    size_t expected;
+    size_t headerSize;
+    ZSTDv06_frameParams fParams;
+    blockType_t bType;   /* used in ZSTDv06_decompressContinue(), to transfer blockType between header decoding and block decoding stages */
+    ZSTDv06_dStage stage;
+    U32 flagRepeatTable;
+    const BYTE* litPtr;
+    size_t litSize;
+    BYTE litBuffer[ZSTDv06_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];
+    BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX];
+};  /* typedef'd to ZSTDv06_DCtx within "zstd_static.h" */
+
+size_t ZSTDv06_sizeofDCtx (void); /* Hidden declaration */
+size_t ZSTDv06_sizeofDCtx (void) { return sizeof(ZSTDv06_DCtx); }
+
+size_t ZSTDv06_decompressBegin(ZSTDv06_DCtx* dctx)
+{
+    dctx->expected = ZSTDv06_frameHeaderSize_min;
+    dctx->stage = ZSTDds_getFrameHeaderSize;
+    dctx->previousDstEnd = NULL;
+    dctx->base = NULL;
+    dctx->vBase = NULL;
+    dctx->dictEnd = NULL;
+    dctx->hufTableX4[0] = HufLog;
+    dctx->flagRepeatTable = 0;
+    return 0;
+}
+
+ZSTDv06_DCtx* ZSTDv06_createDCtx(void)
+{
+    ZSTDv06_DCtx* dctx = (ZSTDv06_DCtx*)malloc(sizeof(ZSTDv06_DCtx));
+    if (dctx==NULL) return NULL;
+    ZSTDv06_decompressBegin(dctx);
+    return dctx;
+}
+
+size_t ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx)
+{
+    free(dctx);
+    return 0;   /* reserved as a potential error code in the future */
+}
+
+void ZSTDv06_copyDCtx(ZSTDv06_DCtx* dstDCtx, const ZSTDv06_DCtx* srcDCtx)
+{
+    memcpy(dstDCtx, srcDCtx,
+           sizeof(ZSTDv06_DCtx) - (ZSTDv06_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH + ZSTDv06_frameHeaderSize_max));  /* no need to copy workspace */
+}
+
+
+/*-*************************************************************
+*   Decompression section
+***************************************************************/
+
+/* Frame format description
+   Frame Header -  [ Block Header - Block ] - Frame End
+   1) Frame Header
+      - 4 bytes - Magic Number : ZSTDv06_MAGICNUMBER (defined within zstd_static.h)
+      - 1 byte  - Frame Descriptor
+   2) Block Header
+      - 3 bytes, starting with a 2-bits descriptor
+                 Uncompressed, Compressed, Frame End, unused
+   3) Block
+      See Block Format Description
+   4) Frame End
+      - 3 bytes, compatible with Block Header
+*/
+
+
+/* Frame descriptor
+
+   1 byte, using :
+   bit 0-3 : windowLog - ZSTDv06_WINDOWLOG_ABSOLUTEMIN   (see zstd_internal.h)
+   bit 4   : minmatch 4(0) or 3(1)
+   bit 5   : reserved (must be zero)
+   bit 6-7 : Frame content size : unknown, 1 byte, 2 bytes, 8 bytes
+
+   Optional : content size (0, 1, 2 or 8 bytes)
+   0 : unknown
+   1 : 0-255 bytes
+   2 : 256 - 65535+256
+   8 : up to 16 exa
+*/
+
+
+/* Compressed Block, format description
+
+   Block = Literal Section - Sequences Section
+   Prerequisite : size of (compressed) block, maximum size of regenerated data
+
+   1) Literal Section
+
+   1.1) Header : 1-5 bytes
+        flags: 2 bits
+            00 compressed by Huff0
+            01 unused
+            10 is Raw (uncompressed)
+            11 is Rle
+            Note : using 01 => Huff0 with precomputed table ?
+            Note : delta map ? => compressed ?
+
+   1.1.1) Huff0-compressed literal block : 3-5 bytes
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
+            srcSize < 1 KB => 3 bytes (2-2-10-10)
+            srcSize < 16KB => 4 bytes (2-2-14-14)
+            else           => 5 bytes (2-2-18-18)
+            big endian convention
+
+   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes
+        size :  5 bits: (IS_RAW<<6) + (0<<4) + size
+               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)
+                        size&255
+               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)
+                        size>>8&255
+                        size&255
+
+   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes
+        size :  5 bits: (IS_RLE<<6) + (0<<4) + size
+               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)
+                        size&255
+               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)
+                        size>>8&255
+                        size&255
+
+   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
+            srcSize < 1 KB => 3 bytes (2-2-10-10)
+            srcSize < 16KB => 4 bytes (2-2-14-14)
+            else           => 5 bytes (2-2-18-18)
+            big endian convention
+
+        1- CTable available (stored into workspace ?)
+        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)
+
+
+   1.2) Literal block content
+
+   1.2.1) Huff0 block, using sizes from header
+        See Huff0 format
+
+   1.2.2) Huff0 block, using prepared table
+
+   1.2.3) Raw content
+
+   1.2.4) single byte
+
+
+   2) Sequences section
+      TO DO
+*/
+
+/** ZSTDv06_frameHeaderSize() :
+*   srcSize must be >= ZSTDv06_frameHeaderSize_min.
+*   @return : size of the Frame Header */
+static size_t ZSTDv06_frameHeaderSize(const void* src, size_t srcSize)
+{
+    if (srcSize < ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong);
+    { U32 const fcsId = (((const BYTE*)src)[4]) >> 6;
+      return ZSTDv06_frameHeaderSize_min + ZSTDv06_fcs_fieldSize[fcsId]; }
+}
+
+
+/** ZSTDv06_getFrameParams() :
+*   decode Frame Header, or provide expected `srcSize`.
+*   @return : 0, `fparamsPtr` is correctly filled,
+*            >0, `srcSize` is too small, result is expected `srcSize`,
+*             or an error code, which can be tested using ZSTDv06_isError() */
+size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+
+    if (srcSize < ZSTDv06_frameHeaderSize_min) return ZSTDv06_frameHeaderSize_min;
+    if (MEM_readLE32(src) != ZSTDv06_MAGICNUMBER) return ERROR(prefix_unknown);
+
+    /* ensure there is enough `srcSize` to fully read/decode frame header */
+    { size_t const fhsize = ZSTDv06_frameHeaderSize(src, srcSize);
+      if (srcSize < fhsize) return fhsize; }
+
+    memset(fparamsPtr, 0, sizeof(*fparamsPtr));
+    {   BYTE const frameDesc = ip[4];
+        fparamsPtr->windowLog = (frameDesc & 0xF) + ZSTDv06_WINDOWLOG_ABSOLUTEMIN;
+        if ((frameDesc & 0x20) != 0) return ERROR(frameParameter_unsupported);   /* reserved 1 bit */
+        switch(frameDesc >> 6)  /* fcsId */
+        {
+            default:   /* impossible */
+            case 0 : fparamsPtr->frameContentSize = 0; break;
+            case 1 : fparamsPtr->frameContentSize = ip[5]; break;
+            case 2 : fparamsPtr->frameContentSize = MEM_readLE16(ip+5)+256; break;
+            case 3 : fparamsPtr->frameContentSize = MEM_readLE64(ip+5); break;
+    }   }
+    return 0;
+}
+
+
+/** ZSTDv06_decodeFrameHeader() :
+*   `srcSize` must be the size provided by ZSTDv06_frameHeaderSize().
+*   @return : 0 if success, or an error code, which can be tested using ZSTDv06_isError() */
+static size_t ZSTDv06_decodeFrameHeader(ZSTDv06_DCtx* zc, const void* src, size_t srcSize)
+{
+    size_t const result = ZSTDv06_getFrameParams(&(zc->fParams), src, srcSize);
+    if ((MEM_32bits()) && (zc->fParams.windowLog > 25)) return ERROR(frameParameter_unsupported);
+    return result;
+}
+
+
+typedef struct
+{
+    blockType_t blockType;
+    U32 origSize;
+} blockProperties_t;
+
+/*! ZSTDv06_getcBlockSize() :
+*   Provides the size of compressed block from block header `src` */
+static size_t ZSTDv06_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
+{
+    const BYTE* const in = (const BYTE* const)src;
+    U32 cSize;
+
+    if (srcSize < ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);
+
+    bpPtr->blockType = (blockType_t)((*in) >> 6);
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
+
+    if (bpPtr->blockType == bt_end) return 0;
+    if (bpPtr->blockType == bt_rle) return 1;
+    return cSize;
+}
+
+
+static size_t ZSTDv06_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    if (dst==NULL) return ERROR(dstSize_tooSmall);
+    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+
+/*! ZSTDv06_decodeLiteralsBlock() :
+    @return : nb of bytes read from src (< srcSize ) */
+static size_t ZSTDv06_decodeLiteralsBlock(ZSTDv06_DCtx* dctx,
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
+{
+    const BYTE* const istart = (const BYTE*) src;
+
+    /* any compressed block with literals segment must be at least this size */
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
+
+    switch(istart[0]>> 6)
+    {
+    case IS_HUF:
+        {   size_t litSize, litCSize, singleStream=0;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            if (srcSize < 5) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for lhSize, + cSize (+nbSeq) */
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                /* 2 - 2 - 10 - 10 */
+                lhSize=3;
+                singleStream = istart[0] & 16;
+                litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
+                litCSize = ((istart[1] &  3) << 8) + istart[2];
+                break;
+            case 2:
+                /* 2 - 2 - 14 - 14 */
+                lhSize=4;
+                litSize  = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);
+                litCSize = ((istart[2] & 63) <<  8) + istart[3];
+                break;
+            case 3:
+                /* 2 - 2 - 18 - 18 */
+                lhSize=5;
+                litSize  = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);
+                litCSize = ((istart[2] &  3) << 16) + (istart[3] << 8) + istart[4];
+                break;
+            }
+            if (litSize > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected);
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
+
+            if (HUFv06_isError(singleStream ?
+                            HUFv06_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) :
+                            HUFv06_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
+                return ERROR(corruption_detected);
+
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+            return litCSize + lhSize;
+        }
+    case IS_PCH:
+        {   size_t litSize, litCSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            if (lhSize != 1)  /* only case supported for now : small litSize, single stream */
+                return ERROR(corruption_detected);
+            if (!dctx->flagRepeatTable)
+                return ERROR(dictionary_corrupted);
+
+            /* 2 - 2 - 10 - 10 */
+            lhSize=3;
+            litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
+            litCSize = ((istart[1] &  3) << 8) + istart[2];
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
+
+            {   size_t const errorCode = HUFv06_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4);
+                if (HUFv06_isError(errorCode)) return ERROR(corruption_detected);
+            }
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+            return litCSize + lhSize;
+        }
+    case IS_RAW:
+        {   size_t litSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                lhSize=1;
+                litSize = istart[0] & 31;
+                break;
+            case 2:
+                litSize = ((istart[0] & 15) << 8) + istart[1];
+                break;
+            case 3:
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
+                break;
+            }
+
+            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
+                if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
+                memcpy(dctx->litBuffer, istart+lhSize, litSize);
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+                return lhSize+litSize;
+            }
+            /* direct reference into compressed stream */
+            dctx->litPtr = istart+lhSize;
+            dctx->litSize = litSize;
+            return lhSize+litSize;
+        }
+    case IS_RLE:
+        {   size_t litSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                lhSize = 1;
+                litSize = istart[0] & 31;
+                break;
+            case 2:
+                litSize = ((istart[0] & 15) << 8) + istart[1];
+                break;
+            case 3:
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
+                if (srcSize<4) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
+                break;
+            }
+            if (litSize > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected);
+            memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            return lhSize+1;
+        }
+    default:
+        return ERROR(corruption_detected);   /* impossible */
+    }
+}
+
+
+/*! ZSTDv06_buildSeqTable() :
+    @return : nb bytes read from src,
+              or an error code if it fails, testable with ZSTDv06_isError()
+*/
+static size_t ZSTDv06_buildSeqTable(FSEv06_DTable* DTable, U32 type, U32 max, U32 maxLog,
+                                 const void* src, size_t srcSize,
+                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable)
+{
+    switch(type)
+    {
+    case FSEv06_ENCODING_RLE :
+        if (!srcSize) return ERROR(srcSize_wrong);
+        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
+        FSEv06_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */
+        return 1;
+    case FSEv06_ENCODING_RAW :
+        FSEv06_buildDTable(DTable, defaultNorm, max, defaultLog);
+        return 0;
+    case FSEv06_ENCODING_STATIC:
+        if (!flagRepeatTable) return ERROR(corruption_detected);
+        return 0;
+    default :   /* impossible */
+    case FSEv06_ENCODING_DYNAMIC :
+        {   U32 tableLog;
+            S16 norm[MaxSeq+1];
+            size_t const headerSize = FSEv06_readNCount(norm, &max, &tableLog, src, srcSize);
+            if (FSEv06_isError(headerSize)) return ERROR(corruption_detected);
+            if (tableLog > maxLog) return ERROR(corruption_detected);
+            FSEv06_buildDTable(DTable, norm, max, tableLog);
+            return headerSize;
+    }   }
+}
+
+
+static size_t ZSTDv06_decodeSeqHeaders(int* nbSeqPtr,
+                             FSEv06_DTable* DTableLL, FSEv06_DTable* DTableML, FSEv06_DTable* DTableOffb, U32 flagRepeatTable,
+                             const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* ip = istart;
+
+    /* check */
+    if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);
+
+    /* SeqHead */
+    {   int nbSeq = *ip++;
+        if (!nbSeq) { *nbSeqPtr=0; return 1; }
+        if (nbSeq > 0x7F) {
+            if (nbSeq == 0xFF) {
+                if (ip+2 > iend) return ERROR(srcSize_wrong);
+                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
+            } else {
+                if (ip >= iend) return ERROR(srcSize_wrong);
+                nbSeq = ((nbSeq-0x80)<<8) + *ip++;
+            }
+        }
+        *nbSeqPtr = nbSeq;
+    }
+
+    /* FSE table descriptors */
+    if (ip + 4 > iend) return ERROR(srcSize_wrong); /* min : header byte + all 3 are "raw", hence no header, but at least xxLog bits per type */
+    {   U32 const LLtype  = *ip >> 6;
+        U32 const Offtype = (*ip >> 4) & 3;
+        U32 const MLtype  = (*ip >> 2) & 3;
+        ip++;
+
+        /* Build DTables */
+        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable);
+            if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);
+            ip += bhSize;
+        }
+        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableOffb, Offtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable);
+            if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);
+            ip += bhSize;
+        }
+        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable);
+            if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);
+            ip += bhSize;
+    }   }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t matchLength;
+    size_t offset;
+} seq_t;
+
+typedef struct {
+    BITv06_DStream_t DStream;
+    FSEv06_DState_t stateLL;
+    FSEv06_DState_t stateOffb;
+    FSEv06_DState_t stateML;
+    size_t prevOffset[ZSTDv06_REP_INIT];
+} seqState_t;
+
+
+
+static void ZSTDv06_decodeSequence(seq_t* seq, seqState_t* seqState)
+{
+    /* Literal length */
+    U32 const llCode = FSEv06_peekSymbol(&(seqState->stateLL));
+    U32 const mlCode = FSEv06_peekSymbol(&(seqState->stateML));
+    U32 const ofCode = FSEv06_peekSymbol(&(seqState->stateOffb));   /* <= maxOff, by table construction */
+
+    U32 const llBits = LL_bits[llCode];
+    U32 const mlBits = ML_bits[mlCode];
+    U32 const ofBits = ofCode;
+    U32 const totalBits = llBits+mlBits+ofBits;
+
+    static const U32 LL_base[MaxLL+1] = {
+                             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,   10,    11,    12,    13,    14,     15,
+                            16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
+                            0x2000, 0x4000, 0x8000, 0x10000 };
+
+    static const U32 ML_base[MaxML+1] = {
+                             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,   11,    12,    13,    14,    15,
+                            16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,   27,    28,    29,    30,    31,
+                            32, 34, 36, 38, 40, 44, 48, 56, 64, 80, 96, 0x80, 0x100, 0x200, 0x400, 0x800,
+                            0x1000, 0x2000, 0x4000, 0x8000, 0x10000 };
+
+    static const U32 OF_base[MaxOff+1] = {
+                 0,        1,       3,       7,     0xF,     0x1F,     0x3F,     0x7F,
+                 0xFF,   0x1FF,   0x3FF,   0x7FF,   0xFFF,   0x1FFF,   0x3FFF,   0x7FFF,
+                 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF,
+                 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, /*fake*/ 1, 1 };
+
+    /* sequence */
+    {   size_t offset;
+        if (!ofCode)
+            offset = 0;
+        else {
+            offset = OF_base[ofCode] + BITv06_readBits(&(seqState->DStream), ofBits);   /* <=  26 bits */
+            if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream));
+        }
+
+        if (offset < ZSTDv06_REP_NUM) {
+            if (llCode == 0 && offset <= 1) offset = 1-offset;
+
+            if (offset != 0) {
+                size_t temp = seqState->prevOffset[offset];
+                if (offset != 1) {
+                    seqState->prevOffset[2] = seqState->prevOffset[1];
+                }
+                seqState->prevOffset[1] = seqState->prevOffset[0];
+                seqState->prevOffset[0] = offset = temp;
+
+            } else {
+                offset = seqState->prevOffset[0];
+            }
+        } else {
+            offset -= ZSTDv06_REP_MOVE;
+            seqState->prevOffset[2] = seqState->prevOffset[1];
+            seqState->prevOffset[1] = seqState->prevOffset[0];
+            seqState->prevOffset[0] = offset;
+        }
+        seq->offset = offset;
+    }
+
+    seq->matchLength = ML_base[mlCode] + MINMATCH + ((mlCode>31) ? BITv06_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */
+    if (MEM_32bits() && (mlBits+llBits>24)) BITv06_reloadDStream(&(seqState->DStream));
+
+    seq->litLength = LL_base[llCode] + ((llCode>15) ? BITv06_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */
+    if (MEM_32bits() ||
+       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv06_reloadDStream(&(seqState->DStream));
+
+    /* ANS state update */
+    FSEv06_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */
+    FSEv06_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */
+    if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream));     /* <= 18 bits */
+    FSEv06_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */
+}
+
+
+static size_t ZSTDv06_execSequence(BYTE* op,
+                                BYTE* const oend, seq_t sequence,
+                                const BYTE** litPtr, const BYTE* const litLimit,
+                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
+{
+    BYTE* const oLitEnd = op + sequence.litLength;
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_8 = oend-8;
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
+
+    /* check */
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
+    if (iLitEnd > litLimit) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
+
+    /* copy Literals */
+    ZSTDv06_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
+    op = oLitEnd;
+    *litPtr = iLitEnd;   /* update for next sequence */
+
+    /* copy Match */
+    if (sequence.offset > (size_t)(oLitEnd - base)) {
+        /* offset beyond prefix */
+        if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
+        match = dictEnd - (base-match);
+        if (match + sequence.matchLength <= dictEnd) {
+            memmove(oLitEnd, match, sequence.matchLength);
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {   size_t const length1 = dictEnd - match;
+            memmove(oLitEnd, match, length1);
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = base;
+            if (op > oend_8 || sequence.matchLength < MINMATCH) {
+              while (op < oMatchEnd) *op++ = *match++;
+              return sequenceLength;
+            }
+    }   }
+    /* Requirement: op <= oend_8 */
+
+    /* match within prefix */
+    if (sequence.offset < 8) {
+        /* close range match, overlap */
+        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */
+        int const sub2 = dec64table[sequence.offset];
+        op[0] = match[0];
+        op[1] = match[1];
+        op[2] = match[2];
+        op[3] = match[3];
+        match += dec32table[sequence.offset];
+        ZSTDv06_copy4(op+4, match);
+        match -= sub2;
+    } else {
+        ZSTDv06_copy8(op, match);
+    }
+    op += 8; match += 8;
+
+    if (oMatchEnd > oend-(16-MINMATCH)) {
+        if (op < oend_8) {
+            ZSTDv06_wildcopy(op, match, oend_8 - op);
+            match += oend_8 - op;
+            op = oend_8;
+        }
+        while (op < oMatchEnd) *op++ = *match++;
+    } else {
+        ZSTDv06_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
+    }
+    return sequenceLength;
+}
+
+
+static size_t ZSTDv06_decompressSequences(
+                               ZSTDv06_DCtx* dctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize)
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* const oend = ostart + maxDstSize;
+    BYTE* op = ostart;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    FSEv06_DTable* DTableLL = dctx->LLTable;
+    FSEv06_DTable* DTableML = dctx->MLTable;
+    FSEv06_DTable* DTableOffb = dctx->OffTable;
+    const BYTE* const base = (const BYTE*) (dctx->base);
+    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
+    int nbSeq;
+
+    /* Build Decoding Tables */
+    {   size_t const seqHSize = ZSTDv06_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->flagRepeatTable, ip, seqSize);
+        if (ZSTDv06_isError(seqHSize)) return seqHSize;
+        ip += seqHSize;
+        dctx->flagRepeatTable = 0;
+    }
+
+    /* Regen sequences */
+    if (nbSeq) {
+        seq_t sequence;
+        seqState_t seqState;
+
+        memset(&sequence, 0, sizeof(sequence));
+        sequence.offset = REPCODE_STARTVALUE;
+        { U32 i; for (i=0; i<ZSTDv06_REP_INIT; i++) seqState.prevOffset[i] = REPCODE_STARTVALUE; }
+        { size_t const errorCode = BITv06_initDStream(&(seqState.DStream), ip, iend-ip);
+          if (ERR_isError(errorCode)) return ERROR(corruption_detected); }
+        FSEv06_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
+        FSEv06_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
+        FSEv06_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
+
+        for ( ; (BITv06_reloadDStream(&(seqState.DStream)) <= BITv06_DStream_completed) && nbSeq ; ) {
+            nbSeq--;
+            ZSTDv06_decodeSequence(&sequence, &seqState);
+
+#if 0  /* debug */
+            static BYTE* start = NULL;
+            if (start==NULL) start = op;
+            size_t pos = (size_t)(op-start);
+            if ((pos >= 5810037) && (pos < 5810400))
+                printf("Dpos %6u :%5u literals & match %3u bytes at distance %6u \n",
+                       pos, (U32)sequence.litLength, (U32)sequence.matchLength, (U32)sequence.offset);
+#endif
+
+            {   size_t const oneSeqSize = ZSTDv06_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);
+                if (ZSTDv06_isError(oneSeqSize)) return oneSeqSize;
+                op += oneSeqSize;
+        }   }
+
+        /* check if reached exact end */
+        if (nbSeq) return ERROR(corruption_detected);
+    }
+
+    /* last literal segment */
+    {   size_t const lastLLSize = litEnd - litPtr;
+        if (litPtr > litEnd) return ERROR(corruption_detected);   /* too many literals already used */
+        if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
+        memcpy(op, litPtr, lastLLSize);
+        op += lastLLSize;
+    }
+
+    return op-ostart;
+}
+
+
+static void ZSTDv06_checkContinuity(ZSTDv06_DCtx* dctx, const void* dst)
+{
+    if (dst != dctx->previousDstEnd) {   /* not contiguous */
+        dctx->dictEnd = dctx->previousDstEnd;
+        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
+        dctx->base = dst;
+        dctx->previousDstEnd = dst;
+    }
+}
+
+
+static size_t ZSTDv06_decompressBlock_internal(ZSTDv06_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{   /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+
+    if (srcSize >= ZSTDv06_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);
+
+    /* Decode literals sub-block */
+    {   size_t const litCSize = ZSTDv06_decodeLiteralsBlock(dctx, src, srcSize);
+        if (ZSTDv06_isError(litCSize)) return litCSize;
+        ip += litCSize;
+        srcSize -= litCSize;
+    }
+    return ZSTDv06_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
+}
+
+
+size_t ZSTDv06_decompressBlock(ZSTDv06_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{
+    ZSTDv06_checkContinuity(dctx, dst);
+    return ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
+}
+
+
+/*! ZSTDv06_decompressFrame() :
+*   `dctx` must be properly initialized */
+static size_t ZSTDv06_decompressFrame(ZSTDv06_DCtx* dctx,
+                                 void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* const iend = ip + srcSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* op = ostart;
+    BYTE* const oend = ostart + dstCapacity;
+    size_t remainingSize = srcSize;
+    blockProperties_t blockProperties = { bt_compressed, 0 };
+
+    /* check */
+    if (srcSize < ZSTDv06_frameHeaderSize_min+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);
+
+    /* Frame Header */
+    {   size_t const frameHeaderSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min);
+        if (ZSTDv06_isError(frameHeaderSize)) return frameHeaderSize;
+        if (srcSize < frameHeaderSize+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);
+        if (ZSTDv06_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected);
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
+    }
+
+    /* Loop on each block */
+    while (1) {
+        size_t decodedSize=0;
+        size_t const cBlockSize = ZSTDv06_getcBlockSize(ip, iend-ip, &blockProperties);
+        if (ZSTDv06_isError(cBlockSize)) return cBlockSize;
+
+        ip += ZSTDv06_blockHeaderSize;
+        remainingSize -= ZSTDv06_blockHeaderSize;
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            decodedSize = ZSTDv06_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
+            break;
+        case bt_raw :
+            decodedSize = ZSTDv06_copyRawBlock(op, oend-op, ip, cBlockSize);
+            break;
+        case bt_rle :
+            return ERROR(GENERIC);   /* not yet supported */
+            break;
+        case bt_end :
+            /* end of frame */
+            if (remainingSize) return ERROR(srcSize_wrong);
+            break;
+        default:
+            return ERROR(GENERIC);   /* impossible */
+        }
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        if (ZSTDv06_isError(decodedSize)) return decodedSize;
+        op += decodedSize;
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+    }
+
+    return op-ostart;
+}
+
+
+size_t ZSTDv06_decompress_usingPreparedDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* refDCtx,
+                                         void* dst, size_t dstCapacity,
+                                   const void* src, size_t srcSize)
+{
+    ZSTDv06_copyDCtx(dctx, refDCtx);
+    ZSTDv06_checkContinuity(dctx, dst);
+    return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
+}
+
+
+size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx,
+                                 void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize,
+                                 const void* dict, size_t dictSize)
+{
+    ZSTDv06_decompressBegin_usingDict(dctx, dict, dictSize);
+    ZSTDv06_checkContinuity(dctx, dst);
+    return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
+}
+
+
+size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    return ZSTDv06_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);
+}
+
+
+size_t ZSTDv06_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+#if defined(ZSTDv06_HEAPMODE) && (ZSTDv06_HEAPMODE==1)
+    size_t regenSize;
+    ZSTDv06_DCtx* dctx = ZSTDv06_createDCtx();
+    if (dctx==NULL) return ERROR(memory_allocation);
+    regenSize = ZSTDv06_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
+    ZSTDv06_freeDCtx(dctx);
+    return regenSize;
+#else   /* stack mode */
+    ZSTDv06_DCtx dctx;
+    return ZSTDv06_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
+#endif
+}
+
+/* ZSTD_errorFrameSizeInfoLegacy() :
+   assumes `cSize` and `dBound` are _not_ NULL */
+static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
+{
+    *cSize = ret;
+    *dBound = ZSTD_CONTENTSIZE_ERROR;
+}
+
+void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t remainingSize = srcSize;
+    size_t nbBlocks = 0;
+    blockProperties_t blockProperties = { bt_compressed, 0 };
+
+    /* Frame Header */
+    {   size_t const frameHeaderSize = ZSTDv06_frameHeaderSize(src, srcSize);
+        if (ZSTDv06_isError(frameHeaderSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, frameHeaderSize);
+            return;
+        }
+        if (MEM_readLE32(src) != ZSTDv06_MAGICNUMBER) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));
+            return;
+        }
+        if (srcSize < frameHeaderSize+ZSTDv06_blockHeaderSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
+    }
+
+    /* Loop on each block */
+    while (1) {
+        size_t const cBlockSize = ZSTDv06_getcBlockSize(ip, remainingSize, &blockProperties);
+        if (ZSTDv06_isError(cBlockSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);
+            return;
+        }
+
+        ip += ZSTDv06_blockHeaderSize;
+        remainingSize -= ZSTDv06_blockHeaderSize;
+        if (cBlockSize > remainingSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+
+        if (cBlockSize == 0) break;   /* bt_end */
+
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+        nbBlocks++;
+    }
+
+    *cSize = ip - (const BYTE*)src;
+    *dBound = nbBlocks * ZSTDv06_BLOCKSIZE_MAX;
+}
+
+/*_******************************
+*  Streaming Decompression API
+********************************/
+size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx)
+{
+    return dctx->expected;
+}
+
+size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    /* Sanity check */
+    if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
+    if (dstCapacity) ZSTDv06_checkContinuity(dctx, dst);
+
+    /* Decompress : frame header; part 1 */
+    switch (dctx->stage)
+    {
+    case ZSTDds_getFrameHeaderSize :
+        if (srcSize != ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
+        dctx->headerSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min);
+        if (ZSTDv06_isError(dctx->headerSize)) return dctx->headerSize;
+        memcpy(dctx->headerBuffer, src, ZSTDv06_frameHeaderSize_min);
+        if (dctx->headerSize > ZSTDv06_frameHeaderSize_min) {
+            dctx->expected = dctx->headerSize - ZSTDv06_frameHeaderSize_min;
+            dctx->stage = ZSTDds_decodeFrameHeader;
+            return 0;
+        }
+        dctx->expected = 0;   /* not necessary to copy more */
+	/* fall-through */
+    case ZSTDds_decodeFrameHeader:
+        {   size_t result;
+            memcpy(dctx->headerBuffer + ZSTDv06_frameHeaderSize_min, src, dctx->expected);
+            result = ZSTDv06_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);
+            if (ZSTDv06_isError(result)) return result;
+            dctx->expected = ZSTDv06_blockHeaderSize;
+            dctx->stage = ZSTDds_decodeBlockHeader;
+            return 0;
+        }
+    case ZSTDds_decodeBlockHeader:
+        {   blockProperties_t bp;
+            size_t const cBlockSize = ZSTDv06_getcBlockSize(src, ZSTDv06_blockHeaderSize, &bp);
+            if (ZSTDv06_isError(cBlockSize)) return cBlockSize;
+            if (bp.blockType == bt_end) {
+                dctx->expected = 0;
+                dctx->stage = ZSTDds_getFrameHeaderSize;
+            } else {
+                dctx->expected = cBlockSize;
+                dctx->bType = bp.blockType;
+                dctx->stage = ZSTDds_decompressBlock;
+            }
+            return 0;
+        }
+    case ZSTDds_decompressBlock:
+        {   size_t rSize;
+            switch(dctx->bType)
+            {
+            case bt_compressed:
+                rSize = ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
+                break;
+            case bt_raw :
+                rSize = ZSTDv06_copyRawBlock(dst, dstCapacity, src, srcSize);
+                break;
+            case bt_rle :
+                return ERROR(GENERIC);   /* not yet handled */
+                break;
+            case bt_end :   /* should never happen (filtered at phase 1) */
+                rSize = 0;
+                break;
+            default:
+                return ERROR(GENERIC);   /* impossible */
+            }
+            dctx->stage = ZSTDds_decodeBlockHeader;
+            dctx->expected = ZSTDv06_blockHeaderSize;
+            dctx->previousDstEnd = (char*)dst + rSize;
+            return rSize;
+        }
+    default:
+        return ERROR(GENERIC);   /* impossible */
+    }
+}
+
+
+static void ZSTDv06_refDictContent(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    dctx->dictEnd = dctx->previousDstEnd;
+    dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
+    dctx->base = dict;
+    dctx->previousDstEnd = (const char*)dict + dictSize;
+}
+
+static size_t ZSTDv06_loadEntropy(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, litlengthHeaderSize;
+
+    hSize = HUFv06_readDTableX4(dctx->hufTableX4, dict, dictSize);
+    if (HUFv06_isError(hSize)) return ERROR(dictionary_corrupted);
+    dict = (const char*)dict + hSize;
+    dictSize -= hSize;
+
+    {   short offcodeNCount[MaxOff+1];
+        U32 offcodeMaxValue=MaxOff, offcodeLog;
+        offcodeHeaderSize = FSEv06_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);
+        if (FSEv06_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
+        if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
+        { size_t const errorCode = FSEv06_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);
+          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }
+        dict = (const char*)dict + offcodeHeaderSize;
+        dictSize -= offcodeHeaderSize;
+    }
+
+    {   short matchlengthNCount[MaxML+1];
+        unsigned matchlengthMaxValue = MaxML, matchlengthLog;
+        matchlengthHeaderSize = FSEv06_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);
+        if (FSEv06_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
+        { size_t const errorCode = FSEv06_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
+          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }
+        dict = (const char*)dict + matchlengthHeaderSize;
+        dictSize -= matchlengthHeaderSize;
+    }
+
+    {   short litlengthNCount[MaxLL+1];
+        unsigned litlengthMaxValue = MaxLL, litlengthLog;
+        litlengthHeaderSize = FSEv06_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);
+        if (FSEv06_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
+        { size_t const errorCode = FSEv06_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
+          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }
+    }
+
+    dctx->flagRepeatTable = 1;
+    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;
+}
+
+static size_t ZSTDv06_decompress_insertDictionary(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    size_t eSize;
+    U32 const magic = MEM_readLE32(dict);
+    if (magic != ZSTDv06_DICT_MAGIC) {
+        /* pure content mode */
+        ZSTDv06_refDictContent(dctx, dict, dictSize);
+        return 0;
+    }
+    /* load entropy tables */
+    dict = (const char*)dict + 4;
+    dictSize -= 4;
+    eSize = ZSTDv06_loadEntropy(dctx, dict, dictSize);
+    if (ZSTDv06_isError(eSize)) return ERROR(dictionary_corrupted);
+
+    /* reference dictionary content */
+    dict = (const char*)dict + eSize;
+    dictSize -= eSize;
+    ZSTDv06_refDictContent(dctx, dict, dictSize);
+
+    return 0;
+}
+
+
+size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    { size_t const errorCode = ZSTDv06_decompressBegin(dctx);
+      if (ZSTDv06_isError(errorCode)) return errorCode; }
+
+    if (dict && dictSize) {
+        size_t const errorCode = ZSTDv06_decompress_insertDictionary(dctx, dict, dictSize);
+        if (ZSTDv06_isError(errorCode)) return ERROR(dictionary_corrupted);
+    }
+
+    return 0;
+}
+
+/*
+    Buffered version of Zstd compression library
+    Copyright (C) 2015-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net/
+*/
+
+
+/*-***************************************************************************
+*  Streaming decompression howto
+*
+*  A ZBUFFv06_DCtx object is required to track streaming operations.
+*  Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources.
+*  Use ZBUFFv06_decompressInit() to start a new decompression operation,
+*   or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary.
+*  Note that ZBUFFv06_DCtx objects can be re-init multiple times.
+*
+*  Use ZBUFFv06_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
+*  The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change @dst.
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
+*            or 0 when a frame is completely decoded,
+*            or an error code, which can be tested using ZBUFFv06_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize()
+*  output : ZBUFFv06_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
+*  input  : ZBUFFv06_recommendedDInSize == 128KB + 3;
+*           just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* *******************************************************************************/
+
+typedef enum { ZBUFFds_init, ZBUFFds_loadHeader,
+               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv06_dStage;
+
+/* *** Resource management *** */
+struct ZBUFFv06_DCtx_s {
+    ZSTDv06_DCtx* zd;
+    ZSTDv06_frameParams fParams;
+    ZBUFFv06_dStage stage;
+    char*  inBuff;
+    size_t inBuffSize;
+    size_t inPos;
+    char*  outBuff;
+    size_t outBuffSize;
+    size_t outStart;
+    size_t outEnd;
+    size_t blockSize;
+    BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX];
+    size_t lhSize;
+};   /* typedef'd to ZBUFFv06_DCtx within "zstd_buffered.h" */
+
+
+ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void)
+{
+    ZBUFFv06_DCtx* zbd = (ZBUFFv06_DCtx*)malloc(sizeof(ZBUFFv06_DCtx));
+    if (zbd==NULL) return NULL;
+    memset(zbd, 0, sizeof(*zbd));
+    zbd->zd = ZSTDv06_createDCtx();
+    zbd->stage = ZBUFFds_init;
+    return zbd;
+}
+
+size_t ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* zbd)
+{
+    if (zbd==NULL) return 0;   /* support free on null */
+    ZSTDv06_freeDCtx(zbd->zd);
+    free(zbd->inBuff);
+    free(zbd->outBuff);
+    free(zbd);
+    return 0;
+}
+
+
+/* *** Initialization *** */
+
+size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* zbd, const void* dict, size_t dictSize)
+{
+    zbd->stage = ZBUFFds_loadHeader;
+    zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0;
+    return ZSTDv06_decompressBegin_usingDict(zbd->zd, dict, dictSize);
+}
+
+size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* zbd)
+{
+    return ZBUFFv06_decompressInitDictionary(zbd, NULL, 0);
+}
+
+
+
+MEM_STATIC size_t ZBUFFv06_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    size_t length = MIN(dstCapacity, srcSize);
+    memcpy(dst, src, length);
+    return length;
+}
+
+
+/* *** Decompression *** */
+
+size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* zbd,
+                                void* dst, size_t* dstCapacityPtr,
+                          const void* src, size_t* srcSizePtr)
+{
+    const char* const istart = (const char*)src;
+    const char* const iend = istart + *srcSizePtr;
+    const char* ip = istart;
+    char* const ostart = (char*)dst;
+    char* const oend = ostart + *dstCapacityPtr;
+    char* op = ostart;
+    U32 notDone = 1;
+
+    while (notDone) {
+        switch(zbd->stage)
+        {
+        case ZBUFFds_init :
+            return ERROR(init_missing);
+
+        case ZBUFFds_loadHeader :
+            {   size_t const hSize = ZSTDv06_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize);
+                if (hSize != 0) {
+                    size_t const toLoad = hSize - zbd->lhSize;   /* if hSize!=0, hSize > zbd->lhSize */
+                    if (ZSTDv06_isError(hSize)) return hSize;
+                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */
+                        memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip);
+                        zbd->lhSize += iend-ip;
+                        *dstCapacityPtr = 0;
+                        return (hSize - zbd->lhSize) + ZSTDv06_blockHeaderSize;   /* remaining header bytes + next block header */
+                    }
+                    memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad;
+                    break;
+            }   }
+
+            /* Consume header */
+            {   size_t const h1Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);  /* == ZSTDv06_frameHeaderSize_min */
+                size_t const h1Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size);
+                if (ZSTDv06_isError(h1Result)) return h1Result;
+                if (h1Size < zbd->lhSize) {   /* long header */
+                    size_t const h2Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
+                    size_t const h2Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size);
+                    if (ZSTDv06_isError(h2Result)) return h2Result;
+            }   }
+
+            /* Frame header instruct buffer sizes */
+            {   size_t const blockSize = MIN(1 << zbd->fParams.windowLog, ZSTDv06_BLOCKSIZE_MAX);
+                zbd->blockSize = blockSize;
+                if (zbd->inBuffSize < blockSize) {
+                    free(zbd->inBuff);
+                    zbd->inBuffSize = blockSize;
+                    zbd->inBuff = (char*)malloc(blockSize);
+                    if (zbd->inBuff == NULL) return ERROR(memory_allocation);
+                }
+                {   size_t const neededOutSize = ((size_t)1 << zbd->fParams.windowLog) + blockSize + WILDCOPY_OVERLENGTH * 2;
+                    if (zbd->outBuffSize < neededOutSize) {
+                        free(zbd->outBuff);
+                        zbd->outBuffSize = neededOutSize;
+                        zbd->outBuff = (char*)malloc(neededOutSize);
+                        if (zbd->outBuff == NULL) return ERROR(memory_allocation);
+            }   }   }
+            zbd->stage = ZBUFFds_read;
+	    /* fall-through */
+        case ZBUFFds_read:
+            {   size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
+                if (neededInSize==0) {  /* end of frame */
+                    zbd->stage = ZBUFFds_init;
+                    notDone = 0;
+                    break;
+                }
+                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */
+                    size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd,
+                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,
+                        ip, neededInSize);
+                    if (ZSTDv06_isError(decodedSize)) return decodedSize;
+                    ip += neededInSize;
+                    if (!decodedSize) break;   /* this was just a header */
+                    zbd->outEnd = zbd->outStart +  decodedSize;
+                    zbd->stage = ZBUFFds_flush;
+                    break;
+                }
+                if (ip==iend) { notDone = 0; break; }   /* no more input */
+                zbd->stage = ZBUFFds_load;
+            }
+	    /* fall-through */
+        case ZBUFFds_load:
+            {   size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
+                size_t const toLoad = neededInSize - zbd->inPos;   /* should always be <= remaining space within inBuff */
+                size_t loadedSize;
+                if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected);   /* should never happen */
+                loadedSize = ZBUFFv06_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip);
+                ip += loadedSize;
+                zbd->inPos += loadedSize;
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
+
+                /* decode loaded input */
+                {   size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd,
+                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,
+                        zbd->inBuff, neededInSize);
+                    if (ZSTDv06_isError(decodedSize)) return decodedSize;
+                    zbd->inPos = 0;   /* input is consumed */
+                    if (!decodedSize) { zbd->stage = ZBUFFds_read; break; }   /* this was just a header */
+                    zbd->outEnd = zbd->outStart +  decodedSize;
+                    zbd->stage = ZBUFFds_flush;
+                    // break; /* ZBUFFds_flush follows */
+                }
+	    }
+	    /* fall-through */
+        case ZBUFFds_flush:
+            {   size_t const toFlushSize = zbd->outEnd - zbd->outStart;
+                size_t const flushedSize = ZBUFFv06_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize);
+                op += flushedSize;
+                zbd->outStart += flushedSize;
+                if (flushedSize == toFlushSize) {
+                    zbd->stage = ZBUFFds_read;
+                    if (zbd->outStart + zbd->blockSize > zbd->outBuffSize)
+                        zbd->outStart = zbd->outEnd = 0;
+                    break;
+                }
+                /* cannot flush everything */
+                notDone = 0;
+                break;
+            }
+        default: return ERROR(GENERIC);   /* impossible */
+    }   }
+
+    /* result */
+    *srcSizePtr = ip-istart;
+    *dstCapacityPtr = op-ostart;
+    {   size_t nextSrcSizeHint = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
+        if (nextSrcSizeHint > ZSTDv06_blockHeaderSize) nextSrcSizeHint+= ZSTDv06_blockHeaderSize;   /* get following block header too */
+        nextSrcSizeHint -= zbd->inPos;   /* already loaded*/
+        return nextSrcSizeHint;
+    }
+}
+
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+size_t ZBUFFv06_recommendedDInSize(void)  { return ZSTDv06_BLOCKSIZE_MAX + ZSTDv06_blockHeaderSize /* block header size*/ ; }
+size_t ZBUFFv06_recommendedDOutSize(void) { return ZSTDv06_BLOCKSIZE_MAX; }
diff --git a/src/zstd_v06.h b/src/zstd_v06.h
new file mode 100644
index 0000000..0781857
--- /dev/null
+++ b/src/zstd_v06.h
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTDv06_H
+#define ZSTDv06_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*======  Dependency  ======*/
+#include <stddef.h>   /* size_t */
+
+
+/*======  Export for Windows  ======*/
+/*!
+*  ZSTDv06_DLL_EXPORT :
+*  Enable exporting of functions when building a Windows DLL
+*/
+#if defined(_WIN32) && defined(ZSTDv06_DLL_EXPORT) && (ZSTDv06_DLL_EXPORT==1)
+#  define ZSTDLIBv06_API __declspec(dllexport)
+#else
+#  define ZSTDLIBv06_API
+#endif
+
+
+/* *************************************
+*  Simple functions
+***************************************/
+/*! ZSTDv06_decompress() :
+    `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail.
+    `dstCapacity` must be large enough, equal or larger than originalSize.
+    @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
+              or an errorCode if it fails (which can be tested using ZSTDv06_isError()) */
+ZSTDLIBv06_API size_t ZSTDv06_decompress( void* dst, size_t dstCapacity,
+                                    const void* src, size_t compressedSize);
+
+/**
+ZSTDv06_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.6.x format
+    srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
+    cSize (output parameter)  : the number of bytes that would be read to decompress this frame
+                                or an error code if it fails (which can be tested using ZSTDv01_isError())
+    dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
+                                or ZSTD_CONTENTSIZE_ERROR if an error occurs
+
+    note : assumes `cSize` and `dBound` are _not_ NULL.
+*/
+void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
+                                     size_t* cSize, unsigned long long* dBound);
+
+/* *************************************
+*  Helper functions
+***************************************/
+ZSTDLIBv06_API size_t      ZSTDv06_compressBound(size_t srcSize); /*!< maximum compressed size (worst case scenario) */
+
+/* Error Management */
+ZSTDLIBv06_API unsigned    ZSTDv06_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
+ZSTDLIBv06_API const char* ZSTDv06_getErrorName(size_t code);     /*!< provides readable string for an error code */
+
+
+/* *************************************
+*  Explicit memory management
+***************************************/
+/** Decompression context */
+typedef struct ZSTDv06_DCtx_s ZSTDv06_DCtx;
+ZSTDLIBv06_API ZSTDv06_DCtx* ZSTDv06_createDCtx(void);
+ZSTDLIBv06_API size_t     ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx);      /*!< @return : errorCode */
+
+/** ZSTDv06_decompressDCtx() :
+*   Same as ZSTDv06_decompress(), but requires an already allocated ZSTDv06_DCtx (see ZSTDv06_createDCtx()) */
+ZSTDLIBv06_API size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+/*-***********************
+*  Dictionary API
+*************************/
+/*! ZSTDv06_decompress_usingDict() :
+*   Decompression using a pre-defined Dictionary content (see dictBuilder).
+*   Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted.
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTDv06_decompressDCtx() */
+ZSTDLIBv06_API size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx,
+                                                   void* dst, size_t dstCapacity,
+                                             const void* src, size_t srcSize,
+                                             const void* dict,size_t dictSize);
+
+
+/*-************************
+*  Advanced Streaming API
+***************************/
+struct ZSTDv06_frameParams_s { unsigned long long frameContentSize; unsigned windowLog; };
+typedef struct ZSTDv06_frameParams_s ZSTDv06_frameParams;
+
+ZSTDLIBv06_API size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
+ZSTDLIBv06_API size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize);
+ZSTDLIBv06_API void   ZSTDv06_copyDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx);
+
+ZSTDLIBv06_API size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx);
+ZSTDLIBv06_API size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+
+/* *************************************
+*  ZBUFF API
+***************************************/
+
+typedef struct ZBUFFv06_DCtx_s ZBUFFv06_DCtx;
+ZSTDLIBv06_API ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void);
+ZSTDLIBv06_API size_t         ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* dctx);
+
+ZSTDLIBv06_API size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* dctx);
+ZSTDLIBv06_API size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* dctx, const void* dict, size_t dictSize);
+
+ZSTDLIBv06_API size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* dctx,
+                                                  void* dst, size_t* dstCapacityPtr,
+                                            const void* src, size_t* srcSizePtr);
+
+/*-***************************************************************************
+*  Streaming decompression howto
+*
+*  A ZBUFFv06_DCtx object is required to track streaming operations.
+*  Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources.
+*  Use ZBUFFv06_decompressInit() to start a new decompression operation,
+*   or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary.
+*  Note that ZBUFFv06_DCtx objects can be re-init multiple times.
+*
+*  Use ZBUFFv06_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
+*            or 0 when a frame is completely decoded,
+*            or an error code, which can be tested using ZBUFFv06_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize()
+*  output : ZBUFFv06_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
+*  input  : ZBUFFv06_recommendedDInSize == 128KB + 3;
+*           just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* *******************************************************************************/
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+ZSTDLIBv06_API unsigned ZBUFFv06_isError(size_t errorCode);
+ZSTDLIBv06_API const char* ZBUFFv06_getErrorName(size_t errorCode);
+
+/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
+*   These sizes are just hints, they tend to offer better latency */
+ZSTDLIBv06_API size_t ZBUFFv06_recommendedDInSize(void);
+ZSTDLIBv06_API size_t ZBUFFv06_recommendedDOutSize(void);
+
+
+/*-*************************************
+*  Constants
+***************************************/
+#define ZSTDv06_MAGICNUMBER 0xFD2FB526   /* v0.6 */
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* ZSTDv06_BUFFERED_H */
diff --git a/src/zstd_v07.c b/src/zstd_v07.c
new file mode 100644
index 0000000..a83ddc9
--- /dev/null
+++ b/src/zstd_v07.c
@@ -0,0 +1,4533 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/*- Dependencies -*/
+#include <stddef.h>     /* size_t, ptrdiff_t */
+#include <string.h>     /* memcpy */
+#include <stdlib.h>     /* malloc, free, qsort */
+
+#ifndef XXH_STATIC_LINKING_ONLY
+#  define XXH_STATIC_LINKING_ONLY    /* XXH64_state_t */
+#endif
+#include "xxhash.h"                  /* XXH64_* */
+#include "zstd_v07.h"
+
+#define FSEv07_STATIC_LINKING_ONLY   /* FSEv07_MIN_TABLELOG */
+#define HUFv07_STATIC_LINKING_ONLY   /* HUFv07_TABLELOG_ABSOLUTEMAX */
+#define ZSTDv07_STATIC_LINKING_ONLY
+
+#include "error_private.h"
+
+
+#ifdef ZSTDv07_STATIC_LINKING_ONLY
+
+/* ====================================================================================
+ * The definitions in this section are considered experimental.
+ * They should never be used with a dynamic library, as they may change in the future.
+ * They are provided for advanced usages.
+ * Use them only in association with static linking.
+ * ==================================================================================== */
+
+/*--- Constants ---*/
+#define ZSTDv07_MAGIC_SKIPPABLE_START  0x184D2A50U
+
+#define ZSTDv07_WINDOWLOG_MAX_32  25
+#define ZSTDv07_WINDOWLOG_MAX_64  27
+#define ZSTDv07_WINDOWLOG_MAX    ((U32)(MEM_32bits() ? ZSTDv07_WINDOWLOG_MAX_32 : ZSTDv07_WINDOWLOG_MAX_64))
+#define ZSTDv07_WINDOWLOG_MIN     18
+#define ZSTDv07_CHAINLOG_MAX     (ZSTDv07_WINDOWLOG_MAX+1)
+#define ZSTDv07_CHAINLOG_MIN       4
+#define ZSTDv07_HASHLOG_MAX       ZSTDv07_WINDOWLOG_MAX
+#define ZSTDv07_HASHLOG_MIN       12
+#define ZSTDv07_HASHLOG3_MAX      17
+#define ZSTDv07_SEARCHLOG_MAX    (ZSTDv07_WINDOWLOG_MAX-1)
+#define ZSTDv07_SEARCHLOG_MIN      1
+#define ZSTDv07_SEARCHLENGTH_MAX   7
+#define ZSTDv07_SEARCHLENGTH_MIN   3
+#define ZSTDv07_TARGETLENGTH_MIN   4
+#define ZSTDv07_TARGETLENGTH_MAX 999
+
+#define ZSTDv07_FRAMEHEADERSIZE_MAX 18    /* for static allocation */
+static const size_t ZSTDv07_frameHeaderSize_min = 5;
+static const size_t ZSTDv07_frameHeaderSize_max = ZSTDv07_FRAMEHEADERSIZE_MAX;
+static const size_t ZSTDv07_skippableHeaderSize = 8;  /* magic number + skippable frame length */
+
+
+/* custom memory allocation functions */
+typedef void* (*ZSTDv07_allocFunction) (void* opaque, size_t size);
+typedef void  (*ZSTDv07_freeFunction) (void* opaque, void* address);
+typedef struct { ZSTDv07_allocFunction customAlloc; ZSTDv07_freeFunction customFree; void* opaque; } ZSTDv07_customMem;
+
+
+/*--- Advanced Decompression functions ---*/
+
+/*! ZSTDv07_estimateDCtxSize() :
+ *  Gives the potential amount of memory allocated to create a ZSTDv07_DCtx */
+ZSTDLIBv07_API size_t ZSTDv07_estimateDCtxSize(void);
+
+/*! ZSTDv07_createDCtx_advanced() :
+ *  Create a ZSTD decompression context using external alloc and free functions */
+ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem);
+
+/*! ZSTDv07_sizeofDCtx() :
+ *  Gives the amount of memory used by a given ZSTDv07_DCtx */
+ZSTDLIBv07_API size_t ZSTDv07_sizeofDCtx(const ZSTDv07_DCtx* dctx);
+
+
+/* ******************************************************************
+*  Buffer-less streaming functions (synchronous mode)
+********************************************************************/
+
+ZSTDLIBv07_API size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx);
+ZSTDLIBv07_API size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize);
+ZSTDLIBv07_API void   ZSTDv07_copyDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* preparedDCtx);
+
+ZSTDLIBv07_API size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx);
+ZSTDLIBv07_API size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+/*
+  Buffer-less streaming decompression (synchronous mode)
+
+  A ZSTDv07_DCtx object is required to track streaming operations.
+  Use ZSTDv07_createDCtx() / ZSTDv07_freeDCtx() to manage it.
+  A ZSTDv07_DCtx object can be re-used multiple times.
+
+  First optional operation is to retrieve frame parameters, using ZSTDv07_getFrameParams(), which doesn't consume the input.
+  It can provide the minimum size of rolling buffer required to properly decompress data (`windowSize`),
+  and optionally the final size of uncompressed content.
+  (Note : content size is an optional info that may not be present. 0 means : content size unknown)
+  Frame parameters are extracted from the beginning of compressed frame.
+  The amount of data to read is variable, from ZSTDv07_frameHeaderSize_min to ZSTDv07_frameHeaderSize_max (so if `srcSize` >= ZSTDv07_frameHeaderSize_max, it will always work)
+  If `srcSize` is too small for operation to succeed, function will return the minimum size it requires to produce a result.
+  Result : 0 when successful, it means the ZSTDv07_frameParams structure has been filled.
+          >0 : means there is not enough data into `src`. Provides the expected size to successfully decode header.
+           errorCode, which can be tested using ZSTDv07_isError()
+
+  Start decompression, with ZSTDv07_decompressBegin() or ZSTDv07_decompressBegin_usingDict().
+  Alternatively, you can copy a prepared context, using ZSTDv07_copyDCtx().
+
+  Then use ZSTDv07_nextSrcSizeToDecompress() and ZSTDv07_decompressContinue() alternatively.
+  ZSTDv07_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv07_decompressContinue().
+  ZSTDv07_decompressContinue() requires this exact amount of bytes, or it will fail.
+
+  @result of ZSTDv07_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
+  It can be zero, which is not an error; it just means ZSTDv07_decompressContinue() has decoded some header.
+
+  ZSTDv07_decompressContinue() needs previous data blocks during decompression, up to `windowSize`.
+  They should preferably be located contiguously, prior to current block.
+  Alternatively, a round buffer of sufficient size is also possible. Sufficient size is determined by frame parameters.
+  ZSTDv07_decompressContinue() is very sensitive to contiguity,
+  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
+    or that previous contiguous segment is large enough to properly handle maximum back-reference.
+
+  A frame is fully decoded when ZSTDv07_nextSrcSizeToDecompress() returns zero.
+  Context can then be reset to start a new decompression.
+
+
+  == Special case : skippable frames ==
+
+  Skippable frames allow the integration of user-defined data into a flow of concatenated frames.
+  Skippable frames will be ignored (skipped) by a decompressor. The format of skippable frame is following:
+  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
+  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
+  c) Frame Content - any content (User Data) of length equal to Frame Size
+  For skippable frames ZSTDv07_decompressContinue() always returns 0.
+  For skippable frames ZSTDv07_getFrameParams() returns fparamsPtr->windowLog==0 what means that a frame is skippable.
+  It also returns Frame Size as fparamsPtr->frameContentSize.
+*/
+
+
+/* **************************************
+*  Block functions
+****************************************/
+/*! Block functions produce and decode raw zstd blocks, without frame metadata.
+    Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes).
+    User will have to take in charge required information to regenerate data, such as compressed and content sizes.
+
+    A few rules to respect :
+    - Compressing and decompressing require a context structure
+      + Use ZSTDv07_createCCtx() and ZSTDv07_createDCtx()
+    - It is necessary to init context before starting
+      + compression : ZSTDv07_compressBegin()
+      + decompression : ZSTDv07_decompressBegin()
+      + variants _usingDict() are also allowed
+      + copyCCtx() and copyDCtx() work too
+    - Block size is limited, it must be <= ZSTDv07_getBlockSizeMax()
+      + If you need to compress more, cut data into multiple blocks
+      + Consider using the regular ZSTDv07_compress() instead, as frame metadata costs become negligible when source size is large.
+    - When a block is considered not compressible enough, ZSTDv07_compressBlock() result will be zero.
+      In which case, nothing is produced into `dst`.
+      + User must test for such outcome and deal directly with uncompressed data
+      + ZSTDv07_decompressBlock() doesn't accept uncompressed data as input !!!
+      + In case of multiple successive blocks, decoder must be informed of uncompressed block existence to follow proper history.
+        Use ZSTDv07_insertBlock() in such a case.
+*/
+
+#define ZSTDv07_BLOCKSIZE_ABSOLUTEMAX (128 * 1024)   /* define, for static allocation */
+ZSTDLIBv07_API size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize);  /**< insert block into `dctx` history. Useful for uncompressed blocks */
+
+
+#endif   /* ZSTDv07_STATIC_LINKING_ONLY */
+
+
+/* ******************************************************************
+   mem.h
+   low-level memory access routines
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+#ifndef MEM_H_MODULE
+#define MEM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*-****************************************
+*  Compiler specifics
+******************************************/
+#if defined(_MSC_VER)   /* Visual Studio */
+#   include <stdlib.h>  /* _byteswap_ulong */
+#   include <intrin.h>  /* _byteswap_* */
+#endif
+#if defined(__GNUC__)
+#  define MEM_STATIC static __attribute__((unused))
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#  define MEM_STATIC static inline
+#elif defined(_MSC_VER)
+#  define MEM_STATIC static __inline
+#else
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
+#endif
+
+
+/*-**************************************************************
+*  Basic Types
+*****************************************************************/
+#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+# include <stdint.h>
+  typedef  uint8_t BYTE;
+  typedef uint16_t U16;
+  typedef  int16_t S16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+  typedef  int64_t S64;
+#else
+  typedef unsigned char       BYTE;
+  typedef unsigned short      U16;
+  typedef   signed short      S16;
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+  typedef unsigned long long  U64;
+  typedef   signed long long  S64;
+#endif
+
+
+/*-**************************************************************
+*  Memory I/O
+*****************************************************************/
+/* MEM_FORCE_MEMORY_ACCESS :
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets depending on alignment.
+ *            In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define MEM_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
+#    define MEM_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
+
+MEM_STATIC unsigned MEM_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
+
+/* violates C standard, by lying on structure alignment.
+Only use if no other choice to achieve best performance on target platform */
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;
+
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
+
+#else
+
+/* default method, safe and standard.
+   can sometimes prove slower */
+
+MEM_STATIC U16 MEM_read16(const void* memPtr)
+{
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U32 MEM_read32(const void* memPtr)
+{
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC U64 MEM_read64(const void* memPtr)
+{
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+MEM_STATIC void MEM_write16(void* memPtr, U16 value)
+{
+    memcpy(memPtr, &value, sizeof(value));
+}
+
+#endif /* MEM_FORCE_MEMORY_ACCESS */
+
+MEM_STATIC U32 MEM_swap32(U32 in)
+{
+#if defined(_MSC_VER)     /* Visual Studio */
+    return _byteswap_ulong(in);
+#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
+    return __builtin_bswap32(in);
+#else
+    return  ((in << 24) & 0xff000000 ) |
+            ((in <<  8) & 0x00ff0000 ) |
+            ((in >>  8) & 0x0000ff00 ) |
+            ((in >> 24) & 0x000000ff );
+#endif
+}
+
+MEM_STATIC U64 MEM_swap64(U64 in)
+{
+#if defined(_MSC_VER)     /* Visual Studio */
+    return _byteswap_uint64(in);
+#elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
+    return __builtin_bswap64(in);
+#else
+    return  ((in << 56) & 0xff00000000000000ULL) |
+            ((in << 40) & 0x00ff000000000000ULL) |
+            ((in << 24) & 0x0000ff0000000000ULL) |
+            ((in << 8)  & 0x000000ff00000000ULL) |
+            ((in >> 8)  & 0x00000000ff000000ULL) |
+            ((in >> 24) & 0x0000000000ff0000ULL) |
+            ((in >> 40) & 0x000000000000ff00ULL) |
+            ((in >> 56) & 0x00000000000000ffULL);
+#endif
+}
+
+
+/*=== Little endian r/w ===*/
+
+MEM_STATIC U16 MEM_readLE16(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read16(memPtr);
+    else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)(p[0] + (p[1]<<8));
+    }
+}
+
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
+{
+    if (MEM_isLittleEndian()) {
+        MEM_write16(memPtr, val);
+    } else {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE)val;
+        p[1] = (BYTE)(val>>8);
+    }
+}
+
+MEM_STATIC U32 MEM_readLE32(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read32(memPtr);
+    else
+        return MEM_swap32(MEM_read32(memPtr));
+}
+
+
+MEM_STATIC U64 MEM_readLE64(const void* memPtr)
+{
+    if (MEM_isLittleEndian())
+        return MEM_read64(memPtr);
+    else
+        return MEM_swap64(MEM_read64(memPtr));
+}
+
+MEM_STATIC size_t MEM_readLEST(const void* memPtr)
+{
+    if (MEM_32bits())
+        return (size_t)MEM_readLE32(memPtr);
+    else
+        return (size_t)MEM_readLE64(memPtr);
+}
+
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* MEM_H_MODULE */
+/* ******************************************************************
+   bitstream
+   Part of FSE library
+   header file (to include)
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef BITSTREAM_H_MODULE
+#define BITSTREAM_H_MODULE
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*
+*  This API consists of small unitary functions, which must be inlined for best performance.
+*  Since link-time-optimization is not available for all compilers,
+*  these functions are defined into a .h to be included.
+*/
+
+
+/*=========================================
+*  Target specific
+=========================================*/
+#if defined(__BMI__) && defined(__GNUC__)
+#  include <immintrin.h>   /* support for bextr (experimental) */
+#endif
+
+/*-********************************************
+*  bitStream decoding API (read backward)
+**********************************************/
+typedef struct
+{
+    size_t   bitContainer;
+    unsigned bitsConsumed;
+    const char* ptr;
+    const char* start;
+} BITv07_DStream_t;
+
+typedef enum { BITv07_DStream_unfinished = 0,
+               BITv07_DStream_endOfBuffer = 1,
+               BITv07_DStream_completed = 2,
+               BITv07_DStream_overflow = 3 } BITv07_DStream_status;  /* result of BITv07_reloadDStream() */
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
+
+MEM_STATIC size_t   BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
+MEM_STATIC size_t   BITv07_readBits(BITv07_DStream_t* bitD, unsigned nbBits);
+MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD);
+MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* bitD);
+
+
+
+/*-****************************************
+*  unsafe API
+******************************************/
+MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, unsigned nbBits);
+/* faster, but works only if nbBits >= 1 */
+
+
+
+/*-**************************************************************
+*  Internal functions
+****************************************************************/
+MEM_STATIC unsigned BITv07_highbit32 (U32 val)
+{
+#   if defined(_MSC_VER)   /* Visual */
+    unsigned long r=0;
+    _BitScanReverse ( &r, val );
+    return (unsigned) r;
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+    return 31 - __builtin_clz (val);
+#   else   /* Software version */
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+    U32 v = val;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
+#   endif
+}
+
+
+
+/*-********************************************************
+* bitStream decoding
+**********************************************************/
+/*! BITv07_initDStream() :
+*   Initialize a BITv07_DStream_t.
+*   `bitD` : a pointer to an already allocated BITv07_DStream_t structure.
+*   `srcSize` must be the *exact* size of the bitStream, in bytes.
+*   @return : size of stream (== srcSize) or an errorCode if a problem is detected
+*/
+MEM_STATIC size_t BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
+{
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
+
+    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+          bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0;
+          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
+    } else {
+        bitD->start = (const char*)srcBuffer;
+        bitD->ptr   = bitD->start;
+        bitD->bitContainer = *(const BYTE*)(bitD->start);
+        switch(srcSize)
+        {
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);/* fall-through */
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);/* fall-through */
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);/* fall-through */
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; /* fall-through */
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8; /* fall-through */
+            default: break;
+        }
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+          bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0;
+          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
+        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
+    }
+
+    return srcSize;
+}
+
+
+ MEM_STATIC size_t BITv07_lookBits(const BITv07_DStream_t* bitD, U32 nbBits)
+{
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
+}
+
+/*! BITv07_lookBitsFast() :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BITv07_lookBitsFast(const BITv07_DStream_t* bitD, U32 nbBits)
+{
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
+}
+
+MEM_STATIC void BITv07_skipBits(BITv07_DStream_t* bitD, U32 nbBits)
+{
+    bitD->bitsConsumed += nbBits;
+}
+
+MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, U32 nbBits)
+{
+    size_t const value = BITv07_lookBits(bitD, nbBits);
+    BITv07_skipBits(bitD, nbBits);
+    return value;
+}
+
+/*! BITv07_readBitsFast() :
+*   unsafe version; only works only if nbBits >= 1 */
+MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, U32 nbBits)
+{
+    size_t const value = BITv07_lookBitsFast(bitD, nbBits);
+    BITv07_skipBits(bitD, nbBits);
+    return value;
+}
+
+MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD)
+{
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should not happen => corruption detected */
+        return BITv07_DStream_overflow;
+
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {
+        bitD->ptr -= bitD->bitsConsumed >> 3;
+        bitD->bitsConsumed &= 7;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);
+        return BITv07_DStream_unfinished;
+    }
+    if (bitD->ptr == bitD->start) {
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv07_DStream_endOfBuffer;
+        return BITv07_DStream_completed;
+    }
+    {   U32 nbBytes = bitD->bitsConsumed >> 3;
+        BITv07_DStream_status result = BITv07_DStream_unfinished;
+        if (bitD->ptr - nbBytes < bitD->start) {
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
+            result = BITv07_DStream_endOfBuffer;
+        }
+        bitD->ptr -= nbBytes;
+        bitD->bitsConsumed -= nbBytes*8;
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
+        return result;
+    }
+}
+
+/*! BITv07_endOfDStream() :
+*   @return Tells if DStream has exactly reached its end (all bits consumed).
+*/
+MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* DStream)
+{
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* BITSTREAM_H_MODULE */
+/* ******************************************************************
+   FSE : Finite State Entropy codec
+   Public Prototypes declaration
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef FSEv07_H
+#define FSEv07_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/*-****************************************
+*  FSE simple functions
+******************************************/
+
+/*! FSEv07_decompress():
+    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated destination buffer 'dst', of size 'dstCapacity'.
+    @return : size of regenerated data (<= maxDstSize),
+              or an error code, which can be tested using FSEv07_isError() .
+
+    ** Important ** : FSEv07_decompress() does not decompress non-compressible nor RLE data !!!
+    Why ? : making this distinction requires a header.
+    Header management is intentionally delegated to the user layer, which can better manage special cases.
+*/
+size_t FSEv07_decompress(void* dst,  size_t dstCapacity,
+                const void* cSrc, size_t cSrcSize);
+
+
+/* Error Management */
+unsigned    FSEv07_isError(size_t code);        /* tells if a return value is an error code */
+const char* FSEv07_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
+
+
+/*-*****************************************
+*  FSE detailed API
+******************************************/
+/*!
+FSEv07_decompress() does the following:
+1. read normalized counters with readNCount()
+2. build decoding table 'DTable' from normalized counters
+3. decode the data stream using decoding table 'DTable'
+
+The following API allows targeting specific sub-functions for advanced tasks.
+For example, it's possible to compress several blocks using the same 'CTable',
+or to save and provide normalized distribution using external method.
+*/
+
+
+/* *** DECOMPRESSION *** */
+
+/*! FSEv07_readNCount():
+    Read compactly saved 'normalizedCounter' from 'rBuffer'.
+    @return : size read from 'rBuffer',
+              or an errorCode, which can be tested using FSEv07_isError().
+              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
+size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
+
+/*! Constructor and Destructor of FSEv07_DTable.
+    Note that its size depends on 'tableLog' */
+typedef unsigned FSEv07_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
+FSEv07_DTable* FSEv07_createDTable(unsigned tableLog);
+void        FSEv07_freeDTable(FSEv07_DTable* dt);
+
+/*! FSEv07_buildDTable():
+    Builds 'dt', which must be already allocated, using FSEv07_createDTable().
+    return : 0, or an errorCode, which can be tested using FSEv07_isError() */
+size_t FSEv07_buildDTable (FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
+
+/*! FSEv07_decompress_usingDTable():
+    Decompress compressed source `cSrc` of size `cSrcSize` using `dt`
+    into `dst` which must be already allocated.
+    @return : size of regenerated data (necessarily <= `dstCapacity`),
+              or an errorCode, which can be tested using FSEv07_isError() */
+size_t FSEv07_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv07_DTable* dt);
+
+/*!
+Tutorial :
+----------
+(Note : these functions only decompress FSE-compressed blocks.
+ If block is uncompressed, use memcpy() instead
+ If block is a single repeated byte, use memset() instead )
+
+The first step is to obtain the normalized frequencies of symbols.
+This can be performed by FSEv07_readNCount() if it was saved using FSEv07_writeNCount().
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
+In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
+or size the table to handle worst case situations (typically 256).
+FSEv07_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
+The result of FSEv07_readNCount() is the number of bytes read from 'rBuffer'.
+Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
+If there is an error, the function will return an error code, which can be tested using FSEv07_isError().
+
+The next step is to build the decompression tables 'FSEv07_DTable' from 'normalizedCounter'.
+This is performed by the function FSEv07_buildDTable().
+The space required by 'FSEv07_DTable' must be already allocated using FSEv07_createDTable().
+If there is an error, the function will return an error code, which can be tested using FSEv07_isError().
+
+`FSEv07_DTable` can then be used to decompress `cSrc`, with FSEv07_decompress_usingDTable().
+`cSrcSize` must be strictly correct, otherwise decompression will fail.
+FSEv07_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).
+If there is an error, the function will return an error code, which can be tested using FSEv07_isError(). (ex: dst buffer too small)
+*/
+
+
+#ifdef FSEv07_STATIC_LINKING_ONLY
+
+
+/* *****************************************
+*  Static allocation
+*******************************************/
+/* FSE buffer bounds */
+#define FSEv07_NCOUNTBOUND 512
+#define FSEv07_BLOCKBOUND(size) (size + (size>>7))
+
+/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */
+#define FSEv07_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
+
+
+/* *****************************************
+*  FSE advanced API
+*******************************************/
+size_t FSEv07_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize);
+/**< same as FSEv07_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */
+
+unsigned FSEv07_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
+/**< same as FSEv07_optimalTableLog(), which used `minus==2` */
+
+size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits);
+/**< build a fake FSEv07_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
+
+size_t FSEv07_buildDTable_rle (FSEv07_DTable* dt, unsigned char symbolValue);
+/**< build a fake FSEv07_DTable, designed to always generate the same symbolValue */
+
+
+
+/* *****************************************
+*  FSE symbol decompression API
+*******************************************/
+typedef struct
+{
+    size_t      state;
+    const void* table;   /* precise table may vary, depending on U16 */
+} FSEv07_DState_t;
+
+
+static void     FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt);
+
+static unsigned char FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD);
+
+
+
+/* *****************************************
+*  FSE unsafe API
+*******************************************/
+static unsigned char FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD);
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
+
+
+/* ======    Decompression    ====== */
+
+typedef struct {
+    U16 tableLog;
+    U16 fastMode;
+} FSEv07_DTableHeader;   /* sizeof U32 */
+
+typedef struct
+{
+    unsigned short newState;
+    unsigned char  symbol;
+    unsigned char  nbBits;
+} FSEv07_decode_t;   /* size == U32 */
+
+MEM_STATIC void FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSEv07_DTableHeader* const DTableH = (const FSEv07_DTableHeader*)ptr;
+    DStatePtr->state = BITv07_readBits(bitD, DTableH->tableLog);
+    BITv07_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+MEM_STATIC BYTE FSEv07_peekSymbol(const FSEv07_DState_t* DStatePtr)
+{
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    return DInfo.symbol;
+}
+
+MEM_STATIC void FSEv07_updateState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)
+{
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    size_t const lowBits = BITv07_readBits(bitD, nbBits);
+    DStatePtr->state = DInfo.newState + lowBits;
+}
+
+MEM_STATIC BYTE FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)
+{
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    BYTE const symbol = DInfo.symbol;
+    size_t const lowBits = BITv07_readBits(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+/*! FSEv07_decodeSymbolFast() :
+    unsafe, only works if no symbol has a probability > 50% */
+MEM_STATIC BYTE FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)
+{
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
+    U32 const nbBits = DInfo.nbBits;
+    BYTE const symbol = DInfo.symbol;
+    size_t const lowBits = BITv07_readBitsFast(bitD, nbBits);
+
+    DStatePtr->state = DInfo.newState + lowBits;
+    return symbol;
+}
+
+
+
+#ifndef FSEv07_COMMONDEFS_ONLY
+
+/* **************************************************************
+*  Tuning parameters
+****************************************************************/
+/*!MEMORY_USAGE :
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+*  Increasing memory usage improves compression ratio
+*  Reduced memory usage can improve speed, due to cache effect
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#define FSEv07_MAX_MEMORY_USAGE 14
+#define FSEv07_DEFAULT_MEMORY_USAGE 13
+
+/*!FSEv07_MAX_SYMBOL_VALUE :
+*  Maximum symbol value authorized.
+*  Required for proper stack allocation */
+#define FSEv07_MAX_SYMBOL_VALUE 255
+
+
+/* **************************************************************
+*  template functions type & suffix
+****************************************************************/
+#define FSEv07_FUNCTION_TYPE BYTE
+#define FSEv07_FUNCTION_EXTENSION
+#define FSEv07_DECODE_TYPE FSEv07_decode_t
+
+
+#endif   /* !FSEv07_COMMONDEFS_ONLY */
+
+
+/* ***************************************************************
+*  Constants
+*****************************************************************/
+#define FSEv07_MAX_TABLELOG  (FSEv07_MAX_MEMORY_USAGE-2)
+#define FSEv07_MAX_TABLESIZE (1U<<FSEv07_MAX_TABLELOG)
+#define FSEv07_MAXTABLESIZE_MASK (FSEv07_MAX_TABLESIZE-1)
+#define FSEv07_DEFAULT_TABLELOG (FSEv07_DEFAULT_MEMORY_USAGE-2)
+#define FSEv07_MIN_TABLELOG 5
+
+#define FSEv07_TABLELOG_ABSOLUTE_MAX 15
+#if FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX
+#  error "FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX is not supported"
+#endif
+
+#define FSEv07_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
+
+
+#endif /* FSEv07_STATIC_LINKING_ONLY */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* FSEv07_H */
+/* ******************************************************************
+   Huffman coder, part of New Generation Entropy library
+   header file
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+****************************************************************** */
+#ifndef HUFv07_H_298734234
+#define HUFv07_H_298734234
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+/* *** simple functions *** */
+/**
+HUFv07_decompress() :
+    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
+    into already allocated buffer 'dst', of minimum size 'dstSize'.
+    `dstSize` : **must** be the ***exact*** size of original (uncompressed) data.
+    Note : in contrast with FSE, HUFv07_decompress can regenerate
+           RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
+           because it knows size to regenerate.
+    @return : size of regenerated data (== dstSize),
+              or an error code, which can be tested using HUFv07_isError()
+*/
+size_t HUFv07_decompress(void* dst,  size_t dstSize,
+                const void* cSrc, size_t cSrcSize);
+
+
+/* ****************************************
+*  Tool functions
+******************************************/
+#define HUFv07_BLOCKSIZE_MAX (128 * 1024)
+
+/* Error Management */
+unsigned    HUFv07_isError(size_t code);        /**< tells if a return value is an error code */
+const char* HUFv07_getErrorName(size_t code);   /**< provides error code string (useful for debugging) */
+
+
+/* *** Advanced function *** */
+
+
+#ifdef HUFv07_STATIC_LINKING_ONLY
+
+
+/* *** Constants *** */
+#define HUFv07_TABLELOG_ABSOLUTEMAX  16   /* absolute limit of HUFv07_MAX_TABLELOG. Beyond that value, code does not work */
+#define HUFv07_TABLELOG_MAX  12           /* max configured tableLog (for static allocation); can be modified up to HUFv07_ABSOLUTEMAX_TABLELOG */
+#define HUFv07_TABLELOG_DEFAULT  11       /* tableLog by default, when not specified */
+#define HUFv07_SYMBOLVALUE_MAX 255
+#if (HUFv07_TABLELOG_MAX > HUFv07_TABLELOG_ABSOLUTEMAX)
+#  error "HUFv07_TABLELOG_MAX is too large !"
+#endif
+
+
+/* ****************************************
+*  Static allocation
+******************************************/
+/* HUF buffer bounds */
+#define HUFv07_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */
+
+/* static allocation of HUF's DTable */
+typedef U32 HUFv07_DTable;
+#define HUFv07_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
+#define HUFv07_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+        HUFv07_DTable DTable[HUFv07_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1)*0x1000001) }
+#define HUFv07_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
+        HUFv07_DTable DTable[HUFv07_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog)*0x1000001) }
+
+
+/* ****************************************
+*  Advanced decompression functions
+******************************************/
+size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
+size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
+
+size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< decodes RLE and uncompressed */
+size_t HUFv07_decompress4X_hufOnly(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
+size_t HUFv07_decompress4X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
+size_t HUFv07_decompress4X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
+
+size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+size_t HUFv07_decompress1X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
+size_t HUFv07_decompress1X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
+
+
+/* ****************************************
+*  HUF detailed API
+******************************************/
+/*!
+The following API allows targeting specific sub-functions for advanced tasks.
+For example, it's possible to compress several blocks using the same 'CTable',
+or to save and regenerate 'CTable' using external methods.
+*/
+/* FSEv07_count() : find it within "fse.h" */
+
+/*! HUFv07_readStats() :
+    Read compact Huffman tree, saved by HUFv07_writeCTable().
+    `huffWeight` is destination buffer.
+    @return : size read from `src` , or an error Code .
+    Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() . */
+size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                     U32* nbSymbolsPtr, U32* tableLogPtr,
+                     const void* src, size_t srcSize);
+
+
+/*
+HUFv07_decompress() does the following:
+1. select the decompression algorithm (X2, X4) based on pre-computed heuristics
+2. build Huffman table from save, using HUFv07_readDTableXn()
+3. decode 1 or 4 segments in parallel using HUFv07_decompressSXn_usingDTable
+*/
+
+/** HUFv07_selectDecoder() :
+*   Tells which decoder is likely to decode faster,
+*   based on a set of pre-determined metrics.
+*   @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 .
+*   Assumption : 0 < cSrcSize < dstSize <= 128 KB */
+U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize);
+
+size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize);
+size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize);
+
+size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
+size_t HUFv07_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
+size_t HUFv07_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
+
+
+/* single stream variants */
+size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
+size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
+
+size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
+size_t HUFv07_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
+size_t HUFv07_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
+
+
+#endif /* HUFv07_STATIC_LINKING_ONLY */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* HUFv07_H_298734234 */
+/*
+   Common functions of New Generation Entropy library
+   Copyright (C) 2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+*************************************************************************** */
+
+
+
+/*-****************************************
+*  FSE Error Management
+******************************************/
+unsigned FSEv07_isError(size_t code) { return ERR_isError(code); }
+
+const char* FSEv07_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+/* **************************************************************
+*  HUF Error Management
+****************************************************************/
+unsigned HUFv07_isError(size_t code) { return ERR_isError(code); }
+
+const char* HUFv07_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+/*-**************************************************************
+*  FSE NCount encoding-decoding
+****************************************************************/
+static short FSEv07_abs(short a) { return (short)(a<0 ? -a : a); }
+
+size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
+                 const void* headerBuffer, size_t hbSize)
+{
+    const BYTE* const istart = (const BYTE*) headerBuffer;
+    const BYTE* const iend = istart + hbSize;
+    const BYTE* ip = istart;
+    int nbBits;
+    int remaining;
+    int threshold;
+    U32 bitStream;
+    int bitCount;
+    unsigned charnum = 0;
+    int previous0 = 0;
+
+    if (hbSize < 4) return ERROR(srcSize_wrong);
+    bitStream = MEM_readLE32(ip);
+    nbBits = (bitStream & 0xF) + FSEv07_MIN_TABLELOG;   /* extract tableLog */
+    if (nbBits > FSEv07_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
+    bitStream >>= 4;
+    bitCount = 4;
+    *tableLogPtr = nbBits;
+    remaining = (1<<nbBits)+1;
+    threshold = 1<<nbBits;
+    nbBits++;
+
+    while ((remaining>1) && (charnum<=*maxSVPtr)) {
+        if (previous0) {
+            unsigned n0 = charnum;
+            while ((bitStream & 0xFFFF) == 0xFFFF) {
+                n0+=24;
+                if (ip < iend-5) {
+                    ip+=2;
+                    bitStream = MEM_readLE32(ip) >> bitCount;
+                } else {
+                    bitStream >>= 16;
+                    bitCount+=16;
+            }   }
+            while ((bitStream & 3) == 3) {
+                n0+=3;
+                bitStream>>=2;
+                bitCount+=2;
+            }
+            n0 += bitStream & 3;
+            bitCount += 2;
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
+            while (charnum < n0) normalizedCounter[charnum++] = 0;
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                ip += bitCount>>3;
+                bitCount &= 7;
+                bitStream = MEM_readLE32(ip) >> bitCount;
+            }
+            else
+                bitStream >>= 2;
+        }
+        {   short const max = (short)((2*threshold-1)-remaining);
+            short count;
+
+            if ((bitStream & (threshold-1)) < (U32)max) {
+                count = (short)(bitStream & (threshold-1));
+                bitCount   += nbBits-1;
+            } else {
+                count = (short)(bitStream & (2*threshold-1));
+                if (count >= threshold) count -= max;
+                bitCount   += nbBits;
+            }
+
+            count--;   /* extra accuracy */
+            remaining -= FSEv07_abs(count);
+            normalizedCounter[charnum++] = count;
+            previous0 = !count;
+            while (remaining < threshold) {
+                nbBits--;
+                threshold >>= 1;
+            }
+
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
+                ip += bitCount>>3;
+                bitCount &= 7;
+            } else {
+                bitCount -= (int)(8 * (iend - 4 - ip));
+                ip = iend - 4;
+            }
+            bitStream = MEM_readLE32(ip) >> (bitCount & 31);
+    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */
+    if (remaining != 1) return ERROR(GENERIC);
+    *maxSVPtr = charnum-1;
+
+    ip += (bitCount+7)>>3;
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
+    return ip-istart;
+}
+
+
+/*! HUFv07_readStats() :
+    Read compact Huffman tree, saved by HUFv07_writeCTable().
+    `huffWeight` is destination buffer.
+    @return : size read from `src` , or an error Code .
+    Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() .
+*/
+size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
+                     U32* nbSymbolsPtr, U32* tableLogPtr,
+                     const void* src, size_t srcSize)
+{
+    U32 weightTotal;
+    const BYTE* ip = (const BYTE*) src;
+    size_t iSize;
+    size_t oSize;
+
+    if (!srcSize) return ERROR(srcSize_wrong);
+    iSize = ip[0];
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
+
+    if (iSize >= 128)  { /* special header */
+        if (iSize >= (242)) {  /* RLE */
+            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+            oSize = l[iSize-242];
+            memset(huffWeight, 1, hwSize);
+            iSize = 0;
+        }
+        else {   /* Incompressible */
+            oSize = iSize - 127;
+            iSize = ((oSize+1)/2);
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+            if (oSize >= hwSize) return ERROR(corruption_detected);
+            ip += 1;
+            {   U32 n;
+                for (n=0; n<oSize; n+=2) {
+                    huffWeight[n]   = ip[n/2] >> 4;
+                    huffWeight[n+1] = ip[n/2] & 15;
+    }   }   }   }
+    else  {   /* header compressed with FSE (normal case) */
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+        oSize = FSEv07_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
+        if (FSEv07_isError(oSize)) return oSize;
+    }
+
+    /* collect weight stats */
+    memset(rankStats, 0, (HUFv07_TABLELOG_ABSOLUTEMAX + 1) * sizeof(U32));
+    weightTotal = 0;
+    {   U32 n; for (n=0; n<oSize; n++) {
+            if (huffWeight[n] >= HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected);
+            rankStats[huffWeight[n]]++;
+            weightTotal += (1 << huffWeight[n]) >> 1;
+    }   }
+    if (weightTotal == 0) return ERROR(corruption_detected);
+
+    /* get last non-null symbol weight (implied, total must be 2^n) */
+    {   U32 const tableLog = BITv07_highbit32(weightTotal) + 1;
+        if (tableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected);
+        *tableLogPtr = tableLog;
+        /* determine last weight */
+        {   U32 const total = 1 << tableLog;
+            U32 const rest = total - weightTotal;
+            U32 const verif = 1 << BITv07_highbit32(rest);
+            U32 const lastWeight = BITv07_highbit32(rest) + 1;
+            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
+            huffWeight[oSize] = (BYTE)lastWeight;
+            rankStats[lastWeight]++;
+    }   }
+
+    /* check tree construction validity */
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
+
+    /* results */
+    *nbSymbolsPtr = (U32)(oSize+1);
+    return iSize+1;
+}
+/* ******************************************************************
+   FSE : Finite State Entropy decoder
+   Copyright (C) 2013-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  define FORCE_INLINE static __forceinline
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#else
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define FSEv07_isError ERR_isError
+#define FSEv07_STATIC_ASSERT(c) { enum { FSEv07_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/* **************************************************************
+*  Complex types
+****************************************************************/
+typedef U32 DTable_max_t[FSEv07_DTABLE_SIZE_U32(FSEv07_MAX_TABLELOG)];
+
+
+/* **************************************************************
+*  Templates
+****************************************************************/
+/*
+  designed to be included
+  for type-specific functions (template emulation in C)
+  Objective is to write these functions only once, for improved maintenance
+*/
+
+/* safety checks */
+#ifndef FSEv07_FUNCTION_EXTENSION
+#  error "FSEv07_FUNCTION_EXTENSION must be defined"
+#endif
+#ifndef FSEv07_FUNCTION_TYPE
+#  error "FSEv07_FUNCTION_TYPE must be defined"
+#endif
+
+/* Function names */
+#define FSEv07_CAT(X,Y) X##Y
+#define FSEv07_FUNCTION_NAME(X,Y) FSEv07_CAT(X,Y)
+#define FSEv07_TYPE_NAME(X,Y) FSEv07_CAT(X,Y)
+
+
+/* Function templates */
+FSEv07_DTable* FSEv07_createDTable (unsigned tableLog)
+{
+    if (tableLog > FSEv07_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv07_TABLELOG_ABSOLUTE_MAX;
+    return (FSEv07_DTable*)malloc( FSEv07_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
+}
+
+void FSEv07_freeDTable (FSEv07_DTable* dt)
+{
+    free(dt);
+}
+
+size_t FSEv07_buildDTable(FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+{
+    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
+    FSEv07_DECODE_TYPE* const tableDecode = (FSEv07_DECODE_TYPE*) (tdPtr);
+    U16 symbolNext[FSEv07_MAX_SYMBOL_VALUE+1];
+
+    U32 const maxSV1 = maxSymbolValue + 1;
+    U32 const tableSize = 1 << tableLog;
+    U32 highThreshold = tableSize-1;
+
+    /* Sanity Checks */
+    if (maxSymbolValue > FSEv07_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
+    if (tableLog > FSEv07_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
+
+    /* Init, lay down lowprob symbols */
+    {   FSEv07_DTableHeader DTableH;
+        DTableH.tableLog = (U16)tableLog;
+        DTableH.fastMode = 1;
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
+            U32 s;
+            for (s=0; s<maxSV1; s++) {
+                if (normalizedCounter[s]==-1) {
+                    tableDecode[highThreshold--].symbol = (FSEv07_FUNCTION_TYPE)s;
+                    symbolNext[s] = 1;
+                } else {
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
+                    symbolNext[s] = normalizedCounter[s];
+        }   }   }
+        memcpy(dt, &DTableH, sizeof(DTableH));
+    }
+
+    /* Spread symbols */
+    {   U32 const tableMask = tableSize-1;
+        U32 const step = FSEv07_TABLESTEP(tableSize);
+        U32 s, position = 0;
+        for (s=0; s<maxSV1; s++) {
+            int i;
+            for (i=0; i<normalizedCounter[s]; i++) {
+                tableDecode[position].symbol = (FSEv07_FUNCTION_TYPE)s;
+                position = (position + step) & tableMask;
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }   }
+
+        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+    }
+
+    /* Build Decoding table */
+    {   U32 u;
+        for (u=0; u<tableSize; u++) {
+            FSEv07_FUNCTION_TYPE const symbol = (FSEv07_FUNCTION_TYPE)(tableDecode[u].symbol);
+            U16 nextState = symbolNext[symbol]++;
+            tableDecode[u].nbBits = (BYTE) (tableLog - BITv07_highbit32 ((U32)nextState) );
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
+    }   }
+
+    return 0;
+}
+
+
+
+#ifndef FSEv07_COMMONDEFS_ONLY
+
+/*-*******************************************************
+*  Decompression (Byte symbols)
+*********************************************************/
+size_t FSEv07_buildDTable_rle (FSEv07_DTable* dt, BYTE symbolValue)
+{
+    void* ptr = dt;
+    FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSEv07_decode_t* const cell = (FSEv07_decode_t*)dPtr;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->newState = 0;
+    cell->symbol = symbolValue;
+    cell->nbBits = 0;
+
+    return 0;
+}
+
+
+size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits)
+{
+    void* ptr = dt;
+    FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr;
+    void* dPtr = dt + 1;
+    FSEv07_decode_t* const dinfo = (FSEv07_decode_t*)dPtr;
+    const unsigned tableSize = 1 << nbBits;
+    const unsigned tableMask = tableSize - 1;
+    const unsigned maxSV1 = tableMask+1;
+    unsigned s;
+
+    /* Sanity checks */
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
+
+    /* Build Decoding Table */
+    DTableH->tableLog = (U16)nbBits;
+    DTableH->fastMode = 1;
+    for (s=0; s<maxSV1; s++) {
+        dinfo[s].newState = 0;
+        dinfo[s].symbol = (BYTE)s;
+        dinfo[s].nbBits = (BYTE)nbBits;
+    }
+
+    return 0;
+}
+
+FORCE_INLINE size_t FSEv07_decompress_usingDTable_generic(
+          void* dst, size_t maxDstSize,
+    const void* cSrc, size_t cSrcSize,
+    const FSEv07_DTable* dt, const unsigned fast)
+{
+    BYTE* const ostart = (BYTE*) dst;
+    BYTE* op = ostart;
+    BYTE* const omax = op + maxDstSize;
+    BYTE* const olimit = omax-3;
+
+    BITv07_DStream_t bitD;
+    FSEv07_DState_t state1;
+    FSEv07_DState_t state2;
+
+    /* Init */
+    { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
+      if (FSEv07_isError(errorCode)) return errorCode; }
+
+    FSEv07_initDState(&state1, &bitD, dt);
+    FSEv07_initDState(&state2, &bitD, dt);
+
+#define FSEv07_GETSYMBOL(statePtr) fast ? FSEv07_decodeSymbolFast(statePtr, &bitD) : FSEv07_decodeSymbol(statePtr, &bitD)
+
+    /* 4 symbols per loop */
+    for ( ; (BITv07_reloadDStream(&bitD)==BITv07_DStream_unfinished) && (op<olimit) ; op+=4) {
+        op[0] = FSEv07_GETSYMBOL(&state1);
+
+        if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BITv07_reloadDStream(&bitD);
+
+        op[1] = FSEv07_GETSYMBOL(&state2);
+
+        if (FSEv07_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            { if (BITv07_reloadDStream(&bitD) > BITv07_DStream_unfinished) { op+=2; break; } }
+
+        op[2] = FSEv07_GETSYMBOL(&state1);
+
+        if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
+            BITv07_reloadDStream(&bitD);
+
+        op[3] = FSEv07_GETSYMBOL(&state2);
+    }
+
+    /* tail */
+    /* note : BITv07_reloadDStream(&bitD) >= FSEv07_DStream_partiallyFilled; Ends at exactly BITv07_DStream_completed */
+    while (1) {
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
+
+        *op++ = FSEv07_GETSYMBOL(&state1);
+
+        if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) {
+            *op++ = FSEv07_GETSYMBOL(&state2);
+            break;
+        }
+
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
+
+        *op++ = FSEv07_GETSYMBOL(&state2);
+
+        if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) {
+            *op++ = FSEv07_GETSYMBOL(&state1);
+            break;
+    }   }
+
+    return op-ostart;
+}
+
+
+size_t FSEv07_decompress_usingDTable(void* dst, size_t originalSize,
+                            const void* cSrc, size_t cSrcSize,
+                            const FSEv07_DTable* dt)
+{
+    const void* ptr = dt;
+    const FSEv07_DTableHeader* DTableH = (const FSEv07_DTableHeader*)ptr;
+    const U32 fastMode = DTableH->fastMode;
+
+    /* select fast mode (static) */
+    if (fastMode) return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
+    return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
+}
+
+
+size_t FSEv07_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* const istart = (const BYTE*)cSrc;
+    const BYTE* ip = istart;
+    short counting[FSEv07_MAX_SYMBOL_VALUE+1];
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
+    unsigned tableLog;
+    unsigned maxSymbolValue = FSEv07_MAX_SYMBOL_VALUE;
+
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
+
+    /* normal FSE decoding mode */
+    {   size_t const NCountLength = FSEv07_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
+        if (FSEv07_isError(NCountLength)) return NCountLength;
+        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
+        ip += NCountLength;
+        cSrcSize -= NCountLength;
+    }
+
+    { size_t const errorCode = FSEv07_buildDTable (dt, counting, maxSymbolValue, tableLog);
+      if (FSEv07_isError(errorCode)) return errorCode; }
+
+    return FSEv07_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */
+}
+
+
+
+#endif   /* FSEv07_COMMONDEFS_ONLY */
+
+/* ******************************************************************
+   Huffman decoder, part of New Generation Entropy library
+   Copyright (C) 2013-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c
+****************************************************************** */
+
+/* **************************************************************
+*  Compiler specifics
+****************************************************************/
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+/* inline is defined */
+#elif defined(_MSC_VER)
+#  define inline __inline
+#else
+#  define inline /* disable inline */
+#endif
+
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#endif
+
+
+
+/* **************************************************************
+*  Error Management
+****************************************************************/
+#define HUFv07_STATIC_ASSERT(c) { enum { HUFv07_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
+
+
+/*-***************************/
+/*  generic DTableDesc       */
+/*-***************************/
+
+typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
+
+static DTableDesc HUFv07_getDTableDesc(const HUFv07_DTable* table)
+{
+    DTableDesc dtd;
+    memcpy(&dtd, table, sizeof(dtd));
+    return dtd;
+}
+
+
+/*-***************************/
+/*  single-symbol decoding   */
+/*-***************************/
+
+typedef struct { BYTE byte; BYTE nbBits; } HUFv07_DEltX2;   /* single-symbol decoding */
+
+size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize)
+{
+    BYTE huffWeight[HUFv07_SYMBOLVALUE_MAX + 1];
+    U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */
+    U32 tableLog = 0;
+    U32 nbSymbols = 0;
+    size_t iSize;
+    void* const dtPtr = DTable + 1;
+    HUFv07_DEltX2* const dt = (HUFv07_DEltX2*)dtPtr;
+
+    HUFv07_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUFv07_DTable));
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUFv07_readStats(huffWeight, HUFv07_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
+    if (HUFv07_isError(iSize)) return iSize;
+
+    /* Table header */
+    {   DTableDesc dtd = HUFv07_getDTableDesc(DTable);
+        if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, huffman tree cannot fit in */
+        dtd.tableType = 0;
+        dtd.tableLog = (BYTE)tableLog;
+        memcpy(DTable, &dtd, sizeof(dtd));
+    }
+
+    /* Prepare ranks */
+    {   U32 n, nextRankStart = 0;
+        for (n=1; n<tableLog+1; n++) {
+            U32 current = nextRankStart;
+            nextRankStart += (rankVal[n] << (n-1));
+            rankVal[n] = current;
+    }   }
+
+    /* fill DTable */
+    {   U32 n;
+        for (n=0; n<nbSymbols; n++) {
+            U32 const w = huffWeight[n];
+            U32 const length = (1 << w) >> 1;
+            U32 i;
+            HUFv07_DEltX2 D;
+            D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
+            for (i = rankVal[w]; i < rankVal[w] + length; i++)
+                dt[i] = D;
+            rankVal[w] += length;
+    }   }
+
+    return iSize;
+}
+
+
+static BYTE HUFv07_decodeSymbolX2(BITv07_DStream_t* Dstream, const HUFv07_DEltX2* dt, const U32 dtLog)
+{
+    size_t const val = BITv07_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
+    BYTE const c = dt[val].byte;
+    BITv07_skipBits(Dstream, dt[val].nbBits);
+    return c;
+}
+
+#define HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    *ptr++ = HUFv07_decodeSymbolX2(DStreamPtr, dt, dtLog)
+
+#define HUFv07_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \
+        HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+#define HUFv07_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
+
+static inline size_t HUFv07_decodeStreamX2(BYTE* p, BITv07_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv07_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 4 symbols at a time */
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-4)) {
+        HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUFv07_DECODE_SYMBOLX2_1(p, bitDPtr);
+        HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr);
+        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);
+    }
+
+    /* closer to the end */
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd))
+        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    /* no more data to retrieve from bitstream, hence no need to reload */
+    while (p < pEnd)
+        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);
+
+    return pEnd-pStart;
+}
+
+static size_t HUFv07_decompress1X2_usingDTable_internal(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + dstSize;
+    const void* dtPtr = DTable + 1;
+    const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr;
+    BITv07_DStream_t bitD;
+    DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
+    U32 const dtLog = dtd.tableLog;
+
+    { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);
+      if (HUFv07_isError(errorCode)) return errorCode; }
+
+    HUFv07_decodeStreamX2(op, &bitD, oend, dt, dtLog);
+
+    /* check */
+    if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    return dstSize;
+}
+
+size_t HUFv07_decompress1X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
+    if (dtd.tableType != 0) return ERROR(GENERIC);
+    return HUFv07_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
+}
+
+size_t HUFv07_decompress1X2_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUFv07_readDTableX2 (DCtx, cSrc, cSrcSize);
+    if (HUFv07_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUFv07_decompress1X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx);
+}
+
+size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX);
+    return HUFv07_decompress1X2_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+
+static size_t HUFv07_decompress4X2_usingDTable_internal(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    /* Check */
+    if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */
+
+    {   const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable + 1;
+        const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr;
+
+        /* Init */
+        BITv07_DStream_t bitD1;
+        BITv07_DStream_t bitD2;
+        BITv07_DStream_t bitD3;
+        BITv07_DStream_t bitD4;
+        size_t const length1 = MEM_readLE16(istart);
+        size_t const length2 = MEM_readLE16(istart+2);
+        size_t const length3 = MEM_readLE16(istart+4);
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        const size_t segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+        DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
+        U32 const dtLog = dtd.tableLog;
+
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+        { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+        { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+        { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);
+        for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) {
+            HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUFv07_DECODE_SYMBOLX2_1(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX2_1(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX2_1(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX2_1(op4, &bitD4);
+            HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4);
+            HUFv07_DECODE_SYMBOLX2_0(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX2_0(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX2_0(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX2_0(op4, &bitD4);
+            endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUFv07_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUFv07_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUFv07_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUFv07_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        endSignal = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4);
+        if (!endSignal) return ERROR(corruption_detected);
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+size_t HUFv07_decompress4X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
+    if (dtd.tableType != 0) return ERROR(GENERIC);
+    return HUFv07_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
+}
+
+
+size_t HUFv07_decompress4X2_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUFv07_readDTableX2 (dctx, cSrc, cSrcSize);
+    if (HUFv07_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUFv07_decompress4X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, dctx);
+}
+
+size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX);
+    return HUFv07_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+
+/* *************************/
+/* double-symbols decoding */
+/* *************************/
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv07_DEltX4;  /* double-symbols decoding */
+
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
+
+static void HUFv07_fillDTableX4Level2(HUFv07_DEltX4* DTable, U32 sizeLog, const U32 consumed,
+                           const U32* rankValOrigin, const int minWeight,
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
+                           U32 nbBitsBaseline, U16 baseSeq)
+{
+    HUFv07_DEltX4 DElt;
+    U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];
+
+    /* get pre-calculated rankVal */
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill skipped values */
+    if (minWeight>1) {
+        U32 i, skipSize = rankVal[minWeight];
+        MEM_writeLE16(&(DElt.sequence), baseSeq);
+        DElt.nbBits   = (BYTE)(consumed);
+        DElt.length   = 1;
+        for (i = 0; i < skipSize; i++)
+            DTable[i] = DElt;
+    }
+
+    /* fill DTable */
+    { U32 s; for (s=0; s<sortedListSize; s++) {   /* note : sortedSymbols already skipped */
+        const U32 symbol = sortedSymbols[s].symbol;
+        const U32 weight = sortedSymbols[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 length = 1 << (sizeLog-nbBits);
+        const U32 start = rankVal[weight];
+        U32 i = start;
+        const U32 end = start + length;
+
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
+        DElt.nbBits = (BYTE)(nbBits + consumed);
+        DElt.length = 2;
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
+
+        rankVal[weight] += length;
+    }}
+}
+
+typedef U32 rankVal_t[HUFv07_TABLELOG_ABSOLUTEMAX][HUFv07_TABLELOG_ABSOLUTEMAX + 1];
+
+static void HUFv07_fillDTableX4(HUFv07_DEltX4* DTable, const U32 targetLog,
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32 nbBitsBaseline)
+{
+    U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
+    const U32 minBits  = nbBitsBaseline - maxWeight;
+    U32 s;
+
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
+
+    /* fill DTable */
+    for (s=0; s<sortedListSize; s++) {
+        const U16 symbol = sortedList[s].symbol;
+        const U32 weight = sortedList[s].weight;
+        const U32 nbBits = nbBitsBaseline - weight;
+        const U32 start = rankVal[weight];
+        const U32 length = 1 << (targetLog-nbBits);
+
+        if (targetLog-nbBits >= minBits) {   /* enough room for a second symbol */
+            U32 sortedRank;
+            int minWeight = nbBits + scaleLog;
+            if (minWeight < 1) minWeight = 1;
+            sortedRank = rankStart[minWeight];
+            HUFv07_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
+                           rankValOrigin[nbBits], minWeight,
+                           sortedList+sortedRank, sortedListSize-sortedRank,
+                           nbBitsBaseline, symbol);
+        } else {
+            HUFv07_DEltX4 DElt;
+            MEM_writeLE16(&(DElt.sequence), symbol);
+            DElt.nbBits = (BYTE)(nbBits);
+            DElt.length = 1;
+            {   U32 u;
+                const U32 end = start + length;
+                for (u = start; u < end; u++) DTable[u] = DElt;
+        }   }
+        rankVal[weight] += length;
+    }
+}
+
+size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize)
+{
+    BYTE weightList[HUFv07_SYMBOLVALUE_MAX + 1];
+    sortedSymbol_t sortedSymbol[HUFv07_SYMBOLVALUE_MAX + 1];
+    U32 rankStats[HUFv07_TABLELOG_ABSOLUTEMAX + 1] = { 0 };
+    U32 rankStart0[HUFv07_TABLELOG_ABSOLUTEMAX + 2] = { 0 };
+    U32* const rankStart = rankStart0+1;
+    rankVal_t rankVal;
+    U32 tableLog, maxW, sizeOfSort, nbSymbols;
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
+    U32 const maxTableLog = dtd.maxTableLog;
+    size_t iSize;
+    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */
+    HUFv07_DEltX4* const dt = (HUFv07_DEltX4*)dtPtr;
+
+    HUFv07_STATIC_ASSERT(sizeof(HUFv07_DEltX4) == sizeof(HUFv07_DTable));   /* if compilation fails here, assertion is false */
+    if (maxTableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(tableLog_tooLarge);
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
+
+    iSize = HUFv07_readStats(weightList, HUFv07_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
+    if (HUFv07_isError(iSize)) return iSize;
+
+    /* check result */
+    if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+
+    /* find maxWeight */
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
+
+    /* Get start index of each weight */
+    {   U32 w, nextRankStart = 0;
+        for (w=1; w<maxW+1; w++) {
+            U32 current = nextRankStart;
+            nextRankStart += rankStats[w];
+            rankStart[w] = current;
+        }
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        sizeOfSort = nextRankStart;
+    }
+
+    /* sort symbols by weight */
+    {   U32 s;
+        for (s=0; s<nbSymbols; s++) {
+            U32 const w = weightList[s];
+            U32 const r = rankStart[w]++;
+            sortedSymbol[r].symbol = (BYTE)s;
+            sortedSymbol[r].weight = (BYTE)w;
+        }
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
+    }
+
+    /* Build rankVal */
+    {   U32* const rankVal0 = rankVal[0];
+        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */
+            U32 nextRankVal = 0;
+            U32 w;
+            for (w=1; w<maxW+1; w++) {
+                U32 current = nextRankVal;
+                nextRankVal += rankStats[w] << (w+rescale);
+                rankVal0[w] = current;
+        }   }
+        {   U32 const minBits = tableLog+1 - maxW;
+            U32 consumed;
+            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
+                U32* const rankValPtr = rankVal[consumed];
+                U32 w;
+                for (w = 1; w < maxW+1; w++) {
+                    rankValPtr[w] = rankVal0[w] >> consumed;
+    }   }   }   }
+
+    HUFv07_fillDTableX4(dt, maxTableLog,
+                   sortedSymbol, sizeOfSort,
+                   rankStart0, rankVal, maxW,
+                   tableLog+1);
+
+    dtd.tableLog = (BYTE)maxTableLog;
+    dtd.tableType = 1;
+    memcpy(DTable, &dtd, sizeof(dtd));
+    return iSize;
+}
+
+
+static U32 HUFv07_decodeSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BITv07_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 2);
+    BITv07_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+static U32 HUFv07_decodeLastSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog)
+{
+    const size_t val = BITv07_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
+    memcpy(op, dt+val, 1);
+    if (dt[val].length==1) BITv07_skipBits(DStream, dt[val].nbBits);
+    else {
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
+            BITv07_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+    }   }
+    return 1;
+}
+
+
+#define HUFv07_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
+    ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUFv07_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \
+        ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+#define HUFv07_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
+
+static inline size_t HUFv07_decodeStreamX4(BYTE* p, BITv07_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv07_DEltX4* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd-7)) {
+        HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUFv07_DECODE_SYMBOLX4_1(p, bitDPtr);
+        HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr);
+        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);
+    }
+
+    /* closer to end : up to 2 symbols at a time */
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-2))
+        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);
+
+    while (p <= pEnd-2)
+        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
+
+    if (p < pEnd)
+        p += HUFv07_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+
+static size_t HUFv07_decompress1X4_usingDTable_internal(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    BITv07_DStream_t bitD;
+
+    /* Init */
+    {   size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);
+        if (HUFv07_isError(errorCode)) return errorCode;
+    }
+
+    /* decode */
+    {   BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */
+        const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr;
+        DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
+        HUFv07_decodeStreamX4(ostart, &bitD, oend, dt, dtd.tableLog);
+    }
+
+    /* check */
+    if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    /* decoded size */
+    return dstSize;
+}
+
+size_t HUFv07_decompress1X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
+    if (dtd.tableType != 1) return ERROR(GENERIC);
+    return HUFv07_decompress1X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
+}
+
+size_t HUFv07_decompress1X4_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t const hSize = HUFv07_readDTableX4 (DCtx, cSrc, cSrcSize);
+    if (HUFv07_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUFv07_decompress1X4_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx);
+}
+
+size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX);
+    return HUFv07_decompress1X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+static size_t HUFv07_decompress4X4_usingDTable_internal(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {   const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable+1;
+        const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr;
+
+        /* Init */
+        BITv07_DStream_t bitD1;
+        BITv07_DStream_t bitD2;
+        BITv07_DStream_t bitD3;
+        BITv07_DStream_t bitD4;
+        size_t const length1 = MEM_readLE16(istart);
+        size_t const length2 = MEM_readLE16(istart+2);
+        size_t const length3 = MEM_readLE16(istart+4);
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        size_t const segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
+        U32 endSignal;
+        DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
+        U32 const dtLog = dtd.tableLog;
+
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+        { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+        { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+        { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+        { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4);
+          if (HUFv07_isError(errorCode)) return errorCode; }
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
+        endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);
+        for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) {
+            HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUFv07_DECODE_SYMBOLX4_1(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX4_1(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX4_1(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX4_1(op4, &bitD4);
+            HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4);
+            HUFv07_DECODE_SYMBOLX4_0(op1, &bitD1);
+            HUFv07_DECODE_SYMBOLX4_0(op2, &bitD2);
+            HUFv07_DECODE_SYMBOLX4_0(op3, &bitD3);
+            HUFv07_DECODE_SYMBOLX4_0(op4, &bitD4);
+
+            endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 supposed already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUFv07_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
+        HUFv07_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
+        HUFv07_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
+        HUFv07_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        { U32 const endCheck = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4);
+          if (!endCheck) return ERROR(corruption_detected); }
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
+
+size_t HUFv07_decompress4X4_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUFv07_DTable* DTable)
+{
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
+    if (dtd.tableType != 1) return ERROR(GENERIC);
+    return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
+}
+
+
+size_t HUFv07_decompress4X4_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    const BYTE* ip = (const BYTE*) cSrc;
+
+    size_t hSize = HUFv07_readDTableX4 (dctx, cSrc, cSrcSize);
+    if (HUFv07_isError(hSize)) return hSize;
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
+    ip += hSize; cSrcSize -= hSize;
+
+    return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx);
+}
+
+size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX);
+    return HUFv07_decompress4X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+}
+
+
+/* ********************************/
+/* Generic decompression selector */
+/* ********************************/
+
+size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize,
+                                    const void* cSrc, size_t cSrcSize,
+                                    const HUFv07_DTable* DTable)
+{
+    DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
+    return dtd.tableType ? HUFv07_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :
+                           HUFv07_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
+}
+
+size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize,
+                                    const void* cSrc, size_t cSrcSize,
+                                    const HUFv07_DTable* DTable)
+{
+    DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
+    return dtd.tableType ? HUFv07_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :
+                           HUFv07_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
+}
+
+
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
+{
+    /* single, double, quad */
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
+};
+
+/** HUFv07_selectDecoder() :
+*   Tells which decoder is likely to decode faster,
+*   based on a set of pre-determined metrics.
+*   @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 .
+*   Assumption : 0 < cSrcSize < dstSize <= 128 KB */
+U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize)
+{
+    /* decoder timing evaluation */
+    U32 const Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
+    U32 const D256 = (U32)(dstSize >> 8);
+    U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
+    U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
+    DTime1 += DTime1 >> 3;  /* advantage to algorithm using less memory, for cache eviction */
+
+    return DTime1 < DTime0;
+}
+
+
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
+
+size_t HUFv07_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    static const decompressionAlgo decompress[2] = { HUFv07_decompress4X2, HUFv07_decompress4X4 };
+
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
+        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
+    }
+
+    //return HUFv07_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
+    //return HUFv07_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
+}
+
+size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
+        return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
+                        HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
+    }
+}
+
+size_t HUFv07_decompress4X_hufOnly (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if ((cSrcSize >= dstSize) || (cSrcSize <= 1)) return ERROR(corruption_detected);   /* invalid */
+
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
+        return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
+                        HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
+    }
+}
+
+size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
+{
+    /* validation checks */
+    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
+
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
+        return algoNb ? HUFv07_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
+                        HUFv07_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
+    }
+}
+/*
+    Common functions of Zstd compression library
+    Copyright (C) 2015-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net/
+*/
+
+
+
+/*-****************************************
+*  ZSTD Error Management
+******************************************/
+/*! ZSTDv07_isError() :
+*   tells if a return value is an error code */
+unsigned ZSTDv07_isError(size_t code) { return ERR_isError(code); }
+
+/*! ZSTDv07_getErrorName() :
+*   provides error code string from function result (useful for debugging) */
+const char* ZSTDv07_getErrorName(size_t code) { return ERR_getErrorName(code); }
+
+
+
+/* **************************************************************
+*  ZBUFF Error Management
+****************************************************************/
+unsigned ZBUFFv07_isError(size_t errorCode) { return ERR_isError(errorCode); }
+
+const char* ZBUFFv07_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
+
+
+
+static void* ZSTDv07_defaultAllocFunction(void* opaque, size_t size)
+{
+    void* address = malloc(size);
+    (void)opaque;
+    /* printf("alloc %p, %d opaque=%p \n", address, (int)size, opaque); */
+    return address;
+}
+
+static void ZSTDv07_defaultFreeFunction(void* opaque, void* address)
+{
+    (void)opaque;
+    /* if (address) printf("free %p opaque=%p \n", address, opaque); */
+    free(address);
+}
+/*
+    zstd_internal - common functions to include
+    Header File for include
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : https://www.zstd.net
+*/
+#ifndef ZSTDv07_CCOMMON_H_MODULE
+#define ZSTDv07_CCOMMON_H_MODULE
+
+
+/*-*************************************
+*  Common macros
+***************************************/
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
+
+
+/*-*************************************
+*  Common constants
+***************************************/
+#define ZSTDv07_OPT_NUM    (1<<12)
+#define ZSTDv07_DICT_MAGIC  0xEC30A437   /* v0.7 */
+
+#define ZSTDv07_REP_NUM    3
+#define ZSTDv07_REP_INIT   ZSTDv07_REP_NUM
+#define ZSTDv07_REP_MOVE   (ZSTDv07_REP_NUM-1)
+static const U32 repStartValue[ZSTDv07_REP_NUM] = { 1, 4, 8 };
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define BIT7 128
+#define BIT6  64
+#define BIT5  32
+#define BIT4  16
+#define BIT1   2
+#define BIT0   1
+
+#define ZSTDv07_WINDOWLOG_ABSOLUTEMIN 10
+static const size_t ZSTDv07_fcs_fieldSize[4] = { 0, 2, 4, 8 };
+static const size_t ZSTDv07_did_fieldSize[4] = { 0, 1, 2, 4 };
+
+#define ZSTDv07_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
+static const size_t ZSTDv07_blockHeaderSize = ZSTDv07_BLOCKHEADERSIZE;
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
+
+#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
+#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */
+
+#define HufLog 12
+typedef enum { lbt_huffman, lbt_repeat, lbt_raw, lbt_rle } litBlockType_t;
+
+#define LONGNBSEQ 0x7F00
+
+#define MINMATCH 3
+#define EQUAL_READ32 4
+
+#define Litbits  8
+#define MaxLit ((1<<Litbits) - 1)
+#define MaxML  52
+#define MaxLL  35
+#define MaxOff 28
+#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */
+#define MLFSELog    9
+#define LLFSELog    9
+#define OffFSELog   8
+
+#define FSEv07_ENCODING_RAW     0
+#define FSEv07_ENCODING_RLE     1
+#define FSEv07_ENCODING_STATIC  2
+#define FSEv07_ENCODING_DYNAMIC 3
+
+#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
+
+static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9,10,11,12,
+                                     13,14,15,16 };
+static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
+                                             2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
+                                            -1,-1,-1,-1 };
+static const U32 LL_defaultNormLog = 6;
+
+static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9,10,11,
+                                     12,13,14,15,16 };
+static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,
+                                            -1,-1,-1,-1,-1 };
+static const U32 ML_defaultNormLog = 6;
+
+static const S16 OF_defaultNorm[MaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
+                                              1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1 };
+static const U32 OF_defaultNormLog = 5;
+
+
+/*-*******************************************
+*  Shared functions to include for inlining
+*********************************************/
+static void ZSTDv07_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
+#define COPY8(d,s) { ZSTDv07_copy8(d,s); d+=8; s+=8; }
+
+/*! ZSTDv07_wildcopy() :
+*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
+#define WILDCOPY_OVERLENGTH 8
+MEM_STATIC void ZSTDv07_wildcopy(void* dst, const void* src, ptrdiff_t length)
+{
+    const BYTE* ip = (const BYTE*)src;
+    BYTE* op = (BYTE*)dst;
+    BYTE* const oend = op + length;
+    do
+        COPY8(op, ip)
+    while (op < oend);
+}
+
+
+/*-*******************************************
+*  Private interfaces
+*********************************************/
+typedef struct ZSTDv07_stats_s ZSTDv07_stats_t;
+
+typedef struct {
+    U32 off;
+    U32 len;
+} ZSTDv07_match_t;
+
+typedef struct {
+    U32 price;
+    U32 off;
+    U32 mlen;
+    U32 litlen;
+    U32 rep[ZSTDv07_REP_INIT];
+} ZSTDv07_optimal_t;
+
+struct ZSTDv07_stats_s { U32 unused; };
+
+typedef struct {
+    void* buffer;
+    U32*  offsetStart;
+    U32*  offset;
+    BYTE* offCodeStart;
+    BYTE* litStart;
+    BYTE* lit;
+    U16*  litLengthStart;
+    U16*  litLength;
+    BYTE* llCodeStart;
+    U16*  matchLengthStart;
+    U16*  matchLength;
+    BYTE* mlCodeStart;
+    U32   longLengthID;   /* 0 == no longLength; 1 == Lit.longLength; 2 == Match.longLength; */
+    U32   longLengthPos;
+    /* opt */
+    ZSTDv07_optimal_t* priceTable;
+    ZSTDv07_match_t* matchTable;
+    U32* matchLengthFreq;
+    U32* litLengthFreq;
+    U32* litFreq;
+    U32* offCodeFreq;
+    U32  matchLengthSum;
+    U32  matchSum;
+    U32  litLengthSum;
+    U32  litSum;
+    U32  offCodeSum;
+    U32  log2matchLengthSum;
+    U32  log2matchSum;
+    U32  log2litLengthSum;
+    U32  log2litSum;
+    U32  log2offCodeSum;
+    U32  factor;
+    U32  cachedPrice;
+    U32  cachedLitLength;
+    const BYTE* cachedLiterals;
+    ZSTDv07_stats_t stats;
+} seqStore_t;
+
+void ZSTDv07_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq);
+
+/* custom memory allocation functions */
+static const ZSTDv07_customMem defaultCustomMem = { ZSTDv07_defaultAllocFunction, ZSTDv07_defaultFreeFunction, NULL };
+
+#endif   /* ZSTDv07_CCOMMON_H_MODULE */
+/*
+    zstd - standard compression library
+    Copyright (C) 2014-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net
+*/
+
+/* ***************************************************************
+*  Tuning parameters
+*****************************************************************/
+/*!
+ * HEAPMODE :
+ * Select how default decompression function ZSTDv07_decompress() will allocate memory,
+ * in memory stack (0), or in memory heap (1, requires malloc())
+ */
+#ifndef ZSTDv07_HEAPMODE
+#  define ZSTDv07_HEAPMODE 1
+#endif
+
+
+/*-*******************************************************
+*  Compiler specifics
+*********************************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#  pragma warning(disable : 4100)        /* disable: C4100: unreferenced formal parameter */
+#endif
+
+
+/*-*************************************
+*  Macros
+***************************************/
+#define ZSTDv07_isError ERR_isError   /* for inlining */
+#define FSEv07_isError  ERR_isError
+#define HUFv07_isError  ERR_isError
+
+
+/*_*******************************************************
+*  Memory operations
+**********************************************************/
+static void ZSTDv07_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
+
+
+/*-*************************************************************
+*   Context management
+***************************************************************/
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
+               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTDv07_dStage;
+
+struct ZSTDv07_DCtx_s
+{
+    FSEv07_DTable LLTable[FSEv07_DTABLE_SIZE_U32(LLFSELog)];
+    FSEv07_DTable OffTable[FSEv07_DTABLE_SIZE_U32(OffFSELog)];
+    FSEv07_DTable MLTable[FSEv07_DTABLE_SIZE_U32(MLFSELog)];
+    HUFv07_DTable hufTable[HUFv07_DTABLE_SIZE(HufLog)];  /* can accommodate HUFv07_decompress4X */
+    const void* previousDstEnd;
+    const void* base;
+    const void* vBase;
+    const void* dictEnd;
+    size_t expected;
+    U32 rep[3];
+    ZSTDv07_frameParams fParams;
+    blockType_t bType;   /* used in ZSTDv07_decompressContinue(), to transfer blockType between header decoding and block decoding stages */
+    ZSTDv07_dStage stage;
+    U32 litEntropy;
+    U32 fseEntropy;
+    XXH64_state_t xxhState;
+    size_t headerSize;
+    U32 dictID;
+    const BYTE* litPtr;
+    ZSTDv07_customMem customMem;
+    size_t litSize;
+    BYTE litBuffer[ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + WILDCOPY_OVERLENGTH];
+    BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX];
+};  /* typedef'd to ZSTDv07_DCtx within "zstd_static.h" */
+
+int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx);
+
+size_t ZSTDv07_sizeofDCtx (const ZSTDv07_DCtx* dctx) { return sizeof(*dctx); }
+
+size_t ZSTDv07_estimateDCtxSize(void) { return sizeof(ZSTDv07_DCtx); }
+
+size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx)
+{
+    dctx->expected = ZSTDv07_frameHeaderSize_min;
+    dctx->stage = ZSTDds_getFrameHeaderSize;
+    dctx->previousDstEnd = NULL;
+    dctx->base = NULL;
+    dctx->vBase = NULL;
+    dctx->dictEnd = NULL;
+    dctx->hufTable[0] = (HUFv07_DTable)((HufLog)*0x1000001);
+    dctx->litEntropy = dctx->fseEntropy = 0;
+    dctx->dictID = 0;
+    { int i; for (i=0; i<ZSTDv07_REP_NUM; i++) dctx->rep[i] = repStartValue[i]; }
+    return 0;
+}
+
+ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem)
+{
+    ZSTDv07_DCtx* dctx;
+
+    if (!customMem.customAlloc && !customMem.customFree)
+        customMem = defaultCustomMem;
+
+    if (!customMem.customAlloc || !customMem.customFree)
+        return NULL;
+
+    dctx = (ZSTDv07_DCtx*) customMem.customAlloc(customMem.opaque, sizeof(ZSTDv07_DCtx));
+    if (!dctx) return NULL;
+    memcpy(&dctx->customMem, &customMem, sizeof(ZSTDv07_customMem));
+    ZSTDv07_decompressBegin(dctx);
+    return dctx;
+}
+
+ZSTDv07_DCtx* ZSTDv07_createDCtx(void)
+{
+    return ZSTDv07_createDCtx_advanced(defaultCustomMem);
+}
+
+size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx)
+{
+    if (dctx==NULL) return 0;   /* support free on NULL */
+    dctx->customMem.customFree(dctx->customMem.opaque, dctx);
+    return 0;   /* reserved as a potential error code in the future */
+}
+
+void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dstDCtx, const ZSTDv07_DCtx* srcDCtx)
+{
+    memcpy(dstDCtx, srcDCtx,
+           sizeof(ZSTDv07_DCtx) - (ZSTDv07_BLOCKSIZE_ABSOLUTEMAX+WILDCOPY_OVERLENGTH + ZSTDv07_frameHeaderSize_max));  /* no need to copy workspace */
+}
+
+
+/*-*************************************************************
+*   Decompression section
+***************************************************************/
+
+/* Frame format description
+   Frame Header -  [ Block Header - Block ] - Frame End
+   1) Frame Header
+      - 4 bytes - Magic Number : ZSTDv07_MAGICNUMBER (defined within zstd.h)
+      - 1 byte  - Frame Descriptor
+   2) Block Header
+      - 3 bytes, starting with a 2-bits descriptor
+                 Uncompressed, Compressed, Frame End, unused
+   3) Block
+      See Block Format Description
+   4) Frame End
+      - 3 bytes, compatible with Block Header
+*/
+
+
+/* Frame Header :
+
+   1 byte - FrameHeaderDescription :
+   bit 0-1 : dictID (0, 1, 2 or 4 bytes)
+   bit 2   : checksumFlag
+   bit 3   : reserved (must be zero)
+   bit 4   : reserved (unused, can be any value)
+   bit 5   : Single Segment (if 1, WindowLog byte is not present)
+   bit 6-7 : FrameContentFieldSize (0, 2, 4, or 8)
+             if (SkippedWindowLog && !FrameContentFieldsize) FrameContentFieldsize=1;
+
+   Optional : WindowLog (0 or 1 byte)
+   bit 0-2 : octal Fractional (1/8th)
+   bit 3-7 : Power of 2, with 0 = 1 KB (up to 2 TB)
+
+   Optional : dictID (0, 1, 2 or 4 bytes)
+   Automatic adaptation
+   0 : no dictID
+   1 : 1 - 255
+   2 : 256 - 65535
+   4 : all other values
+
+   Optional : content size (0, 1, 2, 4 or 8 bytes)
+   0 : unknown          (fcfs==0 and swl==0)
+   1 : 0-255 bytes      (fcfs==0 and swl==1)
+   2 : 256 - 65535+256  (fcfs==1)
+   4 : 0 - 4GB-1        (fcfs==2)
+   8 : 0 - 16EB-1       (fcfs==3)
+*/
+
+
+/* Compressed Block, format description
+
+   Block = Literal Section - Sequences Section
+   Prerequisite : size of (compressed) block, maximum size of regenerated data
+
+   1) Literal Section
+
+   1.1) Header : 1-5 bytes
+        flags: 2 bits
+            00 compressed by Huff0
+            01 unused
+            10 is Raw (uncompressed)
+            11 is Rle
+            Note : using 01 => Huff0 with precomputed table ?
+            Note : delta map ? => compressed ?
+
+   1.1.1) Huff0-compressed literal block : 3-5 bytes
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
+            srcSize < 1 KB => 3 bytes (2-2-10-10)
+            srcSize < 16KB => 4 bytes (2-2-14-14)
+            else           => 5 bytes (2-2-18-18)
+            big endian convention
+
+   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes
+        size :  5 bits: (IS_RAW<<6) + (0<<4) + size
+               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)
+                        size&255
+               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)
+                        size>>8&255
+                        size&255
+
+   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes
+        size :  5 bits: (IS_RLE<<6) + (0<<4) + size
+               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)
+                        size&255
+               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)
+                        size>>8&255
+                        size&255
+
+   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
+            srcSize < 1 KB => 3 bytes (2-2-10-10)
+            srcSize < 16KB => 4 bytes (2-2-14-14)
+            else           => 5 bytes (2-2-18-18)
+            big endian convention
+
+        1- CTable available (stored into workspace ?)
+        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)
+
+
+   1.2) Literal block content
+
+   1.2.1) Huff0 block, using sizes from header
+        See Huff0 format
+
+   1.2.2) Huff0 block, using prepared table
+
+   1.2.3) Raw content
+
+   1.2.4) single byte
+
+
+   2) Sequences section
+      TO DO
+*/
+
+/** ZSTDv07_frameHeaderSize() :
+*   srcSize must be >= ZSTDv07_frameHeaderSize_min.
+*   @return : size of the Frame Header */
+static size_t ZSTDv07_frameHeaderSize(const void* src, size_t srcSize)
+{
+    if (srcSize < ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong);
+    {   BYTE const fhd = ((const BYTE*)src)[4];
+        U32 const dictID= fhd & 3;
+        U32 const directMode = (fhd >> 5) & 1;
+        U32 const fcsId = fhd >> 6;
+        return ZSTDv07_frameHeaderSize_min + !directMode + ZSTDv07_did_fieldSize[dictID] + ZSTDv07_fcs_fieldSize[fcsId]
+                + (directMode && !ZSTDv07_fcs_fieldSize[fcsId]);
+    }
+}
+
+
+/** ZSTDv07_getFrameParams() :
+*   decode Frame Header, or require larger `srcSize`.
+*   @return : 0, `fparamsPtr` is correctly filled,
+*            >0, `srcSize` is too small, result is expected `srcSize`,
+*             or an error code, which can be tested using ZSTDv07_isError() */
+size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+
+    if (srcSize < ZSTDv07_frameHeaderSize_min) return ZSTDv07_frameHeaderSize_min;
+    memset(fparamsPtr, 0, sizeof(*fparamsPtr));
+    if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) {
+        if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) {
+            if (srcSize < ZSTDv07_skippableHeaderSize) return ZSTDv07_skippableHeaderSize; /* magic number + skippable frame length */
+            fparamsPtr->frameContentSize = MEM_readLE32((const char *)src + 4);
+            fparamsPtr->windowSize = 0; /* windowSize==0 means a frame is skippable */
+            return 0;
+        }
+        return ERROR(prefix_unknown);
+    }
+
+    /* ensure there is enough `srcSize` to fully read/decode frame header */
+    { size_t const fhsize = ZSTDv07_frameHeaderSize(src, srcSize);
+      if (srcSize < fhsize) return fhsize; }
+
+    {   BYTE const fhdByte = ip[4];
+        size_t pos = 5;
+        U32 const dictIDSizeCode = fhdByte&3;
+        U32 const checksumFlag = (fhdByte>>2)&1;
+        U32 const directMode = (fhdByte>>5)&1;
+        U32 const fcsID = fhdByte>>6;
+        U32 const windowSizeMax = 1U << ZSTDv07_WINDOWLOG_MAX;
+        U32 windowSize = 0;
+        U32 dictID = 0;
+        U64 frameContentSize = 0;
+        if ((fhdByte & 0x08) != 0)   /* reserved bits, which must be zero */
+            return ERROR(frameParameter_unsupported);
+        if (!directMode) {
+            BYTE const wlByte = ip[pos++];
+            U32 const windowLog = (wlByte >> 3) + ZSTDv07_WINDOWLOG_ABSOLUTEMIN;
+            if (windowLog > ZSTDv07_WINDOWLOG_MAX)
+                return ERROR(frameParameter_unsupported);
+            windowSize = (1U << windowLog);
+            windowSize += (windowSize >> 3) * (wlByte&7);
+        }
+
+        switch(dictIDSizeCode)
+        {
+            default:   /* impossible */
+            case 0 : break;
+            case 1 : dictID = ip[pos]; pos++; break;
+            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
+            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
+        }
+        switch(fcsID)
+        {
+            default:   /* impossible */
+            case 0 : if (directMode) frameContentSize = ip[pos]; break;
+            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
+            case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
+            case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
+        }
+        if (!windowSize) windowSize = (U32)frameContentSize;
+        if (windowSize > windowSizeMax)
+            return ERROR(frameParameter_unsupported);
+        fparamsPtr->frameContentSize = frameContentSize;
+        fparamsPtr->windowSize = windowSize;
+        fparamsPtr->dictID = dictID;
+        fparamsPtr->checksumFlag = checksumFlag;
+    }
+    return 0;
+}
+
+
+/** ZSTDv07_getDecompressedSize() :
+*   compatible with legacy mode
+*   @return : decompressed size if known, 0 otherwise
+              note : 0 can mean any of the following :
+                   - decompressed size is not provided within frame header
+                   - frame header unknown / not supported
+                   - frame header not completely provided (`srcSize` too small) */
+unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize)
+{
+    ZSTDv07_frameParams fparams;
+    size_t const frResult = ZSTDv07_getFrameParams(&fparams, src, srcSize);
+    if (frResult!=0) return 0;
+    return fparams.frameContentSize;
+}
+
+
+/** ZSTDv07_decodeFrameHeader() :
+*   `srcSize` must be the size provided by ZSTDv07_frameHeaderSize().
+*   @return : 0 if success, or an error code, which can be tested using ZSTDv07_isError() */
+static size_t ZSTDv07_decodeFrameHeader(ZSTDv07_DCtx* dctx, const void* src, size_t srcSize)
+{
+    size_t const result = ZSTDv07_getFrameParams(&(dctx->fParams), src, srcSize);
+    if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong);
+    if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);
+    return result;
+}
+
+
+typedef struct
+{
+    blockType_t blockType;
+    U32 origSize;
+} blockProperties_t;
+
+/*! ZSTDv07_getcBlockSize() :
+*   Provides the size of compressed block from block header `src` */
+static size_t ZSTDv07_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
+{
+    const BYTE* const in = (const BYTE* const)src;
+    U32 cSize;
+
+    if (srcSize < ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);
+
+    bpPtr->blockType = (blockType_t)((*in) >> 6);
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
+
+    if (bpPtr->blockType == bt_end) return 0;
+    if (bpPtr->blockType == bt_rle) return 1;
+    return cSize;
+}
+
+
+static size_t ZSTDv07_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
+    memcpy(dst, src, srcSize);
+    return srcSize;
+}
+
+
+/*! ZSTDv07_decodeLiteralsBlock() :
+    @return : nb of bytes read from src (< srcSize ) */
+static size_t ZSTDv07_decodeLiteralsBlock(ZSTDv07_DCtx* dctx,
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
+{
+    const BYTE* const istart = (const BYTE*) src;
+
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
+
+    switch((litBlockType_t)(istart[0]>> 6))
+    {
+    case lbt_huffman:
+        {   size_t litSize, litCSize, singleStream=0;
+            U32 lhSize = (istart[0] >> 4) & 3;
+            if (srcSize < 5) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for lhSize, + cSize (+nbSeq) */
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                /* 2 - 2 - 10 - 10 */
+                lhSize=3;
+                singleStream = istart[0] & 16;
+                litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
+                litCSize = ((istart[1] &  3) << 8) + istart[2];
+                break;
+            case 2:
+                /* 2 - 2 - 14 - 14 */
+                lhSize=4;
+                litSize  = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);
+                litCSize = ((istart[2] & 63) <<  8) + istart[3];
+                break;
+            case 3:
+                /* 2 - 2 - 18 - 18 */
+                lhSize=5;
+                litSize  = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);
+                litCSize = ((istart[2] &  3) << 16) + (istart[3] << 8) + istart[4];
+                break;
+            }
+            if (litSize > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
+
+            if (HUFv07_isError(singleStream ?
+                            HUFv07_decompress1X2_DCtx(dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) :
+                            HUFv07_decompress4X_hufOnly (dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
+                return ERROR(corruption_detected);
+
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            dctx->litEntropy = 1;
+            memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+            return litCSize + lhSize;
+        }
+    case lbt_repeat:
+        {   size_t litSize, litCSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            if (lhSize != 1)  /* only case supported for now : small litSize, single stream */
+                return ERROR(corruption_detected);
+            if (dctx->litEntropy==0)
+                return ERROR(dictionary_corrupted);
+
+            /* 2 - 2 - 10 - 10 */
+            lhSize=3;
+            litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
+            litCSize = ((istart[1] &  3) << 8) + istart[2];
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
+
+            {   size_t const errorCode = HUFv07_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTable);
+                if (HUFv07_isError(errorCode)) return ERROR(corruption_detected);
+            }
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+            return litCSize + lhSize;
+        }
+    case lbt_raw:
+        {   size_t litSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                lhSize=1;
+                litSize = istart[0] & 31;
+                break;
+            case 2:
+                litSize = ((istart[0] & 15) << 8) + istart[1];
+                break;
+            case 3:
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
+                break;
+            }
+
+            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
+                if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
+                memcpy(dctx->litBuffer, istart+lhSize, litSize);
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
+                return lhSize+litSize;
+            }
+            /* direct reference into compressed stream */
+            dctx->litPtr = istart+lhSize;
+            dctx->litSize = litSize;
+            return lhSize+litSize;
+        }
+    case lbt_rle:
+        {   size_t litSize;
+            U32 lhSize = ((istart[0]) >> 4) & 3;
+            switch(lhSize)
+            {
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
+                lhSize = 1;
+                litSize = istart[0] & 31;
+                break;
+            case 2:
+                litSize = ((istart[0] & 15) << 8) + istart[1];
+                break;
+            case 3:
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
+                if (srcSize<4) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
+                break;
+            }
+            if (litSize > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);
+            memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
+            dctx->litPtr = dctx->litBuffer;
+            dctx->litSize = litSize;
+            return lhSize+1;
+        }
+    default:
+        return ERROR(corruption_detected);   /* impossible */
+    }
+}
+
+
+/*! ZSTDv07_buildSeqTable() :
+    @return : nb bytes read from src,
+              or an error code if it fails, testable with ZSTDv07_isError()
+*/
+static size_t ZSTDv07_buildSeqTable(FSEv07_DTable* DTable, U32 type, U32 max, U32 maxLog,
+                                 const void* src, size_t srcSize,
+                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable)
+{
+    switch(type)
+    {
+    case FSEv07_ENCODING_RLE :
+        if (!srcSize) return ERROR(srcSize_wrong);
+        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
+        FSEv07_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */
+        return 1;
+    case FSEv07_ENCODING_RAW :
+        FSEv07_buildDTable(DTable, defaultNorm, max, defaultLog);
+        return 0;
+    case FSEv07_ENCODING_STATIC:
+        if (!flagRepeatTable) return ERROR(corruption_detected);
+        return 0;
+    default :   /* impossible */
+    case FSEv07_ENCODING_DYNAMIC :
+        {   U32 tableLog;
+            S16 norm[MaxSeq+1];
+            size_t const headerSize = FSEv07_readNCount(norm, &max, &tableLog, src, srcSize);
+            if (FSEv07_isError(headerSize)) return ERROR(corruption_detected);
+            if (tableLog > maxLog) return ERROR(corruption_detected);
+            FSEv07_buildDTable(DTable, norm, max, tableLog);
+            return headerSize;
+    }   }
+}
+
+
+static size_t ZSTDv07_decodeSeqHeaders(int* nbSeqPtr,
+                             FSEv07_DTable* DTableLL, FSEv07_DTable* DTableML, FSEv07_DTable* DTableOffb, U32 flagRepeatTable,
+                             const void* src, size_t srcSize)
+{
+    const BYTE* const istart = (const BYTE* const)src;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* ip = istart;
+
+    /* check */
+    if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);
+
+    /* SeqHead */
+    {   int nbSeq = *ip++;
+        if (!nbSeq) { *nbSeqPtr=0; return 1; }
+        if (nbSeq > 0x7F) {
+            if (nbSeq == 0xFF) {
+                if (ip+2 > iend) return ERROR(srcSize_wrong);
+                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
+            } else {
+                if (ip >= iend) return ERROR(srcSize_wrong);
+                nbSeq = ((nbSeq-0x80)<<8) + *ip++;
+            }
+        }
+        *nbSeqPtr = nbSeq;
+    }
+
+    /* FSE table descriptors */
+    if (ip + 4 > iend) return ERROR(srcSize_wrong); /* min : header byte + all 3 are "raw", hence no header, but at least xxLog bits per type */
+    {   U32 const LLtype  = *ip >> 6;
+        U32 const OFtype = (*ip >> 4) & 3;
+        U32 const MLtype  = (*ip >> 2) & 3;
+        ip++;
+
+        /* Build DTables */
+        {   size_t const llhSize = ZSTDv07_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable);
+            if (ZSTDv07_isError(llhSize)) return ERROR(corruption_detected);
+            ip += llhSize;
+        }
+        {   size_t const ofhSize = ZSTDv07_buildSeqTable(DTableOffb, OFtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable);
+            if (ZSTDv07_isError(ofhSize)) return ERROR(corruption_detected);
+            ip += ofhSize;
+        }
+        {   size_t const mlhSize = ZSTDv07_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable);
+            if (ZSTDv07_isError(mlhSize)) return ERROR(corruption_detected);
+            ip += mlhSize;
+    }   }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t matchLength;
+    size_t offset;
+} seq_t;
+
+typedef struct {
+    BITv07_DStream_t DStream;
+    FSEv07_DState_t stateLL;
+    FSEv07_DState_t stateOffb;
+    FSEv07_DState_t stateML;
+    size_t prevOffset[ZSTDv07_REP_INIT];
+} seqState_t;
+
+
+static seq_t ZSTDv07_decodeSequence(seqState_t* seqState)
+{
+    seq_t seq;
+
+    U32 const llCode = FSEv07_peekSymbol(&(seqState->stateLL));
+    U32 const mlCode = FSEv07_peekSymbol(&(seqState->stateML));
+    U32 const ofCode = FSEv07_peekSymbol(&(seqState->stateOffb));   /* <= maxOff, by table construction */
+
+    U32 const llBits = LL_bits[llCode];
+    U32 const mlBits = ML_bits[mlCode];
+    U32 const ofBits = ofCode;
+    U32 const totalBits = llBits+mlBits+ofBits;
+
+    static const U32 LL_base[MaxLL+1] = {
+                             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,   10,    11,    12,    13,    14,     15,
+                            16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
+                            0x2000, 0x4000, 0x8000, 0x10000 };
+
+    static const U32 ML_base[MaxML+1] = {
+                             3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,   14,    15,    16,    17,    18,
+                            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,   30,    31,    32,    33,    34,
+                            35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
+                            0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
+
+    static const U32 OF_base[MaxOff+1] = {
+                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,
+                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,
+                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
+                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD };
+
+    /* sequence */
+    {   size_t offset;
+        if (!ofCode)
+            offset = 0;
+        else {
+            offset = OF_base[ofCode] + BITv07_readBits(&(seqState->DStream), ofBits);   /* <=  (ZSTDv07_WINDOWLOG_MAX-1) bits */
+            if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream));
+        }
+
+        if (ofCode <= 1) {
+            if ((llCode == 0) & (offset <= 1)) offset = 1-offset;
+            if (offset) {
+                size_t const temp = seqState->prevOffset[offset];
+                if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
+                seqState->prevOffset[1] = seqState->prevOffset[0];
+                seqState->prevOffset[0] = offset = temp;
+            } else {
+                offset = seqState->prevOffset[0];
+            }
+        } else {
+            seqState->prevOffset[2] = seqState->prevOffset[1];
+            seqState->prevOffset[1] = seqState->prevOffset[0];
+            seqState->prevOffset[0] = offset;
+        }
+        seq.offset = offset;
+    }
+
+    seq.matchLength = ML_base[mlCode] + ((mlCode>31) ? BITv07_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */
+    if (MEM_32bits() && (mlBits+llBits>24)) BITv07_reloadDStream(&(seqState->DStream));
+
+    seq.litLength = LL_base[llCode] + ((llCode>15) ? BITv07_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */
+    if (MEM_32bits() ||
+       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv07_reloadDStream(&(seqState->DStream));
+
+    /* ANS state update */
+    FSEv07_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */
+    FSEv07_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */
+    if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream));     /* <= 18 bits */
+    FSEv07_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */
+
+    return seq;
+}
+
+
+static
+size_t ZSTDv07_execSequence(BYTE* op,
+                                BYTE* const oend, seq_t sequence,
+                                const BYTE** litPtr, const BYTE* const litLimit,
+                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
+{
+    BYTE* const oLitEnd = op + sequence.litLength;
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
+    BYTE* const oend_w = oend-WILDCOPY_OVERLENGTH;
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
+
+    /* check */
+    if ((oLitEnd>oend_w) | (oMatchEnd>oend)) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
+    if (iLitEnd > litLimit) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
+
+    /* copy Literals */
+    ZSTDv07_wildcopy(op, *litPtr, sequence.litLength);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
+    op = oLitEnd;
+    *litPtr = iLitEnd;   /* update for next sequence */
+
+    /* copy Match */
+    if (sequence.offset > (size_t)(oLitEnd - base)) {
+        /* offset beyond prefix */
+        if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
+        match = dictEnd - (base-match);
+        if (match + sequence.matchLength <= dictEnd) {
+            memmove(oLitEnd, match, sequence.matchLength);
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {   size_t const length1 = dictEnd - match;
+            memmove(oLitEnd, match, length1);
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = base;
+            if (op > oend_w || sequence.matchLength < MINMATCH) {
+              while (op < oMatchEnd) *op++ = *match++;
+              return sequenceLength;
+            }
+    }   }
+    /* Requirement: op <= oend_w */
+
+    /* match within prefix */
+    if (sequence.offset < 8) {
+        /* close range match, overlap */
+        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */
+        int const sub2 = dec64table[sequence.offset];
+        op[0] = match[0];
+        op[1] = match[1];
+        op[2] = match[2];
+        op[3] = match[3];
+        match += dec32table[sequence.offset];
+        ZSTDv07_copy4(op+4, match);
+        match -= sub2;
+    } else {
+        ZSTDv07_copy8(op, match);
+    }
+    op += 8; match += 8;
+
+    if (oMatchEnd > oend-(16-MINMATCH)) {
+        if (op < oend_w) {
+            ZSTDv07_wildcopy(op, match, oend_w - op);
+            match += oend_w - op;
+            op = oend_w;
+        }
+        while (op < oMatchEnd) *op++ = *match++;
+    } else {
+        ZSTDv07_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
+    }
+    return sequenceLength;
+}
+
+
+static size_t ZSTDv07_decompressSequences(
+                               ZSTDv07_DCtx* dctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize)
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* const oend = ostart + maxDstSize;
+    BYTE* op = ostart;
+    const BYTE* litPtr = dctx->litPtr;
+    const BYTE* const litEnd = litPtr + dctx->litSize;
+    FSEv07_DTable* DTableLL = dctx->LLTable;
+    FSEv07_DTable* DTableML = dctx->MLTable;
+    FSEv07_DTable* DTableOffb = dctx->OffTable;
+    const BYTE* const base = (const BYTE*) (dctx->base);
+    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
+    int nbSeq;
+
+    /* Build Decoding Tables */
+    {   size_t const seqHSize = ZSTDv07_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->fseEntropy, ip, seqSize);
+        if (ZSTDv07_isError(seqHSize)) return seqHSize;
+        ip += seqHSize;
+    }
+
+    /* Regen sequences */
+    if (nbSeq) {
+        seqState_t seqState;
+        dctx->fseEntropy = 1;
+        { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) seqState.prevOffset[i] = dctx->rep[i]; }
+        { size_t const errorCode = BITv07_initDStream(&(seqState.DStream), ip, iend-ip);
+          if (ERR_isError(errorCode)) return ERROR(corruption_detected); }
+        FSEv07_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
+        FSEv07_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
+        FSEv07_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
+
+        for ( ; (BITv07_reloadDStream(&(seqState.DStream)) <= BITv07_DStream_completed) && nbSeq ; ) {
+            nbSeq--;
+            {   seq_t const sequence = ZSTDv07_decodeSequence(&seqState);
+                size_t const oneSeqSize = ZSTDv07_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);
+                if (ZSTDv07_isError(oneSeqSize)) return oneSeqSize;
+                op += oneSeqSize;
+        }   }
+
+        /* check if reached exact end */
+        if (nbSeq) return ERROR(corruption_detected);
+        /* save reps for next block */
+        { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) dctx->rep[i] = (U32)(seqState.prevOffset[i]); }
+    }
+
+    /* last literal segment */
+    {   size_t const lastLLSize = litEnd - litPtr;
+        //if (litPtr > litEnd) return ERROR(corruption_detected);   /* too many literals already used */
+        if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
+        memcpy(op, litPtr, lastLLSize);
+        op += lastLLSize;
+    }
+
+    return op-ostart;
+}
+
+
+static void ZSTDv07_checkContinuity(ZSTDv07_DCtx* dctx, const void* dst)
+{
+    if (dst != dctx->previousDstEnd) {   /* not contiguous */
+        dctx->dictEnd = dctx->previousDstEnd;
+        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
+        dctx->base = dst;
+        dctx->previousDstEnd = dst;
+    }
+}
+
+
+static size_t ZSTDv07_decompressBlock_internal(ZSTDv07_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{   /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+
+    if (srcSize >= ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(srcSize_wrong);
+
+    /* Decode literals sub-block */
+    {   size_t const litCSize = ZSTDv07_decodeLiteralsBlock(dctx, src, srcSize);
+        if (ZSTDv07_isError(litCSize)) return litCSize;
+        ip += litCSize;
+        srcSize -= litCSize;
+    }
+    return ZSTDv07_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
+}
+
+
+size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{
+    size_t dSize;
+    ZSTDv07_checkContinuity(dctx, dst);
+    dSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
+    dctx->previousDstEnd = (char*)dst + dSize;
+    return dSize;
+}
+
+
+/** ZSTDv07_insertBlock() :
+    insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
+ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize)
+{
+    ZSTDv07_checkContinuity(dctx, blockStart);
+    dctx->previousDstEnd = (const char*)blockStart + blockSize;
+    return blockSize;
+}
+
+
+static size_t ZSTDv07_generateNxBytes(void* dst, size_t dstCapacity, BYTE byte, size_t length)
+{
+    if (length > dstCapacity) return ERROR(dstSize_tooSmall);
+    memset(dst, byte, length);
+    return length;
+}
+
+
+/*! ZSTDv07_decompressFrame() :
+*   `dctx` must be properly initialized */
+static size_t ZSTDv07_decompressFrame(ZSTDv07_DCtx* dctx,
+                                 void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize)
+{
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* const iend = ip + srcSize;
+    BYTE* const ostart = (BYTE* const)dst;
+    BYTE* const oend = ostart + dstCapacity;
+    BYTE* op = ostart;
+    size_t remainingSize = srcSize;
+
+    /* check */
+    if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);
+
+    /* Frame Header */
+    {   size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min);
+        if (ZSTDv07_isError(frameHeaderSize)) return frameHeaderSize;
+        if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);
+        if (ZSTDv07_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected);
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
+    }
+
+    /* Loop on each block */
+    while (1) {
+        size_t decodedSize;
+        blockProperties_t blockProperties;
+        size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, iend-ip, &blockProperties);
+        if (ZSTDv07_isError(cBlockSize)) return cBlockSize;
+
+        ip += ZSTDv07_blockHeaderSize;
+        remainingSize -= ZSTDv07_blockHeaderSize;
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
+
+        switch(blockProperties.blockType)
+        {
+        case bt_compressed:
+            decodedSize = ZSTDv07_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
+            break;
+        case bt_raw :
+            decodedSize = ZSTDv07_copyRawBlock(op, oend-op, ip, cBlockSize);
+            break;
+        case bt_rle :
+            decodedSize = ZSTDv07_generateNxBytes(op, oend-op, *ip, blockProperties.origSize);
+            break;
+        case bt_end :
+            /* end of frame */
+            if (remainingSize) return ERROR(srcSize_wrong);
+            decodedSize = 0;
+            break;
+        default:
+            return ERROR(GENERIC);   /* impossible */
+        }
+        if (blockProperties.blockType == bt_end) break;   /* bt_end */
+
+        if (ZSTDv07_isError(decodedSize)) return decodedSize;
+        if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize);
+        op += decodedSize;
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+    }
+
+    return op-ostart;
+}
+
+
+/*! ZSTDv07_decompress_usingPreparedDCtx() :
+*   Same as ZSTDv07_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded.
+*   It avoids reloading the dictionary each time.
+*   `preparedDCtx` must have been properly initialized using ZSTDv07_decompressBegin_usingDict().
+*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */
+static size_t ZSTDv07_decompress_usingPreparedDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* refDCtx,
+                                         void* dst, size_t dstCapacity,
+                                   const void* src, size_t srcSize)
+{
+    ZSTDv07_copyDCtx(dctx, refDCtx);
+    ZSTDv07_checkContinuity(dctx, dst);
+    return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
+}
+
+
+size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,
+                                 void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize,
+                                 const void* dict, size_t dictSize)
+{
+    ZSTDv07_decompressBegin_usingDict(dctx, dict, dictSize);
+    ZSTDv07_checkContinuity(dctx, dst);
+    return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
+}
+
+
+size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    return ZSTDv07_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);
+}
+
+
+size_t ZSTDv07_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+#if defined(ZSTDv07_HEAPMODE) && (ZSTDv07_HEAPMODE==1)
+    size_t regenSize;
+    ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx();
+    if (dctx==NULL) return ERROR(memory_allocation);
+    regenSize = ZSTDv07_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
+    ZSTDv07_freeDCtx(dctx);
+    return regenSize;
+#else   /* stack mode */
+    ZSTDv07_DCtx dctx;
+    return ZSTDv07_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
+#endif
+}
+
+/* ZSTD_errorFrameSizeInfoLegacy() :
+   assumes `cSize` and `dBound` are _not_ NULL */
+static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
+{
+    *cSize = ret;
+    *dBound = ZSTD_CONTENTSIZE_ERROR;
+}
+
+void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
+{
+    const BYTE* ip = (const BYTE*)src;
+    size_t remainingSize = srcSize;
+    size_t nbBlocks = 0;
+
+    /* check */
+    if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) {
+        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+        return;
+    }
+
+    /* Frame Header */
+    {   size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, srcSize);
+        if (ZSTDv07_isError(frameHeaderSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, frameHeaderSize);
+            return;
+        }
+        if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));
+            return;
+        }
+        if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
+    }
+
+    /* Loop on each block */
+    while (1) {
+        blockProperties_t blockProperties;
+        size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, remainingSize, &blockProperties);
+        if (ZSTDv07_isError(cBlockSize)) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, cBlockSize);
+            return;
+        }
+
+        ip += ZSTDv07_blockHeaderSize;
+        remainingSize -= ZSTDv07_blockHeaderSize;
+
+        if (blockProperties.blockType == bt_end) break;
+
+        if (cBlockSize > remainingSize) {
+            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
+            return;
+        }
+
+        ip += cBlockSize;
+        remainingSize -= cBlockSize;
+        nbBlocks++;
+    }
+
+    *cSize = ip - (const BYTE*)src;
+    *dBound = nbBlocks * ZSTDv07_BLOCKSIZE_ABSOLUTEMAX;
+}
+
+/*_******************************
+*  Streaming Decompression API
+********************************/
+size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx)
+{
+    return dctx->expected;
+}
+
+int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx)
+{
+    return dctx->stage == ZSTDds_skipFrame;
+}
+
+/** ZSTDv07_decompressContinue() :
+*   @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
+*             or an error code, which can be tested using ZSTDv07_isError() */
+size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    /* Sanity check */
+    if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
+    if (dstCapacity) ZSTDv07_checkContinuity(dctx, dst);
+
+    switch (dctx->stage)
+    {
+    case ZSTDds_getFrameHeaderSize :
+        if (srcSize != ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
+        if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) {
+            memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);
+            dctx->expected = ZSTDv07_skippableHeaderSize - ZSTDv07_frameHeaderSize_min; /* magic number + skippable frame length */
+            dctx->stage = ZSTDds_decodeSkippableHeader;
+            return 0;
+        }
+        dctx->headerSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min);
+        if (ZSTDv07_isError(dctx->headerSize)) return dctx->headerSize;
+        memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);
+        if (dctx->headerSize > ZSTDv07_frameHeaderSize_min) {
+            dctx->expected = dctx->headerSize - ZSTDv07_frameHeaderSize_min;
+            dctx->stage = ZSTDds_decodeFrameHeader;
+            return 0;
+        }
+        dctx->expected = 0;   /* not necessary to copy more */
+	/* fall-through */
+    case ZSTDds_decodeFrameHeader:
+        {   size_t result;
+            memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);
+            result = ZSTDv07_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);
+            if (ZSTDv07_isError(result)) return result;
+            dctx->expected = ZSTDv07_blockHeaderSize;
+            dctx->stage = ZSTDds_decodeBlockHeader;
+            return 0;
+        }
+    case ZSTDds_decodeBlockHeader:
+        {   blockProperties_t bp;
+            size_t const cBlockSize = ZSTDv07_getcBlockSize(src, ZSTDv07_blockHeaderSize, &bp);
+            if (ZSTDv07_isError(cBlockSize)) return cBlockSize;
+            if (bp.blockType == bt_end) {
+                if (dctx->fParams.checksumFlag) {
+                    U64 const h64 = XXH64_digest(&dctx->xxhState);
+                    U32 const h32 = (U32)(h64>>11) & ((1<<22)-1);
+                    const BYTE* const ip = (const BYTE*)src;
+                    U32 const check32 = ip[2] + (ip[1] << 8) + ((ip[0] & 0x3F) << 16);
+                    if (check32 != h32) return ERROR(checksum_wrong);
+                }
+                dctx->expected = 0;
+                dctx->stage = ZSTDds_getFrameHeaderSize;
+            } else {
+                dctx->expected = cBlockSize;
+                dctx->bType = bp.blockType;
+                dctx->stage = ZSTDds_decompressBlock;
+            }
+            return 0;
+        }
+    case ZSTDds_decompressBlock:
+        {   size_t rSize;
+            switch(dctx->bType)
+            {
+            case bt_compressed:
+                rSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
+                break;
+            case bt_raw :
+                rSize = ZSTDv07_copyRawBlock(dst, dstCapacity, src, srcSize);
+                break;
+            case bt_rle :
+                return ERROR(GENERIC);   /* not yet handled */
+                break;
+            case bt_end :   /* should never happen (filtered at phase 1) */
+                rSize = 0;
+                break;
+            default:
+                return ERROR(GENERIC);   /* impossible */
+            }
+            dctx->stage = ZSTDds_decodeBlockHeader;
+            dctx->expected = ZSTDv07_blockHeaderSize;
+            dctx->previousDstEnd = (char*)dst + rSize;
+            if (ZSTDv07_isError(rSize)) return rSize;
+            if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize);
+            return rSize;
+        }
+    case ZSTDds_decodeSkippableHeader:
+        {   memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);
+            dctx->expected = MEM_readLE32(dctx->headerBuffer + 4);
+            dctx->stage = ZSTDds_skipFrame;
+            return 0;
+        }
+    case ZSTDds_skipFrame:
+        {   dctx->expected = 0;
+            dctx->stage = ZSTDds_getFrameHeaderSize;
+            return 0;
+        }
+    default:
+        return ERROR(GENERIC);   /* impossible */
+    }
+}
+
+
+static size_t ZSTDv07_refDictContent(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    dctx->dictEnd = dctx->previousDstEnd;
+    dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
+    dctx->base = dict;
+    dctx->previousDstEnd = (const char*)dict + dictSize;
+    return 0;
+}
+
+static size_t ZSTDv07_loadEntropy(ZSTDv07_DCtx* dctx, const void* const dict, size_t const dictSize)
+{
+    const BYTE* dictPtr = (const BYTE*)dict;
+    const BYTE* const dictEnd = dictPtr + dictSize;
+
+    {   size_t const hSize = HUFv07_readDTableX4(dctx->hufTable, dict, dictSize);
+        if (HUFv07_isError(hSize)) return ERROR(dictionary_corrupted);
+        dictPtr += hSize;
+    }
+
+    {   short offcodeNCount[MaxOff+1];
+        U32 offcodeMaxValue=MaxOff, offcodeLog;
+        size_t const offcodeHeaderSize = FSEv07_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
+        if (FSEv07_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
+        if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
+        { size_t const errorCode = FSEv07_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);
+          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }
+        dictPtr += offcodeHeaderSize;
+    }
+
+    {   short matchlengthNCount[MaxML+1];
+        unsigned matchlengthMaxValue = MaxML, matchlengthLog;
+        size_t const matchlengthHeaderSize = FSEv07_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
+        if (FSEv07_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
+        { size_t const errorCode = FSEv07_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
+          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }
+        dictPtr += matchlengthHeaderSize;
+    }
+
+    {   short litlengthNCount[MaxLL+1];
+        unsigned litlengthMaxValue = MaxLL, litlengthLog;
+        size_t const litlengthHeaderSize = FSEv07_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
+        if (FSEv07_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
+        { size_t const errorCode = FSEv07_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
+          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }
+        dictPtr += litlengthHeaderSize;
+    }
+
+    if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);
+    dctx->rep[0] = MEM_readLE32(dictPtr+0); if (dctx->rep[0] == 0 || dctx->rep[0] >= dictSize) return ERROR(dictionary_corrupted);
+    dctx->rep[1] = MEM_readLE32(dictPtr+4); if (dctx->rep[1] == 0 || dctx->rep[1] >= dictSize) return ERROR(dictionary_corrupted);
+    dctx->rep[2] = MEM_readLE32(dictPtr+8); if (dctx->rep[2] == 0 || dctx->rep[2] >= dictSize) return ERROR(dictionary_corrupted);
+    dictPtr += 12;
+
+    dctx->litEntropy = dctx->fseEntropy = 1;
+    return dictPtr - (const BYTE*)dict;
+}
+
+static size_t ZSTDv07_decompress_insertDictionary(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    if (dictSize < 8) return ZSTDv07_refDictContent(dctx, dict, dictSize);
+    {   U32 const magic = MEM_readLE32(dict);
+        if (magic != ZSTDv07_DICT_MAGIC) {
+            return ZSTDv07_refDictContent(dctx, dict, dictSize);   /* pure content mode */
+    }   }
+    dctx->dictID = MEM_readLE32((const char*)dict + 4);
+
+    /* load entropy tables */
+    dict = (const char*)dict + 8;
+    dictSize -= 8;
+    {   size_t const eSize = ZSTDv07_loadEntropy(dctx, dict, dictSize);
+        if (ZSTDv07_isError(eSize)) return ERROR(dictionary_corrupted);
+        dict = (const char*)dict + eSize;
+        dictSize -= eSize;
+    }
+
+    /* reference dictionary content */
+    return ZSTDv07_refDictContent(dctx, dict, dictSize);
+}
+
+
+size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
+{
+    { size_t const errorCode = ZSTDv07_decompressBegin(dctx);
+      if (ZSTDv07_isError(errorCode)) return errorCode; }
+
+    if (dict && dictSize) {
+        size_t const errorCode = ZSTDv07_decompress_insertDictionary(dctx, dict, dictSize);
+        if (ZSTDv07_isError(errorCode)) return ERROR(dictionary_corrupted);
+    }
+
+    return 0;
+}
+
+
+struct ZSTDv07_DDict_s {
+    void* dict;
+    size_t dictSize;
+    ZSTDv07_DCtx* refContext;
+};  /* typedef'd tp ZSTDv07_CDict within zstd.h */
+
+static ZSTDv07_DDict* ZSTDv07_createDDict_advanced(const void* dict, size_t dictSize, ZSTDv07_customMem customMem)
+{
+    if (!customMem.customAlloc && !customMem.customFree)
+        customMem = defaultCustomMem;
+
+    if (!customMem.customAlloc || !customMem.customFree)
+        return NULL;
+
+    {   ZSTDv07_DDict* const ddict = (ZSTDv07_DDict*) customMem.customAlloc(customMem.opaque, sizeof(*ddict));
+        void* const dictContent = customMem.customAlloc(customMem.opaque, dictSize);
+        ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx_advanced(customMem);
+
+        if (!dictContent || !ddict || !dctx) {
+            customMem.customFree(customMem.opaque, dictContent);
+            customMem.customFree(customMem.opaque, ddict);
+            customMem.customFree(customMem.opaque, dctx);
+            return NULL;
+        }
+
+        memcpy(dictContent, dict, dictSize);
+        {   size_t const errorCode = ZSTDv07_decompressBegin_usingDict(dctx, dictContent, dictSize);
+            if (ZSTDv07_isError(errorCode)) {
+                customMem.customFree(customMem.opaque, dictContent);
+                customMem.customFree(customMem.opaque, ddict);
+                customMem.customFree(customMem.opaque, dctx);
+                return NULL;
+        }   }
+
+        ddict->dict = dictContent;
+        ddict->dictSize = dictSize;
+        ddict->refContext = dctx;
+        return ddict;
+    }
+}
+
+/*! ZSTDv07_createDDict() :
+*   Create a digested dictionary, ready to start decompression without startup delay.
+*   `dict` can be released after `ZSTDv07_DDict` creation */
+ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize)
+{
+    ZSTDv07_customMem const allocator = { NULL, NULL, NULL };
+    return ZSTDv07_createDDict_advanced(dict, dictSize, allocator);
+}
+
+size_t ZSTDv07_freeDDict(ZSTDv07_DDict* ddict)
+{
+    ZSTDv07_freeFunction const cFree = ddict->refContext->customMem.customFree;
+    void* const opaque = ddict->refContext->customMem.opaque;
+    ZSTDv07_freeDCtx(ddict->refContext);
+    cFree(opaque, ddict->dict);
+    cFree(opaque, ddict);
+    return 0;
+}
+
+/*! ZSTDv07_decompress_usingDDict() :
+*   Decompression using a pre-digested Dictionary
+*   Use dictionary without significant overhead. */
+ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,
+                                           void* dst, size_t dstCapacity,
+                                     const void* src, size_t srcSize,
+                                     const ZSTDv07_DDict* ddict)
+{
+    return ZSTDv07_decompress_usingPreparedDCtx(dctx, ddict->refContext,
+                                           dst, dstCapacity,
+                                           src, srcSize);
+}
+/*
+    Buffered version of Zstd compression library
+    Copyright (C) 2015-2016, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+    - zstd homepage : http://www.zstd.net/
+*/
+
+
+
+/*-***************************************************************************
+*  Streaming decompression howto
+*
+*  A ZBUFFv07_DCtx object is required to track streaming operations.
+*  Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources.
+*  Use ZBUFFv07_decompressInit() to start a new decompression operation,
+*   or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary.
+*  Note that ZBUFFv07_DCtx objects can be re-init multiple times.
+*
+*  Use ZBUFFv07_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
+*  The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change @dst.
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
+*            or 0 when a frame is completely decoded,
+*            or an error code, which can be tested using ZBUFFv07_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize()
+*  output : ZBUFFv07_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
+*  input  : ZBUFFv07_recommendedDInSize == 128KB + 3;
+*           just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* *******************************************************************************/
+
+typedef enum { ZBUFFds_init, ZBUFFds_loadHeader,
+               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv07_dStage;
+
+/* *** Resource management *** */
+struct ZBUFFv07_DCtx_s {
+    ZSTDv07_DCtx* zd;
+    ZSTDv07_frameParams fParams;
+    ZBUFFv07_dStage stage;
+    char*  inBuff;
+    size_t inBuffSize;
+    size_t inPos;
+    char*  outBuff;
+    size_t outBuffSize;
+    size_t outStart;
+    size_t outEnd;
+    size_t blockSize;
+    BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX];
+    size_t lhSize;
+    ZSTDv07_customMem customMem;
+};   /* typedef'd to ZBUFFv07_DCtx within "zstd_buffered.h" */
+
+ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem);
+
+ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void)
+{
+    return ZBUFFv07_createDCtx_advanced(defaultCustomMem);
+}
+
+ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem)
+{
+    ZBUFFv07_DCtx* zbd;
+
+    if (!customMem.customAlloc && !customMem.customFree)
+        customMem = defaultCustomMem;
+
+    if (!customMem.customAlloc || !customMem.customFree)
+        return NULL;
+
+    zbd = (ZBUFFv07_DCtx*)customMem.customAlloc(customMem.opaque, sizeof(ZBUFFv07_DCtx));
+    if (zbd==NULL) return NULL;
+    memset(zbd, 0, sizeof(ZBUFFv07_DCtx));
+    memcpy(&zbd->customMem, &customMem, sizeof(ZSTDv07_customMem));
+    zbd->zd = ZSTDv07_createDCtx_advanced(customMem);
+    if (zbd->zd == NULL) { ZBUFFv07_freeDCtx(zbd); return NULL; }
+    zbd->stage = ZBUFFds_init;
+    return zbd;
+}
+
+size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* zbd)
+{
+    if (zbd==NULL) return 0;   /* support free on null */
+    ZSTDv07_freeDCtx(zbd->zd);
+    if (zbd->inBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff);
+    if (zbd->outBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff);
+    zbd->customMem.customFree(zbd->customMem.opaque, zbd);
+    return 0;
+}
+
+
+/* *** Initialization *** */
+
+size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* zbd, const void* dict, size_t dictSize)
+{
+    zbd->stage = ZBUFFds_loadHeader;
+    zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0;
+    return ZSTDv07_decompressBegin_usingDict(zbd->zd, dict, dictSize);
+}
+
+size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* zbd)
+{
+    return ZBUFFv07_decompressInitDictionary(zbd, NULL, 0);
+}
+
+
+/* internal util function */
+MEM_STATIC size_t ZBUFFv07_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    size_t const length = MIN(dstCapacity, srcSize);
+    memcpy(dst, src, length);
+    return length;
+}
+
+
+/* *** Decompression *** */
+
+size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* zbd,
+                                void* dst, size_t* dstCapacityPtr,
+                          const void* src, size_t* srcSizePtr)
+{
+    const char* const istart = (const char*)src;
+    const char* const iend = istart + *srcSizePtr;
+    const char* ip = istart;
+    char* const ostart = (char*)dst;
+    char* const oend = ostart + *dstCapacityPtr;
+    char* op = ostart;
+    U32 notDone = 1;
+
+    while (notDone) {
+        switch(zbd->stage)
+        {
+        case ZBUFFds_init :
+            return ERROR(init_missing);
+
+        case ZBUFFds_loadHeader :
+            {   size_t const hSize = ZSTDv07_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize);
+                if (ZSTDv07_isError(hSize)) return hSize;
+                if (hSize != 0) {
+                    size_t const toLoad = hSize - zbd->lhSize;   /* if hSize!=0, hSize > zbd->lhSize */
+                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */
+                        memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip);
+                        zbd->lhSize += iend-ip;
+                        *dstCapacityPtr = 0;
+                        return (hSize - zbd->lhSize) + ZSTDv07_blockHeaderSize;   /* remaining header bytes + next block header */
+                    }
+                    memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad;
+                    break;
+            }   }
+
+            /* Consume header */
+            {   size_t const h1Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);  /* == ZSTDv07_frameHeaderSize_min */
+                size_t const h1Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size);
+                if (ZSTDv07_isError(h1Result)) return h1Result;
+                if (h1Size < zbd->lhSize) {   /* long header */
+                    size_t const h2Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
+                    size_t const h2Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size);
+                    if (ZSTDv07_isError(h2Result)) return h2Result;
+            }   }
+
+            zbd->fParams.windowSize = MAX(zbd->fParams.windowSize, 1U << ZSTDv07_WINDOWLOG_ABSOLUTEMIN);
+
+            /* Frame header instruct buffer sizes */
+            {   size_t const blockSize = MIN(zbd->fParams.windowSize, ZSTDv07_BLOCKSIZE_ABSOLUTEMAX);
+                zbd->blockSize = blockSize;
+                if (zbd->inBuffSize < blockSize) {
+                    zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff);
+                    zbd->inBuffSize = blockSize;
+                    zbd->inBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, blockSize);
+                    if (zbd->inBuff == NULL) return ERROR(memory_allocation);
+                }
+                {   size_t const neededOutSize = zbd->fParams.windowSize + blockSize + WILDCOPY_OVERLENGTH * 2;
+                    if (zbd->outBuffSize < neededOutSize) {
+                        zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff);
+                        zbd->outBuffSize = neededOutSize;
+                        zbd->outBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, neededOutSize);
+                        if (zbd->outBuff == NULL) return ERROR(memory_allocation);
+            }   }   }
+            zbd->stage = ZBUFFds_read;
+            /* pass-through */
+	    /* fall-through */
+        case ZBUFFds_read:
+            {   size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
+                if (neededInSize==0) {  /* end of frame */
+                    zbd->stage = ZBUFFds_init;
+                    notDone = 0;
+                    break;
+                }
+                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */
+                    const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd);
+                    size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd,
+                        zbd->outBuff + zbd->outStart, (isSkipFrame ? 0 : zbd->outBuffSize - zbd->outStart),
+                        ip, neededInSize);
+                    if (ZSTDv07_isError(decodedSize)) return decodedSize;
+                    ip += neededInSize;
+                    if (!decodedSize && !isSkipFrame) break;   /* this was just a header */
+                    zbd->outEnd = zbd->outStart +  decodedSize;
+                    zbd->stage = ZBUFFds_flush;
+                    break;
+                }
+                if (ip==iend) { notDone = 0; break; }   /* no more input */
+                zbd->stage = ZBUFFds_load;
+            }
+	    /* fall-through */
+        case ZBUFFds_load:
+            {   size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
+                size_t const toLoad = neededInSize - zbd->inPos;   /* should always be <= remaining space within inBuff */
+                size_t loadedSize;
+                if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected);   /* should never happen */
+                loadedSize = ZBUFFv07_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip);
+                ip += loadedSize;
+                zbd->inPos += loadedSize;
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
+
+                /* decode loaded input */
+                {  const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd);
+                   size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd,
+                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,
+                        zbd->inBuff, neededInSize);
+                    if (ZSTDv07_isError(decodedSize)) return decodedSize;
+                    zbd->inPos = 0;   /* input is consumed */
+                    if (!decodedSize && !isSkipFrame) { zbd->stage = ZBUFFds_read; break; }   /* this was just a header */
+                    zbd->outEnd = zbd->outStart +  decodedSize;
+                    zbd->stage = ZBUFFds_flush;
+                    /* break; */
+                    /* pass-through */
+                }
+	    }
+	    /* fall-through */
+        case ZBUFFds_flush:
+            {   size_t const toFlushSize = zbd->outEnd - zbd->outStart;
+                size_t const flushedSize = ZBUFFv07_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize);
+                op += flushedSize;
+                zbd->outStart += flushedSize;
+                if (flushedSize == toFlushSize) {
+                    zbd->stage = ZBUFFds_read;
+                    if (zbd->outStart + zbd->blockSize > zbd->outBuffSize)
+                        zbd->outStart = zbd->outEnd = 0;
+                    break;
+                }
+                /* cannot flush everything */
+                notDone = 0;
+                break;
+            }
+        default: return ERROR(GENERIC);   /* impossible */
+    }   }
+
+    /* result */
+    *srcSizePtr = ip-istart;
+    *dstCapacityPtr = op-ostart;
+    {   size_t nextSrcSizeHint = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
+        nextSrcSizeHint -= zbd->inPos;   /* already loaded*/
+        return nextSrcSizeHint;
+    }
+}
+
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+size_t ZBUFFv07_recommendedDInSize(void)  { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + ZSTDv07_blockHeaderSize /* block header size*/ ; }
+size_t ZBUFFv07_recommendedDOutSize(void) { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX; }
diff --git a/src/zstd_v07.h b/src/zstd_v07.h
new file mode 100644
index 0000000..a566c1d
--- /dev/null
+++ b/src/zstd_v07.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTDv07_H_235446
+#define ZSTDv07_H_235446
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*======  Dependency  ======*/
+#include <stddef.h>   /* size_t */
+
+
+/*======  Export for Windows  ======*/
+/*!
+*  ZSTDv07_DLL_EXPORT :
+*  Enable exporting of functions when building a Windows DLL
+*/
+#if defined(_WIN32) && defined(ZSTDv07_DLL_EXPORT) && (ZSTDv07_DLL_EXPORT==1)
+#  define ZSTDLIBv07_API __declspec(dllexport)
+#else
+#  define ZSTDLIBv07_API
+#endif
+
+
+/* *************************************
+*  Simple API
+***************************************/
+/*! ZSTDv07_getDecompressedSize() :
+*   @return : decompressed size if known, 0 otherwise.
+       note 1 : if `0`, follow up with ZSTDv07_getFrameParams() to know precise failure cause.
+       note 2 : decompressed size could be wrong or intentionally modified !
+                always ensure results fit within application's authorized limits */
+unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize);
+
+/*! ZSTDv07_decompress() :
+    `compressedSize` : must be _exact_ size of compressed input, otherwise decompression will fail.
+    `dstCapacity` must be equal or larger than originalSize.
+    @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
+              or an errorCode if it fails (which can be tested using ZSTDv07_isError()) */
+ZSTDLIBv07_API size_t ZSTDv07_decompress( void* dst, size_t dstCapacity,
+                                    const void* src, size_t compressedSize);
+
+/**
+ZSTDv07_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.7.x format
+    srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
+    cSize (output parameter)  : the number of bytes that would be read to decompress this frame
+                                or an error code if it fails (which can be tested using ZSTDv01_isError())
+    dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
+                                or ZSTD_CONTENTSIZE_ERROR if an error occurs
+
+    note : assumes `cSize` and `dBound` are _not_ NULL.
+*/
+void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
+                                     size_t* cSize, unsigned long long* dBound);
+
+/*======  Helper functions  ======*/
+ZSTDLIBv07_API unsigned    ZSTDv07_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
+ZSTDLIBv07_API const char* ZSTDv07_getErrorName(size_t code);     /*!< provides readable string from an error code */
+
+
+/*-*************************************
+*  Explicit memory management
+***************************************/
+/** Decompression context */
+typedef struct ZSTDv07_DCtx_s ZSTDv07_DCtx;
+ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx(void);
+ZSTDLIBv07_API size_t     ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx);      /*!< @return : errorCode */
+
+/** ZSTDv07_decompressDCtx() :
+*   Same as ZSTDv07_decompress(), requires an allocated ZSTDv07_DCtx (see ZSTDv07_createDCtx()) */
+ZSTDLIBv07_API size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
+/*-************************
+*  Simple dictionary API
+***************************/
+/*! ZSTDv07_decompress_usingDict() :
+*   Decompression using a pre-defined Dictionary content (see dictBuilder).
+*   Dictionary must be identical to the one used during compression.
+*   Note : This function load the dictionary, resulting in a significant startup time */
+ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,
+                                                   void* dst, size_t dstCapacity,
+                                             const void* src, size_t srcSize,
+                                             const void* dict,size_t dictSize);
+
+
+/*-**************************
+*  Advanced Dictionary API
+****************************/
+/*! ZSTDv07_createDDict() :
+*   Create a digested dictionary, ready to start decompression operation without startup delay.
+*   `dict` can be released after creation */
+typedef struct ZSTDv07_DDict_s ZSTDv07_DDict;
+ZSTDLIBv07_API ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize);
+ZSTDLIBv07_API size_t      ZSTDv07_freeDDict(ZSTDv07_DDict* ddict);
+
+/*! ZSTDv07_decompress_usingDDict() :
+*   Decompression using a pre-digested Dictionary
+*   Faster startup than ZSTDv07_decompress_usingDict(), recommended when same dictionary is used multiple times. */
+ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,
+                                                    void* dst, size_t dstCapacity,
+                                              const void* src, size_t srcSize,
+                                              const ZSTDv07_DDict* ddict);
+
+typedef struct {
+    unsigned long long frameContentSize;
+    unsigned windowSize;
+    unsigned dictID;
+    unsigned checksumFlag;
+} ZSTDv07_frameParams;
+
+ZSTDLIBv07_API size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
+
+
+
+
+/* *************************************
+*  Streaming functions
+***************************************/
+typedef struct ZBUFFv07_DCtx_s ZBUFFv07_DCtx;
+ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void);
+ZSTDLIBv07_API size_t      ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* dctx);
+
+ZSTDLIBv07_API size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* dctx);
+ZSTDLIBv07_API size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* dctx, const void* dict, size_t dictSize);
+
+ZSTDLIBv07_API size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* dctx,
+                                            void* dst, size_t* dstCapacityPtr,
+                                      const void* src, size_t* srcSizePtr);
+
+/*-***************************************************************************
+*  Streaming decompression howto
+*
+*  A ZBUFFv07_DCtx object is required to track streaming operations.
+*  Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources.
+*  Use ZBUFFv07_decompressInit() to start a new decompression operation,
+*   or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary.
+*  Note that ZBUFFv07_DCtx objects can be re-init multiple times.
+*
+*  Use ZBUFFv07_decompressContinue() repetitively to consume your input.
+*  *srcSizePtr and *dstCapacityPtr can be any size.
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
+*            or 0 when a frame is completely decoded,
+*            or an error code, which can be tested using ZBUFFv07_isError().
+*
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize()
+*  output : ZBUFFv07_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
+*  input  : ZBUFFv07_recommendedDInSize == 128KB + 3;
+*           just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
+* *******************************************************************************/
+
+
+/* *************************************
+*  Tool functions
+***************************************/
+ZSTDLIBv07_API unsigned ZBUFFv07_isError(size_t errorCode);
+ZSTDLIBv07_API const char* ZBUFFv07_getErrorName(size_t errorCode);
+
+/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
+*   These sizes are just hints, they tend to offer better latency */
+ZSTDLIBv07_API size_t ZBUFFv07_recommendedDInSize(void);
+ZSTDLIBv07_API size_t ZBUFFv07_recommendedDOutSize(void);
+
+
+/*-*************************************
+*  Constants
+***************************************/
+#define ZSTDv07_MAGICNUMBER            0xFD2FB527   /* v0.7 */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  /* ZSTDv07_H_235446 */
diff --git a/src/zstdmt_compress.c b/src/zstdmt_compress.c
new file mode 100644
index 0000000..9e537b8
--- /dev/null
+++ b/src/zstdmt_compress.c
@@ -0,0 +1,2110 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/* ======   Compiler specifics   ====== */
+#if defined(_MSC_VER)
+#  pragma warning(disable : 4204)   /* disable: C4204: non-constant aggregate initializer */
+#endif
+
+
+/* ======   Constants   ====== */
+#define ZSTDMT_OVERLAPLOG_DEFAULT 0
+
+
+/* ======   Dependencies   ====== */
+#include <string.h>      /* memcpy, memset */
+#include <limits.h>      /* INT_MAX, UINT_MAX */
+#include "mem.h"         /* MEM_STATIC */
+#include "pool.h"        /* threadpool */
+#include "threading.h"   /* mutex */
+#include "zstd_compress_internal.h"  /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */
+#include "zstd_ldm.h"
+#include "zstdmt_compress.h"
+
+/* Guards code to support resizing the SeqPool.
+ * We will want to resize the SeqPool to save memory in the future.
+ * Until then, comment the code out since it is unused.
+ */
+#define ZSTD_RESIZE_SEQPOOL 0
+
+/* ======   Debug   ====== */
+#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=2) \
+    && !defined(_MSC_VER) \
+    && !defined(__MINGW32__)
+
+#  include <stdio.h>
+#  include <unistd.h>
+#  include <sys/times.h>
+
+#  define DEBUG_PRINTHEX(l,p,n) {            \
+    unsigned debug_u;                        \
+    for (debug_u=0; debug_u<(n); debug_u++)  \
+        RAWLOG(l, "%02X ", ((const unsigned char*)(p))[debug_u]); \
+    RAWLOG(l, " \n");                        \
+}
+
+static unsigned long long GetCurrentClockTimeMicroseconds(void)
+{
+   static clock_t _ticksPerSecond = 0;
+   if (_ticksPerSecond <= 0) _ticksPerSecond = sysconf(_SC_CLK_TCK);
+
+   {   struct tms junk; clock_t newTicks = (clock_t) times(&junk);
+       return ((((unsigned long long)newTicks)*(1000000))/_ticksPerSecond);
+}  }
+
+#define MUTEX_WAIT_TIME_DLEVEL 6
+#define ZSTD_PTHREAD_MUTEX_LOCK(mutex) {          \
+    if (DEBUGLEVEL >= MUTEX_WAIT_TIME_DLEVEL) {   \
+        unsigned long long const beforeTime = GetCurrentClockTimeMicroseconds(); \
+        ZSTD_pthread_mutex_lock(mutex);           \
+        {   unsigned long long const afterTime = GetCurrentClockTimeMicroseconds(); \
+            unsigned long long const elapsedTime = (afterTime-beforeTime); \
+            if (elapsedTime > 1000) {  /* or whatever threshold you like; I'm using 1 millisecond here */ \
+                DEBUGLOG(MUTEX_WAIT_TIME_DLEVEL, "Thread took %llu microseconds to acquire mutex %s \n", \
+                   elapsedTime, #mutex);          \
+        }   }                                     \
+    } else {                                      \
+        ZSTD_pthread_mutex_lock(mutex);           \
+    }                                             \
+}
+
+#else
+
+#  define ZSTD_PTHREAD_MUTEX_LOCK(m) ZSTD_pthread_mutex_lock(m)
+#  define DEBUG_PRINTHEX(l,p,n) {}
+
+#endif
+
+
+/* =====   Buffer Pool   ===== */
+/* a single Buffer Pool can be invoked from multiple threads in parallel */
+
+typedef struct buffer_s {
+    void* start;
+    size_t capacity;
+} buffer_t;
+
+static const buffer_t g_nullBuffer = { NULL, 0 };
+
+typedef struct ZSTDMT_bufferPool_s {
+    ZSTD_pthread_mutex_t poolMutex;
+    size_t bufferSize;
+    unsigned totalBuffers;
+    unsigned nbBuffers;
+    ZSTD_customMem cMem;
+    buffer_t bTable[1];   /* variable size */
+} ZSTDMT_bufferPool;
+
+static ZSTDMT_bufferPool* ZSTDMT_createBufferPool(unsigned nbWorkers, ZSTD_customMem cMem)
+{
+    unsigned const maxNbBuffers = 2*nbWorkers + 3;
+    ZSTDMT_bufferPool* const bufPool = (ZSTDMT_bufferPool*)ZSTD_calloc(
+        sizeof(ZSTDMT_bufferPool) + (maxNbBuffers-1) * sizeof(buffer_t), cMem);
+    if (bufPool==NULL) return NULL;
+    if (ZSTD_pthread_mutex_init(&bufPool->poolMutex, NULL)) {
+        ZSTD_free(bufPool, cMem);
+        return NULL;
+    }
+    bufPool->bufferSize = 64 KB;
+    bufPool->totalBuffers = maxNbBuffers;
+    bufPool->nbBuffers = 0;
+    bufPool->cMem = cMem;
+    return bufPool;
+}
+
+static void ZSTDMT_freeBufferPool(ZSTDMT_bufferPool* bufPool)
+{
+    unsigned u;
+    DEBUGLOG(3, "ZSTDMT_freeBufferPool (address:%08X)", (U32)(size_t)bufPool);
+    if (!bufPool) return;   /* compatibility with free on NULL */
+    for (u=0; u<bufPool->totalBuffers; u++) {
+        DEBUGLOG(4, "free buffer %2u (address:%08X)", u, (U32)(size_t)bufPool->bTable[u].start);
+        ZSTD_free(bufPool->bTable[u].start, bufPool->cMem);
+    }
+    ZSTD_pthread_mutex_destroy(&bufPool->poolMutex);
+    ZSTD_free(bufPool, bufPool->cMem);
+}
+
+/* only works at initialization, not during compression */
+static size_t ZSTDMT_sizeof_bufferPool(ZSTDMT_bufferPool* bufPool)
+{
+    size_t const poolSize = sizeof(*bufPool)
+                          + (bufPool->totalBuffers - 1) * sizeof(buffer_t);
+    unsigned u;
+    size_t totalBufferSize = 0;
+    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
+    for (u=0; u<bufPool->totalBuffers; u++)
+        totalBufferSize += bufPool->bTable[u].capacity;
+    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
+
+    return poolSize + totalBufferSize;
+}
+
+/* ZSTDMT_setBufferSize() :
+ * all future buffers provided by this buffer pool will have _at least_ this size
+ * note : it's better for all buffers to have same size,
+ * as they become freely interchangeable, reducing malloc/free usages and memory fragmentation */
+static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* const bufPool, size_t const bSize)
+{
+    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
+    DEBUGLOG(4, "ZSTDMT_setBufferSize: bSize = %u", (U32)bSize);
+    bufPool->bufferSize = bSize;
+    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
+}
+
+
+static ZSTDMT_bufferPool* ZSTDMT_expandBufferPool(ZSTDMT_bufferPool* srcBufPool, U32 nbWorkers)
+{
+    unsigned const maxNbBuffers = 2*nbWorkers + 3;
+    if (srcBufPool==NULL) return NULL;
+    if (srcBufPool->totalBuffers >= maxNbBuffers) /* good enough */
+        return srcBufPool;
+    /* need a larger buffer pool */
+    {   ZSTD_customMem const cMem = srcBufPool->cMem;
+        size_t const bSize = srcBufPool->bufferSize;   /* forward parameters */
+        ZSTDMT_bufferPool* newBufPool;
+        ZSTDMT_freeBufferPool(srcBufPool);
+        newBufPool = ZSTDMT_createBufferPool(nbWorkers, cMem);
+        if (newBufPool==NULL) return newBufPool;
+        ZSTDMT_setBufferSize(newBufPool, bSize);
+        return newBufPool;
+    }
+}
+
+/** ZSTDMT_getBuffer() :
+ *  assumption : bufPool must be valid
+ * @return : a buffer, with start pointer and size
+ *  note: allocation may fail, in this case, start==NULL and size==0 */
+static buffer_t ZSTDMT_getBuffer(ZSTDMT_bufferPool* bufPool)
+{
+    size_t const bSize = bufPool->bufferSize;
+    DEBUGLOG(5, "ZSTDMT_getBuffer: bSize = %u", (U32)bufPool->bufferSize);
+    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
+    if (bufPool->nbBuffers) {   /* try to use an existing buffer */
+        buffer_t const buf = bufPool->bTable[--(bufPool->nbBuffers)];
+        size_t const availBufferSize = buf.capacity;
+        bufPool->bTable[bufPool->nbBuffers] = g_nullBuffer;
+        if ((availBufferSize >= bSize) & ((availBufferSize>>3) <= bSize)) {
+            /* large enough, but not too much */
+            DEBUGLOG(5, "ZSTDMT_getBuffer: provide buffer %u of size %u",
+                        bufPool->nbBuffers, (U32)buf.capacity);
+            ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
+            return buf;
+        }
+        /* size conditions not respected : scratch this buffer, create new one */
+        DEBUGLOG(5, "ZSTDMT_getBuffer: existing buffer does not meet size conditions => freeing");
+        ZSTD_free(buf.start, bufPool->cMem);
+    }
+    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
+    /* create new buffer */
+    DEBUGLOG(5, "ZSTDMT_getBuffer: create a new buffer");
+    {   buffer_t buffer;
+        void* const start = ZSTD_malloc(bSize, bufPool->cMem);
+        buffer.start = start;   /* note : start can be NULL if malloc fails ! */
+        buffer.capacity = (start==NULL) ? 0 : bSize;
+        if (start==NULL) {
+            DEBUGLOG(5, "ZSTDMT_getBuffer: buffer allocation failure !!");
+        } else {
+            DEBUGLOG(5, "ZSTDMT_getBuffer: created buffer of size %u", (U32)bSize);
+        }
+        return buffer;
+    }
+}
+
+#if ZSTD_RESIZE_SEQPOOL
+/** ZSTDMT_resizeBuffer() :
+ * assumption : bufPool must be valid
+ * @return : a buffer that is at least the buffer pool buffer size.
+ *           If a reallocation happens, the data in the input buffer is copied.
+ */
+static buffer_t ZSTDMT_resizeBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buffer)
+{
+    size_t const bSize = bufPool->bufferSize;
+    if (buffer.capacity < bSize) {
+        void* const start = ZSTD_malloc(bSize, bufPool->cMem);
+        buffer_t newBuffer;
+        newBuffer.start = start;
+        newBuffer.capacity = start == NULL ? 0 : bSize;
+        if (start != NULL) {
+            assert(newBuffer.capacity >= buffer.capacity);
+            memcpy(newBuffer.start, buffer.start, buffer.capacity);
+            DEBUGLOG(5, "ZSTDMT_resizeBuffer: created buffer of size %u", (U32)bSize);
+            return newBuffer;
+        }
+        DEBUGLOG(5, "ZSTDMT_resizeBuffer: buffer allocation failure !!");
+    }
+    return buffer;
+}
+#endif
+
+/* store buffer for later re-use, up to pool capacity */
+static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buf)
+{
+    DEBUGLOG(5, "ZSTDMT_releaseBuffer");
+    if (buf.start == NULL) return;   /* compatible with release on NULL */
+    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
+    if (bufPool->nbBuffers < bufPool->totalBuffers) {
+        bufPool->bTable[bufPool->nbBuffers++] = buf;  /* stored for later use */
+        DEBUGLOG(5, "ZSTDMT_releaseBuffer: stored buffer of size %u in slot %u",
+                    (U32)buf.capacity, (U32)(bufPool->nbBuffers-1));
+        ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
+        return;
+    }
+    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
+    /* Reached bufferPool capacity (should not happen) */
+    DEBUGLOG(5, "ZSTDMT_releaseBuffer: pool capacity reached => freeing ");
+    ZSTD_free(buf.start, bufPool->cMem);
+}
+
+
+/* =====   Seq Pool Wrapper   ====== */
+
+static rawSeqStore_t kNullRawSeqStore = {NULL, 0, 0, 0};
+
+typedef ZSTDMT_bufferPool ZSTDMT_seqPool;
+
+static size_t ZSTDMT_sizeof_seqPool(ZSTDMT_seqPool* seqPool)
+{
+    return ZSTDMT_sizeof_bufferPool(seqPool);
+}
+
+static rawSeqStore_t bufferToSeq(buffer_t buffer)
+{
+    rawSeqStore_t seq = {NULL, 0, 0, 0};
+    seq.seq = (rawSeq*)buffer.start;
+    seq.capacity = buffer.capacity / sizeof(rawSeq);
+    return seq;
+}
+
+static buffer_t seqToBuffer(rawSeqStore_t seq)
+{
+    buffer_t buffer;
+    buffer.start = seq.seq;
+    buffer.capacity = seq.capacity * sizeof(rawSeq);
+    return buffer;
+}
+
+static rawSeqStore_t ZSTDMT_getSeq(ZSTDMT_seqPool* seqPool)
+{
+    if (seqPool->bufferSize == 0) {
+        return kNullRawSeqStore;
+    }
+    return bufferToSeq(ZSTDMT_getBuffer(seqPool));
+}
+
+#if ZSTD_RESIZE_SEQPOOL
+static rawSeqStore_t ZSTDMT_resizeSeq(ZSTDMT_seqPool* seqPool, rawSeqStore_t seq)
+{
+  return bufferToSeq(ZSTDMT_resizeBuffer(seqPool, seqToBuffer(seq)));
+}
+#endif
+
+static void ZSTDMT_releaseSeq(ZSTDMT_seqPool* seqPool, rawSeqStore_t seq)
+{
+  ZSTDMT_releaseBuffer(seqPool, seqToBuffer(seq));
+}
+
+static void ZSTDMT_setNbSeq(ZSTDMT_seqPool* const seqPool, size_t const nbSeq)
+{
+  ZSTDMT_setBufferSize(seqPool, nbSeq * sizeof(rawSeq));
+}
+
+static ZSTDMT_seqPool* ZSTDMT_createSeqPool(unsigned nbWorkers, ZSTD_customMem cMem)
+{
+    ZSTDMT_seqPool* const seqPool = ZSTDMT_createBufferPool(nbWorkers, cMem);
+    if (seqPool == NULL) return NULL;
+    ZSTDMT_setNbSeq(seqPool, 0);
+    return seqPool;
+}
+
+static void ZSTDMT_freeSeqPool(ZSTDMT_seqPool* seqPool)
+{
+    ZSTDMT_freeBufferPool(seqPool);
+}
+
+static ZSTDMT_seqPool* ZSTDMT_expandSeqPool(ZSTDMT_seqPool* pool, U32 nbWorkers)
+{
+    return ZSTDMT_expandBufferPool(pool, nbWorkers);
+}
+
+
+/* =====   CCtx Pool   ===== */
+/* a single CCtx Pool can be invoked from multiple threads in parallel */
+
+typedef struct {
+    ZSTD_pthread_mutex_t poolMutex;
+    int totalCCtx;
+    int availCCtx;
+    ZSTD_customMem cMem;
+    ZSTD_CCtx* cctx[1];   /* variable size */
+} ZSTDMT_CCtxPool;
+
+/* note : all CCtx borrowed from the pool should be released back to the pool _before_ freeing the pool */
+static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)
+{
+    int cid;
+    for (cid=0; cid<pool->totalCCtx; cid++)
+        ZSTD_freeCCtx(pool->cctx[cid]);  /* note : compatible with free on NULL */
+    ZSTD_pthread_mutex_destroy(&pool->poolMutex);
+    ZSTD_free(pool, pool->cMem);
+}
+
+/* ZSTDMT_createCCtxPool() :
+ * implies nbWorkers >= 1 , checked by caller ZSTDMT_createCCtx() */
+static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers,
+                                              ZSTD_customMem cMem)
+{
+    ZSTDMT_CCtxPool* const cctxPool = (ZSTDMT_CCtxPool*) ZSTD_calloc(
+        sizeof(ZSTDMT_CCtxPool) + (nbWorkers-1)*sizeof(ZSTD_CCtx*), cMem);
+    assert(nbWorkers > 0);
+    if (!cctxPool) return NULL;
+    if (ZSTD_pthread_mutex_init(&cctxPool->poolMutex, NULL)) {
+        ZSTD_free(cctxPool, cMem);
+        return NULL;
+    }
+    cctxPool->cMem = cMem;
+    cctxPool->totalCCtx = nbWorkers;
+    cctxPool->availCCtx = 1;   /* at least one cctx for single-thread mode */
+    cctxPool->cctx[0] = ZSTD_createCCtx_advanced(cMem);
+    if (!cctxPool->cctx[0]) { ZSTDMT_freeCCtxPool(cctxPool); return NULL; }
+    DEBUGLOG(3, "cctxPool created, with %u workers", nbWorkers);
+    return cctxPool;
+}
+
+static ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool,
+                                              int nbWorkers)
+{
+    if (srcPool==NULL) return NULL;
+    if (nbWorkers <= srcPool->totalCCtx) return srcPool;   /* good enough */
+    /* need a larger cctx pool */
+    {   ZSTD_customMem const cMem = srcPool->cMem;
+        ZSTDMT_freeCCtxPool(srcPool);
+        return ZSTDMT_createCCtxPool(nbWorkers, cMem);
+    }
+}
+
+/* only works during initialization phase, not during compression */
+static size_t ZSTDMT_sizeof_CCtxPool(ZSTDMT_CCtxPool* cctxPool)
+{
+    ZSTD_pthread_mutex_lock(&cctxPool->poolMutex);
+    {   unsigned const nbWorkers = cctxPool->totalCCtx;
+        size_t const poolSize = sizeof(*cctxPool)
+                                + (nbWorkers-1) * sizeof(ZSTD_CCtx*);
+        unsigned u;
+        size_t totalCCtxSize = 0;
+        for (u=0; u<nbWorkers; u++) {
+            totalCCtxSize += ZSTD_sizeof_CCtx(cctxPool->cctx[u]);
+        }
+        ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);
+        assert(nbWorkers > 0);
+        return poolSize + totalCCtxSize;
+    }
+}
+
+static ZSTD_CCtx* ZSTDMT_getCCtx(ZSTDMT_CCtxPool* cctxPool)
+{
+    DEBUGLOG(5, "ZSTDMT_getCCtx");
+    ZSTD_pthread_mutex_lock(&cctxPool->poolMutex);
+    if (cctxPool->availCCtx) {
+        cctxPool->availCCtx--;
+        {   ZSTD_CCtx* const cctx = cctxPool->cctx[cctxPool->availCCtx];
+            ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);
+            return cctx;
+    }   }
+    ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);
+    DEBUGLOG(5, "create one more CCtx");
+    return ZSTD_createCCtx_advanced(cctxPool->cMem);   /* note : can be NULL, when creation fails ! */
+}
+
+static void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx* cctx)
+{
+    if (cctx==NULL) return;   /* compatibility with release on NULL */
+    ZSTD_pthread_mutex_lock(&pool->poolMutex);
+    if (pool->availCCtx < pool->totalCCtx)
+        pool->cctx[pool->availCCtx++] = cctx;
+    else {
+        /* pool overflow : should not happen, since totalCCtx==nbWorkers */
+        DEBUGLOG(4, "CCtx pool overflow : free cctx");
+        ZSTD_freeCCtx(cctx);
+    }
+    ZSTD_pthread_mutex_unlock(&pool->poolMutex);
+}
+
+/* ====   Serial State   ==== */
+
+typedef struct {
+    void const* start;
+    size_t size;
+} range_t;
+
+typedef struct {
+    /* All variables in the struct are protected by mutex. */
+    ZSTD_pthread_mutex_t mutex;
+    ZSTD_pthread_cond_t cond;
+    ZSTD_CCtx_params params;
+    ldmState_t ldmState;
+    XXH64_state_t xxhState;
+    unsigned nextJobID;
+    /* Protects ldmWindow.
+     * Must be acquired after the main mutex when acquiring both.
+     */
+    ZSTD_pthread_mutex_t ldmWindowMutex;
+    ZSTD_pthread_cond_t ldmWindowCond;  /* Signaled when ldmWindow is updated */
+    ZSTD_window_t ldmWindow;  /* A thread-safe copy of ldmState.window */
+} serialState_t;
+
+static int ZSTDMT_serialState_reset(serialState_t* serialState, ZSTDMT_seqPool* seqPool, ZSTD_CCtx_params params, size_t jobSize)
+{
+    /* Adjust parameters */
+    if (params.ldmParams.enableLdm) {
+        DEBUGLOG(4, "LDM window size = %u KB", (1U << params.cParams.windowLog) >> 10);
+        ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
+        assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);
+        assert(params.ldmParams.hashRateLog < 32);
+        serialState->ldmState.hashPower =
+                ZSTD_rollingHash_primePower(params.ldmParams.minMatchLength);
+    } else {
+        memset(&params.ldmParams, 0, sizeof(params.ldmParams));
+    }
+    serialState->nextJobID = 0;
+    if (params.fParams.checksumFlag)
+        XXH64_reset(&serialState->xxhState, 0);
+    if (params.ldmParams.enableLdm) {
+        ZSTD_customMem cMem = params.customMem;
+        unsigned const hashLog = params.ldmParams.hashLog;
+        size_t const hashSize = ((size_t)1 << hashLog) * sizeof(ldmEntry_t);
+        unsigned const bucketLog =
+            params.ldmParams.hashLog - params.ldmParams.bucketSizeLog;
+        size_t const bucketSize = (size_t)1 << bucketLog;
+        unsigned const prevBucketLog =
+            serialState->params.ldmParams.hashLog -
+            serialState->params.ldmParams.bucketSizeLog;
+        /* Size the seq pool tables */
+        ZSTDMT_setNbSeq(seqPool, ZSTD_ldm_getMaxNbSeq(params.ldmParams, jobSize));
+        /* Reset the window */
+        ZSTD_window_clear(&serialState->ldmState.window);
+        serialState->ldmWindow = serialState->ldmState.window;
+        /* Resize tables and output space if necessary. */
+        if (serialState->ldmState.hashTable == NULL || serialState->params.ldmParams.hashLog < hashLog) {
+            ZSTD_free(serialState->ldmState.hashTable, cMem);
+            serialState->ldmState.hashTable = (ldmEntry_t*)ZSTD_malloc(hashSize, cMem);
+        }
+        if (serialState->ldmState.bucketOffsets == NULL || prevBucketLog < bucketLog) {
+            ZSTD_free(serialState->ldmState.bucketOffsets, cMem);
+            serialState->ldmState.bucketOffsets = (BYTE*)ZSTD_malloc(bucketSize, cMem);
+        }
+        if (!serialState->ldmState.hashTable || !serialState->ldmState.bucketOffsets)
+            return 1;
+        /* Zero the tables */
+        memset(serialState->ldmState.hashTable, 0, hashSize);
+        memset(serialState->ldmState.bucketOffsets, 0, bucketSize);
+    }
+    serialState->params = params;
+    serialState->params.jobSize = (U32)jobSize;
+    return 0;
+}
+
+static int ZSTDMT_serialState_init(serialState_t* serialState)
+{
+    int initError = 0;
+    memset(serialState, 0, sizeof(*serialState));
+    initError |= ZSTD_pthread_mutex_init(&serialState->mutex, NULL);
+    initError |= ZSTD_pthread_cond_init(&serialState->cond, NULL);
+    initError |= ZSTD_pthread_mutex_init(&serialState->ldmWindowMutex, NULL);
+    initError |= ZSTD_pthread_cond_init(&serialState->ldmWindowCond, NULL);
+    return initError;
+}
+
+static void ZSTDMT_serialState_free(serialState_t* serialState)
+{
+    ZSTD_customMem cMem = serialState->params.customMem;
+    ZSTD_pthread_mutex_destroy(&serialState->mutex);
+    ZSTD_pthread_cond_destroy(&serialState->cond);
+    ZSTD_pthread_mutex_destroy(&serialState->ldmWindowMutex);
+    ZSTD_pthread_cond_destroy(&serialState->ldmWindowCond);
+    ZSTD_free(serialState->ldmState.hashTable, cMem);
+    ZSTD_free(serialState->ldmState.bucketOffsets, cMem);
+}
+
+static void ZSTDMT_serialState_update(serialState_t* serialState,
+                                      ZSTD_CCtx* jobCCtx, rawSeqStore_t seqStore,
+                                      range_t src, unsigned jobID)
+{
+    /* Wait for our turn */
+    ZSTD_PTHREAD_MUTEX_LOCK(&serialState->mutex);
+    while (serialState->nextJobID < jobID) {
+        DEBUGLOG(5, "wait for serialState->cond");
+        ZSTD_pthread_cond_wait(&serialState->cond, &serialState->mutex);
+    }
+    /* A future job may error and skip our job */
+    if (serialState->nextJobID == jobID) {
+        /* It is now our turn, do any processing necessary */
+        if (serialState->params.ldmParams.enableLdm) {
+            size_t error;
+            assert(seqStore.seq != NULL && seqStore.pos == 0 &&
+                   seqStore.size == 0 && seqStore.capacity > 0);
+            assert(src.size <= serialState->params.jobSize);
+            ZSTD_window_update(&serialState->ldmState.window, src.start, src.size);
+            error = ZSTD_ldm_generateSequences(
+                &serialState->ldmState, &seqStore,
+                &serialState->params.ldmParams, src.start, src.size);
+            /* We provide a large enough buffer to never fail. */
+            assert(!ZSTD_isError(error)); (void)error;
+            /* Update ldmWindow to match the ldmState.window and signal the main
+             * thread if it is waiting for a buffer.
+             */
+            ZSTD_PTHREAD_MUTEX_LOCK(&serialState->ldmWindowMutex);
+            serialState->ldmWindow = serialState->ldmState.window;
+            ZSTD_pthread_cond_signal(&serialState->ldmWindowCond);
+            ZSTD_pthread_mutex_unlock(&serialState->ldmWindowMutex);
+        }
+        if (serialState->params.fParams.checksumFlag && src.size > 0)
+            XXH64_update(&serialState->xxhState, src.start, src.size);
+    }
+    /* Now it is the next jobs turn */
+    serialState->nextJobID++;
+    ZSTD_pthread_cond_broadcast(&serialState->cond);
+    ZSTD_pthread_mutex_unlock(&serialState->mutex);
+
+    if (seqStore.size > 0) {
+        size_t const err = ZSTD_referenceExternalSequences(
+            jobCCtx, seqStore.seq, seqStore.size);
+        assert(serialState->params.ldmParams.enableLdm);
+        assert(!ZSTD_isError(err));
+        (void)err;
+    }
+}
+
+static void ZSTDMT_serialState_ensureFinished(serialState_t* serialState,
+                                              unsigned jobID, size_t cSize)
+{
+    ZSTD_PTHREAD_MUTEX_LOCK(&serialState->mutex);
+    if (serialState->nextJobID <= jobID) {
+        assert(ZSTD_isError(cSize)); (void)cSize;
+        DEBUGLOG(5, "Skipping past job %u because of error", jobID);
+        serialState->nextJobID = jobID + 1;
+        ZSTD_pthread_cond_broadcast(&serialState->cond);
+
+        ZSTD_PTHREAD_MUTEX_LOCK(&serialState->ldmWindowMutex);
+        ZSTD_window_clear(&serialState->ldmWindow);
+        ZSTD_pthread_cond_signal(&serialState->ldmWindowCond);
+        ZSTD_pthread_mutex_unlock(&serialState->ldmWindowMutex);
+    }
+    ZSTD_pthread_mutex_unlock(&serialState->mutex);
+
+}
+
+
+/* ------------------------------------------ */
+/* =====          Worker thread         ===== */
+/* ------------------------------------------ */
+
+static const range_t kNullRange = { NULL, 0 };
+
+typedef struct {
+    size_t   consumed;                   /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx */
+    size_t   cSize;                      /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx, then set0 by mtctx */
+    ZSTD_pthread_mutex_t job_mutex;      /* Thread-safe - used by mtctx and worker */
+    ZSTD_pthread_cond_t job_cond;        /* Thread-safe - used by mtctx and worker */
+    ZSTDMT_CCtxPool* cctxPool;           /* Thread-safe - used by mtctx and (all) workers */
+    ZSTDMT_bufferPool* bufPool;          /* Thread-safe - used by mtctx and (all) workers */
+    ZSTDMT_seqPool* seqPool;             /* Thread-safe - used by mtctx and (all) workers */
+    serialState_t* serial;               /* Thread-safe - used by mtctx and (all) workers */
+    buffer_t dstBuff;                    /* set by worker (or mtctx), then read by worker & mtctx, then modified by mtctx => no barrier */
+    range_t prefix;                      /* set by mtctx, then read by worker & mtctx => no barrier */
+    range_t src;                         /* set by mtctx, then read by worker & mtctx => no barrier */
+    unsigned jobID;                      /* set by mtctx, then read by worker => no barrier */
+    unsigned firstJob;                   /* set by mtctx, then read by worker => no barrier */
+    unsigned lastJob;                    /* set by mtctx, then read by worker => no barrier */
+    ZSTD_CCtx_params params;             /* set by mtctx, then read by worker => no barrier */
+    const ZSTD_CDict* cdict;             /* set by mtctx, then read by worker => no barrier */
+    unsigned long long fullFrameSize;    /* set by mtctx, then read by worker => no barrier */
+    size_t   dstFlushed;                 /* used only by mtctx */
+    unsigned frameChecksumNeeded;        /* used only by mtctx */
+} ZSTDMT_jobDescription;
+
+#define JOB_ERROR(e) {                          \
+    ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);   \
+    job->cSize = e;                             \
+    ZSTD_pthread_mutex_unlock(&job->job_mutex); \
+    goto _endJob;                               \
+}
+
+/* ZSTDMT_compressionJob() is a POOL_function type */
+static void ZSTDMT_compressionJob(void* jobDescription)
+{
+    ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
+    ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
+    ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);
+    rawSeqStore_t rawSeqStore = ZSTDMT_getSeq(job->seqPool);
+    buffer_t dstBuff = job->dstBuff;
+    size_t lastCBlockSize = 0;
+
+    /* resources */
+    if (cctx==NULL) JOB_ERROR(ERROR(memory_allocation));
+    if (dstBuff.start == NULL) {   /* streaming job : doesn't provide a dstBuffer */
+        dstBuff = ZSTDMT_getBuffer(job->bufPool);
+        if (dstBuff.start==NULL) JOB_ERROR(ERROR(memory_allocation));
+        job->dstBuff = dstBuff;   /* this value can be read in ZSTDMT_flush, when it copies the whole job */
+    }
+    if (jobParams.ldmParams.enableLdm && rawSeqStore.seq == NULL)
+        JOB_ERROR(ERROR(memory_allocation));
+
+    /* Don't compute the checksum for chunks, since we compute it externally,
+     * but write it in the header.
+     */
+    if (job->jobID != 0) jobParams.fParams.checksumFlag = 0;
+    /* Don't run LDM for the chunks, since we handle it externally */
+    jobParams.ldmParams.enableLdm = 0;
+
+
+    /* init */
+    if (job->cdict) {
+        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast, job->cdict, jobParams, job->fullFrameSize);
+        assert(job->firstJob);  /* only allowed for first job */
+        if (ZSTD_isError(initError)) JOB_ERROR(initError);
+    } else {  /* srcStart points at reloaded section */
+        U64 const pledgedSrcSize = job->firstJob ? job->fullFrameSize : job->src.size;
+        {   size_t const forceWindowError = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_forceMaxWindow, !job->firstJob);
+            if (ZSTD_isError(forceWindowError)) JOB_ERROR(forceWindowError);
+        }
+        {   size_t const initError = ZSTD_compressBegin_advanced_internal(cctx,
+                                        job->prefix.start, job->prefix.size, ZSTD_dct_rawContent, /* load dictionary in "content-only" mode (no header analysis) */
+                                        ZSTD_dtlm_fast,
+                                        NULL, /*cdict*/
+                                        jobParams, pledgedSrcSize);
+            if (ZSTD_isError(initError)) JOB_ERROR(initError);
+    }   }
+
+    /* Perform serial step as early as possible, but after CCtx initialization */
+    ZSTDMT_serialState_update(job->serial, cctx, rawSeqStore, job->src, job->jobID);
+
+    if (!job->firstJob) {  /* flush and overwrite frame header when it's not first job */
+        size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.capacity, job->src.start, 0);
+        if (ZSTD_isError(hSize)) JOB_ERROR(hSize);
+        DEBUGLOG(5, "ZSTDMT_compressionJob: flush and overwrite %u bytes of frame header (not first job)", (U32)hSize);
+        ZSTD_invalidateRepCodes(cctx);
+    }
+
+    /* compress */
+    {   size_t const chunkSize = 4*ZSTD_BLOCKSIZE_MAX;
+        int const nbChunks = (int)((job->src.size + (chunkSize-1)) / chunkSize);
+        const BYTE* ip = (const BYTE*) job->src.start;
+        BYTE* const ostart = (BYTE*)dstBuff.start;
+        BYTE* op = ostart;
+        BYTE* oend = op + dstBuff.capacity;
+        int chunkNb;
+        if (sizeof(size_t) > sizeof(int)) assert(job->src.size < ((size_t)INT_MAX) * chunkSize);   /* check overflow */
+        DEBUGLOG(5, "ZSTDMT_compressionJob: compress %u bytes in %i blocks", (U32)job->src.size, nbChunks);
+        assert(job->cSize == 0);
+        for (chunkNb = 1; chunkNb < nbChunks; chunkNb++) {
+            size_t const cSize = ZSTD_compressContinue(cctx, op, oend-op, ip, chunkSize);
+            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
+            ip += chunkSize;
+            op += cSize; assert(op < oend);
+            /* stats */
+            ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);
+            job->cSize += cSize;
+            job->consumed = chunkSize * chunkNb;
+            DEBUGLOG(5, "ZSTDMT_compressionJob: compress new block : cSize==%u bytes (total: %u)",
+                        (U32)cSize, (U32)job->cSize);
+            ZSTD_pthread_cond_signal(&job->job_cond);   /* warns some more data is ready to be flushed */
+            ZSTD_pthread_mutex_unlock(&job->job_mutex);
+        }
+        /* last block */
+        assert(chunkSize > 0);
+        assert((chunkSize & (chunkSize - 1)) == 0);  /* chunkSize must be power of 2 for mask==(chunkSize-1) to work */
+        if ((nbChunks > 0) | job->lastJob /*must output a "last block" flag*/ ) {
+            size_t const lastBlockSize1 = job->src.size & (chunkSize-1);
+            size_t const lastBlockSize = ((lastBlockSize1==0) & (job->src.size>=chunkSize)) ? chunkSize : lastBlockSize1;
+            size_t const cSize = (job->lastJob) ?
+                 ZSTD_compressEnd     (cctx, op, oend-op, ip, lastBlockSize) :
+                 ZSTD_compressContinue(cctx, op, oend-op, ip, lastBlockSize);
+            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
+            lastCBlockSize = cSize;
+    }   }
+
+_endJob:
+    ZSTDMT_serialState_ensureFinished(job->serial, job->jobID, job->cSize);
+    if (job->prefix.size > 0)
+        DEBUGLOG(5, "Finished with prefix: %zx", (size_t)job->prefix.start);
+    DEBUGLOG(5, "Finished with source: %zx", (size_t)job->src.start);
+    /* release resources */
+    ZSTDMT_releaseSeq(job->seqPool, rawSeqStore);
+    ZSTDMT_releaseCCtx(job->cctxPool, cctx);
+    /* report */
+    ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);
+    if (ZSTD_isError(job->cSize)) assert(lastCBlockSize == 0);
+    job->cSize += lastCBlockSize;
+    job->consumed = job->src.size;  /* when job->consumed == job->src.size , compression job is presumed completed */
+    ZSTD_pthread_cond_signal(&job->job_cond);
+    ZSTD_pthread_mutex_unlock(&job->job_mutex);
+}
+
+
+/* ------------------------------------------ */
+/* =====   Multi-threaded compression   ===== */
+/* ------------------------------------------ */
+
+typedef struct {
+    range_t prefix;         /* read-only non-owned prefix buffer */
+    buffer_t buffer;
+    size_t filled;
+} inBuff_t;
+
+typedef struct {
+  BYTE* buffer;     /* The round input buffer. All jobs get references
+                     * to pieces of the buffer. ZSTDMT_tryGetInputRange()
+                     * handles handing out job input buffers, and makes
+                     * sure it doesn't overlap with any pieces still in use.
+                     */
+  size_t capacity;  /* The capacity of buffer. */
+  size_t pos;       /* The position of the current inBuff in the round
+                     * buffer. Updated past the end if the inBuff once
+                     * the inBuff is sent to the worker thread.
+                     * pos <= capacity.
+                     */
+} roundBuff_t;
+
+static const roundBuff_t kNullRoundBuff = {NULL, 0, 0};
+
+#define RSYNC_LENGTH 32
+
+typedef struct {
+  U64 hash;
+  U64 hitMask;
+  U64 primePower;
+} rsyncState_t;
+
+struct ZSTDMT_CCtx_s {
+    POOL_ctx* factory;
+    ZSTDMT_jobDescription* jobs;
+    ZSTDMT_bufferPool* bufPool;
+    ZSTDMT_CCtxPool* cctxPool;
+    ZSTDMT_seqPool* seqPool;
+    ZSTD_CCtx_params params;
+    size_t targetSectionSize;
+    size_t targetPrefixSize;
+    int jobReady;        /* 1 => one job is already prepared, but pool has shortage of workers. Don't create a new job. */
+    inBuff_t inBuff;
+    roundBuff_t roundBuff;
+    serialState_t serial;
+    rsyncState_t rsync;
+    unsigned singleBlockingThread;
+    unsigned jobIDMask;
+    unsigned doneJobID;
+    unsigned nextJobID;
+    unsigned frameEnded;
+    unsigned allJobsCompleted;
+    unsigned long long frameContentSize;
+    unsigned long long consumed;
+    unsigned long long produced;
+    ZSTD_customMem cMem;
+    ZSTD_CDict* cdictLocal;
+    const ZSTD_CDict* cdict;
+};
+
+static void ZSTDMT_freeJobsTable(ZSTDMT_jobDescription* jobTable, U32 nbJobs, ZSTD_customMem cMem)
+{
+    U32 jobNb;
+    if (jobTable == NULL) return;
+    for (jobNb=0; jobNb<nbJobs; jobNb++) {
+        ZSTD_pthread_mutex_destroy(&jobTable[jobNb].job_mutex);
+        ZSTD_pthread_cond_destroy(&jobTable[jobNb].job_cond);
+    }
+    ZSTD_free(jobTable, cMem);
+}
+
+/* ZSTDMT_allocJobsTable()
+ * allocate and init a job table.
+ * update *nbJobsPtr to next power of 2 value, as size of table */
+static ZSTDMT_jobDescription* ZSTDMT_createJobsTable(U32* nbJobsPtr, ZSTD_customMem cMem)
+{
+    U32 const nbJobsLog2 = ZSTD_highbit32(*nbJobsPtr) + 1;
+    U32 const nbJobs = 1 << nbJobsLog2;
+    U32 jobNb;
+    ZSTDMT_jobDescription* const jobTable = (ZSTDMT_jobDescription*)
+                ZSTD_calloc(nbJobs * sizeof(ZSTDMT_jobDescription), cMem);
+    int initError = 0;
+    if (jobTable==NULL) return NULL;
+    *nbJobsPtr = nbJobs;
+    for (jobNb=0; jobNb<nbJobs; jobNb++) {
+        initError |= ZSTD_pthread_mutex_init(&jobTable[jobNb].job_mutex, NULL);
+        initError |= ZSTD_pthread_cond_init(&jobTable[jobNb].job_cond, NULL);
+    }
+    if (initError != 0) {
+        ZSTDMT_freeJobsTable(jobTable, nbJobs, cMem);
+        return NULL;
+    }
+    return jobTable;
+}
+
+static size_t ZSTDMT_expandJobsTable (ZSTDMT_CCtx* mtctx, U32 nbWorkers) {
+    U32 nbJobs = nbWorkers + 2;
+    if (nbJobs > mtctx->jobIDMask+1) {  /* need more job capacity */
+        ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem);
+        mtctx->jobIDMask = 0;
+        mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, mtctx->cMem);
+        if (mtctx->jobs==NULL) return ERROR(memory_allocation);
+        assert((nbJobs != 0) && ((nbJobs & (nbJobs - 1)) == 0));  /* ensure nbJobs is a power of 2 */
+        mtctx->jobIDMask = nbJobs - 1;
+    }
+    return 0;
+}
+
+
+/* ZSTDMT_CCtxParam_setNbWorkers():
+ * Internal use only */
+size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers)
+{
+    return ZSTD_CCtxParams_setParameter(params, ZSTD_c_nbWorkers, (int)nbWorkers);
+}
+
+MEM_STATIC ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced_internal(unsigned nbWorkers, ZSTD_customMem cMem)
+{
+    ZSTDMT_CCtx* mtctx;
+    U32 nbJobs = nbWorkers + 2;
+    int initError;
+    DEBUGLOG(3, "ZSTDMT_createCCtx_advanced (nbWorkers = %u)", nbWorkers);
+
+    if (nbWorkers < 1) return NULL;
+    nbWorkers = MIN(nbWorkers , ZSTDMT_NBWORKERS_MAX);
+    if ((cMem.customAlloc!=NULL) ^ (cMem.customFree!=NULL))
+        /* invalid custom allocator */
+        return NULL;
+
+    mtctx = (ZSTDMT_CCtx*) ZSTD_calloc(sizeof(ZSTDMT_CCtx), cMem);
+    if (!mtctx) return NULL;
+    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);
+    mtctx->cMem = cMem;
+    mtctx->allJobsCompleted = 1;
+    mtctx->factory = POOL_create_advanced(nbWorkers, 0, cMem);
+    mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, cMem);
+    assert(nbJobs > 0); assert((nbJobs & (nbJobs - 1)) == 0);  /* ensure nbJobs is a power of 2 */
+    mtctx->jobIDMask = nbJobs - 1;
+    mtctx->bufPool = ZSTDMT_createBufferPool(nbWorkers, cMem);
+    mtctx->cctxPool = ZSTDMT_createCCtxPool(nbWorkers, cMem);
+    mtctx->seqPool = ZSTDMT_createSeqPool(nbWorkers, cMem);
+    initError = ZSTDMT_serialState_init(&mtctx->serial);
+    mtctx->roundBuff = kNullRoundBuff;
+    if (!mtctx->factory | !mtctx->jobs | !mtctx->bufPool | !mtctx->cctxPool | !mtctx->seqPool | initError) {
+        ZSTDMT_freeCCtx(mtctx);
+        return NULL;
+    }
+    DEBUGLOG(3, "mt_cctx created, for %u threads", nbWorkers);
+    return mtctx;
+}
+
+ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers, ZSTD_customMem cMem)
+{
+#ifdef ZSTD_MULTITHREAD
+    return ZSTDMT_createCCtx_advanced_internal(nbWorkers, cMem);
+#else
+    (void)nbWorkers;
+    (void)cMem;
+    return NULL;
+#endif
+}
+
+ZSTDMT_CCtx* ZSTDMT_createCCtx(unsigned nbWorkers)
+{
+    return ZSTDMT_createCCtx_advanced(nbWorkers, ZSTD_defaultCMem);
+}
+
+
+/* ZSTDMT_releaseAllJobResources() :
+ * note : ensure all workers are killed first ! */
+static void ZSTDMT_releaseAllJobResources(ZSTDMT_CCtx* mtctx)
+{
+    unsigned jobID;
+    DEBUGLOG(3, "ZSTDMT_releaseAllJobResources");
+    for (jobID=0; jobID <= mtctx->jobIDMask; jobID++) {
+        DEBUGLOG(4, "job%02u: release dst address %08X", jobID, (U32)(size_t)mtctx->jobs[jobID].dstBuff.start);
+        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff);
+        mtctx->jobs[jobID].dstBuff = g_nullBuffer;
+        mtctx->jobs[jobID].cSize = 0;
+    }
+    memset(mtctx->jobs, 0, (mtctx->jobIDMask+1)*sizeof(ZSTDMT_jobDescription));
+    mtctx->inBuff.buffer = g_nullBuffer;
+    mtctx->inBuff.filled = 0;
+    mtctx->allJobsCompleted = 1;
+}
+
+static void ZSTDMT_waitForAllJobsCompleted(ZSTDMT_CCtx* mtctx)
+{
+    DEBUGLOG(4, "ZSTDMT_waitForAllJobsCompleted");
+    while (mtctx->doneJobID < mtctx->nextJobID) {
+        unsigned const jobID = mtctx->doneJobID & mtctx->jobIDMask;
+        ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[jobID].job_mutex);
+        while (mtctx->jobs[jobID].consumed < mtctx->jobs[jobID].src.size) {
+            DEBUGLOG(4, "waiting for jobCompleted signal from job %u", mtctx->doneJobID);   /* we want to block when waiting for data to flush */
+            ZSTD_pthread_cond_wait(&mtctx->jobs[jobID].job_cond, &mtctx->jobs[jobID].job_mutex);
+        }
+        ZSTD_pthread_mutex_unlock(&mtctx->jobs[jobID].job_mutex);
+        mtctx->doneJobID++;
+    }
+}
+
+size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx)
+{
+    if (mtctx==NULL) return 0;   /* compatible with free on NULL */
+    POOL_free(mtctx->factory);   /* stop and free worker threads */
+    ZSTDMT_releaseAllJobResources(mtctx);  /* release job resources into pools first */
+    ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem);
+    ZSTDMT_freeBufferPool(mtctx->bufPool);
+    ZSTDMT_freeCCtxPool(mtctx->cctxPool);
+    ZSTDMT_freeSeqPool(mtctx->seqPool);
+    ZSTDMT_serialState_free(&mtctx->serial);
+    ZSTD_freeCDict(mtctx->cdictLocal);
+    if (mtctx->roundBuff.buffer)
+        ZSTD_free(mtctx->roundBuff.buffer, mtctx->cMem);
+    ZSTD_free(mtctx, mtctx->cMem);
+    return 0;
+}
+
+size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx)
+{
+    if (mtctx == NULL) return 0;   /* supports sizeof NULL */
+    return sizeof(*mtctx)
+            + POOL_sizeof(mtctx->factory)
+            + ZSTDMT_sizeof_bufferPool(mtctx->bufPool)
+            + (mtctx->jobIDMask+1) * sizeof(ZSTDMT_jobDescription)
+            + ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool)
+            + ZSTDMT_sizeof_seqPool(mtctx->seqPool)
+            + ZSTD_sizeof_CDict(mtctx->cdictLocal)
+            + mtctx->roundBuff.capacity;
+}
+
+/* Internal only */
+size_t
+ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params,
+                                   ZSTDMT_parameter parameter,
+                                   int value)
+{
+    DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter");
+    switch(parameter)
+    {
+    case ZSTDMT_p_jobSize :
+        DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter : set jobSize to %i", value);
+        return ZSTD_CCtxParams_setParameter(params, ZSTD_c_jobSize, value);
+    case ZSTDMT_p_overlapLog :
+        DEBUGLOG(4, "ZSTDMT_p_overlapLog : %i", value);
+        return ZSTD_CCtxParams_setParameter(params, ZSTD_c_overlapLog, value);
+    case ZSTDMT_p_rsyncable :
+        DEBUGLOG(4, "ZSTD_p_rsyncable : %i", value);
+        return ZSTD_CCtxParams_setParameter(params, ZSTD_c_rsyncable, value);
+    default :
+        return ERROR(parameter_unsupported);
+    }
+}
+
+size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int value)
+{
+    DEBUGLOG(4, "ZSTDMT_setMTCtxParameter");
+    return ZSTDMT_CCtxParam_setMTCtxParameter(&mtctx->params, parameter, value);
+}
+
+size_t ZSTDMT_getMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int* value)
+{
+    switch (parameter) {
+    case ZSTDMT_p_jobSize:
+        return ZSTD_CCtxParams_getParameter(&mtctx->params, ZSTD_c_jobSize, value);
+    case ZSTDMT_p_overlapLog:
+        return ZSTD_CCtxParams_getParameter(&mtctx->params, ZSTD_c_overlapLog, value);
+    case ZSTDMT_p_rsyncable:
+        return ZSTD_CCtxParams_getParameter(&mtctx->params, ZSTD_c_rsyncable, value);
+    default:
+        return ERROR(parameter_unsupported);
+    }
+}
+
+/* Sets parameters relevant to the compression job,
+ * initializing others to default values. */
+static ZSTD_CCtx_params ZSTDMT_initJobCCtxParams(ZSTD_CCtx_params const params)
+{
+    ZSTD_CCtx_params jobParams = params;
+    /* Clear parameters related to multithreading */
+    jobParams.forceWindow = 0;
+    jobParams.nbWorkers = 0;
+    jobParams.jobSize = 0;
+    jobParams.overlapLog = 0;
+    jobParams.rsyncable = 0;
+    memset(&jobParams.ldmParams, 0, sizeof(ldmParams_t));
+    memset(&jobParams.customMem, 0, sizeof(ZSTD_customMem));
+    return jobParams;
+}
+
+
+/* ZSTDMT_resize() :
+ * @return : error code if fails, 0 on success */
+static size_t ZSTDMT_resize(ZSTDMT_CCtx* mtctx, unsigned nbWorkers)
+{
+    if (POOL_resize(mtctx->factory, nbWorkers)) return ERROR(memory_allocation);
+    FORWARD_IF_ERROR( ZSTDMT_expandJobsTable(mtctx, nbWorkers) );
+    mtctx->bufPool = ZSTDMT_expandBufferPool(mtctx->bufPool, nbWorkers);
+    if (mtctx->bufPool == NULL) return ERROR(memory_allocation);
+    mtctx->cctxPool = ZSTDMT_expandCCtxPool(mtctx->cctxPool, nbWorkers);
+    if (mtctx->cctxPool == NULL) return ERROR(memory_allocation);
+    mtctx->seqPool = ZSTDMT_expandSeqPool(mtctx->seqPool, nbWorkers);
+    if (mtctx->seqPool == NULL) return ERROR(memory_allocation);
+    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);
+    return 0;
+}
+
+
+/*! ZSTDMT_updateCParams_whileCompressing() :
+ *  Updates a selected set of compression parameters, remaining compatible with currently active frame.
+ *  New parameters will be applied to next compression job. */
+void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams)
+{
+    U32 const saved_wlog = mtctx->params.cParams.windowLog;   /* Do not modify windowLog while compressing */
+    int const compressionLevel = cctxParams->compressionLevel;
+    DEBUGLOG(5, "ZSTDMT_updateCParams_whileCompressing (level:%i)",
+                compressionLevel);
+    mtctx->params.compressionLevel = compressionLevel;
+    {   ZSTD_compressionParameters cParams = ZSTD_getCParamsFromCCtxParams(cctxParams, 0, 0);
+        cParams.windowLog = saved_wlog;
+        mtctx->params.cParams = cParams;
+    }
+}
+
+/* ZSTDMT_getFrameProgression():
+ * tells how much data has been consumed (input) and produced (output) for current frame.
+ * able to count progression inside worker threads.
+ * Note : mutex will be acquired during statistics collection inside workers. */
+ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx)
+{
+    ZSTD_frameProgression fps;
+    DEBUGLOG(5, "ZSTDMT_getFrameProgression");
+    fps.ingested = mtctx->consumed + mtctx->inBuff.filled;
+    fps.consumed = mtctx->consumed;
+    fps.produced = fps.flushed = mtctx->produced;
+    fps.currentJobID = mtctx->nextJobID;
+    fps.nbActiveWorkers = 0;
+    {   unsigned jobNb;
+        unsigned lastJobNb = mtctx->nextJobID + mtctx->jobReady; assert(mtctx->jobReady <= 1);
+        DEBUGLOG(6, "ZSTDMT_getFrameProgression: jobs: from %u to <%u (jobReady:%u)",
+                    mtctx->doneJobID, lastJobNb, mtctx->jobReady)
+        for (jobNb = mtctx->doneJobID ; jobNb < lastJobNb ; jobNb++) {
+            unsigned const wJobID = jobNb & mtctx->jobIDMask;
+            ZSTDMT_jobDescription* jobPtr = &mtctx->jobs[wJobID];
+            ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);
+            {   size_t const cResult = jobPtr->cSize;
+                size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;
+                size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;
+                assert(flushed <= produced);
+                fps.ingested += jobPtr->src.size;
+                fps.consumed += jobPtr->consumed;
+                fps.produced += produced;
+                fps.flushed  += flushed;
+                fps.nbActiveWorkers += (jobPtr->consumed < jobPtr->src.size);
+            }
+            ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
+        }
+    }
+    return fps;
+}
+
+
+size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx)
+{
+    size_t toFlush;
+    unsigned const jobID = mtctx->doneJobID;
+    assert(jobID <= mtctx->nextJobID);
+    if (jobID == mtctx->nextJobID) return 0;   /* no active job => nothing to flush */
+
+    /* look into oldest non-fully-flushed job */
+    {   unsigned const wJobID = jobID & mtctx->jobIDMask;
+        ZSTDMT_jobDescription* const jobPtr = &mtctx->jobs[wJobID];
+        ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);
+        {   size_t const cResult = jobPtr->cSize;
+            size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;
+            size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;
+            assert(flushed <= produced);
+            assert(jobPtr->consumed <= jobPtr->src.size);
+            toFlush = produced - flushed;
+            /* if toFlush==0, nothing is available to flush.
+             * However, jobID is expected to still be active:
+             * if jobID was already completed and fully flushed,
+             * ZSTDMT_flushProduced() should have already moved onto next job.
+             * Therefore, some input has not yet been consumed. */
+            if (toFlush==0) {
+                assert(jobPtr->consumed < jobPtr->src.size);
+            }
+        }
+        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
+    }
+
+    return toFlush;
+}
+
+
+/* ------------------------------------------ */
+/* =====   Multi-threaded compression   ===== */
+/* ------------------------------------------ */
+
+static unsigned ZSTDMT_computeTargetJobLog(ZSTD_CCtx_params const params)
+{
+    unsigned jobLog;
+    if (params.ldmParams.enableLdm) {
+        /* In Long Range Mode, the windowLog is typically oversized.
+         * In which case, it's preferable to determine the jobSize
+         * based on chainLog instead. */
+        jobLog = MAX(21, params.cParams.chainLog + 4);
+    } else {
+        jobLog = MAX(20, params.cParams.windowLog + 2);
+    }
+    return MIN(jobLog, (unsigned)ZSTDMT_JOBLOG_MAX);
+}
+
+static int ZSTDMT_overlapLog_default(ZSTD_strategy strat)
+{
+    switch(strat)
+    {
+        case ZSTD_btultra2:
+            return 9;
+        case ZSTD_btultra:
+        case ZSTD_btopt:
+            return 8;
+        case ZSTD_btlazy2:
+        case ZSTD_lazy2:
+            return 7;
+        case ZSTD_lazy:
+        case ZSTD_greedy:
+        case ZSTD_dfast:
+        case ZSTD_fast:
+        default:;
+    }
+    return 6;
+}
+
+static int ZSTDMT_overlapLog(int ovlog, ZSTD_strategy strat)
+{
+    assert(0 <= ovlog && ovlog <= 9);
+    if (ovlog == 0) return ZSTDMT_overlapLog_default(strat);
+    return ovlog;
+}
+
+static size_t ZSTDMT_computeOverlapSize(ZSTD_CCtx_params const params)
+{
+    int const overlapRLog = 9 - ZSTDMT_overlapLog(params.overlapLog, params.cParams.strategy);
+    int ovLog = (overlapRLog >= 8) ? 0 : (params.cParams.windowLog - overlapRLog);
+    assert(0 <= overlapRLog && overlapRLog <= 8);
+    if (params.ldmParams.enableLdm) {
+        /* In Long Range Mode, the windowLog is typically oversized.
+         * In which case, it's preferable to determine the jobSize
+         * based on chainLog instead.
+         * Then, ovLog becomes a fraction of the jobSize, rather than windowSize */
+        ovLog = MIN(params.cParams.windowLog, ZSTDMT_computeTargetJobLog(params) - 2)
+                - overlapRLog;
+    }
+    assert(0 <= ovLog && ovLog <= ZSTD_WINDOWLOG_MAX);
+    DEBUGLOG(4, "overlapLog : %i", params.overlapLog);
+    DEBUGLOG(4, "overlap size : %i", 1 << ovLog);
+    return (ovLog==0) ? 0 : (size_t)1 << ovLog;
+}
+
+static unsigned
+ZSTDMT_computeNbJobs(ZSTD_CCtx_params params, size_t srcSize, unsigned nbWorkers)
+{
+    assert(nbWorkers>0);
+    {   size_t const jobSizeTarget = (size_t)1 << ZSTDMT_computeTargetJobLog(params);
+        size_t const jobMaxSize = jobSizeTarget << 2;
+        size_t const passSizeMax = jobMaxSize * nbWorkers;
+        unsigned const multiplier = (unsigned)(srcSize / passSizeMax) + 1;
+        unsigned const nbJobsLarge = multiplier * nbWorkers;
+        unsigned const nbJobsMax = (unsigned)(srcSize / jobSizeTarget) + 1;
+        unsigned const nbJobsSmall = MIN(nbJobsMax, nbWorkers);
+        return (multiplier>1) ? nbJobsLarge : nbJobsSmall;
+}   }
+
+/* ZSTDMT_compress_advanced_internal() :
+ * This is a blocking function : it will only give back control to caller after finishing its compression job.
+ */
+static size_t ZSTDMT_compress_advanced_internal(
+                ZSTDMT_CCtx* mtctx,
+                void* dst, size_t dstCapacity,
+          const void* src, size_t srcSize,
+          const ZSTD_CDict* cdict,
+                ZSTD_CCtx_params params)
+{
+    ZSTD_CCtx_params const jobParams = ZSTDMT_initJobCCtxParams(params);
+    size_t const overlapSize = ZSTDMT_computeOverlapSize(params);
+    unsigned const nbJobs = ZSTDMT_computeNbJobs(params, srcSize, params.nbWorkers);
+    size_t const proposedJobSize = (srcSize + (nbJobs-1)) / nbJobs;
+    size_t const avgJobSize = (((proposedJobSize-1) & 0x1FFFF) < 0x7FFF) ? proposedJobSize + 0xFFFF : proposedJobSize;   /* avoid too small last block */
+    const char* const srcStart = (const char*)src;
+    size_t remainingSrcSize = srcSize;
+    unsigned const compressWithinDst = (dstCapacity >= ZSTD_compressBound(srcSize)) ? nbJobs : (unsigned)(dstCapacity / ZSTD_compressBound(avgJobSize));  /* presumes avgJobSize >= 256 KB, which should be the case */
+    size_t frameStartPos = 0, dstBufferPos = 0;
+    assert(jobParams.nbWorkers == 0);
+    assert(mtctx->cctxPool->totalCCtx == params.nbWorkers);
+
+    params.jobSize = (U32)avgJobSize;
+    DEBUGLOG(4, "ZSTDMT_compress_advanced_internal: nbJobs=%2u (rawSize=%u bytes; fixedSize=%u) ",
+                nbJobs, (U32)proposedJobSize, (U32)avgJobSize);
+
+    if ((nbJobs==1) | (params.nbWorkers<=1)) {   /* fallback to single-thread mode : this is a blocking invocation anyway */
+        ZSTD_CCtx* const cctx = mtctx->cctxPool->cctx[0];
+        DEBUGLOG(4, "ZSTDMT_compress_advanced_internal: fallback to single-thread mode");
+        if (cdict) return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, jobParams.fParams);
+        return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, NULL, 0, jobParams);
+    }
+
+    assert(avgJobSize >= 256 KB);  /* condition for ZSTD_compressBound(A) + ZSTD_compressBound(B) <= ZSTD_compressBound(A+B), required to compress directly into Dst (no additional buffer) */
+    ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(avgJobSize) );
+    if (ZSTDMT_serialState_reset(&mtctx->serial, mtctx->seqPool, params, avgJobSize))
+        return ERROR(memory_allocation);
+
+    FORWARD_IF_ERROR( ZSTDMT_expandJobsTable(mtctx, nbJobs) );  /* only expands if necessary */
+
+    {   unsigned u;
+        for (u=0; u<nbJobs; u++) {
+            size_t const jobSize = MIN(remainingSrcSize, avgJobSize);
+            size_t const dstBufferCapacity = ZSTD_compressBound(jobSize);
+            buffer_t const dstAsBuffer = { (char*)dst + dstBufferPos, dstBufferCapacity };
+            buffer_t const dstBuffer = u < compressWithinDst ? dstAsBuffer : g_nullBuffer;
+            size_t dictSize = u ? overlapSize : 0;
+
+            mtctx->jobs[u].prefix.start = srcStart + frameStartPos - dictSize;
+            mtctx->jobs[u].prefix.size = dictSize;
+            mtctx->jobs[u].src.start = srcStart + frameStartPos;
+            mtctx->jobs[u].src.size = jobSize; assert(jobSize > 0);  /* avoid job.src.size == 0 */
+            mtctx->jobs[u].consumed = 0;
+            mtctx->jobs[u].cSize = 0;
+            mtctx->jobs[u].cdict = (u==0) ? cdict : NULL;
+            mtctx->jobs[u].fullFrameSize = srcSize;
+            mtctx->jobs[u].params = jobParams;
+            /* do not calculate checksum within sections, but write it in header for first section */
+            mtctx->jobs[u].dstBuff = dstBuffer;
+            mtctx->jobs[u].cctxPool = mtctx->cctxPool;
+            mtctx->jobs[u].bufPool = mtctx->bufPool;
+            mtctx->jobs[u].seqPool = mtctx->seqPool;
+            mtctx->jobs[u].serial = &mtctx->serial;
+            mtctx->jobs[u].jobID = u;
+            mtctx->jobs[u].firstJob = (u==0);
+            mtctx->jobs[u].lastJob = (u==nbJobs-1);
+
+            DEBUGLOG(5, "ZSTDMT_compress_advanced_internal: posting job %u  (%u bytes)", u, (U32)jobSize);
+            DEBUG_PRINTHEX(6, mtctx->jobs[u].prefix.start, 12);
+            POOL_add(mtctx->factory, ZSTDMT_compressionJob, &mtctx->jobs[u]);
+
+            frameStartPos += jobSize;
+            dstBufferPos += dstBufferCapacity;
+            remainingSrcSize -= jobSize;
+    }   }
+
+    /* collect result */
+    {   size_t error = 0, dstPos = 0;
+        unsigned jobID;
+        for (jobID=0; jobID<nbJobs; jobID++) {
+            DEBUGLOG(5, "waiting for job %u ", jobID);
+            ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[jobID].job_mutex);
+            while (mtctx->jobs[jobID].consumed < mtctx->jobs[jobID].src.size) {
+                DEBUGLOG(5, "waiting for jobCompleted signal from job %u", jobID);
+                ZSTD_pthread_cond_wait(&mtctx->jobs[jobID].job_cond, &mtctx->jobs[jobID].job_mutex);
+            }
+            ZSTD_pthread_mutex_unlock(&mtctx->jobs[jobID].job_mutex);
+            DEBUGLOG(5, "ready to write job %u ", jobID);
+
+            {   size_t const cSize = mtctx->jobs[jobID].cSize;
+                if (ZSTD_isError(cSize)) error = cSize;
+                if ((!error) && (dstPos + cSize > dstCapacity)) error = ERROR(dstSize_tooSmall);
+                if (jobID) {   /* note : job 0 is written directly at dst, which is correct position */
+                    if (!error)
+                        memmove((char*)dst + dstPos, mtctx->jobs[jobID].dstBuff.start, cSize);  /* may overlap when job compressed within dst */
+                    if (jobID >= compressWithinDst) {  /* job compressed into its own buffer, which must be released */
+                        DEBUGLOG(5, "releasing buffer %u>=%u", jobID, compressWithinDst);
+                        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff);
+                }   }
+                mtctx->jobs[jobID].dstBuff = g_nullBuffer;
+                mtctx->jobs[jobID].cSize = 0;
+                dstPos += cSize ;
+            }
+        }  /* for (jobID=0; jobID<nbJobs; jobID++) */
+
+        DEBUGLOG(4, "checksumFlag : %u ", params.fParams.checksumFlag);
+        if (params.fParams.checksumFlag) {
+            U32 const checksum = (U32)XXH64_digest(&mtctx->serial.xxhState);
+            if (dstPos + 4 > dstCapacity) {
+                error = ERROR(dstSize_tooSmall);
+            } else {
+                DEBUGLOG(4, "writing checksum : %08X \n", checksum);
+                MEM_writeLE32((char*)dst + dstPos, checksum);
+                dstPos += 4;
+        }   }
+
+        if (!error) DEBUGLOG(4, "compressed size : %u  ", (U32)dstPos);
+        return error ? error : dstPos;
+    }
+}
+
+size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
+                                void* dst, size_t dstCapacity,
+                          const void* src, size_t srcSize,
+                          const ZSTD_CDict* cdict,
+                                ZSTD_parameters params,
+                                int overlapLog)
+{
+    ZSTD_CCtx_params cctxParams = mtctx->params;
+    cctxParams.cParams = params.cParams;
+    cctxParams.fParams = params.fParams;
+    assert(ZSTD_OVERLAPLOG_MIN <= overlapLog && overlapLog <= ZSTD_OVERLAPLOG_MAX);
+    cctxParams.overlapLog = overlapLog;
+    return ZSTDMT_compress_advanced_internal(mtctx,
+                                             dst, dstCapacity,
+                                             src, srcSize,
+                                             cdict, cctxParams);
+}
+
+
+size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,
+                           void* dst, size_t dstCapacity,
+                     const void* src, size_t srcSize,
+                           int compressionLevel)
+{
+    ZSTD_parameters params = ZSTD_getParams(compressionLevel, srcSize, 0);
+    int const overlapLog = ZSTDMT_overlapLog_default(params.cParams.strategy);
+    params.fParams.contentSizeFlag = 1;
+    return ZSTDMT_compress_advanced(mtctx, dst, dstCapacity, src, srcSize, NULL, params, overlapLog);
+}
+
+
+/* ====================================== */
+/* =======      Streaming API     ======= */
+/* ====================================== */
+
+size_t ZSTDMT_initCStream_internal(
+        ZSTDMT_CCtx* mtctx,
+        const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,
+        const ZSTD_CDict* cdict, ZSTD_CCtx_params params,
+        unsigned long long pledgedSrcSize)
+{
+    DEBUGLOG(4, "ZSTDMT_initCStream_internal (pledgedSrcSize=%u, nbWorkers=%u, cctxPool=%u)",
+                (U32)pledgedSrcSize, params.nbWorkers, mtctx->cctxPool->totalCCtx);
+
+    /* params supposed partially fully validated at this point */
+    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
+    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
+
+    /* init */
+    if (params.nbWorkers != mtctx->params.nbWorkers)
+        FORWARD_IF_ERROR( ZSTDMT_resize(mtctx, params.nbWorkers) );
+
+    if (params.jobSize != 0 && params.jobSize < ZSTDMT_JOBSIZE_MIN) params.jobSize = ZSTDMT_JOBSIZE_MIN;
+    if (params.jobSize > (size_t)ZSTDMT_JOBSIZE_MAX) params.jobSize = (size_t)ZSTDMT_JOBSIZE_MAX;
+
+    mtctx->singleBlockingThread = (pledgedSrcSize <= ZSTDMT_JOBSIZE_MIN);  /* do not trigger multi-threading when srcSize is too small */
+    if (mtctx->singleBlockingThread) {
+        ZSTD_CCtx_params const singleThreadParams = ZSTDMT_initJobCCtxParams(params);
+        DEBUGLOG(5, "ZSTDMT_initCStream_internal: switch to single blocking thread mode");
+        assert(singleThreadParams.nbWorkers == 0);
+        return ZSTD_initCStream_internal(mtctx->cctxPool->cctx[0],
+                                         dict, dictSize, cdict,
+                                         singleThreadParams, pledgedSrcSize);
+    }
+
+    DEBUGLOG(4, "ZSTDMT_initCStream_internal: %u workers", params.nbWorkers);
+
+    if (mtctx->allJobsCompleted == 0) {   /* previous compression not correctly finished */
+        ZSTDMT_waitForAllJobsCompleted(mtctx);
+        ZSTDMT_releaseAllJobResources(mtctx);
+        mtctx->allJobsCompleted = 1;
+    }
+
+    mtctx->params = params;
+    mtctx->frameContentSize = pledgedSrcSize;
+    if (dict) {
+        ZSTD_freeCDict(mtctx->cdictLocal);
+        mtctx->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,
+                                                    ZSTD_dlm_byCopy, dictContentType, /* note : a loadPrefix becomes an internal CDict */
+                                                    params.cParams, mtctx->cMem);
+        mtctx->cdict = mtctx->cdictLocal;
+        if (mtctx->cdictLocal == NULL) return ERROR(memory_allocation);
+    } else {
+        ZSTD_freeCDict(mtctx->cdictLocal);
+        mtctx->cdictLocal = NULL;
+        mtctx->cdict = cdict;
+    }
+
+    mtctx->targetPrefixSize = ZSTDMT_computeOverlapSize(params);
+    DEBUGLOG(4, "overlapLog=%i => %u KB", params.overlapLog, (U32)(mtctx->targetPrefixSize>>10));
+    mtctx->targetSectionSize = params.jobSize;
+    if (mtctx->targetSectionSize == 0) {
+        mtctx->targetSectionSize = 1ULL << ZSTDMT_computeTargetJobLog(params);
+    }
+    assert(mtctx->targetSectionSize <= (size_t)ZSTDMT_JOBSIZE_MAX);
+
+    if (params.rsyncable) {
+        /* Aim for the targetsectionSize as the average job size. */
+        U32 const jobSizeMB = (U32)(mtctx->targetSectionSize >> 20);
+        U32 const rsyncBits = ZSTD_highbit32(jobSizeMB) + 20;
+        assert(jobSizeMB >= 1);
+        DEBUGLOG(4, "rsyncLog = %u", rsyncBits);
+        mtctx->rsync.hash = 0;
+        mtctx->rsync.hitMask = (1ULL << rsyncBits) - 1;
+        mtctx->rsync.primePower = ZSTD_rollingHash_primePower(RSYNC_LENGTH);
+    }
+    if (mtctx->targetSectionSize < mtctx->targetPrefixSize) mtctx->targetSectionSize = mtctx->targetPrefixSize;  /* job size must be >= overlap size */
+    DEBUGLOG(4, "Job Size : %u KB (note : set to %u)", (U32)(mtctx->targetSectionSize>>10), (U32)params.jobSize);
+    DEBUGLOG(4, "inBuff Size : %u KB", (U32)(mtctx->targetSectionSize>>10));
+    ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(mtctx->targetSectionSize));
+    {
+        /* If ldm is enabled we need windowSize space. */
+        size_t const windowSize = mtctx->params.ldmParams.enableLdm ? (1U << mtctx->params.cParams.windowLog) : 0;
+        /* Two buffers of slack, plus extra space for the overlap
+         * This is the minimum slack that LDM works with. One extra because
+         * flush might waste up to targetSectionSize-1 bytes. Another extra
+         * for the overlap (if > 0), then one to fill which doesn't overlap
+         * with the LDM window.
+         */
+        size_t const nbSlackBuffers = 2 + (mtctx->targetPrefixSize > 0);
+        size_t const slackSize = mtctx->targetSectionSize * nbSlackBuffers;
+        /* Compute the total size, and always have enough slack */
+        size_t const nbWorkers = MAX(mtctx->params.nbWorkers, 1);
+        size_t const sectionsSize = mtctx->targetSectionSize * nbWorkers;
+        size_t const capacity = MAX(windowSize, sectionsSize) + slackSize;
+        if (mtctx->roundBuff.capacity < capacity) {
+            if (mtctx->roundBuff.buffer)
+                ZSTD_free(mtctx->roundBuff.buffer, mtctx->cMem);
+            mtctx->roundBuff.buffer = (BYTE*)ZSTD_malloc(capacity, mtctx->cMem);
+            if (mtctx->roundBuff.buffer == NULL) {
+                mtctx->roundBuff.capacity = 0;
+                return ERROR(memory_allocation);
+            }
+            mtctx->roundBuff.capacity = capacity;
+        }
+    }
+    DEBUGLOG(4, "roundBuff capacity : %u KB", (U32)(mtctx->roundBuff.capacity>>10));
+    mtctx->roundBuff.pos = 0;
+    mtctx->inBuff.buffer = g_nullBuffer;
+    mtctx->inBuff.filled = 0;
+    mtctx->inBuff.prefix = kNullRange;
+    mtctx->doneJobID = 0;
+    mtctx->nextJobID = 0;
+    mtctx->frameEnded = 0;
+    mtctx->allJobsCompleted = 0;
+    mtctx->consumed = 0;
+    mtctx->produced = 0;
+    if (ZSTDMT_serialState_reset(&mtctx->serial, mtctx->seqPool, params, mtctx->targetSectionSize))
+        return ERROR(memory_allocation);
+    return 0;
+}
+
+size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
+                             const void* dict, size_t dictSize,
+                                   ZSTD_parameters params,
+                                   unsigned long long pledgedSrcSize)
+{
+    ZSTD_CCtx_params cctxParams = mtctx->params;  /* retrieve sticky params */
+    DEBUGLOG(4, "ZSTDMT_initCStream_advanced (pledgedSrcSize=%u)", (U32)pledgedSrcSize);
+    cctxParams.cParams = params.cParams;
+    cctxParams.fParams = params.fParams;
+    return ZSTDMT_initCStream_internal(mtctx, dict, dictSize, ZSTD_dct_auto, NULL,
+                                       cctxParams, pledgedSrcSize);
+}
+
+size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,
+                               const ZSTD_CDict* cdict,
+                                     ZSTD_frameParameters fParams,
+                                     unsigned long long pledgedSrcSize)
+{
+    ZSTD_CCtx_params cctxParams = mtctx->params;
+    if (cdict==NULL) return ERROR(dictionary_wrong);   /* method incompatible with NULL cdict */
+    cctxParams.cParams = ZSTD_getCParamsFromCDict(cdict);
+    cctxParams.fParams = fParams;
+    return ZSTDMT_initCStream_internal(mtctx, NULL, 0 /*dictSize*/, ZSTD_dct_auto, cdict,
+                                       cctxParams, pledgedSrcSize);
+}
+
+
+/* ZSTDMT_resetCStream() :
+ * pledgedSrcSize can be zero == unknown (for the time being)
+ * prefer using ZSTD_CONTENTSIZE_UNKNOWN,
+ * as `0` might mean "empty" in the future */
+size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize)
+{
+    if (!pledgedSrcSize) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
+    return ZSTDMT_initCStream_internal(mtctx, NULL, 0, ZSTD_dct_auto, 0, mtctx->params,
+                                       pledgedSrcSize);
+}
+
+size_t ZSTDMT_initCStream(ZSTDMT_CCtx* mtctx, int compressionLevel) {
+    ZSTD_parameters const params = ZSTD_getParams(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, 0);
+    ZSTD_CCtx_params cctxParams = mtctx->params;   /* retrieve sticky params */
+    DEBUGLOG(4, "ZSTDMT_initCStream (cLevel=%i)", compressionLevel);
+    cctxParams.cParams = params.cParams;
+    cctxParams.fParams = params.fParams;
+    return ZSTDMT_initCStream_internal(mtctx, NULL, 0, ZSTD_dct_auto, NULL, cctxParams, ZSTD_CONTENTSIZE_UNKNOWN);
+}
+
+
+/* ZSTDMT_writeLastEmptyBlock()
+ * Write a single empty block with an end-of-frame to finish a frame.
+ * Job must be created from streaming variant.
+ * This function is always successful if expected conditions are fulfilled.
+ */
+static void ZSTDMT_writeLastEmptyBlock(ZSTDMT_jobDescription* job)
+{
+    assert(job->lastJob == 1);
+    assert(job->src.size == 0);   /* last job is empty -> will be simplified into a last empty block */
+    assert(job->firstJob == 0);   /* cannot be first job, as it also needs to create frame header */
+    assert(job->dstBuff.start == NULL);   /* invoked from streaming variant only (otherwise, dstBuff might be user's output) */
+    job->dstBuff = ZSTDMT_getBuffer(job->bufPool);
+    if (job->dstBuff.start == NULL) {
+      job->cSize = ERROR(memory_allocation);
+      return;
+    }
+    assert(job->dstBuff.capacity >= ZSTD_blockHeaderSize);   /* no buffer should ever be that small */
+    job->src = kNullRange;
+    job->cSize = ZSTD_writeLastEmptyBlock(job->dstBuff.start, job->dstBuff.capacity);
+    assert(!ZSTD_isError(job->cSize));
+    assert(job->consumed == 0);
+}
+
+static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* mtctx, size_t srcSize, ZSTD_EndDirective endOp)
+{
+    unsigned const jobID = mtctx->nextJobID & mtctx->jobIDMask;
+    int const endFrame = (endOp == ZSTD_e_end);
+
+    if (mtctx->nextJobID > mtctx->doneJobID + mtctx->jobIDMask) {
+        DEBUGLOG(5, "ZSTDMT_createCompressionJob: will not create new job : table is full");
+        assert((mtctx->nextJobID & mtctx->jobIDMask) == (mtctx->doneJobID & mtctx->jobIDMask));
+        return 0;
+    }
+
+    if (!mtctx->jobReady) {
+        BYTE const* src = (BYTE const*)mtctx->inBuff.buffer.start;
+        DEBUGLOG(5, "ZSTDMT_createCompressionJob: preparing job %u to compress %u bytes with %u preload ",
+                    mtctx->nextJobID, (U32)srcSize, (U32)mtctx->inBuff.prefix.size);
+        mtctx->jobs[jobID].src.start = src;
+        mtctx->jobs[jobID].src.size = srcSize;
+        assert(mtctx->inBuff.filled >= srcSize);
+        mtctx->jobs[jobID].prefix = mtctx->inBuff.prefix;
+        mtctx->jobs[jobID].consumed = 0;
+        mtctx->jobs[jobID].cSize = 0;
+        mtctx->jobs[jobID].params = mtctx->params;
+        mtctx->jobs[jobID].cdict = mtctx->nextJobID==0 ? mtctx->cdict : NULL;
+        mtctx->jobs[jobID].fullFrameSize = mtctx->frameContentSize;
+        mtctx->jobs[jobID].dstBuff = g_nullBuffer;
+        mtctx->jobs[jobID].cctxPool = mtctx->cctxPool;
+        mtctx->jobs[jobID].bufPool = mtctx->bufPool;
+        mtctx->jobs[jobID].seqPool = mtctx->seqPool;
+        mtctx->jobs[jobID].serial = &mtctx->serial;
+        mtctx->jobs[jobID].jobID = mtctx->nextJobID;
+        mtctx->jobs[jobID].firstJob = (mtctx->nextJobID==0);
+        mtctx->jobs[jobID].lastJob = endFrame;
+        mtctx->jobs[jobID].frameChecksumNeeded = mtctx->params.fParams.checksumFlag && endFrame && (mtctx->nextJobID>0);
+        mtctx->jobs[jobID].dstFlushed = 0;
+
+        /* Update the round buffer pos and clear the input buffer to be reset */
+        mtctx->roundBuff.pos += srcSize;
+        mtctx->inBuff.buffer = g_nullBuffer;
+        mtctx->inBuff.filled = 0;
+        /* Set the prefix */
+        if (!endFrame) {
+            size_t const newPrefixSize = MIN(srcSize, mtctx->targetPrefixSize);
+            mtctx->inBuff.prefix.start = src + srcSize - newPrefixSize;
+            mtctx->inBuff.prefix.size = newPrefixSize;
+        } else {   /* endFrame==1 => no need for another input buffer */
+            mtctx->inBuff.prefix = kNullRange;
+            mtctx->frameEnded = endFrame;
+            if (mtctx->nextJobID == 0) {
+                /* single job exception : checksum is already calculated directly within worker thread */
+                mtctx->params.fParams.checksumFlag = 0;
+        }   }
+
+        if ( (srcSize == 0)
+          && (mtctx->nextJobID>0)/*single job must also write frame header*/ ) {
+            DEBUGLOG(5, "ZSTDMT_createCompressionJob: creating a last empty block to end frame");
+            assert(endOp == ZSTD_e_end);  /* only possible case : need to end the frame with an empty last block */
+            ZSTDMT_writeLastEmptyBlock(mtctx->jobs + jobID);
+            mtctx->nextJobID++;
+            return 0;
+        }
+    }
+
+    DEBUGLOG(5, "ZSTDMT_createCompressionJob: posting job %u : %u bytes  (end:%u, jobNb == %u (mod:%u))",
+                mtctx->nextJobID,
+                (U32)mtctx->jobs[jobID].src.size,
+                mtctx->jobs[jobID].lastJob,
+                mtctx->nextJobID,
+                jobID);
+    if (POOL_tryAdd(mtctx->factory, ZSTDMT_compressionJob, &mtctx->jobs[jobID])) {
+        mtctx->nextJobID++;
+        mtctx->jobReady = 0;
+    } else {
+        DEBUGLOG(5, "ZSTDMT_createCompressionJob: no worker available for job %u", mtctx->nextJobID);
+        mtctx->jobReady = 1;
+    }
+    return 0;
+}
+
+
+/*! ZSTDMT_flushProduced() :
+ *  flush whatever data has been produced but not yet flushed in current job.
+ *  move to next job if current one is fully flushed.
+ * `output` : `pos` will be updated with amount of data flushed .
+ * `blockToFlush` : if >0, the function will block and wait if there is no data available to flush .
+ * @return : amount of data remaining within internal buffer, 0 if no more, 1 if unknown but > 0, or an error code */
+static size_t ZSTDMT_flushProduced(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, unsigned blockToFlush, ZSTD_EndDirective end)
+{
+    unsigned const wJobID = mtctx->doneJobID & mtctx->jobIDMask;
+    DEBUGLOG(5, "ZSTDMT_flushProduced (blocking:%u , job %u <= %u)",
+                blockToFlush, mtctx->doneJobID, mtctx->nextJobID);
+    assert(output->size >= output->pos);
+
+    ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[wJobID].job_mutex);
+    if (  blockToFlush
+      && (mtctx->doneJobID < mtctx->nextJobID) ) {
+        assert(mtctx->jobs[wJobID].dstFlushed <= mtctx->jobs[wJobID].cSize);
+        while (mtctx->jobs[wJobID].dstFlushed == mtctx->jobs[wJobID].cSize) {  /* nothing to flush */
+            if (mtctx->jobs[wJobID].consumed == mtctx->jobs[wJobID].src.size) {
+                DEBUGLOG(5, "job %u is completely consumed (%u == %u) => don't wait for cond, there will be none",
+                            mtctx->doneJobID, (U32)mtctx->jobs[wJobID].consumed, (U32)mtctx->jobs[wJobID].src.size);
+                break;
+            }
+            DEBUGLOG(5, "waiting for something to flush from job %u (currently flushed: %u bytes)",
+                        mtctx->doneJobID, (U32)mtctx->jobs[wJobID].dstFlushed);
+            ZSTD_pthread_cond_wait(&mtctx->jobs[wJobID].job_cond, &mtctx->jobs[wJobID].job_mutex);  /* block when nothing to flush but some to come */
+    }   }
+
+    /* try to flush something */
+    {   size_t cSize = mtctx->jobs[wJobID].cSize;                  /* shared */
+        size_t const srcConsumed = mtctx->jobs[wJobID].consumed;   /* shared */
+        size_t const srcSize = mtctx->jobs[wJobID].src.size;       /* read-only, could be done after mutex lock, but no-declaration-after-statement */
+        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
+        if (ZSTD_isError(cSize)) {
+            DEBUGLOG(5, "ZSTDMT_flushProduced: job %u : compression error detected : %s",
+                        mtctx->doneJobID, ZSTD_getErrorName(cSize));
+            ZSTDMT_waitForAllJobsCompleted(mtctx);
+            ZSTDMT_releaseAllJobResources(mtctx);
+            return cSize;
+        }
+        /* add frame checksum if necessary (can only happen once) */
+        assert(srcConsumed <= srcSize);
+        if ( (srcConsumed == srcSize)   /* job completed -> worker no longer active */
+          && mtctx->jobs[wJobID].frameChecksumNeeded ) {
+            U32 const checksum = (U32)XXH64_digest(&mtctx->serial.xxhState);
+            DEBUGLOG(4, "ZSTDMT_flushProduced: writing checksum : %08X \n", checksum);
+            MEM_writeLE32((char*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].cSize, checksum);
+            cSize += 4;
+            mtctx->jobs[wJobID].cSize += 4;  /* can write this shared value, as worker is no longer active */
+            mtctx->jobs[wJobID].frameChecksumNeeded = 0;
+        }
+
+        if (cSize > 0) {   /* compression is ongoing or completed */
+            size_t const toFlush = MIN(cSize - mtctx->jobs[wJobID].dstFlushed, output->size - output->pos);
+            DEBUGLOG(5, "ZSTDMT_flushProduced: Flushing %u bytes from job %u (completion:%u/%u, generated:%u)",
+                        (U32)toFlush, mtctx->doneJobID, (U32)srcConsumed, (U32)srcSize, (U32)cSize);
+            assert(mtctx->doneJobID < mtctx->nextJobID);
+            assert(cSize >= mtctx->jobs[wJobID].dstFlushed);
+            assert(mtctx->jobs[wJobID].dstBuff.start != NULL);
+            memcpy((char*)output->dst + output->pos,
+                   (const char*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].dstFlushed,
+                   toFlush);
+            output->pos += toFlush;
+            mtctx->jobs[wJobID].dstFlushed += toFlush;  /* can write : this value is only used by mtctx */
+
+            if ( (srcConsumed == srcSize)    /* job is completed */
+              && (mtctx->jobs[wJobID].dstFlushed == cSize) ) {   /* output buffer fully flushed => free this job position */
+                DEBUGLOG(5, "Job %u completed (%u bytes), moving to next one",
+                        mtctx->doneJobID, (U32)mtctx->jobs[wJobID].dstFlushed);
+                ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[wJobID].dstBuff);
+                DEBUGLOG(5, "dstBuffer released");
+                mtctx->jobs[wJobID].dstBuff = g_nullBuffer;
+                mtctx->jobs[wJobID].cSize = 0;   /* ensure this job slot is considered "not started" in future check */
+                mtctx->consumed += srcSize;
+                mtctx->produced += cSize;
+                mtctx->doneJobID++;
+        }   }
+
+        /* return value : how many bytes left in buffer ; fake it to 1 when unknown but >0 */
+        if (cSize > mtctx->jobs[wJobID].dstFlushed) return (cSize - mtctx->jobs[wJobID].dstFlushed);
+        if (srcSize > srcConsumed) return 1;   /* current job not completely compressed */
+    }
+    if (mtctx->doneJobID < mtctx->nextJobID) return 1;   /* some more jobs ongoing */
+    if (mtctx->jobReady) return 1;      /* one job is ready to push, just not yet in the list */
+    if (mtctx->inBuff.filled > 0) return 1;   /* input is not empty, and still needs to be converted into a job */
+    mtctx->allJobsCompleted = mtctx->frameEnded;   /* all jobs are entirely flushed => if this one is last one, frame is completed */
+    if (end == ZSTD_e_end) return !mtctx->frameEnded;  /* for ZSTD_e_end, question becomes : is frame completed ? instead of : are internal buffers fully flushed ? */
+    return 0;   /* internal buffers fully flushed */
+}
+
+/**
+ * Returns the range of data used by the earliest job that is not yet complete.
+ * If the data of the first job is broken up into two segments, we cover both
+ * sections.
+ */
+static range_t ZSTDMT_getInputDataInUse(ZSTDMT_CCtx* mtctx)
+{
+    unsigned const firstJobID = mtctx->doneJobID;
+    unsigned const lastJobID = mtctx->nextJobID;
+    unsigned jobID;
+
+    for (jobID = firstJobID; jobID < lastJobID; ++jobID) {
+        unsigned const wJobID = jobID & mtctx->jobIDMask;
+        size_t consumed;
+
+        ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[wJobID].job_mutex);
+        consumed = mtctx->jobs[wJobID].consumed;
+        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
+
+        if (consumed < mtctx->jobs[wJobID].src.size) {
+            range_t range = mtctx->jobs[wJobID].prefix;
+            if (range.size == 0) {
+                /* Empty prefix */
+                range = mtctx->jobs[wJobID].src;
+            }
+            /* Job source in multiple segments not supported yet */
+            assert(range.start <= mtctx->jobs[wJobID].src.start);
+            return range;
+        }
+    }
+    return kNullRange;
+}
+
+/**
+ * Returns non-zero iff buffer and range overlap.
+ */
+static int ZSTDMT_isOverlapped(buffer_t buffer, range_t range)
+{
+    BYTE const* const bufferStart = (BYTE const*)buffer.start;
+    BYTE const* const bufferEnd = bufferStart + buffer.capacity;
+    BYTE const* const rangeStart = (BYTE const*)range.start;
+    BYTE const* const rangeEnd = rangeStart + range.size;
+
+    if (rangeStart == NULL || bufferStart == NULL)
+        return 0;
+    /* Empty ranges cannot overlap */
+    if (bufferStart == bufferEnd || rangeStart == rangeEnd)
+        return 0;
+
+    return bufferStart < rangeEnd && rangeStart < bufferEnd;
+}
+
+static int ZSTDMT_doesOverlapWindow(buffer_t buffer, ZSTD_window_t window)
+{
+    range_t extDict;
+    range_t prefix;
+
+    DEBUGLOG(5, "ZSTDMT_doesOverlapWindow");
+    extDict.start = window.dictBase + window.lowLimit;
+    extDict.size = window.dictLimit - window.lowLimit;
+
+    prefix.start = window.base + window.dictLimit;
+    prefix.size = window.nextSrc - (window.base + window.dictLimit);
+    DEBUGLOG(5, "extDict [0x%zx, 0x%zx)",
+                (size_t)extDict.start,
+                (size_t)extDict.start + extDict.size);
+    DEBUGLOG(5, "prefix  [0x%zx, 0x%zx)",
+                (size_t)prefix.start,
+                (size_t)prefix.start + prefix.size);
+
+    return ZSTDMT_isOverlapped(buffer, extDict)
+        || ZSTDMT_isOverlapped(buffer, prefix);
+}
+
+static void ZSTDMT_waitForLdmComplete(ZSTDMT_CCtx* mtctx, buffer_t buffer)
+{
+    if (mtctx->params.ldmParams.enableLdm) {
+        ZSTD_pthread_mutex_t* mutex = &mtctx->serial.ldmWindowMutex;
+        DEBUGLOG(5, "ZSTDMT_waitForLdmComplete");
+        DEBUGLOG(5, "source  [0x%zx, 0x%zx)",
+                    (size_t)buffer.start,
+                    (size_t)buffer.start + buffer.capacity);
+        ZSTD_PTHREAD_MUTEX_LOCK(mutex);
+        while (ZSTDMT_doesOverlapWindow(buffer, mtctx->serial.ldmWindow)) {
+            DEBUGLOG(5, "Waiting for LDM to finish...");
+            ZSTD_pthread_cond_wait(&mtctx->serial.ldmWindowCond, mutex);
+        }
+        DEBUGLOG(6, "Done waiting for LDM to finish");
+        ZSTD_pthread_mutex_unlock(mutex);
+    }
+}
+
+/**
+ * Attempts to set the inBuff to the next section to fill.
+ * If any part of the new section is still in use we give up.
+ * Returns non-zero if the buffer is filled.
+ */
+static int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx* mtctx)
+{
+    range_t const inUse = ZSTDMT_getInputDataInUse(mtctx);
+    size_t const spaceLeft = mtctx->roundBuff.capacity - mtctx->roundBuff.pos;
+    size_t const target = mtctx->targetSectionSize;
+    buffer_t buffer;
+
+    DEBUGLOG(5, "ZSTDMT_tryGetInputRange");
+    assert(mtctx->inBuff.buffer.start == NULL);
+    assert(mtctx->roundBuff.capacity >= target);
+
+    if (spaceLeft < target) {
+        /* ZSTD_invalidateRepCodes() doesn't work for extDict variants.
+         * Simply copy the prefix to the beginning in that case.
+         */
+        BYTE* const start = (BYTE*)mtctx->roundBuff.buffer;
+        size_t const prefixSize = mtctx->inBuff.prefix.size;
+
+        buffer.start = start;
+        buffer.capacity = prefixSize;
+        if (ZSTDMT_isOverlapped(buffer, inUse)) {
+            DEBUGLOG(5, "Waiting for buffer...");
+            return 0;
+        }
+        ZSTDMT_waitForLdmComplete(mtctx, buffer);
+        memmove(start, mtctx->inBuff.prefix.start, prefixSize);
+        mtctx->inBuff.prefix.start = start;
+        mtctx->roundBuff.pos = prefixSize;
+    }
+    buffer.start = mtctx->roundBuff.buffer + mtctx->roundBuff.pos;
+    buffer.capacity = target;
+
+    if (ZSTDMT_isOverlapped(buffer, inUse)) {
+        DEBUGLOG(5, "Waiting for buffer...");
+        return 0;
+    }
+    assert(!ZSTDMT_isOverlapped(buffer, mtctx->inBuff.prefix));
+
+    ZSTDMT_waitForLdmComplete(mtctx, buffer);
+
+    DEBUGLOG(5, "Using prefix range [%zx, %zx)",
+                (size_t)mtctx->inBuff.prefix.start,
+                (size_t)mtctx->inBuff.prefix.start + mtctx->inBuff.prefix.size);
+    DEBUGLOG(5, "Using source range [%zx, %zx)",
+                (size_t)buffer.start,
+                (size_t)buffer.start + buffer.capacity);
+
+
+    mtctx->inBuff.buffer = buffer;
+    mtctx->inBuff.filled = 0;
+    assert(mtctx->roundBuff.pos + buffer.capacity <= mtctx->roundBuff.capacity);
+    return 1;
+}
+
+typedef struct {
+  size_t toLoad;  /* The number of bytes to load from the input. */
+  int flush;      /* Boolean declaring if we must flush because we found a synchronization point. */
+} syncPoint_t;
+
+/**
+ * Searches through the input for a synchronization point. If one is found, we
+ * will instruct the caller to flush, and return the number of bytes to load.
+ * Otherwise, we will load as many bytes as possible and instruct the caller
+ * to continue as normal.
+ */
+static syncPoint_t
+findSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input)
+{
+    BYTE const* const istart = (BYTE const*)input.src + input.pos;
+    U64 const primePower = mtctx->rsync.primePower;
+    U64 const hitMask = mtctx->rsync.hitMask;
+
+    syncPoint_t syncPoint;
+    U64 hash;
+    BYTE const* prev;
+    size_t pos;
+
+    syncPoint.toLoad = MIN(input.size - input.pos, mtctx->targetSectionSize - mtctx->inBuff.filled);
+    syncPoint.flush = 0;
+    if (!mtctx->params.rsyncable)
+        /* Rsync is disabled. */
+        return syncPoint;
+    if (mtctx->inBuff.filled + syncPoint.toLoad < RSYNC_LENGTH)
+        /* Not enough to compute the hash.
+         * We will miss any synchronization points in this RSYNC_LENGTH byte
+         * window. However, since it depends only in the internal buffers, if the
+         * state is already synchronized, we will remain synchronized.
+         * Additionally, the probability that we miss a synchronization point is
+         * low: RSYNC_LENGTH / targetSectionSize.
+         */
+        return syncPoint;
+    /* Initialize the loop variables. */
+    if (mtctx->inBuff.filled >= RSYNC_LENGTH) {
+        /* We have enough bytes buffered to initialize the hash.
+         * Start scanning at the beginning of the input.
+         */
+        pos = 0;
+        prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH;
+        hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH);
+    } else {
+        /* We don't have enough bytes buffered to initialize the hash, but
+         * we know we have at least RSYNC_LENGTH bytes total.
+         * Start scanning after the first RSYNC_LENGTH bytes less the bytes
+         * already buffered.
+         */
+        pos = RSYNC_LENGTH - mtctx->inBuff.filled;
+        prev = (BYTE const*)mtctx->inBuff.buffer.start - pos;
+        hash = ZSTD_rollingHash_compute(mtctx->inBuff.buffer.start, mtctx->inBuff.filled);
+        hash = ZSTD_rollingHash_append(hash, istart, pos);
+    }
+    /* Starting with the hash of the previous RSYNC_LENGTH bytes, roll
+     * through the input. If we hit a synchronization point, then cut the
+     * job off, and tell the compressor to flush the job. Otherwise, load
+     * all the bytes and continue as normal.
+     * If we go too long without a synchronization point (targetSectionSize)
+     * then a block will be emitted anyways, but this is okay, since if we
+     * are already synchronized we will remain synchronized.
+     */
+    for (; pos < syncPoint.toLoad; ++pos) {
+        BYTE const toRemove = pos < RSYNC_LENGTH ? prev[pos] : istart[pos - RSYNC_LENGTH];
+        /* if (pos >= RSYNC_LENGTH) assert(ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash); */
+        hash = ZSTD_rollingHash_rotate(hash, toRemove, istart[pos], primePower);
+        if ((hash & hitMask) == hitMask) {
+            syncPoint.toLoad = pos + 1;
+            syncPoint.flush = 1;
+            break;
+        }
+    }
+    return syncPoint;
+}
+
+size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx)
+{
+    size_t hintInSize = mtctx->targetSectionSize - mtctx->inBuff.filled;
+    if (hintInSize==0) hintInSize = mtctx->targetSectionSize;
+    return hintInSize;
+}
+
+/** ZSTDMT_compressStream_generic() :
+ *  internal use only - exposed to be invoked from zstd_compress.c
+ *  assumption : output and input are valid (pos <= size)
+ * @return : minimum amount of data remaining to flush, 0 if none */
+size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
+                                     ZSTD_outBuffer* output,
+                                     ZSTD_inBuffer* input,
+                                     ZSTD_EndDirective endOp)
+{
+    unsigned forwardInputProgress = 0;
+    DEBUGLOG(5, "ZSTDMT_compressStream_generic (endOp=%u, srcSize=%u)",
+                (U32)endOp, (U32)(input->size - input->pos));
+    assert(output->pos <= output->size);
+    assert(input->pos  <= input->size);
+
+    if (mtctx->singleBlockingThread) {  /* delegate to single-thread (synchronous) */
+        return ZSTD_compressStream2(mtctx->cctxPool->cctx[0], output, input, endOp);
+    }
+
+    if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) {
+        /* current frame being ended. Only flush/end are allowed */
+        return ERROR(stage_wrong);
+    }
+
+    /* single-pass shortcut (note : synchronous-mode) */
+    if ( (!mtctx->params.rsyncable)   /* rsyncable mode is disabled */
+      && (mtctx->nextJobID == 0)      /* just started */
+      && (mtctx->inBuff.filled == 0)  /* nothing buffered */
+      && (!mtctx->jobReady)           /* no job already created */
+      && (endOp == ZSTD_e_end)        /* end order */
+      && (output->size - output->pos >= ZSTD_compressBound(input->size - input->pos)) ) { /* enough space in dst */
+        size_t const cSize = ZSTDMT_compress_advanced_internal(mtctx,
+                (char*)output->dst + output->pos, output->size - output->pos,
+                (const char*)input->src + input->pos, input->size - input->pos,
+                mtctx->cdict, mtctx->params);
+        if (ZSTD_isError(cSize)) return cSize;
+        input->pos = input->size;
+        output->pos += cSize;
+        mtctx->allJobsCompleted = 1;
+        mtctx->frameEnded = 1;
+        return 0;
+    }
+
+    /* fill input buffer */
+    if ( (!mtctx->jobReady)
+      && (input->size > input->pos) ) {   /* support NULL input */
+        if (mtctx->inBuff.buffer.start == NULL) {
+            assert(mtctx->inBuff.filled == 0); /* Can't fill an empty buffer */
+            if (!ZSTDMT_tryGetInputRange(mtctx)) {
+                /* It is only possible for this operation to fail if there are
+                 * still compression jobs ongoing.
+                 */
+                DEBUGLOG(5, "ZSTDMT_tryGetInputRange failed");
+                assert(mtctx->doneJobID != mtctx->nextJobID);
+            } else
+                DEBUGLOG(5, "ZSTDMT_tryGetInputRange completed successfully : mtctx->inBuff.buffer.start = %p", mtctx->inBuff.buffer.start);
+        }
+        if (mtctx->inBuff.buffer.start != NULL) {
+            syncPoint_t const syncPoint = findSynchronizationPoint(mtctx, *input);
+            if (syncPoint.flush && endOp == ZSTD_e_continue) {
+                endOp = ZSTD_e_flush;
+            }
+            assert(mtctx->inBuff.buffer.capacity >= mtctx->targetSectionSize);
+            DEBUGLOG(5, "ZSTDMT_compressStream_generic: adding %u bytes on top of %u to buffer of size %u",
+                        (U32)syncPoint.toLoad, (U32)mtctx->inBuff.filled, (U32)mtctx->targetSectionSize);
+            memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, syncPoint.toLoad);
+            input->pos += syncPoint.toLoad;
+            mtctx->inBuff.filled += syncPoint.toLoad;
+            forwardInputProgress = syncPoint.toLoad>0;
+        }
+        if ((input->pos < input->size) && (endOp == ZSTD_e_end))
+            endOp = ZSTD_e_flush;   /* can't end now : not all input consumed */
+    }
+
+    if ( (mtctx->jobReady)
+      || (mtctx->inBuff.filled >= mtctx->targetSectionSize)  /* filled enough : let's compress */
+      || ((endOp != ZSTD_e_continue) && (mtctx->inBuff.filled > 0))  /* something to flush : let's go */
+      || ((endOp == ZSTD_e_end) && (!mtctx->frameEnded)) ) {   /* must finish the frame with a zero-size block */
+        size_t const jobSize = mtctx->inBuff.filled;
+        assert(mtctx->inBuff.filled <= mtctx->targetSectionSize);
+        FORWARD_IF_ERROR( ZSTDMT_createCompressionJob(mtctx, jobSize, endOp) );
+    }
+
+    /* check for potential compressed data ready to be flushed */
+    {   size_t const remainingToFlush = ZSTDMT_flushProduced(mtctx, output, !forwardInputProgress, endOp); /* block if there was no forward input progress */
+        if (input->pos < input->size) return MAX(remainingToFlush, 1);  /* input not consumed : do not end flush yet */
+        DEBUGLOG(5, "end of ZSTDMT_compressStream_generic: remainingToFlush = %u", (U32)remainingToFlush);
+        return remainingToFlush;
+    }
+}
+
+
+size_t ZSTDMT_compressStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
+{
+    FORWARD_IF_ERROR( ZSTDMT_compressStream_generic(mtctx, output, input, ZSTD_e_continue) );
+
+    /* recommended next input size : fill current input buffer */
+    return mtctx->targetSectionSize - mtctx->inBuff.filled;   /* note : could be zero when input buffer is fully filled and no more availability to create new job */
+}
+
+
+static size_t ZSTDMT_flushStream_internal(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_EndDirective endFrame)
+{
+    size_t const srcSize = mtctx->inBuff.filled;
+    DEBUGLOG(5, "ZSTDMT_flushStream_internal");
+
+    if ( mtctx->jobReady     /* one job ready for a worker to pick up */
+      || (srcSize > 0)       /* still some data within input buffer */
+      || ((endFrame==ZSTD_e_end) && !mtctx->frameEnded)) {  /* need a last 0-size block to end frame */
+           DEBUGLOG(5, "ZSTDMT_flushStream_internal : create a new job (%u bytes, end:%u)",
+                        (U32)srcSize, (U32)endFrame);
+        FORWARD_IF_ERROR( ZSTDMT_createCompressionJob(mtctx, srcSize, endFrame) );
+    }
+
+    /* check if there is any data available to flush */
+    return ZSTDMT_flushProduced(mtctx, output, 1 /* blockToFlush */, endFrame);
+}
+
+
+size_t ZSTDMT_flushStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output)
+{
+    DEBUGLOG(5, "ZSTDMT_flushStream");
+    if (mtctx->singleBlockingThread)
+        return ZSTD_flushStream(mtctx->cctxPool->cctx[0], output);
+    return ZSTDMT_flushStream_internal(mtctx, output, ZSTD_e_flush);
+}
+
+size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output)
+{
+    DEBUGLOG(4, "ZSTDMT_endStream");
+    if (mtctx->singleBlockingThread)
+        return ZSTD_endStream(mtctx->cctxPool->cctx[0], output);
+    return ZSTDMT_flushStream_internal(mtctx, output, ZSTD_e_end);
+}
diff --git a/src/zstdmt_compress.h b/src/zstdmt_compress.h
new file mode 100644
index 0000000..12a5260
--- /dev/null
+++ b/src/zstdmt_compress.h
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+ #ifndef ZSTDMT_COMPRESS_H
+ #define ZSTDMT_COMPRESS_H
+
+ #if defined (__cplusplus)
+ extern "C" {
+ #endif
+
+
+/* Note : This is an internal API.
+ *        These APIs used to be exposed with ZSTDLIB_API,
+ *        because it used to be the only way to invoke MT compression.
+ *        Now, it's recommended to use ZSTD_compress2 and ZSTD_compressStream2()
+ *        instead.
+ *
+ *        If you depend on these APIs and can't switch, then define
+ *        ZSTD_LEGACY_MULTITHREADED_API when making the dynamic library.
+ *        However, we may completely remove these functions in a future
+ *        release, so please switch soon.
+ *
+ *        This API requires ZSTD_MULTITHREAD to be defined during compilation,
+ *        otherwise ZSTDMT_createCCtx*() will fail.
+ */
+
+#ifdef ZSTD_LEGACY_MULTITHREADED_API
+#  define ZSTDMT_API ZSTDLIB_API
+#else
+#  define ZSTDMT_API
+#endif
+
+/* ===   Dependencies   === */
+#include <stddef.h>                /* size_t */
+#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_parameters */
+#include "zstd.h"            /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */
+
+
+/* ===   Constants   === */
+#ifndef ZSTDMT_NBWORKERS_MAX
+#  define ZSTDMT_NBWORKERS_MAX 200
+#endif
+#ifndef ZSTDMT_JOBSIZE_MIN
+#  define ZSTDMT_JOBSIZE_MIN (1 MB)
+#endif
+#define ZSTDMT_JOBLOG_MAX   (MEM_32bits() ? 29 : 30)
+#define ZSTDMT_JOBSIZE_MAX  (MEM_32bits() ? (512 MB) : (1024 MB))
+
+
+/* ===   Memory management   === */
+typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;
+/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */
+ZSTDMT_API ZSTDMT_CCtx* ZSTDMT_createCCtx(unsigned nbWorkers);
+/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */
+ZSTDMT_API ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers,
+                                                    ZSTD_customMem cMem);
+ZSTDMT_API size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx);
+
+ZSTDMT_API size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx);
+
+
+/* ===   Simple one-pass compression function   === */
+
+ZSTDMT_API size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,
+                                       void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize,
+                                       int compressionLevel);
+
+
+
+/* ===   Streaming functions   === */
+
+ZSTDMT_API size_t ZSTDMT_initCStream(ZSTDMT_CCtx* mtctx, int compressionLevel);
+ZSTDMT_API size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize);  /**< if srcSize is not known at reset time, use ZSTD_CONTENTSIZE_UNKNOWN. Note: for compatibility with older programs, 0 means the same as ZSTD_CONTENTSIZE_UNKNOWN, but it will change in the future to mean "empty" */
+
+ZSTDMT_API size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx);
+ZSTDMT_API size_t ZSTDMT_compressStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
+
+ZSTDMT_API size_t ZSTDMT_flushStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output);   /**< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) */
+ZSTDMT_API size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output);     /**< @return : 0 == all flushed; >0 : still some data to be flushed; or an error code (ZSTD_isError()) */
+
+
+/* ===   Advanced functions and parameters  === */
+
+ZSTDMT_API size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
+                                          void* dst, size_t dstCapacity,
+                                    const void* src, size_t srcSize,
+                                    const ZSTD_CDict* cdict,
+                                          ZSTD_parameters params,
+                                          int overlapLog);
+
+ZSTDMT_API size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
+                                        const void* dict, size_t dictSize,   /* dict can be released after init, a local copy is preserved within zcs */
+                                        ZSTD_parameters params,
+                                        unsigned long long pledgedSrcSize);  /* pledgedSrcSize is optional and can be zero == unknown */
+
+ZSTDMT_API size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,
+                                        const ZSTD_CDict* cdict,
+                                        ZSTD_frameParameters fparams,
+                                        unsigned long long pledgedSrcSize);  /* note : zero means empty */
+
+/* ZSTDMT_parameter :
+ * List of parameters that can be set using ZSTDMT_setMTCtxParameter() */
+typedef enum {
+    ZSTDMT_p_jobSize,     /* Each job is compressed in parallel. By default, this value is dynamically determined depending on compression parameters. Can be set explicitly here. */
+    ZSTDMT_p_overlapLog,  /* Each job may reload a part of previous job to enhance compression ratio; 0 == no overlap, 6(default) == use 1/8th of window, >=9 == use full window. This is a "sticky" parameter : its value will be re-used on next compression job */
+    ZSTDMT_p_rsyncable    /* Enables rsyncable mode. */
+} ZSTDMT_parameter;
+
+/* ZSTDMT_setMTCtxParameter() :
+ * allow setting individual parameters, one at a time, among a list of enums defined in ZSTDMT_parameter.
+ * The function must be called typically after ZSTD_createCCtx() but __before ZSTDMT_init*() !__
+ * Parameters not explicitly reset by ZSTDMT_init*() remain the same in consecutive compression sessions.
+ * @return : 0, or an error code (which can be tested using ZSTD_isError()) */
+ZSTDMT_API size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int value);
+
+/* ZSTDMT_getMTCtxParameter() :
+ * Query the ZSTDMT_CCtx for a parameter value.
+ * @return : 0, or an error code (which can be tested using ZSTD_isError()) */
+ZSTDMT_API size_t ZSTDMT_getMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, int* value);
+
+
+/*! ZSTDMT_compressStream_generic() :
+ *  Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream()
+ *  depending on flush directive.
+ * @return : minimum amount of data still to be flushed
+ *           0 if fully flushed
+ *           or an error code
+ *  note : needs to be init using any ZSTD_initCStream*() variant */
+ZSTDMT_API size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
+                                                ZSTD_outBuffer* output,
+                                                ZSTD_inBuffer* input,
+                                                ZSTD_EndDirective endOp);
+
+
+/* ========================================================
+ * ===  Private interface, for use by ZSTD_compress.c   ===
+ * ===  Not exposed in libzstd. Never invoke directly   ===
+ * ======================================================== */
+
+ /*! ZSTDMT_toFlushNow()
+  *  Tell how many bytes are ready to be flushed immediately.
+  *  Probe the oldest active job (not yet entirely flushed) and check its output buffer.
+  *  If return 0, it means there is no active job,
+  *  or, it means oldest job is still active, but everything produced has been flushed so far,
+  *  therefore flushing is limited by speed of oldest job. */
+size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx);
+
+/*! ZSTDMT_CCtxParam_setMTCtxParameter()
+ *  like ZSTDMT_setMTCtxParameter(), but into a ZSTD_CCtx_Params */
+size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, int value);
+
+/*! ZSTDMT_CCtxParam_setNbWorkers()
+ *  Set nbWorkers, and clamp it.
+ *  Also reset jobSize and overlapLog */
+size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers);
+
+/*! ZSTDMT_updateCParams_whileCompressing() :
+ *  Updates only a selected set of compression parameters, to remain compatible with current frame.
+ *  New parameters will be applied to next compression job. */
+void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams);
+
+/*! ZSTDMT_getFrameProgression():
+ *  tells how much data has been consumed (input) and produced (output) for current frame.
+ *  able to count progression inside worker threads.
+ */
+ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx);
+
+
+/*! ZSTDMT_initCStream_internal() :
+ *  Private use only. Init streaming operation.
+ *  expects params to be valid.
+ *  must receive dict, or cdict, or none, but not both.
+ *  @return : 0, or an error code */
+size_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* zcs,
+                    const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,
+                    const ZSTD_CDict* cdict,
+                    ZSTD_CCtx_params params, unsigned long long pledgedSrcSize);
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* ZSTDMT_COMPRESS_H */
diff --git a/tests/testthat/test_chunk.R b/tests/testthat/test_chunk.R
new file mode 100644
index 0000000..50d85a0
--- /dev/null
+++ b/tests/testthat/test_chunk.R
@@ -0,0 +1,222 @@
+context("chunk-based API")
+
+
+
+test_that("can read a vector chunk", {
+  tvec <- as.integer(1:5)
+  tempf <- tempfile()
+  write_vector_h5(data = tvec,filename = tempf,"grp/dat",filter="none")
+  #write_vector_h5v(filename = tempf, datapath = "grp/dat",filter="none",data= tvec)
+  #rd <- read_vector_h5(tempf,datapath="grp/dat")
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",1:2)
+  expect_equal(trd, tvec[1:2],check.attributes=F)
+  
+
+  tvec <- as.integer(1:5)
+  tempf <- tempfile()
+  write_vector_h5(filename = tempf, datapath = "grp/dat",data =  tvec)
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",2:5)
+  expect_equal(trd, tvec[2:5],check.attributes=F)
+})
+
+
+
+
+test_that("can read a (string) vector chunk", {
+  
+  fruit <- c("apple", "apricot", "avocado", "banana", "bell pepper", "bilberry", 
+             "blackberry", "blackcurrant", "blood orange", "blueberry", "boysenberry", 
+             "breadfruit", "canary melon", "cantaloupe", "cherimoya", "cherry", 
+             "chili pepper", "clementine", "cloudberry", "coconut", "cranberry", 
+             "cucumber", "currant", "damson", "date", "dragonfruit", "durian", 
+             "eggplant", "elderberry", "feijoa", "fig", "goji berry", "gooseberry", 
+             "grape", "grapefruit", "guava", "honeydew", "huckleberry", "jackfruit", 
+             "jambul", "jujube", "kiwi fruit", "kumquat", "lemon", "lime", 
+             "loquat", "lychee", "mandarine", "mango", "mulberry", "nectarine", 
+             "nut", "olive", "orange", "pamelo", "papaya", "passionfruit", 
+             "peach", "pear", "persimmon", "physalis", "pineapple", "plum", 
+             "pomegranate", "pomelo", "purple mangosteen", "quince", "raisin", 
+             "rambutan", "raspberry", "redcurrant", "rock melon", "salal berry", 
+             "satsuma", "star fruit", "strawberry", "tamarillo", "tangerine", 
+             "ugli fruit", "watermelon")
+  library(EigenH5)
+  library(testthat)
+  tvec <- as.character(c(1,2,10,4))
+  tempf <- tempfile()
+  write_vector_h5(filename = tempf, datapath = "grp/dat",filter="none",data= tvec)
+  read_vector_h5(tempf,"grp/dat")
+  #rd <- read_vector_h5(tempf,datapath="grp/dat")
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",1:2)
+  expect_equal(trd, tvec[1:2],check.attributes=F)
+  
+  
+  tvec <- fruit
+  tempf <- tempfile()
+  write_vector_h5(filename = tempf, datapath = "grp/dat",data =  tvec)
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",2:5)
+  expect_equal(trd, tvec[2:5],check.attributes=F)
+})
+
+
+
+
+test_that("can read a vector index", {
+  
+  tvec <- as.integer(1:100000)
+  iv <- sort(sample(1:length(tvec),3,replace=F))
+  tempf <- tempfile()
+  write_vector_h5v(filename = tempf, datapath = "grp/dat",filter="none",data =  tvec)
+  #rd <- read_vector_h5(tempf,datapath="grp/dat")
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",iv)
+  expect_equal(trd, tvec[iv])
+  
+  
+  riv <- sample(1:length(tvec),5000,replace=T)
+  
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",riv)
+  expect_equal(trd, tvec[riv])
+  
+})
+
+
+test_that("can read a vector index out of order", {
+  
+  tvec <- as.integer(1:100)
+  iv <- sort(sample(1:length(tvec),300,replace=T))
+  tempf <- tempfile()
+  write_vector_h5(filename = tempf, datapath = "grp/dat",filter="none", tvec)
+  #rd <- read_vector_h5(tempf,datapath="grp/dat")
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",iv)
+  expect_equal(c(trd), tvec[iv],check.attributes=F)
+  
+  riv <- sample(1:length(tvec),5000,replace=T)
+  
+  trd <- read_vector_h5v(filename = tempf, datapath="grp/dat",riv)
+  expect_equal(trd, tvec[riv],check.attributes=F)
+  
+})
+
+
+test_that("can read a matrix rowchunk",{
+  
+  tmat <- matrix(1:180,60,3)
+  tf <- tempfile()
+  write_matrix_h5(tmat,tf,"test",chunksizes=c(3L,3L),filter="none")  
+  
+  check_mat <- read_matrix_h5v(tf,"test",1:6,1:3)
+  expect_equal(tmat[1:6,1:3],check_mat)
+  check_imat <- read_matrix_h5v(tf,"test",c(1:6),c(1:3))
+  expect_equal(check_imat,tmat[c(1:6),c(1:3)])  
+})
+
+
+test_that("can read a matrix rowchunk to a list",{
+  
+  tmat <- matrix(1:180,60,3)
+  tf <- tempfile()
+  write_matrix_h5(tmat,tf,"test",chunksizes=c(3L,3L),filter="none")  
+  
+  check_mat <- read_matrix_rl(tf,"test",1:6,1:3)
+   
+  expect_equal(check_mat,list(tmat[1:3,1:3],tmat[4:6,1:3]))
+  check_mat <- read_matrix_rl(tf,"test",1:60,c(1L,3L))
+  tmat_l <- purrr::map(split(1:60,gl(n = 20,k = 3,length = 60)),~tmat[.x,c(1,3)])
+  names(tmat_l) <- NULL
+  # check_imat <- read_matrix_h5v(tf,"test",c(1:6),c(1:3))
+  expect_equal(tmat_l,check_mat)  
+})
+
+
+
+
+test_that("can read a (string) matrix rowchunk",{
+  gen_rstrings <- function(n,max_len=300){
+    replicate(n,paste0(sample(letters,size=sample(1:max_len,1),replace=T),collapse = ""))
+    
+  }
+
+  tmat <- matrix(as.character(1:(6*3)),6,3)
+  tf <- tempfile()
+  write_matrix_h5v(tmat,tf,"test",chunksizes=c(1L,3L),filter="none")  
+  r_matrix <- read_matrix_h5v(tf,"test")
+  
+  check_mat <- read_matrix_h5v(tf,"test",1:6,1:3)
+  expect_equal(tmat[1:6,1:3],check_mat)
+  check_imat <- read_matrix_h5v(tf,"test",c(1:6),c(1:3))
+  expect_equal(check_imat,tmat[c(1:6),c(1:3)])  
+})
+
+
+test_that("can read an off-center matrix rowchunk",{
+  
+  
+  tmat <- matrix(1:18,6,3)
+  tf <- tempfile()
+  write_matrix_h5(tmat,tf,"test",chunksizes=c(3L,3L))  
+  
+  check_mat <- read_matrix_h5v(tf,"test",2:6,2:3)
+  expect_equal(tmat[2:6,2:3],check_mat)
+  check_imat <- read_matrix_h5v(tf,"test",c(2:6),c(2:3))
+  expect_equal(check_imat,tmat[2:6,2:3])  
+})
+
+
+
+
+test_that("can read an off-center matrix rowchunk smaller than disk chunk",{
+  
+  
+  tmat <- matrix(1:18,6,3)
+  tf <- tempfile()
+  write_matrix_h5(tmat,tf,"test",chunksizes=c(3L,3L))  
+  
+  check_mat <- read_matrix_h5v(tf,"test",2:2,2:2)
+  expect_equal(tmat[2:2,2:2,drop=F],check_mat)
+  check_imat <- read_matrix_h5v(tf,"test",c(2L),c(2L))
+  expect_equal(check_imat,tmat[2,2,drop=F])  
+  
+  tmat <- matrix(1:(60*30),60,30)
+  tf <- tempfile()
+  write_matrix_h5(tmat,tf,"test",chunksizes=c(30L,30L))  
+  
+  check_mat <- read_matrix_h5v(tf,"test",20:25,20:25)
+  expect_equal(tmat[20:25,20:25,drop=F],check_mat)
+  check_imat <- read_matrix_h5v(tf,"test",c(20:25),c(20:25))
+  expect_equal(check_imat,tmat[20:25,20:25,drop=F])
+  
+})
+
+
+
+
+test_that("can read a matrix that's actually chunked",{
+  
+  tmat <- matrix(1:2700,90,30)
+  tf <- tempfile()
+  write_matrix_h5v(tmat,tf,"test",chunksizes=c(10L,3L))  
+  
+  check_mat <- read_matrix_h5v(tf,"test")
+  expect_equal(tmat,check_mat)
+  
+})
+
+
+
+
+test_that("can write a matrix chunkwise",{
+
+    tmat <- matrix(1:2700,90,30)
+    tf <- tempfile()
+    write_matrix_h5v(tmat,tf,"test",chunksizes=c(10L,3L))  
+    
+    trm <- read_matrix_h5(tf,"test")
+    expect_equal(trm,tmat)
+    check_mat <- read_matrix_h5v(tf,"test",1:90,1:30)
+    expect_equal(tmat,check_mat)
+
+  
+  
+})
+
+
+
diff --git a/tests/testthat/test_compression.R b/tests/testthat/test_compression.R
index 25d9619..61448d2 100644
--- a/tests/testthat/test_compression.R
+++ b/tests/testthat/test_compression.R
@@ -7,72 +7,230 @@ test_that("datasets are zstd by default",{
   retl <- get_datset_filter(tempf,"grp/grp2/dat")
   expect_equal(retl$name,"zstd")
 })
+
 # 
-# test_that("can compress with blosc",{
+# test_that("can write without compression",{
 #   tvec <- as.integer(1:10)
 #   tempf <- tempfile()
-#   write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="blosc")
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="none",chunksizes=9L)
+#   expect_equal(dataset_chunks(tempf,"grp/grp2/dat"),9L)
+#   
+#   h5f = rhdf5::H5Fopen(tempf)
+#   
+#   test_d <- rhdf5::h5read(tempf,"grp/grp2/dat")
+#   expect_equal(test_d,tvec)
+#   
 #   retl <- get_datset_filter(tempf,"grp/grp2/dat")
-#   expect_equal(retl$name,"blosc")
+#   expect_equal(retl$name,"no_filter")
+# })
+# 
+# test_that("can write without compression and without chunking",{
+#   tvec <- as.integer(1:10)
+#   tempf <- tempfile()
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="none",chunksize=integer())
+#   expect_equal(dataset_chunks(tempf,"grp/grp2/dat"),integer())
+#   retl <- get_datset_filter(tempf,"grp/grp2/dat")
+#   expect_equal(retl$name,"no_filter")
 # })
-
-test_that("can write without compression",{
-  tvec <- as.integer(1:10)
-  tempf <- tempfile()
-  write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="none",chunksizes=9L)
-  expect_equal(dataset_chunks(tempf,"grp/grp2/dat"),9L)
-  retl <- get_datset_filter(tempf,"grp/grp2/dat")
-  expect_equal(retl$name,"no_filter")
-})
-
-test_that("can write without compression and without chunking",{
-  tvec <- as.integer(1:10)
-  tempf <- tempfile()
-  write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="none",chunksize=integer())
-  expect_equal(dataset_chunks(tempf,"grp/grp2/dat"),integer())
-  retl <- get_datset_filter(tempf,"grp/grp2/dat")
-  expect_equal(retl$name,"no_filter")
-})
 
 test_that("can write a matrix without compression and without chunking",{
   tmat <- matrix(sample(1:00),10,10)
   tempf <- tempfile()
-  write_matrix_h5(tmat,tempf,"grp/grp2/mdat",filter="none",chunksizes=integer())
-  expect_equal(dataset_chunks(tempf,"grp/grp2/mdat"),integer())
+  write_matrix_h5(tmat,tempf,"grp/grp2/mdat", filter = "none",chunksizes = integer())
+  expect_equal(dataset_chunks(tempf,"grp/grp2/mdat"),integer()) 
   retl <- get_datset_filter(tempf,"grp/grp2/mdat")
   expect_equal(retl$name,"no_filter")
   expect_equal(retl$options,numeric())
 })
 
 
+# 
+# test_that("can read raw chunks of data without compression",{
+#   tvec <- as.integer(1:10)
+#   tempf <- tempfile()
+#   
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="none",chunksizes=10L)
+#   
+#   trv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = 0L)
+#   expect_identical(tvec,readBin(trv,what=integer(),n=length(tvec)))
+#   
+#   tvec <- as.numeric(1:10)+.Machine$double.eps*10
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat2",filter="none",chunksizes=10L)
+#   trv <- read_raw_chunk(tempf,"grp/grp2/dat2",chunk_idx = 0L)
+#   expect_identical(tvec,readBin(trv,what=numeric(),n=length(tvec)))
+#   
+#   
+#   })
+
+# 
+# test_that("can read whole dataset with zstd compression",{
+#   tvec <- as.integer(1:10)
+#   tempf <- tempfile()
+#   
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat",chunksizes=10L)
+#   
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = 0L)
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   expect_identical(tvec,readBin(trv,what=integer(),n=length(tvec)))
+#   
+#   tvec <- as.numeric(1:10)+.Machine$double.eps*10
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat2",chunksizes=10L)
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat2",chunk_idx = 0L)
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   expect_identical(tvec,readBin(trv,what=numeric(),n=length(tvec)))
+#   
+#   
+# })
+
+
+# 
+# test_that("can read raw chunks of data with zstd compression",{
+#   tvec <- as.integer(1:10000)
+#   tempf <- tempfile()
+#   
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat",chunksizes=100L)
+#   
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = 0L)
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   expect_identical(tvec[1:100L],readBin(trv,what=integer(),n=100L))
+#   
+#   
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = 1L)
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   expect_identical(tvec[101L:200L],readBin(trv,what=integer(),n=100L))
+#   
+#   
+#   tvec <- as.numeric(1:10000)+.Machine$double.eps*10
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat2",chunksizes=100L)
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat2",chunk_idx = 0L)
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   expect_identical(tvec[1:100L],readBin(trv,what=numeric(),n=100L))
+#   
+#   
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat2",chunk_idx = 1L)
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   expect_identical(tvec[101L:200L],readBin(trv,what=numeric(),n=100L))
+# })
+# 
+# test_that("can read chunks when data is uncompressable",{
+#   tvec <- sample(-.Machine$integer.max:.Machine$integer.max,10000)
+#   tempf <- tempfile()
+#   
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat",chunksizes=100L)
+#   
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = 0L)
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_lt(length(trv),length(crv))
+#   expect_identical(tvec[1:100L],readBin(trv,what=integer(),n=100L))
+# })
+
+
+# 
+# test_that("can read raw chunks from matrices",{
+#   
+#   tmat <- matrix(as.integer(1:1000),100L,10L)
+#   tempf <- tempfile()
+#   
+#   write_matrix_h5(tmat,tempf,"grp/grp2/dat",chunksizes=c(10L,5L))
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = c(0L,0L))
+#   
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   ttmat <- matrix(readBin(trv,what=integer(),n=50L),10L,5L,byrow = T)
+#   expect_identical(tmat[1:10,1:5],ttmat)
+# 
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = c(0L,1L))
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   ttmat <- matrix(readBin(trv,what=integer(),n=50L),10L,5L,byrow = T)
+#   expect_identical(tmat[1:10,6:10],ttmat)
+#   
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = c(1L,0L))
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   ttmat <- matrix(readBin(trv,what=integer(),n=50L),10L,5L,byrow = T)
+#   expect_identical(tmat[11:20,1:5],ttmat)
+#   
+#   crv <- read_raw_chunk(tempf,"grp/grp2/dat",chunk_idx = c(1L,1L))
+#   trv <- rzstdlib::zstdDecompressImpl(crv)
+#   expect_gt(length(trv),length(crv))
+#   ttmat <- matrix(readBin(trv,what=integer(),n=50L),10L,5L,byrow = T)
+#   expect_identical(tmat[11:20,6:10],ttmat)
+#   
+# })
+# 
 
 
 
 test_that("can compress with gzip",{
+  data(iris)
   tvec <- as.integer(1:10)
   tempf <- tempfile()
   write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="gzip")
   retl <- get_datset_filter(tempf,"grp/grp2/dat")
   expect_equal(retl$name,"deflate")
+  
 })
 
 
-test_that("can compress with gzip level 9",{
+test_that("can compress dataframe with gzip",{
+  data(iris)
   tvec <- as.integer(1:10)
   tempf <- tempfile()
-  write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="gzip",filter_options=9L)
+  write_df_h5(iris,filename = tempf,datapath = "iris",filter="gzip")
+  retl <- get_datset_filter(tempf,"iris/Species")
+  expect_equal(retl$name,"deflate")
+  
+})
+
+test_that("can read a matrix compressed with gzip (using chunk iterator)",{
+  tmat <- matrix(as.integer(1:100),1000,100)
+  tempf <- tempfile()
+  write_matrix_h5(tmat,tempf,"grp/grp2/dat",filter="gzip")
   retl <- get_datset_filter(tempf,"grp/grp2/dat")
-  expect_equal(retl$options,9L)
+  expect_equal(retl$name,"deflate")
+  rm <- read_matrix_h5v(tempf,"grp/grp2/dat")
+  expect_equal(rm,tmat)
 })
 
-test_that("can compress with lzf",{
+
+
+
+
+test_that("can compress with gzip level 9",{
   tvec <- as.integer(1:10)
   tempf <- tempfile()
-  write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="lzf")
+  write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="gzip",filter_options=9L)
   retl <- get_datset_filter(tempf,"grp/grp2/dat")
-  expect_equal(retl$name,"lzf")
-  expect_equal(retl$options,numeric())
+  expect_equal(retl$options,9L)
 })
+# 
+# test_that("can compress with lzf",{
+#   tvec <- as.integer(1:10)
+#   tempf <- tempfile()
+#   write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="lzf")
+#   retl <- get_datset_filter(tempf,"grp/grp2/dat")
+#   expect_equal(retl$name,"lzf")
+#   expect_equal(retl$options,numeric())
+# })
+# 
+# test_that("can compress with lzf and read with chunk iterator",{
+#   # library(EigenH5)
+#   
+#   tmat <- matrix(as.integer(1:100),1000,100)
+#   tempf <- tempfile()
+#   write_matrix_h5(tmat,tempf,"grp/grp2/dat",filter="lzf")
+#   retl <- get_datset_filter(tempf,"grp/grp2/dat")
+#   expect_equal(retl$name,"lzf")
+#   rm <- read_matrix_h5v(tempf,"grp/grp2/dat")
+#   expect_equal(rm,tmat)
+# })
 
 test_that("can compress with zstd",{
   tvec <- as.integer(1:10)
@@ -82,6 +240,14 @@ test_that("can compress with zstd",{
   expect_equal(retl$name,"zstd")
 })
 
+test_that("can compress with nothing",{
+  tvec <- as.integer(1:10)
+  tempf <- tempfile()
+  write_vector_h5(tvec,tempf,"grp/grp2/dat",filter="none")
+  retl <- get_datset_filter(tempf,"grp/grp2/dat")
+  expect_equal(retl$name,"no_filter")
+})
+
 
 test_that("can compress with zstd with high compression level",{
   tvec <- as.integer(1:10)
diff --git a/tests/testthat/test_df.R b/tests/testthat/test_df.R
index e6f412c..7667c10 100644
--- a/tests/testthat/test_df.R
+++ b/tests/testthat/test_df.R
@@ -1,22 +1,40 @@
 context("dataframes")
 
 
-test_that("we can write an empty data_frame",{
+test_that("we can write an empty tibble",{
   
-  td <- tibble::data_frame(a=1:5,b=letters[1:5],c=runif(5))
+  td <- tibble::tibble(a=1:5,b=letters[1:5],c=runif(5))
   ntd <- dplyr::slice(td,integer())
   tf <- tempfile()
+  expect_equal(file_acc_ct(tf)$count,rep(0L,5))
   write_df_h5(ntd,tf,"test",chunksizes=9L,max_dims=NA_integer_)
+  expect_equal(file_acc_ct(tf)$count,rep(0L,5))
+  dim_h5(tf,"test/a")
+  expect_equal(file_acc_ct(tf)$count,rep(0L,5))
   expect_equal(c(dim_h5(tf,"test/a"),dim_h5(tf,"test/b"),dim_h5(tf,"test/c")),c(0L,0L,0L))
+  expect_equal(file_acc_ct(tf)$count,rep(0L,5))
   write_df_h5(td,tf,"test",append=T)
+  expect_equal(file_acc_ct(tf)$count,rep(0L,5))
   srtd <- read_df_h5(tf,"test")
+  expect_equal(file_acc_ct(tf)$count,rep(0L,5))
   expect_equal(td,srtd)
 })
 
 
+test_that("we can start with appending",{
+  
+  td <- tibble::tibble(a=1:5,b=letters[1:5],c=runif(5))
+  tf <- tempfile()
+  write_df_h5(td,tf,"test",append=TRUE)
+  write_df_h5(td,tf,"test",append=TRUE)
+  srtd <- read_df_h5(tf,"test")
+  expect_equal(dplyr::bind_rows(td,td),srtd)
+})
+
+
 test_that("We can read and write dataframes correctly",{
   
-  td <- tibble::data_frame(a=1:5,b=paste0(letters[1:5],letters[5:1]),c=runif(5))
+  td <- tibble::tibble(a=1:5,b=paste0(letters[1:5],letters[5:1]),c=runif(5))
   std <- dplyr::slice(td,3:5)
   tf <- tempfile()
   write_df_h5(td,tf,"test",filter="none")
@@ -25,7 +43,7 @@ test_that("We can read and write dataframes correctly",{
   expect_equal(ls_h5(tf),"test")
   dn <- ls_h5(tf,"test")
   expect_equal(dn,c("a","b","c"))
-  srtd <- read_df_h5(tf,"test",offset=2,datasize = 3)
+  srtd <- read_df_h5(tf,"test",subset=3:5)
   
   expect_equal(std,srtd)
 })
@@ -34,7 +52,7 @@ test_that("We can read and write dataframes correctly",{
 test_that("We can read and write dataframe subcols correctly",{
   
   
-  td <- tibble::data_frame(a=1:5,b=letters[1:5],c=runif(5))
+  td <- tibble::tibble(a=1:5,b=letters[1:5],c=runif(5))
   std <- dplyr::slice(td,3:5)
   tf <- tempfile()
   write_df_h5(td,tf,"test")
@@ -51,12 +69,12 @@ test_that("We can read and write dataframe subcols correctly",{
 
 test_that("We can read and dataframe slices correctly",{
 
-  td <- tibble::data_frame(a=1:5,b=letters[1:5],c=runif(5))
+  td <- tibble::tibble(a=1:5,b=letters[1:5],c=runif(5))
   std <- dplyr::slice(td,c(1,3,5))
   tf <- tempfile()
   write_df_h5(td,tf,"test")
   rtd <- read_df_h5(tf,"test")
-  srtd <- read_df_h5(tf,"test",filtervec = c(1,3,5))
+  srtd <- read_df_h5(tf,"test",subset = c(1,3,5))
   nstrd <- read_df_h5(tf,"test",subset=c(1,3,5))
   expect_equal(td,rtd)
   expect_equal(std,srtd)
@@ -64,3 +82,53 @@ test_that("We can read and dataframe slices correctly",{
 })
 
 
+
+test_that("chunked sorting workflow works like an on-disk grouped-sort",{
+
+  p <- 10000
+  levels_a <- 23
+  sa <- integer()
+  while(length(unique(sa))<levels_a){
+    sa <- sort(sample(levels_a,p,replace=T))
+  }
+  sb <- sample(p,p,replace=F)
+  sc <- runif(p)
+  tf <- tempfile(fileext=".tsv.gz")
+  df <- tibble::tibble(a=sa,b=sb,c=sc)
+  rledf <- rle2offset(df$a)
+  readr::write_tsv(df,tf)
+  
+  otf <- tempfile(fileext=".h5")
+  delim2h5(tf,otf,h5_args=list(datapath="test"),delim="\t",col_types=readr::cols(
+  a = readr::col_integer(),
+  b = readr::col_integer(),
+  c = readr::col_double()
+))
+  expect_equal(read_df_h5(otf,"test"),df)
+  
+  purrr::pwalk(rledf,function(value,offset,datasize){
+    tdf <- read_df_h5(otf,"test",subset=seq(offset+1,length.out = datasize)) %>% dplyr::arrange(b)
+    expect_equal(tdf$a,rep(value,datasize))
+    write_df_h5(tdf,otf,datapath = "test",subset=seq(offset+1,length.out = datasize))
+  })
+  expect_equal(dplyr::arrange(df,a,b),read_df_h5(otf,"test"))
+})
+
+
+
+
+test_that("We can convert mtcars to hdf5",{
+  tf <- tempfile()
+  mtcf <- readr::readr_example("mtcars.csv")
+  x <- delim2h5(input_file =mtcf ,output_file = tf,delim=",",h5_args=list(datapath="mtcars"))
+  check_df <- readr::read_delim(mtcf,delim=",")
+  tdf <- read_df_h5(tf,datapath = "mtcars")
+  testthat::expect_equal(check_df,tdf)
+  delim2h5(input_file =mtcf ,output_file = tf,delim=",",h5_args=list(datapath="mtcars_id"),id_col = TRUE,chunk_size=5)
+  tdf_id <- read_df_h5(tf,datapath = "mtcars_id")
+  testthat::expect_equal(tdf_id$id_col,1:nrow(check_df))
+  delim2h5(input_file =mtcf ,output_file = tf,delim=",",h5_args=list(datapath="mtcars_idn"),id_col = "IdenT",chunk_size=2)
+  tdf_id2 <- read_df_h5(tf,datapath = "mtcars_idn")
+  testthat::expect_equal(tdf_id2$IdenT,1:nrow(check_df))
+})
+
diff --git a/tests/testthat/test_h5.R b/tests/testthat/test_h5.R
index 29cff9e..205c159 100644
--- a/tests/testthat/test_h5.R
+++ b/tests/testthat/test_h5.R
@@ -3,8 +3,8 @@ context("h5")
 test_that("Can append a dataframe",{
   
   p_a <- 3
-  tdf <- tibble::data_frame(a=runif(p_a),b=sample(1:p_a,p_a))
-  tdfb <- tibble::data_frame(a=runif(p_a),b=sample(1:p_a,p_a))
+  tdf <- tibble::tibble(a=runif(p_a),b=sample(1:p_a,p_a))
+  tdfb <- tibble::tibble(a=runif(p_a),b=sample(1:p_a,p_a))
   tf <- tempfile()
   write_df_h5(tdf,tf,"test",max_dim=c(NA_integer_))
   write_df_h5(tdfb,tf,"test",append=T)
@@ -25,7 +25,7 @@ test_that("Can append a dataframe",{
 # tsnp_mat <- matrix(sprintf("%.3f",runif(min=0,max=2,N*p)),nrow = N,byrow=T)
 # expect_true(all(nchar(tsnp_mat)==5))
 # wtsnp_mat <- cbind(cbind(sample_ids,rep("DOSE",N)),tsnp_mat)
-# readr::write_delim(tibble::as_data_frame(wtsnp_mat[sample(1:N),]),path = ntsnpf,delim = "\t",col_names = F)
+# readr::write_delim(tibble::as_tibble(wtsnp_mat[sample(1:N),]),path = ntsnpf,delim = "\t",col_names = F)
 # 
 # 
 # 
@@ -80,8 +80,8 @@ test_that("Can append a dataframe",{
 #   
 #   expect_equal(nrow(wtsnp_mat_a),N_a)
 #   expect_equal(nrow(wtsnp_mat_b),N_b)
-#   readr::write_delim(tibble::as_data_frame(wtsnp_mat_a[sample(1:N_a),]),path = ntsnpf_a,delim = "\t",col_names = F)
-#   readr::write_delim(tibble::as_data_frame(wtsnp_mat_b[sample(1:N_b),]),path = ntsnpf_b,delim = "\t",col_names = F)
+#   readr::write_delim(tibble::as_tibble(wtsnp_mat_a[sample(1:N_a),]),path = ntsnpf_a,delim = "\t",col_names = F)
+#   readr::write_delim(tibble::as_tibble(wtsnp_mat_b[sample(1:N_b),]),path = ntsnpf_b,delim = "\t",col_names = F)
 #   
 #   class(tsnp_mat) <- "numeric"
 # 
@@ -147,8 +147,8 @@ test_that("Can append a dataframe",{
 #   all_tsnp_a <- rbind(wtsnp_a,wtsnp_b)
 #   all_tsnp_b <- rbind(wtsnp_c,wtsnp_d)
 # 
-#   readr::write_delim(tibble::as_data_frame(all_tsnp_a[sample(1:(2*N)),]),path = ntsnpf_a,delim = "\t",col_names = F)
-#   readr::write_delim(tibble::as_data_frame(all_tsnp_b[sample(1:(2*N)),]),path = ntsnpf_b,delim = "\t",col_names = F)
+#   readr::write_delim(tibble::as_tibble(all_tsnp_a[sample(1:(2*N)),]),path = ntsnpf_a,delim = "\t",col_names = F)
+#   readr::write_delim(tibble::as_tibble(all_tsnp_b[sample(1:(2*N)),]),path = ntsnpf_b,delim = "\t",col_names = F)
 #   
 #   tsnp_mat <- good_tsnp[,-c(1,2)]
 #   class(tsnp_mat) <- "numeric"
diff --git a/tests/testthat/test_util.R b/tests/testthat/test_util.R
index 731139e..5a1bd75 100644
--- a/tests/testthat/test_util.R
+++ b/tests/testthat/test_util.R
@@ -1,5 +1,7 @@
 context("metadata/utilities")
 
+
+
 test_that("Can get back chunksize", {
         tv <- sample(1:100, 10)
         tm <- matrix(1:9, 3, 3)
@@ -11,7 +13,7 @@ test_that("Can get back chunksize", {
         write_matrix_h5(filename = tf, datapath = "ltestm", data = ltm)
         dataset_chunks(tf, "ltestm")
 
-        # ltv <- rep(42,
+
 
         expect_equal(dataset_chunks(tf, "testm"), c(3, 3))
         # Verified using h5ls -rv
@@ -38,6 +40,26 @@ test_that("I can create an extendable dataset and extend it", {
 })
 
 
+
+
+test_that("fast conversion works", {
+        letter_d <- sample(letters,100,replace=T)
+        int_d <- sample(as.character(1:100),100,replace=TRUE)
+        ascii_i <- purrr::map_int(letter_d,utf8ToInt)
+        int_i <- as.integer(int_d)
+        
+        testthat::expect_equal(fast_str2ascii(letter_d),ascii_i)
+        testthat::expect_equal(fast_str2int(int_d),int_i)
+        
+        for(i in 1:10){
+                testthat::expect_equal(fast_str2ascii(paste0(paste0(rep("p",i),collapse=""),letter_d),offset = i),ascii_i)
+                testthat::expect_equal(fast_str2int(paste0(paste0(rep("p",i),collapse=""),int_d),offset = i),int_i)
+        }
+        
+        
+        
+})
+
 test_that("We can write a vector", {
         expect_true(EigenH5::write_vector_h5(numeric(3), tempfile(), "test"))
 })
@@ -131,3 +153,7 @@ test_that("we can reorder stuff using link_objects", {
         retv <- read_vector_h5(ntf, "/testg/test")
         expect_equal(retv, tv)
 })
+
+
+        
+
diff --git a/tests/testthat/test_vec.R b/tests/testthat/test_vec.R
index 2857103..db0a1dc 100644
--- a/tests/testthat/test_vec.R
+++ b/tests/testthat/test_vec.R
@@ -14,6 +14,18 @@ test_that("I can overwrite a vector", {
         expect_equal(read_vector_h5(tf, "test"), ntv)
 })
 
+
+
+testthat::test_that("I can write a factor", {
+        tf <- tempfile()
+        factor_d <- gl(n = 15,k = 4)
+        EigenH5::write_vector_h5(factor_d, tf, "factor")
+        ret <- EigenH5::read_vector_h5(tf,"factor")
+        expect_equal(factor_d,ret)
+})
+
+
+
 test_that("I can append a vector", {
         tf <- tempfile()
         tv <- runif(3)
@@ -40,6 +52,24 @@ test_that("can write and read long strings", {
         expect_equal(res_vec, tvec)
 })
 
+
+test_that("can write short strings then long strings", {
+        tvec <- paste0(sample(letters, 25, replace = T), collapse = "")
+        tempf <- tempfile()
+        write_vector_h5(tvec, tempf, "testw",max_dims=NA_integer_,min_string_size=27L)
+        expect_equal(ArrayTypeSize(tempf,"testw"),28L)
+        tvec2 <- paste0(sample(letters, 30, replace = T), collapse = "")
+        expect_error(write_vector_h5(tvec2,tempf,"testw",append=TRUE),"string will not fit in dataset")
+        
+        write_vector_h5(tvec, tempf, "testw2",max_dims=NA_integer_,min_string_size=31)
+        expect_equal(ArrayTypeSize(tempf,"testw2"),32)
+        tvec2 <- paste0(sample(letters, 30, replace = T), collapse = "")
+        write_vector_h5(tvec2,tempf,"testw2",append=TRUE)
+        rvec <- read_vector_h5(filename = tempf, "testw2",subset=2)
+        expect_equal(rvec, tvec2)
+})
+
+
 test_that("can write string vector", {
         tvec <- c("allb", "allc", "alld")
         tempf <- tempfile()
@@ -89,16 +119,10 @@ test_that("can check type of vectors", {
         expect_equal(dim_h5(filename = tempf, datapath = "dat"), 10)
 })
 
-test_that("can write a vector subset", {
-        tvec <- numeric(3)
-        tempf <- tempfile()
-        write_vector_h5(filename = tempf, datapath = "grp/dat", tvec)
-        write_vector_h5(filename = tempf, datapath="grp/dat", .5, subset = c(3))
-        trd <- read_vector_h5(filename = tempf, datapath="grp/dat", subset = 3)
-        expect_equal(trd, trd)
-        trd <- read_vector_h5(filename = tempf, datapath="grp/dat")
-        expect_equal(trd, c(0, 0, 0.5))
-})
+
+
+
+
 
 test_that("can write a vector out of order", {
         tvec <- c(1.0, 2.0, 3.0)
@@ -200,6 +224,15 @@ test_that("can read string vector", {
                 datapath="grp/tdat",
                 data = tvec
         )
+        # otvec <- tvec
+        # otvec[2] <- NA_character_
+        # write_vector_h5(filename = tempf,
+        #         datapath="grp/otdat",
+        #         data = otvec
+        # )
+        # 
+        # ord <- read_vector_h5(filename = tempf, datapath="grp/otdat")
+        # expect_equal(ord,otvec,na.rm=T)
         rd <- read_vector_h5(filename = tempf, datapath="grp/tdat")
         expect_equal(rd, tvec)
 })