Carter Schonwald avatar Carter Schonwald committed dd107ca

Imported from SVN by Bitbucket

Comments (0)

Files changed (13)

+CC=gcc
+CFLAGS=-I. -std=c99 -Wall -W -Wundef -Wno-implicit-function-declaration
+
+OS := $(shell uname)
+ifeq ($(OS),Linux)
+EXT =
+else
+EXT =.exe
+endif
+
+default: lz4demo
+
+all: lz4demo lz4demo32 fuzzer
+
+lz4demo: lz4.c lz4hc.c bench.c lz4demo.c
+	$(CC)      -O3 $(CFLAGS) $^ -o $@$(EXT)
+
+lz4demo32: lz4.c lz4hc.c bench.c lz4demo.c
+	$(CC) -m32 -Os -march=native $(CFLAGS) $^ -o $@$(EXT)
+
+fuzzer : lz4.c fuzzer.c
+	$(CC)      -O3 $(CFLAGS) $^ -o $@$(EXT)
+	
+clean:
+	rm -f core *.o lz4demo$(EXT) lz4demo32$(EXT) fuzzer$(EXT)
+/*
+    bench.c - Demo program to benchmark open-source compression algorithm
+    Copyright (C) Yann Collet 2012
+	GPL v2 License
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+	You can contact the author at :
+	- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+	- LZ4 source repository : http://code.google.com/p/lz4/
+*/
+
+//**************************************
+// Compiler Options
+//**************************************
+// Disable some Visual warning messages
+#define _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_DEPRECATE     // VS2005
+
+// Unix Large Files support (>4GB)
+#if (defined(__sun__) && (!defined(__LP64__)))   // Sun Solaris 32-bits requires specific definitions
+#  define _LARGEFILE_SOURCE 
+#  define FILE_OFFSET_BITS=64
+#elif ! defined(__LP64__)                        // No point defining Large file for 64 bit
+#  define _LARGEFILE64_SOURCE
+#endif
+
+// S_ISREG & gettimeofday() are not supported by MSVC
+#if defined(_MSC_VER)
+#  define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
+#  define BMK_LEGACY_TIMER 1
+#endif
+
+// GCC does not support _rotl outside of Windows
+#if !defined(_WIN32)
+#  define _rotl(x,r) ((x << r) | (x >> (32 - r)))
+#endif
+
+
+//**************************************
+// Includes
+//**************************************
+#include <stdlib.h>      // malloc
+#include <stdio.h>       // fprintf, fopen, ftello64
+#include <sys/types.h>   // stat64
+#include <sys/stat.h>    // stat64
+
+// Use ftime() if gettimeofday() is not available on your target
+#if defined(BMK_LEGACY_TIMER)   
+#  include <sys/timeb.h>   // timeb, ftime
+#else
+#  include <sys/time.h>    // gettimeofday
+#endif
+
+#include "lz4.h"
+#define COMPRESSOR0 LZ4_compress
+#include "lz4hc.h"
+#define COMPRESSOR1 LZ4_compressHC
+#define DEFAULTCOMPRESSOR LZ4_compress
+
+
+
+//**************************************
+// Basic Types
+//**************************************
+#if defined(_MSC_VER)    // Visual Studio does not support 'stdint' natively
+#define BYTE	unsigned __int8
+#define U16		unsigned __int16
+#define U32		unsigned __int32
+#define S32		__int32
+#define U64		unsigned __int64
+#else
+#include <stdint.h>
+#define BYTE	uint8_t
+#define U16		uint16_t
+#define U32		uint32_t
+#define S32		int32_t
+#define U64		uint64_t
+#endif
+
+
+//**************************************
+// Constants
+//**************************************
+#define NBLOOPS		3
+#define TIMELOOP	2000
+
+#define KNUTH		2654435761U
+#define MAX_MEM		(1984<<20)
+#define DEFAULT_CHUNKSIZE   (8<<20)
+
+
+//**************************************
+// Local structures
+//**************************************
+struct chunkParameters
+{
+	U32   id;
+	char* inputBuffer;
+	char* outputBuffer;
+	int   inputSize;
+	int   outputSize;
+};
+
+struct compressionParameters
+{
+	int (*compressionFunction)(const char*, char*, int);
+	int (*decompressionFunction)(const char*, char*, int);
+};
+
+
+//**************************************
+// MACRO
+//**************************************
+#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
+
+
+
+//**************************************
+// Benchmark Parameters
+//**************************************
+static int chunkSize = DEFAULT_CHUNKSIZE;
+static int nbIterations = NBLOOPS;
+static int BMK_pause = 0;
+
+void BMK_SetBlocksize(int bsize)
+{
+	chunkSize = bsize;
+	DISPLAY("-Using Block Size of %i KB-", chunkSize>>10);
+}
+
+void BMK_SetNbIterations(int nbLoops)
+{
+	nbIterations = nbLoops;
+	DISPLAY("- %i iterations-", nbIterations);
+}
+
+void BMK_SetPause()
+{
+    BMK_pause = 1;
+}
+
+//*********************************************************
+//  Private functions
+//*********************************************************
+
+#if defined(BMK_LEGACY_TIMER)
+
+static int BMK_GetMilliStart()
+{
+  // Based on Legacy ftime()
+  // Rolls over every ~ 12.1 days (0x100000/24/60/60)
+  // Use GetMilliSpan to correct for rollover
+  struct timeb tb;
+  int nCount;
+  ftime( &tb );
+  nCount = (int) (tb.millitm + (tb.time & 0xfffff) * 1000);
+  return nCount;
+}
+
+#else
+
+static int BMK_GetMilliStart()
+{
+  // Based on newer gettimeofday()
+  // Use GetMilliSpan to correct for rollover
+  struct timeval tv;
+  int nCount;
+  gettimeofday(&tv, NULL);
+  nCount = (int) (tv.tv_usec/1000 + (tv.tv_sec & 0xfffff) * 1000);
+  return nCount;
+}
+
+#endif
+
+
+static int BMK_GetMilliSpan( int nTimeStart )
+{
+  int nSpan = BMK_GetMilliStart() - nTimeStart;
+  if ( nSpan < 0 )
+    nSpan += 0x100000 * 1000;
+  return nSpan;
+}
+
+
+static U32 BMK_checksum_MMH3A (char* buff, U32 length)
+{
+  const BYTE* data = (const BYTE*)buff;
+  const int nblocks = length >> 2;
+
+  U32 h1 = KNUTH;
+  U32 c1 = 0xcc9e2d51;
+  U32 c2 = 0x1b873593;
+
+  const U32* blocks = (const U32*)(data + nblocks*4);
+  int i;
+
+  for(i = -nblocks; i; i++)
+  {
+    U32 k1 = blocks[i];
+
+    k1 *= c1;
+    k1 = _rotl(k1,15);
+    k1 *= c2;
+
+    h1 ^= k1;
+    h1 = _rotl(h1,13);
+    h1 = h1*5+0xe6546b64;
+  }
+
+  {
+	  const BYTE* tail = (const BYTE*)(data + nblocks*4);
+	  U32 k1 = 0;
+
+	  switch(length & 3)
+	  {
+	  case 3: k1 ^= tail[2] << 16;
+	  case 2: k1 ^= tail[1] << 8;
+	  case 1: k1 ^= tail[0];
+			  k1 *= c1; k1 = _rotl(k1,15); k1 *= c2; h1 ^= k1;
+	  };
+  }
+
+  h1 ^= length;
+  h1 ^= h1 >> 16;
+  h1 *= 0x85ebca6b;
+  h1 ^= h1 >> 13;
+  h1 *= 0xc2b2ae35;
+  h1 ^= h1 >> 16;
+
+  return h1;
+}
+
+
+static size_t BMK_findMaxMem(U64 requiredMem)
+{
+	size_t step = (64U<<20);   // 64 MB
+	BYTE* testmem=NULL;
+
+	requiredMem = (((requiredMem >> 25) + 1) << 26);
+	if (requiredMem > MAX_MEM) requiredMem = MAX_MEM;
+
+	requiredMem += 2*step;
+	while (!testmem)
+	{
+		requiredMem -= step;
+		testmem = malloc ((size_t)requiredMem);
+	}
+
+	free (testmem);
+	return (size_t) (requiredMem - step);
+}
+
+
+static U64 BMK_GetFileSize(char* infilename)
+{
+	int r;
+#if defined(_MSC_VER)
+	struct _stat64 statbuf;
+	r = _stat64(infilename, &statbuf);
+#else
+	struct stat statbuf;
+	r = stat(infilename, &statbuf);
+#endif
+	if (r || !S_ISREG(statbuf.st_mode)) return 0;   // No good...
+	return (U64)statbuf.st_size;
+}
+
+
+//*********************************************************
+//  Public function
+//*********************************************************
+
+int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
+{
+  int fileIdx=0;
+  FILE* fileIn;
+  char* infilename;
+  U64 largefilesize;
+  size_t benchedsize;
+  int nbChunks;
+  int maxCChunkSize;
+  size_t readSize;
+  char* in_buff;
+  char* out_buff; int out_buff_size;
+  struct chunkParameters* chunkP;
+  U32 crcc, crcd=0;
+  struct compressionParameters compP;
+
+  U64 totals = 0;
+  U64 totalz = 0;
+  double totalc = 0.;
+  double totald = 0.;
+
+
+  // Init
+  switch (cLevel)
+  {
+#ifdef COMPRESSOR0
+  case 0 : compP.compressionFunction = COMPRESSOR0; break;
+#endif
+#ifdef COMPRESSOR1
+  case 1 : compP.compressionFunction = COMPRESSOR1; break;
+#endif
+  default : compP.compressionFunction = DEFAULTCOMPRESSOR;
+  }
+  compP.decompressionFunction = LZ4_uncompress;
+
+  // Loop for each file
+  while (fileIdx<nbFiles)
+  {
+	  // Check file existence
+	  infilename = fileNamesTable[fileIdx++];
+	  fileIn = fopen( infilename, "rb" );
+	  if (fileIn==NULL)
+	  {
+		DISPLAY( "Pb opening %s\n", infilename);
+		return 11;
+	  }
+
+	  // Memory allocation & restrictions
+	  largefilesize = BMK_GetFileSize(infilename);
+	  benchedsize = (size_t) BMK_findMaxMem(largefilesize) / 2;
+	  if ((U64)benchedsize > largefilesize) benchedsize = (size_t)largefilesize;
+	  if (benchedsize < largefilesize)
+	  {
+		  DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", infilename, (int)(benchedsize>>20));
+	  }
+
+	  // Alloc
+	  chunkP = (struct chunkParameters*) malloc(((benchedsize / chunkSize)+1) * sizeof(struct chunkParameters));
+	  in_buff = malloc((size_t )benchedsize);
+	  nbChunks = (int) (benchedsize / chunkSize) + 1;
+	  maxCChunkSize = LZ4_compressBound(chunkSize);
+	  out_buff_size = nbChunks * maxCChunkSize;
+	  out_buff = malloc((size_t )out_buff_size);
+
+
+	  if(!in_buff || !out_buff)
+	  {
+		DISPLAY("\nError: not enough memory!\n");
+		free(in_buff);
+		free(out_buff);
+		fclose(fileIn);
+		return 12;
+	  }
+
+	  // Init chunks data
+	  {
+		  int i;
+		  size_t remaining = benchedsize;
+		  char* in = in_buff;
+		  char* out = out_buff;
+		  for (i=0; i<nbChunks; i++)
+		  {
+			  chunkP[i].id = i;
+			  chunkP[i].inputBuffer = in; in += chunkSize;
+			  if ((int)remaining > chunkSize) { chunkP[i].inputSize = chunkSize; remaining -= chunkSize; } else { chunkP[i].inputSize = (int)remaining; remaining = 0; }
+			  chunkP[i].outputBuffer = out; out += maxCChunkSize;
+			  chunkP[i].outputSize = 0;
+		  }
+	  }
+
+	  // Fill input buffer
+	  DISPLAY("Loading %s...       \r", infilename);
+	  readSize = fread(in_buff, 1, benchedsize, fileIn);
+	  fclose(fileIn);
+
+	  if(readSize != benchedsize)
+	  {
+		DISPLAY("\nError: problem reading file '%s' !!    \n", infilename);
+		free(in_buff);
+		free(out_buff);
+		return 13;
+	  }
+
+	  // Calculating input Checksum
+	  crcc = BMK_checksum_MMH3A(in_buff, (unsigned int)benchedsize);
+
+
+	  // Bench
+	  {
+		int loopNb, nb_loops, chunkNb;
+		size_t cSize=0;
+	    int milliTime;
+		double fastestC = 100000000., fastestD = 100000000.;
+		double ratio=0.;
+
+		DISPLAY("\r%79s\r", "");
+		for (loopNb = 1; loopNb <= nbIterations; loopNb++)
+		{
+		  // Compression
+		  DISPLAY("%1i-%-14.14s : %9i ->\r", loopNb, infilename, (int)benchedsize);
+		  { size_t i; for (i=0; i<benchedsize; i++) out_buff[i]=(char)i; }     // warmimg up memory
+
+		  nb_loops = 0;
+		  milliTime = BMK_GetMilliStart();
+		  while(BMK_GetMilliStart() == milliTime);
+		  milliTime = BMK_GetMilliStart();
+		  while(BMK_GetMilliSpan(milliTime) < TIMELOOP)
+		  {
+			for (chunkNb=0; chunkNb<nbChunks; chunkNb++)
+				chunkP[chunkNb].outputSize = compP.compressionFunction(chunkP[chunkNb].inputBuffer, chunkP[chunkNb].outputBuffer, chunkP[chunkNb].inputSize);
+			nb_loops++;
+		  }
+		  milliTime = BMK_GetMilliSpan(milliTime);
+
+		  if ((double)milliTime < fastestC*nb_loops) fastestC = (double)milliTime/nb_loops;
+		  cSize=0; for (chunkNb=0; chunkNb<nbChunks; chunkNb++) cSize += chunkP[chunkNb].outputSize;
+		  ratio = (double)cSize/(double)benchedsize*100.;
+
+		  DISPLAY("%1i-%-14.14s : %9i -> %9i (%5.2f%%),%7.1f MB/s\r", loopNb, infilename, (int)benchedsize, (int)cSize, ratio, (double)benchedsize / fastestC / 1000.);
+
+		  // Decompression
+		  { size_t i; for (i=0; i<benchedsize; i++) in_buff[i]=0; }     // zeroing area, for CRC checking
+
+		  nb_loops = 0;
+		  milliTime = BMK_GetMilliStart();
+		  while(BMK_GetMilliStart() == milliTime);
+		  milliTime = BMK_GetMilliStart();
+		  while(BMK_GetMilliSpan(milliTime) < TIMELOOP)
+		  {
+			for (chunkNb=0; chunkNb<nbChunks; chunkNb++)
+				chunkP[chunkNb].outputSize = compP.decompressionFunction(chunkP[chunkNb].outputBuffer, chunkP[chunkNb].inputBuffer, chunkP[chunkNb].inputSize);
+			nb_loops++;
+		  }
+		  milliTime = BMK_GetMilliSpan(milliTime);
+
+		  if ((double)milliTime < fastestD*nb_loops) fastestD = (double)milliTime/nb_loops;
+		  DISPLAY("%1i-%-14.14s : %9i -> %9i (%5.2f%%),%7.1f MB/s ,%7.1f MB/s\r", loopNb, infilename, (int)benchedsize, (int)cSize, ratio, (double)benchedsize / fastestC / 1000., (double)benchedsize / fastestD / 1000.);
+
+		  // CRC Checking
+		  crcd = BMK_checksum_MMH3A(in_buff, (unsigned int)benchedsize);
+		  if (crcc!=crcd) { DISPLAY("\n!!! WARNING !!! %14s : Invalid Checksum : %x != %x\n", infilename, (unsigned)crcc, (unsigned)crcd); break; }
+		}
+
+	    if (crcc==crcd)
+		{
+			if (ratio<100.)
+				DISPLAY("%-16.16s : %9i -> %9i (%5.2f%%),%7.1f MB/s ,%7.1f MB/s\n", infilename, (int)benchedsize, (int)cSize, ratio, (double)benchedsize / fastestC / 1000., (double)benchedsize / fastestD / 1000.);
+			else
+				DISPLAY("%-16.16s : %9i -> %9i (%5.1f%%),%7.1f MB/s ,%7.1f MB/s \n", infilename, (int)benchedsize, (int)cSize, ratio, (double)benchedsize / fastestC / 1000., (double)benchedsize / fastestD / 1000.);
+		}
+		totals += benchedsize;
+		totalz += cSize;
+		totalc += fastestC;
+		totald += fastestD;
+	  }
+
+	  free(in_buff);
+	  free(out_buff);
+	  free(chunkP);
+  }
+
+  if (nbFiles > 1)
+		printf("%-16.16s :%10llu ->%10llu (%5.2f%%), %6.1f MB/s , %6.1f MB/s\n", "  TOTAL", (long long unsigned int)totals, (long long unsigned int)totalz, (double)totalz/(double)totals*100., (double)totals/totalc/1000., (double)totals/totald/1000.);
+
+  if (BMK_pause) { printf("press enter...\n"); getchar(); }
+
+  return 0;
+}
+
+
+
+/*
+    bench.h - Demo program to benchmark open-source compression algorithm
+    Copyright (C) Yann Collet 2012
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+	You can contact the author at :
+	- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+	- LZ4 source repository : http://code.google.com/p/lz4/
+*/
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel);
+
+// Parameters
+void BMK_SetBlocksize(int bsize);
+void BMK_SetNbIterations(int nbLoops);
+void BMK_SetPause();
+
+
+
+#if defined (__cplusplus)
+}
+#endif

cmake/CMakeLists.txt

+PROJECT(LZ4)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "ASN.1 Compiler")
+set(CPACK_PACKAGE_VERSION_MAJOR 0)
+set(CPACK_PACKAGE_VERSION_MINOR 0)
+set(CPACK_PACKAGE_VERSION_PATCH r51)
+#set(CPACK_RESOURCE_FILE_LICENSE  ${CMAKE_CURRENT_BINARY_DIR}/COPYING_LGPL)
+                                  set(VERSION_STRING	" \"${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}\" ")
+include(CPack)
+
+
+cmake_minimum_required (VERSION 2.6)
+INCLUDE (CheckTypeSize)
+check_type_size("void *" SIZEOF_VOID_P)
+IF( ${SIZEOF_VOID_P} STREQUAL  "8" )
+    set (CMAKE_SYSTEM_PROCESSOR "64bit")
+    MESSAGE( STATUS "64 bit architecture detected size of void * is " ${SIZEOF_VOID_P})
+ENDIF()
+
+
+set(SRC_DIR ../)
+set(LZ4_SRCS_LIB ${SRC_DIR}lz4.c ${SRC_DIR}lz4hc.c ${SRC_DIR}lz4.h )
+set(LZ4_SRCS ${LZ4_SRCS_LIB} ${SRC_DIR}bench.c ${SRC_DIR}lz4demo.c )
+
+# EXECUTABLES FOR 32 Bit and 64 versions
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "64bit")
+	add_executable(lz4demo64 ${LZ4_SRCS})
+        install(TARGETS lz4demo64 RUNTIME DESTINATION "./")
+endif()
+
+	add_executable(lz4demo32 ${LZ4_SRCS})
+        install(TARGETS lz4demo32 RUNTIME DESTINATION "./")
+
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "64bit")
+SET_TARGET_PROPERTIES(lz4demo32 PROPERTIES
+	COMPILE_FLAGS PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
+endif()
+
+
+#warnings
+
+ADD_DEFINITIONS("-Wall")
+ADD_DEFINITIONS("-W")
+ADD_DEFINITIONS("-Wundef")
+ADD_DEFINITIONS("-Wcast-align")
+ADD_DEFINITIONS("-Wno-implicit-function-declaration")
+ADD_DEFINITIONS("-Os -march=native -std=c99")
+INCLUDE_DIRECTORIES (${SRC_DIR})
+
+
+#target_link_libraries(lz4 ${LZ4_SRCS_LIB})
+
+

cmake/pack/CMakeLists.txt

+cmake_minimum_required (VERSION 2.8)
+PROJECT(LZ4)
+
+############################## CPACK
+set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "LZ4 Packer")
+set(CPACK_PACKAGE_VERSION_MAJOR 0)
+set(CPACK_PACKAGE_VERSION_MINOR 0)
+set(CPACK_PACKAGE_VERSION_PATCH r89)
+#set(CPACK_RESOURCE_FILE_LICENSE  ${CMAKE_CURRENT_BINARY_DIR}/COPYING_LGPL)
+##############################
+FIND_PACKAGE(Subversion)
+IF(SUBVERSION_FOUND)
+	Subversion_WC_INFO(${SRC_DIR}  revision)
+	set(revision_MY_WC_STATUS "LZ4 has revision ${revision_WC_REVISION} at ${revision_WC_LAST_CHANGED_DATE}")
+	message(STATUS ${revision_MY_WC_STATUS})
+	if(NOT ${revision_WC_REVISION})
+	else(NOT ${revision_WC_REVISION})
+		set(CPACK_PACKAGE_VERSION_PATCH "r${revision_WC_REVISION}")
+	endif(NOT ${revision_WC_REVISION})
+ELSE(SUBVERSION_FOUND)
+	message(WARNING "NO Subversion FOUND!!!")
+ENDIF(SUBVERSION_FOUND)
+set(VERSION_STRING	" \"${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}\" ")
+##############################
+INCLUDE (CheckTypeSize)
+check_type_size("void *" SIZEOF_VOID_P)
+IF( ${SIZEOF_VOID_P} STREQUAL  "8" )
+    set (CMAKE_SYSTEM_PROCESSOR "64bit")
+    MESSAGE( STATUS "64 bit architecture detected size of void * is " ${SIZEOF_VOID_P})
+ENDIF()
+###############################     warnings
+
+ADD_DEFINITIONS("-Wall")
+ADD_DEFINITIONS("-W")
+ADD_DEFINITIONS("-Wundef")
+ADD_DEFINITIONS("-Wcast-align")
+ADD_DEFINITIONS("-Wno-implicit-function-declaration")
+ADD_DEFINITIONS("-O3 -march=native -std=c99")
+INCLUDE_DIRECTORIES (${SRC_DIR})
+
+
+
+set(LZ4_SRCS_LIB ${SRC_DIR}lz4.c ${SRC_DIR}lz4hc.c ${SRC_DIR}lz4.h ${SRC_DIR}lz4_format_description.txt)
+set(LZ4_SRCS ${LZ4_SRCS_LIB} ${SRC_DIR}bench.c ${SRC_DIR}lz4demo.c )
+set(FIZZER_SRCS ${SRC_DIR}lz4.c ${SRC_DIR}lz4hc.c ${SRC_DIR}lz4.h ${SRC_DIR}fuzzer.c)
+
+# EXECUTABLES FOR 32 Bit and 64 versions
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "64bit")
+	add_executable(lz4demo32 ${LZ4_SRCS})
+	install(TARGETS lz4demo32 RUNTIME DESTINATION "./")
+SET_TARGET_PROPERTIES(lz4demo32 PROPERTIES
+	COMPILE_FLAGS PROPERTIES COMPILE_FLAGS "-m32 -Os" LINK_FLAGS "-m32")
+endif()
+
+add_executable(lz4demo ${LZ4_SRCS})
+install(TARGETS lz4demo RUNTIME DESTINATION "./")
+
+add_executable(fuzzer ${FIZZER_SRCS})
+install(TARGETS fuzzer RUNTIME DESTINATION "./")
+
+#target_link_libraries(lz4 ${LZ4_SRCS_LIB})
+####################### CPACK PACKAGING ###################
+install(FILES ${SRC_DIR}lz4_format_description.txt DESTINATION "./")
+
+set(CPACK_PACKAGE_NAME ${CMAKE_PROJECT_NAME})
+set(CPACK_RESOURCE_FILE_LICENSE  "${CMAKE_CURRENT_LIST_DIR}/release_COPYING.txt")
+set(CPACK_PACKAGE_VENDOR "Yann Collet")
+set(CPACK_WWW_SITE "http://fastcompression.blogspot.com/p/lz4.html")
+set(CPACK_NSIS_URL_INFO_ABOUT "${CPACK_WWW_SITE}")
+set(CPACK_NSIS_HELP_LINK "${CPACK_WWW_SITE}")
+
+set(CPACK_NSIS_DISPLAY_NAME ${CPACK_PACKAGE_NAME})
+set(CPACK_NSIS_COMPRESSOR "/SOLID lzma \r\n SetCompressorDictSize 32")
+
+set(CPACK_NSIS_MENU_LINKS
+	"${CPACK_WWW_SITE}" "${CPACK_PACKAGE_NAME} homepage"
+ 	"/lz4_format_description.txt "	"lz4 format description"
+ 	"/"	"LZ4 directory "
+)
+
+include (CPack)

cmake/pack/release_COPYING.txt

+
+    lz4demo and fuzzer is an open-source demo compression algorithm LZ4 programs
+    Copyright (C) Yann Collet 2012
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+	You can contact the author at :
+	- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+	- LZ4 source repository : http://code.google.com/p/lz4/
+/*
+    fuzzer.c - Fuzzer test tool for LZ4
+    Copyright (C) Andrew Mahone - Yann Collet 2012
+	Original code by Andrew Mahone / Modified by Yann Collet
+	GPL v2 License
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+	You can contact the author at :
+	- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+	- LZ4 source repository : http://code.google.com/p/lz4/
+*/
+
+//**************************************
+// Remove Visual warning messages
+//**************************************
+#define _CRT_SECURE_NO_WARNINGS  // fgets
+
+
+//**************************************
+// Includes
+//**************************************
+#include <stdlib.h>
+#include <stdio.h>      // fgets, sscanf
+#include <sys/timeb.h>  // timeb
+#include "lz4.h"
+
+
+//**************************************
+// Constants
+//**************************************
+#define NB_ATTEMPTS (1<<18)
+#define LEN ((1<<15))
+#define SEQ_POW 2
+#define NUM_SEQ (1 << SEQ_POW)
+#define SEQ_MSK ((NUM_SEQ) - 1)
+#define MOD_SEQ(x) ((((x) >> 8) & 255) == 0)
+#define NEW_SEQ(x) ((((x) >> 10) %10) == 0)
+#define PAGE_SIZE 4096
+#define ROUND_PAGE(x) (((x) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
+#define PRIME1   2654435761U
+#define PRIME2   2246822519U
+#define PRIME3   3266489917U
+
+
+
+//*********************************************************
+//  Functions
+//*********************************************************
+static int FUZ_GetMilliStart()
+{
+  struct timeb tb;
+  int nCount;
+  ftime( &tb );
+  nCount = (int) (tb.millitm + (tb.time & 0xfffff) * 1000);
+  return nCount;
+}
+
+static int FUZ_GetMilliSpan( int nTimeStart )
+{
+  int nSpan = FUZ_GetMilliStart() - nTimeStart;
+  if ( nSpan < 0 )
+    nSpan += 0x100000 * 1000;
+  return nSpan;
+}
+
+
+unsigned int FUZ_rand(unsigned int* src)
+{
+	*src =  ((*src) * PRIME1) + PRIME2;
+	return *src;
+}
+
+
+int test_canary(unsigned char *buf) {
+        int i;
+        for (i = 0; i < 2048; i++)
+                if (buf[i] != buf[i + 2048])
+                        return 0;
+        return 1;
+}
+
+int FUZ_SecurityTest()
+{
+  char* output;
+  char* input;
+  int i, r;
+
+  printf("Starting security tests...");
+  input = (char*) malloc (20<<20);
+  output = (char*) malloc (20<<20);
+  input[0] = 0x0F;
+  input[1] = 0x00;
+  input[2] = 0x00;
+  for(i = 3; i < 16840000; i++)
+    input[i] = 0xff;
+  r = LZ4_uncompress(input, output, 20<<20);
+
+  free(input);
+  free(output);
+  printf(" Completed (r=%i)\n",r);
+  return 0;
+}
+
+
+//int main(int argc, char *argv[]) {
+int main() {
+        unsigned long long bytes = 0;
+        unsigned long long cbytes = 0;
+        unsigned char buf[LEN];
+        unsigned char testOut[LEN+1];
+#       define FUZ_max   LZ4_COMPRESSBOUND(LEN)
+#       define FUZ_avail ROUND_PAGE(FUZ_max)
+        const int off_full = FUZ_avail - FUZ_max;
+        unsigned char cbuf[FUZ_avail + PAGE_SIZE];
+		unsigned int seed, cur_seq=PRIME3, seeds[NUM_SEQ], timestamp=FUZ_GetMilliStart();
+        int i, j, k, ret, len;
+		char userInput[30] = {0};
+
+		printf("starting LZ4 fuzzer\n");
+		printf("Select an Initialisation number (default : random) : ");
+		fflush(stdout);
+		if ( fgets(userInput, sizeof userInput, stdin) )
+		{
+			if ( sscanf(userInput, "%d", &seed) == 1 ) {}
+			else seed = FUZ_GetMilliSpan(timestamp);
+		}
+		printf("Seed = %u\n", seed);
+
+		FUZ_SecurityTest();
+
+		for (i = 0; i < 2048; i++)
+                cbuf[FUZ_avail + i] = cbuf[FUZ_avail + 2048 + i] = FUZ_rand(&seed) >> 16;
+
+        for (i = 0; i < NB_ATTEMPTS; i++) {
+			printf("\r%7i /%7i\r", i, NB_ATTEMPTS);
+			
+			FUZ_rand(&seed);
+            for (j = 0; j < NUM_SEQ; j++) {
+                    seeds[j] = FUZ_rand(&seed) << 8;
+                    seeds[j] ^= (FUZ_rand(&seed) >> 8) & 65535;
+            }
+            for (j = 0; j < LEN; j++) {
+                    k = FUZ_rand(&seed);
+                    if (j == 0 || NEW_SEQ(k))
+                            cur_seq = seeds[(FUZ_rand(&seed) >> 16) & SEQ_MSK];
+                    if (MOD_SEQ(k)) {
+                            k = (FUZ_rand(&seed) >> 16) & SEQ_MSK;
+                            seeds[k] = FUZ_rand(&seed) << 8;
+                            seeds[k] ^= (FUZ_rand(&seed) >> 8) & 65535;
+                    }
+                    buf[j] = FUZ_rand(&cur_seq) >> 16;
+            }
+
+			// Test compression
+            ret = LZ4_compress_limitedOutput((const char*)buf, (char*)&cbuf[off_full], LEN, FUZ_max);
+			if (ret == 0) { printf("compression failed despite sufficient space: seed %u, len %d\n", seed, LEN); goto _output_error; }
+            len = ret;
+
+			// Test decoding with output size being exactly what's necessary => must work
+			ret = LZ4_uncompress((char*)&cbuf[off_full], (char*)testOut, LEN);
+			if (ret<0) { printf("decompression failed despite sufficient space: seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test decoding with one byte missing => must fail
+			ret = LZ4_uncompress((char*)&cbuf[off_full], (char*)testOut, LEN-1);
+			if (ret>=0) { printf("decompression should have failed, due to Output Size being too small : seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test decoding with one byte too much => must fail
+			ret = LZ4_uncompress((char*)&cbuf[off_full], (char*)testOut, LEN+1);
+			if (ret>=0) { printf("decompression should have failed, due to Output Size being too large : seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test decoding with enough output size => must work
+			ret = LZ4_uncompress_unknownOutputSize((char*)&cbuf[off_full], (char*)testOut, len, LEN+1);
+			if (ret<0) { printf("decompression failed despite sufficient space: seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test decoding with output size being exactly what's necessary => should work
+			ret = LZ4_uncompress_unknownOutputSize((char*)&cbuf[off_full], (char*)testOut, len, LEN);
+			if (ret<0) { printf("decompression failed despite sufficient space: seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test decoding with output size being one byte too short => must fail
+			ret = LZ4_uncompress_unknownOutputSize((char*)&cbuf[off_full], (char*)testOut, len, LEN-1);
+			if (ret>=0) { printf("decompression should have failed, due to Output Size being too small : seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test decoding with input size being one byte too short => must fail
+			ret = LZ4_uncompress_unknownOutputSize((char*)&cbuf[off_full], (char*)testOut, len-1, LEN);
+			if (ret>=0) { printf("decompression should have failed, due to input size being too small : seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test decoding with input size being one byte too large => must fail
+			ret = LZ4_uncompress_unknownOutputSize((char*)&cbuf[off_full], (char*)testOut, len+1, LEN);
+			if (ret>=0) { printf("decompression should have failed, due to input size being too large : seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test compression with output size being exactly what's necessary (should work)
+            ret = LZ4_compress_limitedOutput((const char*)buf, (char*)&cbuf[FUZ_avail-len], LEN, len);
+            if (!test_canary(&cbuf[FUZ_avail])) { printf("compression overran output buffer: seed %u, len %d, olen %d\n", seed, LEN, len); goto _output_error; }
+            if (ret == 0) { printf("compression failed despite sufficient space: seed %u, len %d\n", seed, LEN); goto _output_error; }
+
+			// Test compression with just one missing byte into output buffer => must fail
+            ret = LZ4_compress_limitedOutput((const char*)buf, (char*)&cbuf[FUZ_avail-(len-1)], LEN, len-1);
+            if (ret) { printf("compression overran output buffer: seed %u, len %d, olen %d => ret %d", seed, LEN, len-1, ret); goto _output_error; }
+            if (!test_canary(&cbuf[FUZ_avail])) { printf("compression overran output buffer: seed %u, len %d, olen %d", seed, LEN, len-1); goto _output_error; }
+
+			bytes += LEN;
+            cbytes += len;
+        }
+
+		printf("all tests completed successfully \n");
+        printf("compression ratio: %0.3f%%\n", (double)cbytes/bytes*100);
+		getchar();
+        return 0;
+
+_output_error:
+		getchar();
+		return 1;
+}
+/*
+   LZ4 - Fast LZ compression algorithm
+   Copyright (C) 2011-2012, 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 :
+   - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+   - LZ4 source repository : http://code.google.com/p/lz4/
+*/
+
+//**************************************
+// 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
+// Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
+#define MEMORY_USAGE 14
+
+// NOTCOMPRESSIBLE_DETECTIONLEVEL :
+// Decreasing this value will make the algorithm skip faster data segments considered "incompressible"
+// This may decrease compression ratio dramatically, but will be faster on incompressible data
+// Increasing this value will make the algorithm search more before declaring a segment "incompressible"
+// This could improve compression a bit, but will be slower on incompressible data
+// The default value (6) is recommended
+#define NOTCOMPRESSIBLE_DETECTIONLEVEL 6
+
+// BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE :
+// This will provide a small boost to performance for big endian cpu, but the resulting compressed stream will be incompatible with little-endian CPU.
+// You can set this option to 1 in situations where data will remain within closed environment
+// This option is useless on Little_Endian CPU (such as x86)
+//#define BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE 1
+
+
+
+//**************************************
+// CPU Feature Detection
+//**************************************
+// 32 or 64 bits ?
+#if (defined(__x86_64__) || defined(__x86_64) || defined(__amd64__) || defined(__amd64) || defined(__ppc64__) || defined(_WIN64) || defined(__LP64__) || defined(_LP64) )   // Detects 64 bits mode
+#  define LZ4_ARCH64 1
+#else
+#  define LZ4_ARCH64 0
+#endif
+
+// Little Endian or Big Endian ?
+// Overwrite the #define below if you know your architecture endianess
+#if defined (__GLIBC__)
+#  include <endian.h>
+#  if (__BYTE_ORDER == __BIG_ENDIAN)
+#     define LZ4_BIG_ENDIAN 1
+#  endif
+#elif (defined(__BIG_ENDIAN__) || defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN)) && !(defined(__LITTLE_ENDIAN__) || defined(__LITTLE_ENDIAN) || defined(_LITTLE_ENDIAN))
+#  define LZ4_BIG_ENDIAN 1
+#elif defined(__sparc) || defined(__sparc__) \
+   || defined(__ppc__) || defined(_POWER) || defined(__powerpc__) || defined(_ARCH_PPC) || defined(__PPC__) || defined(__PPC) || defined(PPC) || defined(__powerpc__) || defined(__powerpc) || defined(powerpc) \
+   || defined(__hpux)  || defined(__hppa) \
+   || defined(_MIPSEB) || defined(__s390__)
+#  define LZ4_BIG_ENDIAN 1
+#else
+// Little Endian assumed. PDP Endian and other very rare endian format are unsupported.
+#endif
+
+// Unaligned memory access is automatically enabled for "common" CPU, such as x86.
+// For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected
+// If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance
+#if defined(__ARM_FEATURE_UNALIGNED)
+#  define LZ4_FORCE_UNALIGNED_ACCESS 1
+#endif
+
+// Define this parameter if your target system or compiler does not support hardware bit count
+#if defined(_MSC_VER) && defined(_WIN32_WCE)            // Visual Studio for Windows CE does not support Hardware bit count
+#  define LZ4_FORCE_SW_BITCOUNT
+#endif
+
+
+//**************************************
+// Compiler Options
+//**************************************
+#if __STDC_VERSION__ >= 199901L   // C99
+/* "restrict" is a known keyword */
+#else
+#  define restrict // Disable restrict
+#endif
+
+#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+
+#ifdef _MSC_VER  // Visual Studio
+#  include <intrin.h>   // For Visual 2005
+#  if LZ4_ARCH64	// 64-bit
+#    pragma intrinsic(_BitScanForward64) // For Visual 2005
+#    pragma intrinsic(_BitScanReverse64) // For Visual 2005
+#  else
+#    pragma intrinsic(_BitScanForward)   // For Visual 2005
+#    pragma intrinsic(_BitScanReverse)   // For Visual 2005
+#  endif
+#endif
+
+#ifdef _MSC_VER
+#  define lz4_bswap16(x) _byteswap_ushort(x)
+#else
+#  define lz4_bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8)))
+#endif
+
+#if (GCC_VERSION >= 302) || (__INTEL_COMPILER >= 800) || defined(__clang__)
+#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
+#else
+#  define expect(expr,value)    (expr)
+#endif
+
+#define likely(expr)     expect((expr) != 0, 1)
+#define unlikely(expr)   expect((expr) != 0, 0)
+
+
+//**************************************
+// Includes
+//**************************************
+#include <stdlib.h>   // for malloc
+#include <string.h>   // for memset
+#include "lz4.h"
+
+
+//**************************************
+// Basic Types
+//**************************************
+#if defined(_MSC_VER)    // Visual Studio does not support 'stdint' natively
+#  define BYTE	unsigned __int8
+#  define U16		unsigned __int16
+#  define U32		unsigned __int32
+#  define S32		__int32
+#  define U64		unsigned __int64
+#else
+#  include <stdint.h>
+#  define BYTE	uint8_t
+#  define U16		uint16_t
+#  define U32		uint32_t
+#  define S32		int32_t
+#  define U64		uint64_t
+#endif
+
+#ifndef LZ4_FORCE_UNALIGNED_ACCESS
+#  pragma pack(push, 1)
+#endif
+
+typedef struct _U16_S { U16 v; } U16_S;
+typedef struct _U32_S { U32 v; } U32_S;
+typedef struct _U64_S { U64 v; } U64_S;
+
+#ifndef LZ4_FORCE_UNALIGNED_ACCESS
+#  pragma pack(pop)
+#endif
+
+#define A64(x) (((U64_S *)(x))->v)
+#define A32(x) (((U32_S *)(x))->v)
+#define A16(x) (((U16_S *)(x))->v)
+
+
+//**************************************
+// Constants
+//**************************************
+#define MINMATCH 4
+
+#define HASH_LOG (MEMORY_USAGE-2)
+#define HASHTABLESIZE (1 << HASH_LOG)
+#define HASH_MASK (HASHTABLESIZE - 1)
+
+#define SKIPSTRENGTH (NOTCOMPRESSIBLE_DETECTIONLEVEL>2?NOTCOMPRESSIBLE_DETECTIONLEVEL:2)
+#define STACKLIMIT 13
+#define HEAPMODE (HASH_LOG>STACKLIMIT)  // Defines if memory is allocated into the stack (local variable), or into the heap (malloc()).
+#define COPYLENGTH 8
+#define LASTLITERALS 5
+#define MFLIMIT (COPYLENGTH+MINMATCH)
+#define MINLENGTH (MFLIMIT+1)
+
+#define MAXD_LOG 16
+#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)
+
+#define ML_BITS  4
+#define ML_MASK  ((1U<<ML_BITS)-1)
+#define RUN_BITS (8-ML_BITS)
+#define RUN_MASK ((1U<<RUN_BITS)-1)
+
+
+//**************************************
+// Architecture-specific macros
+//**************************************
+#if LZ4_ARCH64	// 64-bit
+#  define STEPSIZE 8
+#  define UARCH U64
+#  define AARCH A64
+#  define LZ4_COPYSTEP(s,d)       A64(d) = A64(s); d+=8; s+=8;
+#  define LZ4_COPYPACKET(s,d)     LZ4_COPYSTEP(s,d)
+#  define LZ4_SECURECOPY(s,d,e)   if (d<e) LZ4_WILDCOPY(s,d,e)
+#  define HTYPE                   U32
+#  define INITBASE(base)          const BYTE* const base = ip
+#else		// 32-bit
+#  define STEPSIZE 4
+#  define UARCH U32
+#  define AARCH A32
+#  define LZ4_COPYSTEP(s,d)       A32(d) = A32(s); d+=4; s+=4;
+#  define LZ4_COPYPACKET(s,d)     LZ4_COPYSTEP(s,d); LZ4_COPYSTEP(s,d);
+#  define LZ4_SECURECOPY          LZ4_WILDCOPY
+#  define HTYPE                   const BYTE*
+#  define INITBASE(base)          const int base = 0
+#endif
+
+#if (defined(LZ4_BIG_ENDIAN) && !defined(BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE))
+#  define LZ4_READ_LITTLEENDIAN_16(d,s,p) { U16 v = A16(p); v = lz4_bswap16(v); d = (s) - v; }
+#  define LZ4_WRITE_LITTLEENDIAN_16(p,i)  { U16 v = (U16)(i); v = lz4_bswap16(v); A16(p) = v; p+=2; }
+#else		// Little Endian
+#  define LZ4_READ_LITTLEENDIAN_16(d,s,p) { d = (s) - A16(p); }
+#  define LZ4_WRITE_LITTLEENDIAN_16(p,v)  { A16(p) = v; p+=2; }
+#endif
+
+
+//**************************************
+// Local structures
+//**************************************
+struct refTables
+{
+    HTYPE hashTable[HASHTABLESIZE];
+};
+
+
+//**************************************
+// Macros
+//**************************************
+#define LZ4_HASH_FUNCTION(i)	(((i) * 2654435761U) >> ((MINMATCH*8)-HASH_LOG))
+#define LZ4_HASH_VALUE(p)		LZ4_HASH_FUNCTION(A32(p))
+#define LZ4_WILDCOPY(s,d,e)		do { LZ4_COPYPACKET(s,d) } while (d<e);
+#define LZ4_BLINDCOPY(s,d,l)	{ BYTE* e=(d)+l; LZ4_WILDCOPY(s,d,e); d=e; }
+
+
+//****************************
+// Private functions
+//****************************
+#if LZ4_ARCH64
+
+static inline int LZ4_NbCommonBytes (register U64 val)
+{
+#if defined(LZ4_BIG_ENDIAN)
+    #if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    unsigned long r = 0;
+    _BitScanReverse64( &r, val );
+    return (int)(r>>3);
+    #elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    return (__builtin_clzll(val) >> 3);
+    #else
+    int r;
+    if (!(val>>32)) { r=4; } else { r=0; val>>=32; }
+    if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
+    r += (!val);
+    return r;
+    #endif
+#else
+    #if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    unsigned long r = 0;
+    _BitScanForward64( &r, val );
+    return (int)(r>>3);
+    #elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    return (__builtin_ctzll(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 & -val) * 0x0218A392CDABBD3F)) >> 58];
+    #endif
+#endif
+}
+
+#else
+
+static inline int LZ4_NbCommonBytes (register U32 val)
+{
+#if defined(LZ4_BIG_ENDIAN)
+    #if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    unsigned long r = 0;
+    _BitScanReverse( &r, val );
+    return (int)(r>>3);
+    #elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    return (__builtin_clz(val) >> 3);
+    #else
+    int r;
+    if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
+    r += (!val);
+    return r;
+    #endif
+#else
+    #if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    unsigned long r = 0;
+    _BitScanForward( &r, val );
+    return (int)(r>>3);
+    #elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
+    return (__builtin_ctz(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
+#endif
+}
+
+#endif
+
+
+
+//******************************
+// Compression functions
+//******************************
+
+// LZ4_compressCtx :
+// -----------------
+// Compress 'isize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
+// If it cannot achieve it, compression will stop, and result of the function will be zero.
+// return : the number of bytes written in buffer 'dest', or 0 if the compression fails
+
+static inline int LZ4_compressCtx(void** ctx,
+                 const char* source,
+                 char* dest,
+                 int isize,
+                 int maxOutputSize)
+{
+#if HEAPMODE
+    struct refTables *srt = (struct refTables *) (*ctx);
+    HTYPE* HashTable;
+#else
+    HTYPE HashTable[HASHTABLESIZE] = {0};
+#endif
+
+    const BYTE* ip = (BYTE*) source;
+    INITBASE(base);
+    const BYTE* anchor = ip;
+    const BYTE* const iend = ip + isize;
+    const BYTE* const mflimit = iend - MFLIMIT;
+#define matchlimit (iend - LASTLITERALS)
+
+    BYTE* op = (BYTE*) dest;
+    BYTE* const oend = op + maxOutputSize;
+
+    int len, length;
+    const int skipStrength = SKIPSTRENGTH;
+    U32 forwardH;
+
+
+    // Init
+    if (isize<MINLENGTH) goto _last_literals;
+#if HEAPMODE
+    if (*ctx == NULL)
+    {
+        srt = (struct refTables *) malloc ( sizeof(struct refTables) );
+        *ctx = (void*) srt;
+    }
+    HashTable = (HTYPE*)(srt->hashTable);
+    memset((void*)HashTable, 0, sizeof(srt->hashTable));
+#else
+    (void) ctx;
+#endif
+
+
+    // First Byte
+    HashTable[LZ4_HASH_VALUE(ip)] = ip - base;
+    ip++; forwardH = LZ4_HASH_VALUE(ip);
+
+    // Main Loop
+    for ( ; ; )
+    {
+        int findMatchAttempts = (1U << skipStrength) + 3;
+        const BYTE* forwardIp = ip;
+        const BYTE* ref;
+        BYTE* token;
+
+        // Find a match
+        do {
+            U32 h = forwardH;
+            int step = findMatchAttempts++ >> skipStrength;
+            ip = forwardIp;
+            forwardIp = ip + step;
+
+            if unlikely(forwardIp > mflimit) { goto _last_literals; }
+
+            forwardH = LZ4_HASH_VALUE(forwardIp);
+            ref = base + HashTable[h];
+            HashTable[h] = ip - base;
+
+        } while ((ref < ip - MAX_DISTANCE) || (A32(ref) != A32(ip)));
+
+        // Catch up
+        while ((ip>anchor) && (ref>(BYTE*)source) && unlikely(ip[-1]==ref[-1])) { ip--; ref--; }
+
+        // Encode Literal length
+        length = (int)(ip - anchor);
+        token = op++;
+        if unlikely(op + length + (2 + 1 + LASTLITERALS) + (length>>8) > oend) return 0; 		// Check output limit
+#ifdef _MSC_VER
+        if (length>=(int)RUN_MASK) 
+        { 
+            int len = length-RUN_MASK; 
+            *token=(RUN_MASK<<ML_BITS); 
+            if (len>254)
+            {
+                do { *op++ = 255; len -= 255; } while (len>254);
+                *op++ = (BYTE)len; 
+                memcpy(op, anchor, length);
+                op += length;
+                goto _next_match;
+            }
+            else
+            *op++ = (BYTE)len; 
+        }
+        else *token = (length<<ML_BITS);
+#else
+        if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; }
+        else *token = (length<<ML_BITS);
+#endif
+
+        // Copy Literals
+        LZ4_BLINDCOPY(anchor, op, length);
+
+_next_match:
+        // Encode Offset
+        LZ4_WRITE_LITTLEENDIAN_16(op,(U16)(ip-ref));
+
+        // Start Counting
+        ip+=MINMATCH; ref+=MINMATCH;   // MinMatch verified
+        anchor = ip;
+        while likely(ip<matchlimit-(STEPSIZE-1))
+        {
+            UARCH diff = AARCH(ref) ^ AARCH(ip);
+            if (!diff) { ip+=STEPSIZE; ref+=STEPSIZE; continue; }
+            ip += LZ4_NbCommonBytes(diff);
+            goto _endCount;
+        }
+        if (LZ4_ARCH64) if ((ip<(matchlimit-3)) && (A32(ref) == A32(ip))) { ip+=4; ref+=4; }
+        if ((ip<(matchlimit-1)) && (A16(ref) == A16(ip))) { ip+=2; ref+=2; }
+        if ((ip<matchlimit) && (*ref == *ip)) ip++;
+_endCount:
+
+        // Encode MatchLength
+        len = (int)(ip - anchor);
+        if unlikely(op + (1 + LASTLITERALS) + (len>>8) > oend) return 0; 		// Check output limit
+        if (len>=(int)ML_MASK) { *token+=ML_MASK; len-=ML_MASK; for(; len > 509 ; len-=510) { *op++ = 255; *op++ = 255; } if (len > 254) { len-=255; *op++ = 255; } *op++ = (BYTE)len; }
+        else *token += len;
+
+        // Test end of chunk
+        if (ip > mflimit) { anchor = ip;  break; }
+
+        // Fill table
+        HashTable[LZ4_HASH_VALUE(ip-2)] = ip - 2 - base;
+
+        // Test next position
+        ref = base + HashTable[LZ4_HASH_VALUE(ip)];
+        HashTable[LZ4_HASH_VALUE(ip)] = ip - base;
+        if ((ref > ip - (MAX_DISTANCE + 1)) && (A32(ref) == A32(ip))) { token = op++; *token=0; goto _next_match; }
+
+        // Prepare next loop
+        anchor = ip++;
+        forwardH = LZ4_HASH_VALUE(ip);
+    }
+
+_last_literals:
+    // Encode Last Literals
+    {
+        int lastRun = (int)(iend - anchor);
+        if (((char*)op - dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize) return 0;
+        if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }
+        else *op++ = (lastRun<<ML_BITS);
+        memcpy(op, anchor, iend - anchor);
+        op += iend-anchor;
+    }
+
+    // End
+    return (int) (((char*)op)-dest);
+}
+
+
+
+// Note : this function is valid only if isize < LZ4_64KLIMIT
+#define LZ4_64KLIMIT ((1<<16) + (MFLIMIT-1))
+#define HASHLOG64K (HASH_LOG+1)
+#define HASH64KTABLESIZE (1U<<HASHLOG64K)
+#define LZ4_HASH64K_FUNCTION(i)	(((i) * 2654435761U) >> ((MINMATCH*8)-HASHLOG64K))
+#define LZ4_HASH64K_VALUE(p)	LZ4_HASH64K_FUNCTION(A32(p))
+static inline int LZ4_compress64kCtx(void** ctx,
+                 const char* source,
+                 char* dest,
+                 int isize,
+                 int maxOutputSize)
+{
+#if HEAPMODE
+    struct refTables *srt = (struct refTables *) (*ctx);
+    U16* HashTable;
+#else
+    U16 HashTable[HASH64KTABLESIZE] = {0};
+#endif
+
+    const BYTE* ip = (BYTE*) source;
+    const BYTE* anchor = ip;
+    const BYTE* const base = ip;
+    const BYTE* const iend = ip + isize;
+    const BYTE* const mflimit = iend - MFLIMIT;
+#define matchlimit (iend - LASTLITERALS)
+
+    BYTE* op = (BYTE*) dest;
+    BYTE* const oend = op + maxOutputSize;
+
+    int len, length;
+    const int skipStrength = SKIPSTRENGTH;
+    U32 forwardH;
+
+
+    // Init
+    if (isize<MINLENGTH) goto _last_literals;
+#if HEAPMODE
+    if (*ctx == NULL)
+    {
+        srt = (struct refTables *) malloc ( sizeof(struct refTables) );
+        *ctx = (void*) srt;
+    }
+    HashTable = (U16*)(srt->hashTable);
+    memset((void*)HashTable, 0, sizeof(srt->hashTable));
+#else
+    (void) ctx;
+#endif
+
+
+    // First Byte
+    ip++; forwardH = LZ4_HASH64K_VALUE(ip);
+
+    // Main Loop
+    for ( ; ; )
+    {
+        int findMatchAttempts = (1U << skipStrength) + 3;
+        const BYTE* forwardIp = ip;
+        const BYTE* ref;
+        BYTE* token;
+
+        // Find a match
+        do {
+            U32 h = forwardH;
+            int step = findMatchAttempts++ >> skipStrength;
+            ip = forwardIp;
+            forwardIp = ip + step;
+
+            if (forwardIp > mflimit) { goto _last_literals; }
+
+            forwardH = LZ4_HASH64K_VALUE(forwardIp);
+            ref = base + HashTable[h];
+            HashTable[h] = (U16)(ip - base);
+
+        } while (A32(ref) != A32(ip));
+
+        // Catch up
+        while ((ip>anchor) && (ref>(BYTE*)source) && (ip[-1]==ref[-1])) { ip--; ref--; }
+
+        // Encode Literal length
+        length = (int)(ip - anchor);
+        token = op++;
+        if unlikely(op + length + (2 + 1 + LASTLITERALS) + (length>>8) > oend) return 0; 		// Check output limit
+#ifdef _MSC_VER
+        if (length>=(int)RUN_MASK) 
+        { 
+            int len = length-RUN_MASK; 
+            *token=(RUN_MASK<<ML_BITS); 
+            if (len>254)
+            {
+                do { *op++ = 255; len -= 255; } while (len>254);
+                *op++ = (BYTE)len; 
+                memcpy(op, anchor, length);
+                op += length;
+                goto _next_match;
+            }
+            else
+            *op++ = (BYTE)len; 
+        }
+        else *token = (length<<ML_BITS);
+#else
+        if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; }
+        else *token = (length<<ML_BITS);
+#endif
+
+        // Copy Literals
+        LZ4_BLINDCOPY(anchor, op, length);
+
+_next_match:
+        // Encode Offset
+        LZ4_WRITE_LITTLEENDIAN_16(op,(U16)(ip-ref));
+
+        // Start Counting
+        ip+=MINMATCH; ref+=MINMATCH;   // MinMatch verified
+        anchor = ip;
+        while (ip<matchlimit-(STEPSIZE-1))
+        {
+            UARCH diff = AARCH(ref) ^ AARCH(ip);
+            if (!diff) { ip+=STEPSIZE; ref+=STEPSIZE; continue; }
+            ip += LZ4_NbCommonBytes(diff);
+            goto _endCount;
+        }
+        if (LZ4_ARCH64) if ((ip<(matchlimit-3)) && (A32(ref) == A32(ip))) { ip+=4; ref+=4; }
+        if ((ip<(matchlimit-1)) && (A16(ref) == A16(ip))) { ip+=2; ref+=2; }
+        if ((ip<matchlimit) && (*ref == *ip)) ip++;
+_endCount:
+
+        // Encode MatchLength
+        len = (int)(ip - anchor);
+        if unlikely(op + (1 + LASTLITERALS) + (len>>8) > oend) return 0; 		// Check output limit
+        if (len>=(int)ML_MASK) { *token+=ML_MASK; len-=ML_MASK; for(; len > 509 ; len-=510) { *op++ = 255; *op++ = 255; } if (len > 254) { len-=255; *op++ = 255; } *op++ = (BYTE)len; }
+        else *token += len;
+
+        // Test end of chunk
+        if (ip > mflimit) { anchor = ip;  break; }
+
+        // Fill table
+        HashTable[LZ4_HASH64K_VALUE(ip-2)] = (U16)(ip - 2 - base);
+
+        // Test next position
+        ref = base + HashTable[LZ4_HASH64K_VALUE(ip)];
+        HashTable[LZ4_HASH64K_VALUE(ip)] = (U16)(ip - base);
+        if (A32(ref) == A32(ip)) { token = op++; *token=0; goto _next_match; }
+
+        // Prepare next loop
+        anchor = ip++;
+        forwardH = LZ4_HASH64K_VALUE(ip);
+    }
+
+_last_literals:
+    // Encode Last Literals
+    {
+        int lastRun = (int)(iend - anchor);
+        if (op + lastRun + 1 + (lastRun-RUN_MASK+255)/255 > oend) return 0;
+        if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }
+        else *op++ = (lastRun<<ML_BITS);
+        memcpy(op, anchor, iend - anchor);
+        op += iend-anchor;
+    }
+
+    // End
+    return (int) (((char*)op)-dest);
+}
+
+
+int LZ4_compress_limitedOutput(const char* source, 
+                               char* dest, 
+                               int isize, 
+                               int maxOutputSize)
+{
+#if HEAPMODE
+    void* ctx = malloc(sizeof(struct refTables));
+    int result;
+    if (isize < LZ4_64KLIMIT)
+        result = LZ4_compress64kCtx(&ctx, source, dest, isize, maxOutputSize);
+    else result = LZ4_compressCtx(&ctx, source, dest, isize, maxOutputSize);
+    free(ctx);
+    return result;
+#else
+    if (isize < (int)LZ4_64KLIMIT) return LZ4_compress64kCtx(NULL, source, dest, isize, maxOutputSize);
+    return LZ4_compressCtx(NULL, source, dest, isize, maxOutputSize);
+#endif
+}
+
+
+int LZ4_compress(const char* source,
+                 char* dest,
+                 int isize)
+{
+    return LZ4_compress_limitedOutput(source, dest, isize, LZ4_compressBound(isize));
+}
+
+
+
+
+//****************************
+// Decompression functions
+//****************************
+
+// Note : The decoding functions LZ4_uncompress() and LZ4_uncompress_unknownOutputSize()
+//		are safe against "buffer overflow" attack type.
+//		They will never write nor read outside of the provided output buffers.
+//      LZ4_uncompress_unknownOutputSize() also insures that it will never read outside of the input buffer.
+//		A corrupted input will produce an error result, a negative int, indicating the position of the error within input stream.
+
+int LZ4_uncompress(const char* source,
+                 char* dest,
+                 int osize)
+{
+    // Local Variables
+    const BYTE* restrict ip = (const BYTE*) source;
+    const BYTE* ref;
+
+    BYTE* op = (BYTE*) dest;
+    BYTE* const oend = op + osize;
+    BYTE* cpy;
+
+    unsigned token;
+
+    size_t length;
+    size_t dec32table[] = {0, 3, 2, 3, 0, 0, 0, 0};
+#if LZ4_ARCH64
+    size_t dec64table[] = {0, 0, 0, -1, 0, 1, 2, 3};
+#endif
+
+
+    // Main Loop
+    while (1)
+    {
+        // get runlength
+        token = *ip++;
+        if ((length=(token>>ML_BITS)) == RUN_MASK)  { size_t len; for (;(len=*ip++)==255;length+=255){} length += len; }
+
+        // copy literals
+        cpy = op+length;
+        if unlikely(cpy>oend-COPYLENGTH)
+        {
+            if (cpy != oend) goto _output_error;         // Error : not enough place for another match (min 4) + 5 literals
+            memcpy(op, ip, length);
+            ip += length;
+            break;                                       // EOF
+        }
+        LZ4_WILDCOPY(ip, op, cpy); ip -= (op-cpy); op = cpy;
+
+        // get offset
+        LZ4_READ_LITTLEENDIAN_16(ref,cpy,ip); ip+=2;
+        if unlikely(ref < (BYTE* const)dest) goto _output_error;   // Error : offset create reference outside destination buffer
+
+        // get matchlength
+        if ((length=(token&ML_MASK)) == ML_MASK) { for (;*ip==255;length+=255) {ip++;} length += *ip++; }
+
+        // copy repeated sequence
+        if unlikely((op-ref)<STEPSIZE)
+        {
+#if LZ4_ARCH64
+            size_t dec64 = dec64table[op-ref];
+#else
+            const int dec64 = 0;
+#endif
+            op[0] = ref[0];
+            op[1] = ref[1];
+            op[2] = ref[2];
+            op[3] = ref[3];
+            op += 4, ref += 4; ref -= dec32table[op-ref];
+            A32(op) = A32(ref); 
+            op += STEPSIZE-4; ref -= dec64;
+        } else { LZ4_COPYSTEP(ref,op); }
+        cpy = op + length - (STEPSIZE-4);
+        if (cpy>oend-COPYLENGTH)
+        {
+            if (cpy > oend) goto _output_error;             // Error : request to write beyond destination buffer
+            LZ4_SECURECOPY(ref, op, (oend-COPYLENGTH));
+            while(op<cpy) *op++=*ref++;
+            op=cpy;
+            if (op == oend) goto _output_error;    // Check EOF (should never happen, since last 5 bytes are supposed to be literals)
+            continue;
+        }
+        LZ4_SECURECOPY(ref, op, cpy);
+        op=cpy;		// correction
+    }
+
+    // end of decoding
+    return (int) (((char*)ip)-source);
+
+    // write overflow error detected
+_output_error:
+    return (int) (-(((char*)ip)-source));
+}
+
+
+int LZ4_uncompress_unknownOutputSize(
+                const char* source,
+                char* dest,
+                int isize,
+                int maxOutputSize)
+{
+    // Local Variables
+    const BYTE* restrict ip = (const BYTE*) source;
+    const BYTE* const iend = ip + isize;
+    const BYTE* ref;
+
+    BYTE* op = (BYTE*) dest;
+    BYTE* const oend = op + maxOutputSize;
+    BYTE* cpy;
+
+    size_t dec32table[] = {0, 3, 2, 3, 0, 0, 0, 0};
+#if LZ4_ARCH64
+    size_t dec64table[] = {0, 0, 0, -1, 0, 1, 2, 3};
+#endif
+
+
+    // Main Loop
+    while (ip<iend)
+    {
+        unsigned token;
+        size_t length;
+
+        // get runlength
+        token = *ip++;
+        if ((length=(token>>ML_BITS)) == RUN_MASK) { int s=255; while ((ip<iend) && (s==255)) { s=*ip++; length += s; } }
+
+        // copy literals
+        cpy = op+length;
+        if ((cpy>oend-COPYLENGTH) || (ip+length>iend-COPYLENGTH))
+        {
+            if (cpy > oend) goto _output_error;          // Error : writes beyond output buffer
+            if (ip+length != iend) goto _output_error;   // Error : LZ4 format requires to consume all input at this stage
+            memcpy(op, ip, length);
+            op += length;
+            break;                                       // Necessarily EOF, due to parsing restrictions
+        }
+        LZ4_WILDCOPY(ip, op, cpy); ip -= (op-cpy); op = cpy;
+
+        // get offset
+        LZ4_READ_LITTLEENDIAN_16(ref,cpy,ip); ip+=2;
+        if (ref < (BYTE* const)dest) goto _output_error;   // Error : offset creates reference outside of destination buffer
+
+        // get matchlength
+        if ((length=(token&ML_MASK)) == ML_MASK) { while (ip<iend) { int s = *ip++; length +=s; if (s==255) continue; break; } }
+
+        // copy repeated sequence
+        if unlikely(op-ref<STEPSIZE)
+        {
+#if LZ4_ARCH64
+            size_t dec64 = dec64table[op-ref];
+#else
+            const int dec64 = 0;
+#endif
+            op[0] = ref[0];
+            op[1] = ref[1];
+            op[2] = ref[2];
+            op[3] = ref[3];
+            op += 4, ref += 4; ref -= dec32table[op-ref];
+            A32(op) = A32(ref); 
+            op += STEPSIZE-4; ref -= dec64;
+        } else { LZ4_COPYSTEP(ref,op); }
+        cpy = op + length - (STEPSIZE-4);
+        if (cpy>oend-COPYLENGTH)
+        {
+            if (cpy > oend) goto _output_error;    // Error : request to write outside of destination buffer
+            LZ4_SECURECOPY(ref, op, (oend-COPYLENGTH));
+            while(op<cpy) *op++=*ref++;
+            op=cpy;
+            if (op == oend) goto _output_error;    // Check EOF (should never happen, since last 5 bytes are supposed to be literals)
+            continue;
+        }
+        LZ4_SECURECOPY(ref, op, cpy);
+        op=cpy;		// correction
+    }
+
+    // end of decoding
+    return (int) (((char*)op)-dest);
+
+    // write overflow error detected
+_output_error:
+    return (int) (-(((char*)ip)-source));
+}
+
+/*
+   LZ4 - Fast LZ compression algorithm
+   Header File
+   Copyright (C) 2011-2012, 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 :
+   - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+   - LZ4 source repository : http://code.google.com/p/lz4/
+*/
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+//**************************************
+// Compiler Options
+//**************************************
+#if defined(_MSC_VER) && !defined(__cplusplus)   // Visual Studio
+#  define inline __inline           // Visual is not C99, but supports some kind of inline
+#endif
+
+
+//****************************
+// Simple Functions
+//****************************
+
+int LZ4_compress   (const char* source, char* dest, int isize);
+int LZ4_uncompress (const char* source, char* dest, int osize);
+
+/*
+LZ4_compress() :
+    Compresses 'isize' bytes from 'source' into 'dest'.
+    Destination buffer must be already allocated,
+    and must be sized to handle worst cases situations (input data not compressible)
+    Worst case size evaluation is provided by function LZ4_compressBound()
+
+    isize  : is the input size. Max supported value is ~1.9GB
+    return : the number of bytes written in buffer dest
+
+
+LZ4_uncompress() :
+    osize  : is the output size, therefore the original size
+    return : the number of bytes read in the source buffer
+             If the source stream is malformed, the function will stop decoding and return a negative result, indicating the byte position of the faulty instruction
+             This function never writes outside of provided buffers, and never modifies input buffer.
+    note : destination buffer must be already allocated.
+           its size must be a minimum of 'osize' bytes.
+*/
+
+
+//****************************
+// Advanced Functions
+//****************************
+
+static inline int LZ4_compressBound(int isize)   { return ((isize) + ((isize)/255) + 16); }
+#define           LZ4_COMPRESSBOUND(    isize)            ((isize) + ((isize)/255) + 16)
+
+/*
+LZ4_compressBound() :
+    Provides the maximum size that LZ4 may output in a "worst case" scenario (input data not compressible)
+    primarily useful for memory allocation of output buffer.
+	inline function is recommended for the general case,
+	but macro is also provided when results need to be evaluated at compile time (such as table size allocation).
+
+    isize  : is the input size. Max supported value is ~1.9GB
+    return : maximum output size in a "worst case" scenario
+    note : this function is limited by "int" range (2^31-1)
+*/
+
+
+int LZ4_compress_limitedOutput   (const char* source, char* dest, int isize, int maxOutputSize);
+
+/*
+LZ4_compress_limitedOutput() :
+    Compress 'isize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
+    If it cannot achieve it, compression will stop, and result of the function will be zero.
+    This function never writes outside of provided output buffer.
+
+    isize  : is the input size. Max supported value is ~1.9GB
+    maxOutputSize : is the size of the destination buffer (which must be already allocated)
+    return : the number of bytes written in buffer 'dest'
+             or 0 if the compression fails
+*/
+
+
+int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
+
+/*
+LZ4_uncompress_unknownOutputSize() :
+    isize  : is the input size, therefore the compressed size
+    maxOutputSize : is the size of the destination buffer (which must be already allocated)
+    return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize)
+             If the source stream is malformed, the function will stop decoding and return a negative result, indicating the byte position of the faulty instruction
+             This function never writes beyond dest + maxOutputSize, and is therefore protected against malicious data packets
+    note   : Destination buffer must be already allocated.
+             This version is slightly slower than LZ4_uncompress()
+*/
+
+
+#if defined (__cplusplus)
+}
+#endif

lz4_format_description.txt

+LZ4 Format Description
+Last revised: 2012-02-27
+Author : Y. Collet
+
+
+
+This small specification intents to provide enough information
+to anyone willing to produce LZ4-compatible compressed streams
+using any programming language.
+
+LZ4 is an LZ77-type compressor with a fixed, byte-oriented encoding.
+The most important design principle behind LZ4 is simplicity.
+It helps to create an easy to read and maintain source code.
+It also helps later on for optimisations, compactness, and speed.
+There is no entropy encoder backend nor framing layer.
+The latter is assumed to be handled by other parts of the system.
+
+This document only describes the format,
+not how the LZ4 compressor nor decompressor actually work.
+The correctness of the decompressor should not depend
+on implementation details of the compressor, and vice versa.
+
+
+
+-- Compressed stream format --
+
+An LZ4 compressed stream is composed of sequences.
+Schematically, a sequence is a suite of literals, followed by a match copy.
+
+Each sequence starts with a token.
+The token is a one byte value, separated into two 4-bits fields.
+Therefore each field ranges from 0 to 15.
+
+
+The first field uses the 4 high-bits of the token.
+It provides the length of literals to follow.
+(Note : a literal is a not-compressed byte).
+If the field value is 0, then there is no literal.
+If it is 15, then we need to add some more bytes to indicate the full length.
+Each additionnal byte then represent a value from 0 to 255,
+which is added to the previous value to produce a total length.
+When the byte value is 255, another byte is output.
+There can be any number of bytes following the token. There is no "size limit".
+(Sidenote this is why a not-compressible input stream is expanded by 0.4%).
+
+Example 1 : A length of 48 will be represented as :
+- 15 : value for the 4-bits High field
+- 33 : (=48-15) remaining length to reach 48
+
+Example 2 : A length of 280 will be represented as :
+- 15  : value for the 4-bits High field
+- 255 : following byte is maxed, since 280-15 >= 255
+- 10  : (=280 - 15 - 255) ) remaining length to reach 280
+
+Example 3 : A length of 15 will be represented as :
+- 15 : value for the 4-bits High field
+- 0  : (=15-15) yes, the zero must be output
+
+Following the token and optional length bytes, are the literals themselves.
+They are exactly as numerous as previously decoded (length of literals).
+It's possible that there are zero literal.
+
+
+Following the literals is the match copy operation.
+
+It starts by the offset.
+This is a 2 bytes value, in little endian format :
+the lower byte is the first one in the stream.
+
+The offset represents the position of the match to be copied from.
+1 means "current position - 1 byte".
+The maximum offset value is 65535, 65536 cannot be coded.
+Note that 0 is an invalid value, not used. 
+
+Then we need to extract the match length.
+For this, we use the second token field, the low 4-bits.
+Value, obviously, ranges from 0 to 15.
+However here, 0 means that the copy operation will be minimal.
+The minimum length of a match, called minmatch, is 4. 
+As a consequence, a 0 value means 4 bytes, and a value of 15 means 19+ bytes.
+Similar to literal length, on reaching the highest possible value (15), 
+we output additional bytes, one at a time, with values ranging from 0 to 255.
+They are added to total to provide the final match length.
+A 255 value means there is another byte to read and add.
+There is no limit to the number of optional bytes that can be output this way.
+(This points towards a maximum achievable compression ratio of ~250).
+
+With the offset and the matchlength,
+the decoder can now proceed to copy the data from the already decoded buffer.
+On decoding the matchlength, we reach the end of the compressed sequence,
+and therefore start another one.
+
+
+-- Parsing restrictions --
+
+There are specific parsing rules to respect in order to remain compatible
+with assumptions made by the decoder :
+1) The last 5 bytes are always literals
+2) The last match must start at least 12 bytes before end of stream
+Consequently, a file with less than 13 bytes cannot be compressed.
+These rules are in place to ensure that the decoder
+will never read beyond the input buffer, nor write beyond the output buffer.
+
+Note that the last sequence is also incomplete,
+and stops right after literals.
+
+
+-- Additional notes --
+
+There is no assumption nor limits to the way the compressor
+searches and selects matches within the source stream.
+It could be a fast scan, a multi-probe, a full search using BST,
+standard hash chains or MMC, well whatever.
+
+Advanced parsing strategies can also be implemented, such as lazy match,
+or full optimal parsing.
+
+All these trade-off offer distinctive speed/memory/compression advantages.
+Whatever the method used by the compressor, its result will be decodable
+by any LZ4 decoder if it follows the format specification described above.
+
+/*
+    LZ4Demo - Demo CLI program using LZ4 compression
+    Copyright (C) Yann Collet 2011-2012
+	GPL v2 License
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+	You can contact the author at :
+	- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+	- LZ4 source repository : http://code.google.com/p/lz4/
+*/
+/*
+	Note : this is *only* a demo program, an example to show how LZ4 can be used.
+	It is not considered part of LZ4 compression library.
+	The license of LZ4 is BSD.
+	The license of the demo program is GPL.
+*/
+
+//**************************************
+// Compiler Options
+//**************************************
+// Disable some Visual warning messages
+#define _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_DEPRECATE     // VS2005
+
+
+//****************************
+// Includes
+//****************************
+#include <stdio.h>		// fprintf, fopen, fread, _fileno(?)
+#include <stdlib.h>		// malloc
+#include <string.h>		// strcmp
+#include <time.h>		// clock
+#ifdef _WIN32
+#include <io.h>			// _setmode
+#include <fcntl.h>		// _O_BINARY
+#endif
+#include "lz4.h"
+#include "lz4hc.h"
+#include "bench.h"
+
+
+//**************************************
+// Compiler-specific functions
+//**************************************
+#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+
+#if defined(_MSC_VER)    // Visual Studio
+#define swap32 _byteswap_ulong
+#elif GCC_VERSION >= 403
+#define swap32 __builtin_bswap32
+#else
+static inline unsigned int swap32(unsigned int x) {
+			return	((x << 24) & 0xff000000 ) |
+				((x <<  8) & 0x00ff0000 ) |
+				((x >>  8) & 0x0000ff00 ) |
+				((x >> 24) & 0x000000ff );
+		 }
+#endif
+
+
+//****************************
+// Constants
+//****************************
+#define COMPRESSOR_NAME "Compression CLI using LZ4 algorithm"
+#define COMPRESSOR_VERSION ""
+#define COMPILED __DATE__
+#define AUTHOR "Yann Collet"
+#define EXTENSION ".lz4"
+#define WELCOME_MESSAGE "*** %s %s, by %s (%s) ***\n", COMPRESSOR_NAME, COMPRESSOR_VERSION, AUTHOR, COMPILED
+
+#define CHUNKSIZE (8<<20)    // 8 MB
+#define CACHELINE 64
+#define ARCHIVE_MAGICNUMBER 0x184C2102
+#define ARCHIVE_MAGICNUMBER_SIZE 4
+
+
+//**************************************
+// Architecture Macros
+//**************************************
+static const int one = 1;
+#define CPU_LITTLE_ENDIAN  (*(char*)(&one))
+#define CPU_BIG_ENDIAN     (!CPU_LITTLE_ENDIAN)
+#define LITTLE_ENDIAN32(i) if (CPU_BIG_ENDIAN) { i = swap32(i); }
+
+
+//**************************************
+// Macros
+//**************************************
+#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
+
+
+//****************************
+// Functions
+//****************************
+int usage(char* exename)
+{
+	DISPLAY( "Usage :\n");
+	DISPLAY( "      %s [arg] input output\n", exename);
+	DISPLAY( "Arguments :\n");
+	DISPLAY( " -c0: Fast compression (default) \n");
+	DISPLAY( " -c1: High compression \n");
+	DISPLAY( " -d : decompression \n");
+	DISPLAY( " -b#: Benchmark files, using # compression level\n");
+	DISPLAY( " -t : check compressed file \n");
+	DISPLAY( " -h : help (this text)\n");
+	DISPLAY( "input  : can be 'stdin' (pipe) or a filename\n");
+	DISPLAY( "output : can be 'stdout'(pipe) or a filename or 'null'\n");
+	return 0;
+}
+
+
+int badusage(char* exename)
+{
+	DISPLAY("Wrong parameters\n");
+	usage(exename);
+	return 0;
+}
+
+
+
+int get_fileHandle(char* input_filename, char* output_filename, FILE** pfinput, FILE** pfoutput)
+{
+	char stdinmark[] = "stdin";
+	char stdoutmark[] = "stdout";
+
+	if (!strcmp (input_filename, stdinmark)) {
+		DISPLAY( "Using stdin for input\n");
+		*pfinput = stdin;
+#ifdef _WIN32 // Need to set stdin/stdout to binary mode specifically for windows
+		_setmode( _fileno( stdin ), _O_BINARY );
+#endif
+	} else {
+		*pfinput = fopen( input_filename, "rb" );
+	}
+
+	if (!strcmp (output_filename, stdoutmark)) {
+		DISPLAY( "Using stdout for output\n");
+		*pfoutput = stdout;
+#ifdef _WIN32 // Need to set stdin/stdout to binary mode specifically for windows
+		_setmode( _fileno( stdout ), _O_BINARY );
+#endif
+	} else {
+		*pfoutput = fopen( output_filename, "wb" );
+	}
+
+	if ( *pfinput==0 ) { DISPLAY( "Pb opening %s\n", input_filename);  return 2; }
+	if ( *pfoutput==0) { DISPLAY( "Pb opening %s\n", output_filename); return 3; }
+
+	return 0;
+}
+
+
+
+int compress_file(char* input_filename, char* output_filename, int compressionlevel)
+{
+	int (*compressionFunction)(const char*, char*, int);
+	unsigned long long filesize = 0;
+	unsigned long long compressedfilesize = ARCHIVE_MAGICNUMBER_SIZE;
+	unsigned int u32var;
+	char* in_buff;
+	char* out_buff;
+	FILE* finput;
+	FILE* foutput;
+	int r;
+	int displayLevel = (compressionlevel>0);
+	clock_t start, end;
+	size_t sizeCheck;
+
+
+	// Init
+	switch (compressionlevel)
+	{
+	case 0 : compressionFunction = LZ4_compress; break;
+	case 1 : compressionFunction = LZ4_compressHC; break;
+	default : compressionFunction = LZ4_compress;
+	}
+	start = clock();
+	r = get_fileHandle(input_filename, output_filename, &finput, &foutput);
+	if (r) return r;
+
+	// Allocate Memory
+	in_buff = (char*)malloc(CHUNKSIZE);
+	out_buff = (char*)malloc(LZ4_compressBound(CHUNKSIZE));
+	if (!in_buff || !out_buff) { DISPLAY("Allocation error : not enough memory\n"); return 8; }
+
+	// Write Archive Header
+	u32var = ARCHIVE_MAGICNUMBER;
+	LITTLE_ENDIAN32(u32var);
+	*(unsigned int*)out_buff = u32var;
+	sizeCheck = fwrite(out_buff, 1, ARCHIVE_MAGICNUMBER_SIZE, foutput);
+	if (sizeCheck!=ARCHIVE_MAGICNUMBER_SIZE) { DISPLAY("write error\n"); return 10; }
+
+	// Main Loop
+	while (1)
+	{
+		int outSize;
+		// Read Block
+	    int inSize = (int) fread(in_buff, (size_t)1, (size_t)CHUNKSIZE, finput);
+		if( inSize<=0 ) break;
+		filesize += inSize;
+		if (displayLevel) DISPLAY("Read : %i MB  \r", (int)(filesize>>20));
+
+		// Compress Block
+		outSize = compressionFunction(in_buff, out_buff+4, inSize);
+		compressedfilesize += outSize+4;
+		if (displayLevel) DISPLAY("Read : %i MB  ==> %.2f%%\r", (int)(filesize>>20), (double)compressedfilesize/filesize*100);
+
+		// Write Block
+		LITTLE_ENDIAN32(outSize);
+		* (unsigned int*) out_buff = outSize;
+		LITTLE_ENDIAN32(outSize);
+		sizeCheck = fwrite(out_buff, 1, outSize+4, foutput);
+		if (sizeCheck!=(size_t)(outSize+4)) { DISPLAY("write error\n"); return 11; }
+	}
+
+	// Status
+	end = clock();
+	DISPLAY( "Compressed %llu bytes into %llu bytes ==> %.2f%%\n",
+		(unsigned long long) filesize, (unsigned long long) compressedfilesize, (double)compressedfilesize/filesize*100);
+	{
+		double seconds = (double)(end - start)/CLOCKS_PER_SEC;
+		DISPLAY( "Done in %.2f s ==> %.2f MB/s\n", seconds, (double)filesize / seconds / 1024 / 1024);
+	}
+
+	// Close & Free
+	free(in_buff);
+	free(out_buff);
+	fclose(finput);
+	fclose(foutput);
+
+	return 0;
+}
+
+
+int decode_file(char* input_filename, char* output_filename)
+{
+	unsigned long long filesize = 0;
+	char* in_buff;
+	char* out_buff;
+	size_t uselessRet;
+	int sinkint;
+	unsigned int chunkSize;
+	FILE* finput;
+	FILE* foutput;
+	clock_t start, end;
+	int r;
+	size_t sizeCheck;
+
+
+	// Init
+	start = clock();
+	r = get_fileHandle(input_filename, output_filename, &finput, &foutput);
+	if (r) return r;
+
+	// Allocate Memory
+	in_buff = (char*)malloc(LZ4_compressBound(CHUNKSIZE));
+	out_buff = (char*)malloc(CHUNKSIZE);
+	if (!in_buff || !out_buff) { DISPLAY("Allocation error : not enough memory\n"); return 7; }
+
+	// Check Archive Header
+	chunkSize = 0;
+	uselessRet = fread(&chunkSize, 1, ARCHIVE_MAGICNUMBER_SIZE, finput);
+	LITTLE_ENDIAN32(chunkSize);
+	if (chunkSize != ARCHIVE_MAGICNUMBER) { DISPLAY("Unrecognized header : file cannot be decoded\n"); return 6; }
+
+	// Main Loop
+	while (1)
+	{
+		// Block Size
+		uselessRet = fread(&chunkSize, 1, 4, finput);
+		if( uselessRet==0 ) break;   // Nothing to read : file read is completed
+		LITTLE_ENDIAN32(chunkSize);
+		if (chunkSize == ARCHIVE_MAGICNUMBER) 
+			continue;   // appended compressed stream
+		
+		// Read Block
+	    uselessRet = fread(in_buff, 1, chunkSize, finput);
+
+		// Decode Block
+		sinkint = LZ4_uncompress_unknownOutputSize(in_buff, out_buff, chunkSize, CHUNKSIZE);
+		if (sinkint < 0) { DISPLAY("Decoding Failed ! Corrupted input !\n"); return 9; }
+		filesize += sinkint;
+
+		// Write Block
+		sizeCheck = fwrite(out_buff, 1, sinkint, foutput);
+		if (sizeCheck != (size_t)sinkint) { DISPLAY("write error\n"); return 12; }
+	}
+
+	// Status
+	end = clock();
+	DISPLAY( "Successfully decoded %llu bytes \n", (unsigned long long)filesize);
+	{
+		double seconds = (double)(end - start)/CLOCKS_PER_SEC;
+		DISPLAY( "Done in %.2f s ==> %.2f MB/s\n", seconds, (double)filesize / seconds / 1024 / 1024);
+	}
+
+	// Close & Free
+	free(in_buff);
+	free(out_buff);
+	fclose(finput);
+	fclose(foutput);
+
+	return 0;
+}
+
+
+int main(int argc, char** argv)
+{
+  int i,
+	  cLevel=0,
+	  decode=0,
+	  bench=0,
+	  filenamesStart=2;
+  char* exename=argv[0];
+  char* input_filename=0;
+  char* output_filename=0;
+#ifdef _WIN32
+  char nulmark[] = "nul";
+#else
+  char nulmark[] = "/dev/null";
+#endif
+  char nullinput[] = "null";
+
+  // Welcome message
+  DISPLAY( WELCOME_MESSAGE);
+
+  if (argc<2) { badusage(exename); return 1; }
+
+  for(i=1; i<argc; i++)
+  {
+    char* argument = argv[i];
+
+    if(!argument) continue;   // Protection if argument empty