Merge pull request #24 from Cyan4973/dev

Catch up r122

17 files changed, 1676 insertions, 988 deletions

diff --git a/.travis.yml b/.travis.yml
index fea2b3d..472ca18 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,6 @@
 language: c
 compiler: gcc
-script: make test-travis
+script: make test
 before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -qq gcc-multilib
diff --git a/LZ4_Framing_Format.html b/LZ4_Framing_Format.html
index bd1304c..bd1304c 100755..100644
--- a/LZ4_Framing_Format.html
+++ b/LZ4_Framing_Format.html
diff --git a/Makefile b/Makefile
index a81f30b..30ecbb7 100644
--- a/Makefile
+++ b/Makefile
@@ -107,6 +107,7 @@ liblz4: lz4.c lz4hc.c
 clean:
 	@rm -f core *.o *.a *.$(SHARED_EXT) *.$(SHARED_EXT).* $(DISTRIBNAME) *.sha1 liblz4.pc
 	@cd $(PRGDIR); $(MAKE) clean
+	@cd examples; $(MAKE) clean
 	@echo Cleaning completed
 
 
@@ -162,9 +163,7 @@ dist: clean
 	@echo Distribution $(DISTRIBNAME) built
 
 test:
-	@cd $(PRGDIR); $(MAKE) -e $@
-
-test-travis: lz4programs
+	@cd examples; $(MAKE) -e $@
 	@cd $(PRGDIR); $(MAKE) -e $@
 
 endif
diff --git a/NEWS b/NEWS
index 6ad8906..69e5c4e 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,10 @@
+r122:
+Fix : AIX & AIX64 support (SamG)
+Fix : mips 64-bits support (lew van)
+Added : Examples directory, using code examples from Takayuki Matsuoka
+Updated : Framing specification, to v1.4.1
+Updated : xxHash, to r36
+
 r121:
 Added : Makefile : install for kFreeBSD and Hurd (Nobuhiro Iwamatsu)
 Fix : Makefile : install for OS-X and BSD, thanks to Takayuki Matsuoka
diff --git a/cmake_unofficial/CMakeLists.txt b/cmake_unofficial/CMakeLists.txt
index 480654e..fab1946 100644
--- a/cmake_unofficial/CMakeLists.txt
+++ b/cmake_unofficial/CMakeLists.txt
@@ -1,8 +1,8 @@
 PROJECT(LZ4 C)
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "LZ4 compression library")
-set(CPACK_PACKAGE_VERSION_MAJOR 0)
-set(CPACK_PACKAGE_VERSION_MINOR 0)
-set(CPACK_PACKAGE_VERSION_PATCH r111)
+set(CPACK_PACKAGE_VERSION_MAJOR 1)
+set(CPACK_PACKAGE_VERSION_MINOR 3)
+set(CPACK_PACKAGE_VERSION_PATCH r122)
 #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)
@@ -70,7 +70,7 @@ endif()
 #warnings
 
 ADD_DEFINITIONS("-Wall")
-ADD_DEFINITIONS("-W")
+ADD_DEFINITIONS("-Wextra")
 ADD_DEFINITIONS("-Wundef")
 ADD_DEFINITIONS("-Wcast-align")
 ADD_DEFINITIONS("-std=c99")
diff --git a/examples/Makefile b/examples/Makefile
new file mode 100644
index 0000000..5704c55
--- /dev/null
+++ b/examples/Makefile
@@ -0,0 +1,85 @@
+# ##########################################################################
+# LZ4 examples - Makefile
+# Copyright (C) Yann Collet 2011-2014
+# 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 source repository : http://code.google.com/p/lz4/
+#  - LZ4 forum froup : https://groups.google.com/forum/#!forum/lz4c
+# ##########################################################################
+# lz4 : Command Line Utility, supporting gzip-like arguments
+# lz4c  : CLU, supporting also legacy lz4demo arguments
+# lz4c32: Same as lz4c, but forced to compile in 32-bits mode
+# fuzzer  : Test tool, to check lz4 integrity on target platform
+# fuzzer32: Same as fuzzer, but forced to compile in 32-bits mode
+# fullbench  : Precisely measure speed for each LZ4 function variant
+# fullbench32: Same as fullbench, but forced to compile in 32-bits mode
+# ##########################################################################
+
+CC     := $(CC)
+CFLAGS ?= -O3
+CFLAGS += -std=c99 -Wall -Wextra -Wundef -Wshadow -Wstrict-prototypes -Wno-missing-braces   # Wno-missing-braces required due to GCC <4.8.3 bug
+FLAGS   = -I.. $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
+
+TESTFILE= Makefile
+LZ4DIR=..
+
+
+# Minimize test target for Travis CI's Build Matrix
+ifeq ($(LZ4_TRAVIS_CI_ENV),-m32)
+CFLAGS += -m32
+else ifeq ($(LZ4_TRAVIS_CI_ENV),-m64)
+endif
+
+
+# Define *.exe as extension for Windows systems
+ifneq (,$(filter Windows%,$(OS)))
+EXT =.exe
+VOID = nul
+else
+EXT =
+VOID = /dev/null
+endif
+
+
+default: all
+
+all: printVersion doubleBuffer ringBuffer lineCompress
+
+printVersion: $(LZ4DIR)/lz4.c printVersion.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+
+doubleBuffer: $(LZ4DIR)/lz4.c blockStreaming_doubleBuffer.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+
+ringBuffer  : $(LZ4DIR)/lz4.c blockStreaming_ringBuffer.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+
+lineCompress: $(LZ4DIR)/lz4.c blockStreaming_lineByLine.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+
+test : all
+	./printVersion$(EXT)
+	./doubleBuffer$(EXT) $(TESTFILE)
+	./ringBuffer$(EXT)   $(TESTFILE)
+	./lineCompress$(EXT) $(TESTFILE)
+
+clean:
+	@rm -f core *.o *.dec *-0 *-8192 *.lz4s \
+        printVersion$(EXT) doubleBuffer$(EXT) ringBuffer$(EXT) lineCompress$(EXT)
+	@echo Cleaning completed
+
diff --git a/examples/blockStreaming_doubleBuffer.c b/examples/blockStreaming_doubleBuffer.c
new file mode 100644
index 0000000..bd87e77
--- /dev/null
+++ b/examples/blockStreaming_doubleBuffer.c
@@ -0,0 +1,195 @@
+// LZ4 streaming API example : double buffer
+// Copyright : Takayuki Matsuoka
+
+
+#define _CRT_SECURE_NO_WARNINGS // for MSVC
+#include "lz4.h"
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+    BLOCK_BYTES = 1024 * 8,
+//  BLOCK_BYTES = 1024 * 64,
+};
+
+
+size_t write_int(FILE* fp, int i) {
+    return fwrite(&i, sizeof(i), 1, fp);
+}
+
+size_t write_bin(FILE* fp, const void* array, size_t arrayBytes) {
+    return fwrite(array, 1, arrayBytes, fp);
+}
+
+size_t read_int(FILE* fp, int* i) {
+    return fread(i, sizeof(*i), 1, fp);
+}
+
+size_t read_bin(FILE* fp, void* array, size_t arrayBytes) {
+    return fread(array, 1, arrayBytes, fp);
+}
+
+
+void test_compress(FILE* outFp, FILE* inpFp)
+{
+    LZ4_stream_t lz4Stream_body = { 0 };
+    LZ4_stream_t* lz4Stream = &lz4Stream_body;
+
+    char inpBuf[2][BLOCK_BYTES];
+    int  inpBufIndex = 0;
+
+    for(;;) {
+        char* const inpPtr = inpBuf[inpBufIndex];
+        const int inpBytes = (int) read_bin(inpFp, inpPtr, BLOCK_BYTES);
+        if(0 == inpBytes) {
+            break;
+        }
+
+        {
+            char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
+            const int cmpBytes = LZ4_compress_continue(
+                lz4Stream, inpPtr, cmpBuf, inpBytes);
+            if(cmpBytes <= 0) {
+                break;
+            }
+            write_int(outFp, cmpBytes);
+            write_bin(outFp, cmpBuf, (size_t) cmpBytes);
+        }
+
+        inpBufIndex = (inpBufIndex + 1) % 2;
+    }
+
+    write_int(outFp, 0);
+}
+
+
+void test_decompress(FILE* outFp, FILE* inpFp)
+{
+    LZ4_streamDecode_t lz4StreamDecode_body = { 0 };
+    LZ4_streamDecode_t* lz4StreamDecode = &lz4StreamDecode_body;
+
+    char decBuf[2][BLOCK_BYTES];
+    int  decBufIndex = 0;
+
+    for(;;) {
+        char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
+        int  cmpBytes = 0;
+
+        {
+            const size_t readCount0 = read_int(inpFp, &cmpBytes);
+            if(readCount0 != 1 || cmpBytes <= 0) {
+                break;
+            }
+
+            const size_t readCount1 = read_bin(inpFp, cmpBuf, (size_t) cmpBytes);
+            if(readCount1 != (size_t) cmpBytes) {
+                break;
+            }
+        }
+
+        {
+            char* const decPtr = decBuf[decBufIndex];
+            const int decBytes = LZ4_decompress_safe_continue(
+                lz4StreamDecode, cmpBuf, decPtr, cmpBytes, BLOCK_BYTES);
+            if(decBytes <= 0) {
+                break;
+            }
+            write_bin(outFp, decPtr, (size_t) decBytes);
+        }
+
+        decBufIndex = (decBufIndex + 1) % 2;
+    }
+}
+
+
+int compare(FILE* fp0, FILE* fp1)
+{
+    int result = 0;
+
+    while(0 == result) {
+        char b0[65536];
+        char b1[65536];
+        const size_t r0 = read_bin(fp0, b0, sizeof(b0));
+        const size_t r1 = read_bin(fp1, b1, sizeof(b1));
+
+        result = (int) r0 - (int) r1;
+
+        if(0 == r0 || 0 == r1) {
+            break;
+        }
+        if(0 == result) {
+            result = memcmp(b0, b1, r0);
+        }
+    }
+
+    return result;
+}
+
+
+int main(int argc, char* argv[])
+{
+    char inpFilename[256] = { 0 };
+    char lz4Filename[256] = { 0 };
+    char decFilename[256] = { 0 };
+
+    if(argc < 2) {
+        printf("Please specify input filename\n");
+        return 0;
+    }
+
+    sprintf(inpFilename, "%s", argv[1]);
+    sprintf(lz4Filename, "%s.lz4s-%d", argv[1], BLOCK_BYTES);
+    sprintf(decFilename, "%s.lz4s-%d.dec", argv[1], BLOCK_BYTES);
+
+    printf("inp = [%s]\n", inpFilename);
+    printf("lz4 = [%s]\n", lz4Filename);
+    printf("dec = [%s]\n", decFilename);
+
+    // compress
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* outFp = fopen(lz4Filename, "wb");
+
+        printf("compress : %s -> %s\n", inpFilename, lz4Filename);
+        test_compress(outFp, inpFp);
+        printf("compress : done\n");
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    // decompress
+    {
+        FILE* inpFp = fopen(lz4Filename, "rb");
+        FILE* outFp = fopen(decFilename, "wb");
+
+        printf("decompress : %s -> %s\n", lz4Filename, decFilename);
+        test_decompress(outFp, inpFp);
+        printf("decompress : done\n");
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    // verify
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* decFp = fopen(decFilename, "rb");
+
+        printf("verify : %s <-> %s\n", inpFilename, decFilename);
+        const int cmp = compare(inpFp, decFp);
+        if(0 == cmp) {
+            printf("verify : OK\n");
+        } else {
+            printf("verify : NG\n");
+        }
+
+        fclose(decFp);
+        fclose(inpFp);
+    }
+
+    return 0;
+}
diff --git a/examples/blockStreaming_lineByLine.c b/examples/blockStreaming_lineByLine.c
new file mode 100644
index 0000000..e236a44
--- /dev/null
+++ b/examples/blockStreaming_lineByLine.c
@@ -0,0 +1,207 @@
+// LZ4 streaming API example : line-by-line logfile compression
+// Copyright : Takayuki Matsuoka
+
+
+#define _CRT_SECURE_NO_WARNINGS // for MSVC
+#include "lz4.h"
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+static size_t write_uint16(FILE* fp, uint16_t i)
+{
+    return fwrite(&i, sizeof(i), 1, fp);
+}
+
+static size_t write_bin(FILE* fp, const void* array, int arrayBytes)
+{
+    return fwrite(array, 1, arrayBytes, fp);
+}
+
+static size_t read_uint16(FILE* fp, uint16_t* i)
+{
+    return fread(i, sizeof(*i), 1, fp);
+}
+
+static size_t read_bin(FILE* fp, void* array, int arrayBytes)
+{
+    return fread(array, 1, arrayBytes, fp);
+}
+
+
+static void test_compress(
+    FILE* outFp,
+    FILE* inpFp,
+    size_t messageMaxBytes,
+    size_t ringBufferBytes)
+{
+    LZ4_stream_t* const lz4Stream = LZ4_createStream();
+    char* const cmpBuf = malloc(LZ4_COMPRESSBOUND(messageMaxBytes));
+    char* const inpBuf = malloc(ringBufferBytes);
+    int inpOffset = 0;
+
+    for ( ; ; )
+    {
+        char* const inpPtr = &inpBuf[inpOffset];
+
+#if 0
+        // Read random length data to the ring buffer.
+        const int randomLength = (rand() % messageMaxBytes) + 1;
+        const int inpBytes = (int) read_bin(inpFp, inpPtr, randomLength);
+        if (0 == inpBytes) break;
+#else
+        // Read line to the ring buffer.
+        int inpBytes = 0;
+        if (!fgets(inpPtr, (int) messageMaxBytes, inpFp))
+            break;
+        inpBytes = (int) strlen(inpPtr);
+#endif
+
+        {
+            const int cmpBytes = LZ4_compress_continue(
+                lz4Stream, inpPtr, cmpBuf, inpBytes);
+            if (cmpBytes <= 0) break;
+            write_uint16(outFp, (uint16_t) cmpBytes);
+            write_bin(outFp, cmpBuf, cmpBytes);
+
+            // Add and wraparound the ringbuffer offset
+            inpOffset += inpBytes;
+            if ((size_t)inpOffset >= ringBufferBytes - messageMaxBytes) inpOffset = 0;
+        }
+    }
+    write_uint16(outFp, 0);
+
+    free(inpBuf);
+    free(cmpBuf);
+    LZ4_freeStream(lz4Stream);
+}
+
+
+static void test_decompress(
+    FILE* outFp,
+    FILE* inpFp,
+    size_t messageMaxBytes,
+    size_t ringBufferBytes)
+{
+    LZ4_streamDecode_t* const lz4StreamDecode = LZ4_createStreamDecode();
+    char* const cmpBuf = malloc(LZ4_COMPRESSBOUND(messageMaxBytes));
+    char* const decBuf = malloc(ringBufferBytes);
+    int decOffset = 0;
+
+    for ( ; ; )
+    {
+        uint16_t cmpBytes = 0;
+
+        if (read_uint16(inpFp, &cmpBytes) != 1) break;
+        if (cmpBytes <= 0) break;
+        if (read_bin(inpFp, cmpBuf, cmpBytes) != cmpBytes) break;
+
+        {
+            char* const decPtr = &decBuf[decOffset];
+            const int decBytes = LZ4_decompress_safe_continue(
+                lz4StreamDecode, cmpBuf, decPtr, cmpBytes, (int) messageMaxBytes);
+            if (decBytes <= 0) break;
+            write_bin(outFp, decPtr, decBytes);
+
+            // Add and wraparound the ringbuffer offset
+            decOffset += decBytes;
+            if ((size_t)decOffset >= ringBufferBytes - messageMaxBytes) decOffset = 0;
+        }
+    }
+
+    free(decBuf);
+    free(cmpBuf);
+    LZ4_freeStreamDecode(lz4StreamDecode);
+}
+
+
+static int compare(FILE* f0, FILE* f1)
+{
+    int result = 0;
+    const size_t tempBufferBytes = 65536;
+    char* const b0 = malloc(tempBufferBytes);
+    char* const b1 = malloc(tempBufferBytes);
+
+    while(0 == result)
+    {
+        const size_t r0 = fread(b0, 1, tempBufferBytes, f0);
+        const size_t r1 = fread(b1, 1, tempBufferBytes, f1);
+
+        result = (int) r0 - (int) r1;
+
+        if (0 == r0 || 0 == r1) break;
+        if (0 == result) result = memcmp(b0, b1, r0);
+    }
+
+    free(b1);
+    free(b0);
+    return result;
+}
+
+
+int main(int argc, char* argv[])
+{
+    enum {
+        MESSAGE_MAX_BYTES   = 1024,
+        RING_BUFFER_BYTES   = 1024 * 256 + MESSAGE_MAX_BYTES,
+    };
+
+    char inpFilename[256] = { 0 };
+    char lz4Filename[256] = { 0 };
+    char decFilename[256] = { 0 };
+
+    if (argc < 2)
+    {
+        printf("Please specify input filename\n");
+        return 0;
+    }
+
+    sprintf(inpFilename, "%s", argv[1]);
+    sprintf(lz4Filename, "%s.lz4s", argv[1]);
+    sprintf(decFilename, "%s.lz4s.dec", argv[1]);
+
+    printf("inp = [%s]\n", inpFilename);
+    printf("lz4 = [%s]\n", lz4Filename);
+    printf("dec = [%s]\n", decFilename);
+
+    // compress
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* outFp = fopen(lz4Filename, "wb");
+
+        test_compress(outFp, inpFp, MESSAGE_MAX_BYTES, RING_BUFFER_BYTES);
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    // decompress
+    {
+        FILE* inpFp = fopen(lz4Filename, "rb");
+        FILE* outFp = fopen(decFilename, "wb");
+
+        test_decompress(outFp, inpFp, MESSAGE_MAX_BYTES, RING_BUFFER_BYTES);
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    // verify
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* decFp = fopen(decFilename, "rb");
+
+        const int cmp = compare(inpFp, decFp);
+        if (0 == cmp)
+            printf("Verify : OK\n");
+        else
+            printf("Verify : NG\n");
+
+        fclose(decFp);
+        fclose(inpFp);
+    }
+
+    return 0;
+}
diff --git a/examples/blockStreaming_ringBuffer.c b/examples/blockStreaming_ringBuffer.c
new file mode 100644
index 0000000..725e375
--- /dev/null
+++ b/examples/blockStreaming_ringBuffer.c
@@ -0,0 +1,186 @@
+// LZ4 streaming API example : ring buffer
+// Copyright : Takayuki Matsuoka
+
+
+#define _CRT_SECURE_NO_WARNINGS // for MSVC
+#include "lz4.h"
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+    MESSAGE_MAX_BYTES   = 1024,
+    RING_BUFFER_BYTES   = 1024 * 256 + MESSAGE_MAX_BYTES,
+    DICT_BYTES          = 65536,
+};
+
+
+size_t write_int32(FILE* fp, int32_t i) {
+    return fwrite(&i, sizeof(i), 1, fp);
+}
+
+size_t write_bin(FILE* fp, const void* array, int arrayBytes) {
+    return fwrite(array, 1, arrayBytes, fp);
+}
+
+size_t read_int32(FILE* fp, int32_t* i) {
+    return fread(i, sizeof(*i), 1, fp);
+}
+
+size_t read_bin(FILE* fp, void* array, int arrayBytes) {
+    return fread(array, 1, arrayBytes, fp);
+}
+
+
+void test_compress(FILE* outFp, FILE* inpFp)
+{
+    LZ4_stream_t lz4Stream_body = { 0 };
+    LZ4_stream_t* lz4Stream = &lz4Stream_body;
+
+    static char inpBuf[RING_BUFFER_BYTES];
+    int inpOffset = 0;
+
+    for(;;) {
+        // Read random length ([1,MESSAGE_MAX_BYTES]) data to the ring buffer.
+        char* const inpPtr = &inpBuf[inpOffset];
+        const int randomLength = (rand() % MESSAGE_MAX_BYTES) + 1;
+        const int inpBytes = (int) read_bin(inpFp, inpPtr, randomLength);
+        if (0 == inpBytes) break;
+
+        {
+            char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)];
+            const int cmpBytes = LZ4_compress_continue(lz4Stream, inpPtr, cmpBuf, inpBytes);
+            if(cmpBytes <= 0) break;
+            write_int32(outFp, cmpBytes);
+            write_bin(outFp, cmpBuf, cmpBytes);
+
+            inpOffset += inpBytes;
+
+            // Wraparound the ringbuffer offset
+            if(inpOffset >= RING_BUFFER_BYTES - MESSAGE_MAX_BYTES) inpOffset = 0;
+        }
+    }
+
+    write_int32(outFp, 0);
+}
+
+
+void test_decompress(FILE* outFp, FILE* inpFp)
+{
+    static char decBuf[RING_BUFFER_BYTES];
+    int   decOffset    = 0;
+    LZ4_streamDecode_t lz4StreamDecode_body = { 0 };
+    LZ4_streamDecode_t* lz4StreamDecode = &lz4StreamDecode_body;
+
+    for(;;) {
+        int cmpBytes = 0;
+        char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)];
+
+        {
+            const size_t r0 = read_int32(inpFp, &cmpBytes);
+            if(r0 != 1 || cmpBytes <= 0) break;
+
+            const size_t r1 = read_bin(inpFp, cmpBuf, cmpBytes);
+            if(r1 != (size_t) cmpBytes) break;
+        }
+
+        {
+            char* const decPtr = &decBuf[decOffset];
+            const int decBytes = LZ4_decompress_safe_continue(
+                lz4StreamDecode, cmpBuf, decPtr, cmpBytes, MESSAGE_MAX_BYTES);
+            if(decBytes <= 0) break;
+            decOffset += decBytes;
+            write_bin(outFp, decPtr, decBytes);
+
+            // Wraparound the ringbuffer offset
+            if(decOffset >= RING_BUFFER_BYTES - MESSAGE_MAX_BYTES) decOffset = 0;
+        }
+    }
+}
+
+
+int compare(FILE* f0, FILE* f1)
+{
+    int result = 0;
+
+    while(0 == result) {
+        char b0[65536];
+        char b1[65536];
+        const size_t r0 = fread(b0, 1, sizeof(b0), f0);
+        const size_t r1 = fread(b1, 1, sizeof(b1), f1);
+
+        result = (int) r0 - (int) r1;
+
+        if(0 == r0 || 0 == r1) {
+            break;
+        }
+        if(0 == result) {
+            result = memcmp(b0, b1, r0);
+        }
+    }
+
+    return result;
+}
+
+
+int main(int argc, char** argv)
+{
+    char inpFilename[256] = { 0 };
+    char lz4Filename[256] = { 0 };
+    char decFilename[256] = { 0 };
+
+    if(argc < 2) {
+        printf("Please specify input filename\n");
+        return 0;
+    }
+
+    sprintf(inpFilename, "%s", argv[1]);
+    sprintf(lz4Filename, "%s.lz4s-%d", argv[1], 0);
+    sprintf(decFilename, "%s.lz4s-%d.dec", argv[1], 0);
+
+    printf("inp = [%s]\n", inpFilename);
+    printf("lz4 = [%s]\n", lz4Filename);
+    printf("dec = [%s]\n", decFilename);
+
+    // compress
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* outFp = fopen(lz4Filename, "wb");
+
+        test_compress(outFp, inpFp);
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    // decompress
+    {
+        FILE* inpFp = fopen(lz4Filename, "rb");
+        FILE* outFp = fopen(decFilename, "wb");
+
+        test_decompress(outFp, inpFp);
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    // verify
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* decFp = fopen(decFilename, "rb");
+
+        const int cmp = compare(inpFp, decFp);
+        if(0 == cmp) {
+            printf("Verify : OK\n");
+        } else {
+            printf("Verify : NG\n");
+        }
+
+        fclose(decFp);
+        fclose(inpFp);
+    }
+
+    return 0;
+}
diff --git a/examples/printVersion.c b/examples/printVersion.c
new file mode 100644
index 0000000..8607139
--- /dev/null
+++ b/examples/printVersion.c
@@ -0,0 +1,13 @@
+// LZ4 trivial example : print Library version number
+// Copyright : Takayuki Matsuoka & Yann Collet
+
+
+#include <stdio.h>
+#include "lz4.h"
+
+int main(int argc, char** argv)
+{
+	(void)argc; (void)argv;
+    printf("Hello World ! LZ4 Library version = %d\n", LZ4_versionNumber());
+    return 0;
+}
diff --git a/lz4.c b/lz4.c
index 518521b..435f1ea 100644
--- a/lz4.c
+++ b/lz4.c
@@ -47,6 +47,7 @@
 **************************************/
 /* 32 or 64 bits ? */
 #if (defined(__x86_64__) || defined(_M_X64) || defined(_WIN64) \
+  || defined(__64BIT__)  || defined(__mips64) \
   || defined(__powerpc64__) || defined(__powerpc64le__) \
   || defined(__ppc64__) || defined(__ppc64le__) \
   || defined(__PPC64__) || defined(__PPC64LE__) \
diff --git a/lz4.h b/lz4.h
index f8327f0..377e075 100644
--- a/lz4.h
+++ b/lz4.h
@@ -64,12 +64,12 @@ int LZ4_versionNumber (void);
    Simple Functions
 **************************************/
 
-int LZ4_compress        (const char* source, char* dest, int inputSize);
+int LZ4_compress        (const char* source, char* dest, int sourceSize);
 int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
 
 /*
 LZ4_compress() :
-    Compresses 'inputSize' bytes from 'source' into 'dest'.
+    Compresses 'sourceSize' 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()
@@ -83,16 +83,9 @@ LZ4_decompress_safe() :
     return : the number of bytes decompressed into the destination buffer (necessarily <= maxDecompressedSize)
              If the destination buffer is not large enough, decoding will stop and output an error code (<0).
              If the source stream is detected malformed, the function will stop decoding and return a negative result.
-             This function is protected against buffer overflow exploits :
-             it never writes outside of output buffer, and never reads outside of input buffer.
-             Therefore, it is protected against malicious data packets.
-*/
-
-
-/*
-Note :
-    Should you prefer to explicitly allocate compression-table memory using your own allocation method,
-    use the streaming functions provided below, simply reset the memory area between each call to LZ4_compress_continue()
+             This function is protected against buffer overflow exploits,
+             and never writes outside of output buffer, nor reads outside of input buffer.
+             It is also protected against malicious data packets.
 */
 
 
@@ -104,9 +97,9 @@ Note :
 
 /*
 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.
-    macro is also provided when result needs to be evaluated at compilation (such as stack memory allocation).
+    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
+    This function is primarily useful for memory allocation purposes (output buffer size).
+    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
 
     isize  : is the input size. Max supported value is LZ4_MAX_INPUT_SIZE
     return : maximum output size in a "worst case" scenario
@@ -117,16 +110,17 @@ int LZ4_compressBound(int isize);
 
 /*
 LZ4_compress_limitedOutput() :
-    Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
+    Compress 'sourceSize' 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 saves time and memory on detecting non-compressible (or barely compressible) data.
     This function never writes outside of provided output buffer.
 
-    inputSize  : Max supported value is LZ4_MAX_INPUT_VALUE
+    sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
     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
+             or 0 if compression fails
 */
-int LZ4_compress_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
+int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
 
 
 /*
diff --git a/lz4hc.c b/lz4hc.c
index 7de9811..441a1d6 100644
--- a/lz4hc.c
+++ b/lz4hc.c
@@ -54,6 +54,7 @@
 **************************************/
 /* 32 or 64 bits ? */
 #if (defined(__x86_64__) || defined(_M_X64) || defined(_WIN64) \
+  || defined(__64BIT__)  || defined(__mips64) \
   || defined(__powerpc64__) || defined(__powerpc64le__) \
   || defined(__ppc64__) || defined(__ppc64le__) \
   || defined(__PPC64__) || defined(__PPC64LE__) \
diff --git a/programs/Makefile b/programs/Makefile
index d8d38f7..a04c323 100644
--- a/programs/Makefile
+++ b/programs/Makefile
@@ -44,7 +44,7 @@ MANDIR=$(PREFIX)/share/man/man1
 LZ4DIR=..
 
 TEST_FILES = COPYING
-TEST_TARGETS=test
+TEST_TARGETS=test-native
 BENCH_NB=-i5
 
 # Minimize test target for Travis CI's Build Matrix
@@ -52,7 +52,6 @@ ifeq ($(LZ4_TRAVIS_CI_ENV),-m32)
 TEST_TARGETS=test-force32
 BENCH_NB=-i1
 else ifeq ($(LZ4_TRAVIS_CI_ENV),-m64)
-TEST_TARGETS=test
 BENCH_NB=-i1
 endif
 
@@ -129,13 +128,13 @@ uninstall:
 	[ -f $(DESTDIR)$(MANDIR)/lz4cat.1 ] && rm -f $(DESTDIR)$(MANDIR)/lz4cat.1
 	@echo lz4 successfully uninstalled
 
-test: test-lz4 test-lz4c test-fullbench test-fuzzer test-mem
+test-native: test-lz4 test-lz4c test-fullbench test-fuzzer test-mem
 
 test-force32: test-lz4c32 test-fullbench32 test-fuzzer32 test-mem32
 
-test-all: test test-force32
+test-all: test-native test-force32
 
-test-travis: $(TEST_TARGETS)
+test: $(TEST_TARGETS)
 
 test-lz4: lz4 datagen
 	./datagen -g16KB  | ./lz4 -9     | ./lz4 -vdq > $(VOID)
diff --git a/programs/lz4io.c b/programs/lz4io.c
index 8bd10fc..2715972 100644
--- a/programs/lz4io.c
+++ b/programs/lz4io.c
@@ -45,6 +45,7 @@
 #  endif
 #endif
 
+#define _LARGE_FILES           // Large file support on 32-bits AIX
 #define _FILE_OFFSET_BITS 64   // Large file support on 32-bits unix
 #define _POSIX_SOURCE 1        // for fileno() within <stdio.h> on unix
 
diff --git a/programs/xxhash.c b/programs/xxhash.c
index 1ac77a4..be48370 100644
--- a/programs/xxhash.c
+++ b/programs/xxhash.c
@@ -1,806 +1,806 @@
-/*

-xxHash - Fast Hash algorithm

-Copyright (C) 2012-2014, 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 : http://code.google.com/p/xxhash/

-*/

-

-

-//**************************************

-// Tuning parameters

-//**************************************

-// 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.

-// You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32).

-#if defined(__ARM_FEATURE_UNALIGNED) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)

-#  define XXH_USE_UNALIGNED_ACCESS 1

-#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.

-// This option has a very small performance cost (only measurable on small inputs).

-// 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-independant 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-independance be of no importance for your application, you may set the #define below to 1.

-// It will improve speed for Big-endian CPU.

-// This option has no impact on Little_Endian CPU.

-#define XXH_FORCE_NATIVE_FORMAT 0

-

-//**************************************

-// Compiler Specific Options

-//**************************************

-// Disable some Visual warning messages

-#ifdef _MSC_VER  // Visual Studio

-#  pragma warning(disable : 4127)      // disable: C4127: conditional expression is constant

-#endif

-

-#ifdef _MSC_VER    // Visual Studio

-#  define FORCE_INLINE static __forceinline

-#else

-#  ifdef __GNUC__

-#    define FORCE_INLINE static inline __attribute__((always_inline))

-#  else

-#    define FORCE_INLINE static inline

-#  endif

-#endif

-

-//**************************************

-// Includes & Memory related functions

-//**************************************

-#include "xxhash.h"

-// Modify the local functions below should you wish to use some other memory related routines

-// for malloc(), free()

-#include <stdlib.h>

-FORCE_INLINE void* XXH_malloc(size_t s) { return malloc(s); }

-FORCE_INLINE void  XXH_free  (void* p)  { free(p); }

-// for memcpy()

-#include <string.h>

-FORCE_INLINE void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }

-

-

-//**************************************

-// Basic Types

-//**************************************

-#if 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;

-#endif

-

-#if defined(__GNUC__)  && !defined(XXH_USE_UNALIGNED_ACCESS)

-#  define _PACKED __attribute__ ((packed))

-#else

-#  define _PACKED

-#endif

-

-#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__)

-#  ifdef __IBMC__

-#    pragma pack(1)

-#  else

-#    pragma pack(push, 1)

-#  endif

-#endif

-

-typedef struct _U32_S { U32 v; } _PACKED U32_S;

-typedef struct _U64_S { U64 v; } _PACKED U64_S;

-

-#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__)

-#  pragma pack(pop)

-#endif

-

-#define A32(x) (((U32_S *)(x))->v)

-#define A64(x) (((U64_S *)(x))->v)

-

-

-//***************************************

-// 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

-#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))

-#  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 inline U32 XXH_swap32 (U32 x) {

-    return  ((x << 24) & 0xff000000 ) |

-			((x <<  8) & 0x00ff0000 ) |

-			((x >>  8) & 0x0000ff00 ) |

-			((x >> 24) & 0x000000ff );}

-static inline 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

-

-

-//**************************************

-// Constants

-//**************************************

-#define PRIME32_1   2654435761U

-#define PRIME32_2   2246822519U

-#define PRIME32_3   3266489917U

-#define PRIME32_4    668265263U

-#define PRIME32_5    374761393U

-

-#define PRIME64_1 11400714785074694791ULL

-#define PRIME64_2 14029467366897019727ULL

-#define PRIME64_3  1609587929392839161ULL

-#define PRIME64_4  9650029242287828579ULL

-#define PRIME64_5  2870177450012600261ULL

-

-//**************************************

-// Architecture Macros

-//**************************************

-typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;

-#ifndef XXH_CPU_LITTLE_ENDIAN   // It is possible to define XXH_CPU_LITTLE_ENDIAN externally, for example using a compiler switch

-    static const int one = 1;

-#   define XXH_CPU_LITTLE_ENDIAN   (*(char*)(&one))

-#endif

-

-

-//**************************************

-// Macros

-//**************************************

-#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(!!(c)) }; }    // use only *after* variable declarations

-

-

-//****************************

-// Memory reads

-//****************************

-typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;

-

-FORCE_INLINE U32 XXH_readLE32_align(const U32* ptr, XXH_endianess endian, XXH_alignment align)

-{

-    if (align==XXH_unaligned)

-        return endian==XXH_littleEndian ? A32(ptr) : XXH_swap32(A32(ptr));

-    else

-        return endian==XXH_littleEndian ? *ptr : XXH_swap32(*ptr);

-}

-

-FORCE_INLINE U32 XXH_readLE32(const U32* ptr, XXH_endianess endian) { return XXH_readLE32_align(ptr, endian, XXH_unaligned); }

-

-FORCE_INLINE U64 XXH_readLE64_align(const U64* ptr, XXH_endianess endian, XXH_alignment align)

-{

-    if (align==XXH_unaligned)

-        return endian==XXH_littleEndian ? A64(ptr) : XXH_swap64(A64(ptr));

-    else

-        return endian==XXH_littleEndian ? *ptr : XXH_swap64(*ptr);

-}

-

-FORCE_INLINE U64 XXH_readLE64(const U64* ptr, XXH_endianess endian) { return XXH_readLE64_align(ptr, endian, XXH_unaligned); }

-

-

-//****************************

-// Simple Hash Functions

-//****************************

-FORCE_INLINE U32 XXH32_endian_align(const void* input, unsigned int len, U32 seed, XXH_endianess endian, XXH_alignment align)

-{

-    const BYTE* p = (const BYTE*)input;

+/*
+xxHash - Fast Hash algorithm
+Copyright (C) 2012-2014, 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 : http://code.google.com/p/xxhash/
+*/
+
+
+//**************************************
+// Tuning parameters
+//**************************************
+// 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.
+// You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32).
+#if defined(__ARM_FEATURE_UNALIGNED) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
+#  define XXH_USE_UNALIGNED_ACCESS 1
+#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.
+// This option has a very small performance cost (only measurable on small inputs).
+// 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-independant 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-independance be of no importance for your application, you may set the #define below to 1.
+// It will improve speed for Big-endian CPU.
+// This option has no impact on Little_Endian CPU.
+#define XXH_FORCE_NATIVE_FORMAT 0
+
+//**************************************
+// Compiler Specific Options
+//**************************************
+// Disable some Visual warning messages
+#ifdef _MSC_VER  // Visual Studio
+#  pragma warning(disable : 4127)      // disable: C4127: conditional expression is constant
+#endif
+
+#ifdef _MSC_VER    // Visual Studio
+#  define FORCE_INLINE static __forceinline
+#else
+#  ifdef __GNUC__
+#    define FORCE_INLINE static inline __attribute__((always_inline))
+#  else
+#    define FORCE_INLINE static inline
+#  endif
+#endif
+
+//**************************************
+// Includes & Memory related functions
+//**************************************
+#include "xxhash.h"
+// Modify the local functions below should you wish to use some other memory related routines
+// for malloc(), free()
+#include <stdlib.h>
+FORCE_INLINE void* XXH_malloc(size_t s) { return malloc(s); }
+FORCE_INLINE void  XXH_free  (void* p)  { free(p); }
+// for memcpy()
+#include <string.h>
+FORCE_INLINE void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
+
+
+//**************************************
+// Basic Types
+//**************************************
+#if 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;
+#endif
+
+#if defined(__GNUC__)  && !defined(XXH_USE_UNALIGNED_ACCESS)
+#  define _PACKED __attribute__ ((packed))
+#else
+#  define _PACKED
+#endif
+
+#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__)
+#  ifdef __IBMC__
+#    pragma pack(1)
+#  else
+#    pragma pack(push, 1)
+#  endif
+#endif
+
+typedef struct _U32_S { U32 v; } _PACKED U32_S;
+typedef struct _U64_S { U64 v; } _PACKED U64_S;
+
+#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__)
+#  pragma pack(pop)
+#endif
+
+#define A32(x) (((U32_S *)(x))->v)
+#define A64(x) (((U64_S *)(x))->v)
+
+
+//***************************************
+// 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
+#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
+#  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 inline U32 XXH_swap32 (U32 x) {
+    return  ((x << 24) & 0xff000000 ) |
+			((x <<  8) & 0x00ff0000 ) |
+			((x >>  8) & 0x0000ff00 ) |
+			((x >> 24) & 0x000000ff );}
+static inline 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
+
+
+//**************************************
+// Constants
+//**************************************
+#define PRIME32_1   2654435761U
+#define PRIME32_2   2246822519U
+#define PRIME32_3   3266489917U
+#define PRIME32_4    668265263U
+#define PRIME32_5    374761393U
+
+#define PRIME64_1 11400714785074694791ULL
+#define PRIME64_2 14029467366897019727ULL
+#define PRIME64_3  1609587929392839161ULL
+#define PRIME64_4  9650029242287828579ULL
+#define PRIME64_5  2870177450012600261ULL
+
+//**************************************
+// Architecture Macros
+//**************************************
+typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
+#ifndef XXH_CPU_LITTLE_ENDIAN   // It is possible to define XXH_CPU_LITTLE_ENDIAN externally, for example using a compiler switch
+    static const int one = 1;
+#   define XXH_CPU_LITTLE_ENDIAN   (*(char*)(&one))
+#endif
+
+
+//**************************************
+// Macros
+//**************************************
+#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(!!(c)) }; }    // use only *after* variable declarations
+
+
+//****************************
+// Memory reads
+//****************************
+typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
+
+FORCE_INLINE U32 XXH_readLE32_align(const U32* ptr, XXH_endianess endian, XXH_alignment align)
+{
+    if (align==XXH_unaligned)
+        return endian==XXH_littleEndian ? A32(ptr) : XXH_swap32(A32(ptr));
+    else
+        return endian==XXH_littleEndian ? *ptr : XXH_swap32(*ptr);
+}
+
+FORCE_INLINE U32 XXH_readLE32(const U32* ptr, XXH_endianess endian) { return XXH_readLE32_align(ptr, endian, XXH_unaligned); }
+
+FORCE_INLINE U64 XXH_readLE64_align(const U64* ptr, XXH_endianess endian, XXH_alignment align)
+{
+    if (align==XXH_unaligned)
+        return endian==XXH_littleEndian ? A64(ptr) : XXH_swap64(A64(ptr));
+    else
+        return endian==XXH_littleEndian ? *ptr : XXH_swap64(*ptr);
+}
+
+FORCE_INLINE U64 XXH_readLE64(const U64* ptr, XXH_endianess endian) { return XXH_readLE64_align(ptr, endian, XXH_unaligned); }
+
+
+//****************************
+// Simple Hash Functions
+//****************************
+FORCE_INLINE U32 XXH32_endian_align(const void* input, unsigned int 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((const U32*)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 += XXH_get32bits(p) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;
+            v2 += XXH_get32bits(p) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;
+            v3 += XXH_get32bits(p) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;
+            v4 += XXH_get32bits(p) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; 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;
+}
+
+
+U32 XXH32(const void* input, unsigned int len, U32 seed)
+{
+#if 0
+    // Simple version, good for code maintenance, but unfortunately slow for small inputs
+    void* state = XXH32_init(seed);
+    XXH32_update(state, input, len);
+    return XXH32_digest(state);
+#else
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+#  if !defined(XXH_USE_UNALIGNED_ACCESS)
+    if ((((size_t)input) & 3) == 0)   // Input is aligned, let's leverage the speed advantage
+    {
+        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);
+    }
+#  endif
+
+    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
+}
+
+FORCE_INLINE U64 XXH64_endian_align(const void* input, unsigned int len, U64 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((const U32*)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 += XXH_get32bits(p) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;

-            v2 += XXH_get32bits(p) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;

-            v3 += XXH_get32bits(p) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;

-            v4 += XXH_get32bits(p) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; 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;

-}

-

-

-U32 XXH32(const void* input, unsigned int len, U32 seed)

-{

-#if 0

-    // Simple version, good for code maintenance, but unfortunately slow for small inputs

-    void* state = XXH32_init(seed);

-    XXH32_update(state, input, len);

-    return XXH32_digest(state);

-#else

-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

-

-#  if !defined(XXH_USE_UNALIGNED_ACCESS)

-    if ((((size_t)input) & 3) == 0)   // Input is aligned, let's leverage the speed advantage

-    {

-        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);

-    }

-#  endif

-

-    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

-}

-

-FORCE_INLINE U64 XXH64_endian_align(const void* input, unsigned int len, U64 seed, XXH_endianess endian, XXH_alignment align)

-{

-    const BYTE* p = (const BYTE*)input;

-    const BYTE* bEnd = p + len;

     U64 h64;
-#define XXH_get64bits(p) XXH_readLE64_align((const U64*)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

+#define XXH_get64bits(p) XXH_readLE64_align((const U64*)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 += XXH_get64bits(p) * PRIME64_2; p+=8; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1;

-            v2 += XXH_get64bits(p) * PRIME64_2; p+=8; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1;

-            v3 += XXH_get64bits(p) * PRIME64_2; p+=8; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1;

+            v1 += XXH_get64bits(p) * PRIME64_2; p+=8; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1;
+            v2 += XXH_get64bits(p) * PRIME64_2; p+=8; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1;
+            v3 += XXH_get64bits(p) * PRIME64_2; p+=8; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1;
             v4 += XXH_get64bits(p) * PRIME64_2; p+=8; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1;
-        } while (p<=limit);

-

-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);

-

-        v1 *= PRIME64_2; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1; h64 ^= v1;

-    	h64 = h64 * PRIME64_1 + PRIME64_4;

-

-        v2 *= PRIME64_2; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1; h64 ^= v2;

-    	h64 = h64 * PRIME64_1 + PRIME64_4;

-

-        v3 *= PRIME64_2; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1; h64 ^= v3;

-    	h64 = h64 * PRIME64_1 + PRIME64_4;

-

-        v4 *= PRIME64_2; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1; h64 ^= v4;

-    	h64 = h64 * PRIME64_1 + PRIME64_4;

-    }

-    else

-    {

-        h64  = seed + PRIME64_5;

-    }

-

-    h64 += (U64) len;

-

-    while (p+8<=bEnd)

-    {

-    	U64 k1 = XXH_get64bits(p);

-    	k1 *= PRIME64_2; k1 = XXH_rotl64(k1,31); k1 *= PRIME64_1; h64 ^= k1;

+        } while (p<=limit);
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+
+        v1 *= PRIME64_2; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1; h64 ^= v1;
+    	h64 = h64 * PRIME64_1 + PRIME64_4;
+
+        v2 *= PRIME64_2; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1; h64 ^= v2;
+    	h64 = h64 * PRIME64_1 + PRIME64_4;
+
+        v3 *= PRIME64_2; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1; h64 ^= v3;
+    	h64 = h64 * PRIME64_1 + PRIME64_4;
+
+        v4 *= PRIME64_2; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1; h64 ^= v4;
+    	h64 = h64 * PRIME64_1 + PRIME64_4;
+    }
+    else
+    {
+        h64  = seed + PRIME64_5;
+    }
+
+    h64 += (U64) len;
+
+    while (p+8<=bEnd)
+    {
+    	U64 k1 = XXH_get64bits(p);
+    	k1 *= PRIME64_2; k1 = XXH_rotl64(k1,31); k1 *= PRIME64_1; h64 ^= k1;
     	h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-    	p+=8;

-    }

+    	p+=8;
+    }
 
-    if (p+4<=bEnd)

-    {

-    	h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;

+    if (p+4<=bEnd)
+    {
+    	h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
         h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;

-    }

+        p+=4;
+    }
 
-    while (p<bEnd)

-    {

-    	h64 ^= (*p) * PRIME64_5;

+    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;

-}

-
-

-unsigned long long XXH64(const void* input, unsigned int len, unsigned long long seed)

-{

-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

-

-#  if !defined(XXH_USE_UNALIGNED_ACCESS)

-    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);

-    }

-#  endif

-

-    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);

-}

-

-//****************************

-// Advanced Hash Functions

-//****************************

-

-struct XXH_state32_t

-{

-    U64 total_len;

-    U32 seed;

-    U32 v1;

-    U32 v2;

-    U32 v3;

-    U32 v4;

-    int memsize;

-    char memory[16];

-};

-

-struct XXH_state64_t

-{

-    U64 total_len;

-    U64 seed;

-    U64 v1;

-    U64 v2;

-    U64 v3;

-    U64 v4;

-    int memsize;

-    char memory[32];

-};

-

-

-int XXH32_sizeofState(void)

-{

-    XXH_STATIC_ASSERT(XXH32_SIZEOFSTATE >= sizeof(struct XXH_state32_t));   // A compilation error here means XXH32_SIZEOFSTATE is not large enough

-    return sizeof(struct XXH_state32_t);

-}

-

-int XXH64_sizeofState(void)

-{

-    XXH_STATIC_ASSERT(XXH64_SIZEOFSTATE >= sizeof(struct XXH_state64_t));   // A compilation error here means XXH64_SIZEOFSTATE is not large enough

-    return sizeof(struct XXH_state64_t);

-}

-

-

-XXH_errorcode XXH32_resetState(void* state_in, U32 seed)

-{

-    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;

-    state->seed = seed;

-    state->v1 = seed + PRIME32_1 + PRIME32_2;

-    state->v2 = seed + PRIME32_2;

-    state->v3 = seed + 0;

-    state->v4 = seed - PRIME32_1;

-    state->total_len = 0;

-    state->memsize = 0;

-    return XXH_OK;

-}

-

-XXH_errorcode XXH64_resetState(void* state_in, unsigned long long seed)

-{

-    struct XXH_state64_t * state = (struct XXH_state64_t *) state_in;

-    state->seed = seed;

-    state->v1 = seed + PRIME64_1 + PRIME64_2;

-    state->v2 = seed + PRIME64_2;

-    state->v3 = seed + 0;

-    state->v4 = seed - PRIME64_1;

-    state->total_len = 0;

-    state->memsize = 0;

-    return XXH_OK;

-}

-

-

-void* XXH32_init (U32 seed)

-{

-    void* state = XXH_malloc (sizeof(struct XXH_state32_t));

+
+    h64 ^= h64 >> 33;
+    h64 *= PRIME64_2;
+    h64 ^= h64 >> 29;
+    h64 *= PRIME64_3;
+    h64 ^= h64 >> 32;
+
+    return h64;
+}
+
+
+unsigned long long XXH64(const void* input, unsigned int len, unsigned long long seed)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+#  if !defined(XXH_USE_UNALIGNED_ACCESS)
+    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);
+    }
+#  endif
+
+    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);
+}
+
+//****************************
+// Advanced Hash Functions
+//****************************
+
+struct XXH_state32_t
+{
+    U64 total_len;
+    U32 seed;
+    U32 v1;
+    U32 v2;
+    U32 v3;
+    U32 v4;
+    int memsize;
+    char memory[16];
+};
+
+struct XXH_state64_t
+{
+    U64 total_len;
+    U64 seed;
+    U64 v1;
+    U64 v2;
+    U64 v3;
+    U64 v4;
+    int memsize;
+    char memory[32];
+};
+
+
+int XXH32_sizeofState(void)
+{
+    XXH_STATIC_ASSERT(XXH32_SIZEOFSTATE >= sizeof(struct XXH_state32_t));   // A compilation error here means XXH32_SIZEOFSTATE is not large enough
+    return sizeof(struct XXH_state32_t);
+}
+
+int XXH64_sizeofState(void)
+{
+    XXH_STATIC_ASSERT(XXH64_SIZEOFSTATE >= sizeof(struct XXH_state64_t));   // A compilation error here means XXH64_SIZEOFSTATE is not large enough
+    return sizeof(struct XXH_state64_t);
+}
+
+
+XXH_errorcode XXH32_resetState(void* state_in, U32 seed)
+{
+    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;
+    state->seed = seed;
+    state->v1 = seed + PRIME32_1 + PRIME32_2;
+    state->v2 = seed + PRIME32_2;
+    state->v3 = seed + 0;
+    state->v4 = seed - PRIME32_1;
+    state->total_len = 0;
+    state->memsize = 0;
+    return XXH_OK;
+}
+
+XXH_errorcode XXH64_resetState(void* state_in, unsigned long long seed)
+{
+    struct XXH_state64_t * state = (struct XXH_state64_t *) state_in;
+    state->seed = seed;
+    state->v1 = seed + PRIME64_1 + PRIME64_2;
+    state->v2 = seed + PRIME64_2;
+    state->v3 = seed + 0;
+    state->v4 = seed - PRIME64_1;
+    state->total_len = 0;
+    state->memsize = 0;
+    return XXH_OK;
+}
+
+
+void* XXH32_init (U32 seed)
+{
+    void* state = XXH_malloc (sizeof(struct XXH_state32_t));
     if (state != NULL) XXH32_resetState(state, seed);
-    return state;

-}

-

-void* XXH64_init (unsigned long long seed)

-{

-    void* state = XXH_malloc (sizeof(struct XXH_state64_t));

-    if (state != NULL) XXH64_resetState(state, seed);

-    return state;

-}

-

-

-FORCE_INLINE XXH_errorcode XXH32_update_endian (void* state_in, const void* input, int len, XXH_endianess endian)

-{

-    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;

-    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 < 16)   // fill in tmp buffer

-    {

-        XXH_memcpy(state->memory + state->memsize, input, len);

-        state->memsize +=  len;

-        return XXH_OK;

-    }

-

-    if (state->memsize)   // some data left from previous update

-    {

-        XXH_memcpy(state->memory + state->memsize, input, 16-state->memsize);

-        {

-            const U32* p32 = (const U32*)state->memory;

-            state->v1 += XXH_readLE32(p32, endian) * PRIME32_2; state->v1 = XXH_rotl32(state->v1, 13); state->v1 *= PRIME32_1; p32++;

-            state->v2 += XXH_readLE32(p32, endian) * PRIME32_2; state->v2 = XXH_rotl32(state->v2, 13); state->v2 *= PRIME32_1; p32++;

-            state->v3 += XXH_readLE32(p32, endian) * PRIME32_2; state->v3 = XXH_rotl32(state->v3, 13); state->v3 *= PRIME32_1; p32++;

-            state->v4 += XXH_readLE32(p32, endian) * PRIME32_2; state->v4 = XXH_rotl32(state->v4, 13); state->v4 *= PRIME32_1; 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 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;

-            v2 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;

-            v3 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;

-            v4 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4;

-        } while (p<=limit);

-

-        state->v1 = v1;

-        state->v2 = v2;

-        state->v3 = v3;

-        state->v4 = v4;

-    }

-

-    if (p < bEnd)

-    {

-        XXH_memcpy(state->memory, p, bEnd-p);

-        state->memsize = (int)(bEnd-p);

-    }

-

-    return XXH_OK;

-}

-

-XXH_errorcode XXH32_update (void* state_in, const void* input, unsigned int 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 U32 XXH32_intermediateDigest_endian (void* state_in, XXH_endianess endian)

-{

-    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;

-    const BYTE * p = (const BYTE*)state->memory;

-    BYTE* bEnd = (BYTE*)state->memory + state->memsize;

-    U32 h32;

-

-    if (state->total_len >= 16)

-    {

-        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);

-    }

-    else

-    {

-        h32  = state->seed + PRIME32_5;

-    }

-

-    h32 += (U32) state->total_len;

-

-    while (p+4<=bEnd)

-    {

-        h32 += XXH_readLE32((const U32*)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;

-}

-

-

-U32 XXH32_intermediateDigest (void* state_in)

-{

-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

-

-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)

-        return XXH32_intermediateDigest_endian(state_in, XXH_littleEndian);

-    else

-        return XXH32_intermediateDigest_endian(state_in, XXH_bigEndian);

-}

-

-

-U32 XXH32_digest (void* state_in)

-{

-    U32 h32 = XXH32_intermediateDigest(state_in);

-

-    XXH_free(state_in);

-

-    return h32;

-}

-

-

-FORCE_INLINE XXH_errorcode XXH64_update_endian (void* state_in, const void* input, int len, XXH_endianess endian)

-{

-    struct XXH_state64_t * state = (struct XXH_state64_t *) state_in;

-    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(state->memory + state->memsize, input, len);

-        state->memsize +=  len;

-        return XXH_OK;

-    }

-

-    if (state->memsize)   // some data left from previous update

-    {

-        XXH_memcpy(state->memory + state->memsize, input, 32-state->memsize);

-        {

-            const U64* p64 = (const U64*)state->memory;

-            state->v1 += XXH_readLE64(p64, endian) * PRIME64_2; state->v1 = XXH_rotl64(state->v1, 31); state->v1 *= PRIME64_1; p64++;

-            state->v2 += XXH_readLE64(p64, endian) * PRIME64_2; state->v2 = XXH_rotl64(state->v2, 31); state->v2 *= PRIME64_1; p64++;

-            state->v3 += XXH_readLE64(p64, endian) * PRIME64_2; state->v3 = XXH_rotl64(state->v3, 31); state->v3 *= PRIME64_1; p64++;

-            state->v4 += XXH_readLE64(p64, endian) * PRIME64_2; state->v4 = XXH_rotl64(state->v4, 31); state->v4 *= PRIME64_1; p64++;

-        }

-        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 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1; p+=8;

-            v2 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1; p+=8;

-            v3 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1; p+=8;

-            v4 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1; p+=8;

-        } while (p<=limit);

-

-        state->v1 = v1;

-        state->v2 = v2;

-        state->v3 = v3;

-        state->v4 = v4;

-    }

-

-    if (p < bEnd)

-    {

-        XXH_memcpy(state->memory, p, bEnd-p);

-        state->memsize = (int)(bEnd-p);

-    }

-

-    return XXH_OK;

-}

-

-XXH_errorcode XXH64_update (void* state_in, const void* input, unsigned int 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 U64 XXH64_intermediateDigest_endian (void* state_in, XXH_endianess endian)

-{

-    struct XXH_state64_t * state = (struct XXH_state64_t *) state_in;

-    const BYTE * p = (const BYTE*)state->memory;

-    BYTE* bEnd = (BYTE*)state->memory + state->memsize;

-    U64 h64;

-

-    if (state->total_len >= 32)

-    {

-    	U64 v1 = state->v1;

-    	U64 v2 = state->v2;

-    	U64 v3 = state->v3;

-    	U64 v4 = state->v4;

-

-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);

-

-        v1 *= PRIME64_2; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1; h64 ^= v1;

-    	h64 = h64*PRIME64_1 + PRIME64_4;

-

-        v2 *= PRIME64_2; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1; h64 ^= v2;

-    	h64 = h64*PRIME64_1 + PRIME64_4;

-

-        v3 *= PRIME64_2; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1; h64 ^= v3;

-    	h64 = h64*PRIME64_1 + PRIME64_4;

-

-        v4 *= PRIME64_2; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1; h64 ^= v4;

-    	h64 = h64*PRIME64_1 + PRIME64_4;

-    }

-    else

-    {

-        h64  = state->seed + PRIME64_5;

-    }

-

-    h64 += (U64) state->total_len;

-

-    while (p+8<=bEnd)

-    {

-    	U64 k1 = XXH_readLE64((const U64*)p, endian);

-    	k1 *= PRIME64_2; k1 = XXH_rotl64(k1,31); k1 *= PRIME64_1; h64 ^= k1;

+    return state;
+}
+
+void* XXH64_init (unsigned long long seed)
+{
+    void* state = XXH_malloc (sizeof(struct XXH_state64_t));
+    if (state != NULL) XXH64_resetState(state, seed);
+    return state;
+}
+
+
+FORCE_INLINE XXH_errorcode XXH32_update_endian (void* state_in, const void* input, int len, XXH_endianess endian)
+{
+    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;
+    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 < 16)   // fill in tmp buffer
+    {
+        XXH_memcpy(state->memory + state->memsize, input, len);
+        state->memsize +=  len;
+        return XXH_OK;
+    }
+
+    if (state->memsize)   // some data left from previous update
+    {
+        XXH_memcpy(state->memory + state->memsize, input, 16-state->memsize);
+        {
+            const U32* p32 = (const U32*)state->memory;
+            state->v1 += XXH_readLE32(p32, endian) * PRIME32_2; state->v1 = XXH_rotl32(state->v1, 13); state->v1 *= PRIME32_1; p32++;
+            state->v2 += XXH_readLE32(p32, endian) * PRIME32_2; state->v2 = XXH_rotl32(state->v2, 13); state->v2 *= PRIME32_1; p32++;
+            state->v3 += XXH_readLE32(p32, endian) * PRIME32_2; state->v3 = XXH_rotl32(state->v3, 13); state->v3 *= PRIME32_1; p32++;
+            state->v4 += XXH_readLE32(p32, endian) * PRIME32_2; state->v4 = XXH_rotl32(state->v4, 13); state->v4 *= PRIME32_1; 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 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;
+            v2 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;
+            v3 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;
+            v4 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4;
+        } while (p<=limit);
+
+        state->v1 = v1;
+        state->v2 = v2;
+        state->v3 = v3;
+        state->v4 = v4;
+    }
+
+    if (p < bEnd)
+    {
+        XXH_memcpy(state->memory, p, bEnd-p);
+        state->memsize = (int)(bEnd-p);
+    }
+
+    return XXH_OK;
+}
+
+XXH_errorcode XXH32_update (void* state_in, const void* input, unsigned int 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 U32 XXH32_intermediateDigest_endian (void* state_in, XXH_endianess endian)
+{
+    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;
+    const BYTE * p = (const BYTE*)state->memory;
+    BYTE* bEnd = (BYTE*)state->memory + state->memsize;
+    U32 h32;
+
+    if (state->total_len >= 16)
+    {
+        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
+    }
+    else
+    {
+        h32  = state->seed + PRIME32_5;
+    }
+
+    h32 += (U32) state->total_len;
+
+    while (p+4<=bEnd)
+    {
+        h32 += XXH_readLE32((const U32*)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;
+}
+
+
+U32 XXH32_intermediateDigest (void* state_in)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_intermediateDigest_endian(state_in, XXH_littleEndian);
+    else
+        return XXH32_intermediateDigest_endian(state_in, XXH_bigEndian);
+}
+
+
+U32 XXH32_digest (void* state_in)
+{
+    U32 h32 = XXH32_intermediateDigest(state_in);
+
+    XXH_free(state_in);
+
+    return h32;
+}
+
+
+FORCE_INLINE XXH_errorcode XXH64_update_endian (void* state_in, const void* input, int len, XXH_endianess endian)
+{
+    struct XXH_state64_t * state = (struct XXH_state64_t *) state_in;
+    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(state->memory + state->memsize, input, len);
+        state->memsize +=  len;
+        return XXH_OK;
+    }
+
+    if (state->memsize)   // some data left from previous update
+    {
+        XXH_memcpy(state->memory + state->memsize, input, 32-state->memsize);
+        {
+            const U64* p64 = (const U64*)state->memory;
+            state->v1 += XXH_readLE64(p64, endian) * PRIME64_2; state->v1 = XXH_rotl64(state->v1, 31); state->v1 *= PRIME64_1; p64++;
+            state->v2 += XXH_readLE64(p64, endian) * PRIME64_2; state->v2 = XXH_rotl64(state->v2, 31); state->v2 *= PRIME64_1; p64++;
+            state->v3 += XXH_readLE64(p64, endian) * PRIME64_2; state->v3 = XXH_rotl64(state->v3, 31); state->v3 *= PRIME64_1; p64++;
+            state->v4 += XXH_readLE64(p64, endian) * PRIME64_2; state->v4 = XXH_rotl64(state->v4, 31); state->v4 *= PRIME64_1; p64++;
+        }
+        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 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1; p+=8;
+            v2 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1; p+=8;
+            v3 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1; p+=8;
+            v4 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1; p+=8;
+        } while (p<=limit);
+
+        state->v1 = v1;
+        state->v2 = v2;
+        state->v3 = v3;
+        state->v4 = v4;
+    }
+
+    if (p < bEnd)
+    {
+        XXH_memcpy(state->memory, p, bEnd-p);
+        state->memsize = (int)(bEnd-p);
+    }
+
+    return XXH_OK;
+}
+
+XXH_errorcode XXH64_update (void* state_in, const void* input, unsigned int 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 U64 XXH64_intermediateDigest_endian (void* state_in, XXH_endianess endian)
+{
+    struct XXH_state64_t * state = (struct XXH_state64_t *) state_in;
+    const BYTE * p = (const BYTE*)state->memory;
+    BYTE* bEnd = (BYTE*)state->memory + state->memsize;
+    U64 h64;
+
+    if (state->total_len >= 32)
+    {
+    	U64 v1 = state->v1;
+    	U64 v2 = state->v2;
+    	U64 v3 = state->v3;
+    	U64 v4 = state->v4;
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+
+        v1 *= PRIME64_2; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1; h64 ^= v1;
+    	h64 = h64*PRIME64_1 + PRIME64_4;
+
+        v2 *= PRIME64_2; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1; h64 ^= v2;
+    	h64 = h64*PRIME64_1 + PRIME64_4;
+
+        v3 *= PRIME64_2; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1; h64 ^= v3;
+    	h64 = h64*PRIME64_1 + PRIME64_4;
+
+        v4 *= PRIME64_2; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1; h64 ^= v4;
+    	h64 = h64*PRIME64_1 + PRIME64_4;
+    }
+    else
+    {
+        h64  = state->seed + PRIME64_5;
+    }
+
+    h64 += (U64) state->total_len;
+
+    while (p+8<=bEnd)
+    {
+    	U64 k1 = XXH_readLE64((const U64*)p, endian);
+    	k1 *= PRIME64_2; k1 = XXH_rotl64(k1,31); k1 *= PRIME64_1; h64 ^= k1;
     	h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-    	p+=8;

-    }

-

-    if (p+4<=bEnd)

-    {

-    	h64 ^= (U64)(XXH_readLE32((const U32*)p, endian)) * PRIME64_1;

+    	p+=8;
+    }
+
+    if (p+4<=bEnd)
+    {
+    	h64 ^= (U64)(XXH_readLE32((const U32*)p, endian)) * PRIME64_1;
         h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;

-    }

+        p+=4;
+    }
 
-    while (p<bEnd)

-    {

-    	h64 ^= (*p) * PRIME64_5;

+    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;

-}

-

-

-unsigned long long XXH64_intermediateDigest (void* state_in)

-{

-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

-

-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)

-        return XXH64_intermediateDigest_endian(state_in, XXH_littleEndian);

-    else

-        return XXH64_intermediateDigest_endian(state_in, XXH_bigEndian);

-}

-

-

-unsigned long long XXH64_digest (void* state_in)

-{

-    U64 h64 = XXH64_intermediateDigest(state_in);

-

-    XXH_free(state_in);

-

-    return h64;

-}

-

+    }
+
+    h64 ^= h64 >> 33;
+    h64 *= PRIME64_2;
+    h64 ^= h64 >> 29;
+    h64 *= PRIME64_3;
+    h64 ^= h64 >> 32;
+
+    return h64;
+}
+
+
+unsigned long long XXH64_intermediateDigest (void* state_in)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH64_intermediateDigest_endian(state_in, XXH_littleEndian);
+    else
+        return XXH64_intermediateDigest_endian(state_in, XXH_bigEndian);
+}
+
+
+unsigned long long XXH64_digest (void* state_in)
+{
+    U64 h64 = XXH64_intermediateDigest(state_in);
+
+    XXH_free(state_in);
+
+    return h64;
+}
+
diff --git a/programs/xxhash.h b/programs/xxhash.h
index a12ec60..4311485 100644
--- a/programs/xxhash.h
+++ b/programs/xxhash.h
@@ -1,168 +1,168 @@
-/*

-   xxHash - Extremely Fast Hash algorithm

-   Header File

-   Copyright (C) 2012-2014, 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 : http://code.google.com/p/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.

-*/

-

-#pragma once

-

-#if defined (__cplusplus)

-extern "C" {

-#endif

-

-

-/*****************************

-   Type

-*****************************/

-typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;

-

-

-

-/*****************************

-   Simple Hash Functions

-*****************************/

-

-unsigned int       XXH32 (const void* input, unsigned int len, unsigned int seed);

-unsigned long long XXH64 (const void* input, unsigned int len, unsigned long long seed);

-

-/*

-XXH32() :

-    Calculate the 32-bits hash of sequence of length "len" stored at memory address "input".

-    The memory between input & input+len must be valid (allocated and read-accessible).

-    "seed" can be used to alter the result predictably.

-    This function successfully passes all SMHasher tests.

-    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s

-    Note that "len" is type "int", which means it is limited to 2^31-1.

-    If your data is larger, use the advanced functions below.

-XXH64() :

-    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".

-*/

-

-

-

-/*****************************

-   Advanced Hash Functions

-*****************************/

-

-void*         XXH32_init   (unsigned int seed);

-XXH_errorcode XXH32_update (void* state, const void* input, unsigned int len);

-unsigned int  XXH32_digest (void* state);

-

-void*         		XXH64_init   (unsigned long long seed);

-XXH_errorcode 		XXH64_update (void* state, const void* input, unsigned int len);

-unsigned long long  XXH64_digest (void* state);

-

-/*

-These functions calculate the xxhash of an input provided in several small packets,

-as opposed to an input provided as a single block.

-

-It must be started with :

-void* XXHnn_init()

+/*
+   xxHash - Extremely Fast Hash algorithm
+   Header File
+   Copyright (C) 2012-2014, 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 : http://code.google.com/p/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.
+*/
+
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/*****************************
+   Type
+*****************************/
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+
+
+
+/*****************************
+   Simple Hash Functions
+*****************************/
+
+unsigned int       XXH32 (const void* input, unsigned int len, unsigned int seed);
+unsigned long long XXH64 (const void* input, unsigned int len, unsigned long long seed);
+
+/*
+XXH32() :
+    Calculate the 32-bits hash of sequence of length "len" stored at memory address "input".
+    The memory between input & input+len must be valid (allocated and read-accessible).
+    "seed" can be used to alter the result predictably.
+    This function successfully passes all SMHasher tests.
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
+    Note that "len" is type "int", which means it is limited to 2^31-1.
+    If your data is larger, use the advanced functions below.
+XXH64() :
+    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
+*/
+
+
+
+/*****************************
+   Advanced Hash Functions
+*****************************/
+
+void*         XXH32_init   (unsigned int seed);
+XXH_errorcode XXH32_update (void* state, const void* input, unsigned int len);
+unsigned int  XXH32_digest (void* state);
+
+void*         		XXH64_init   (unsigned long long seed);
+XXH_errorcode 		XXH64_update (void* state, const void* input, unsigned int len);
+unsigned long long  XXH64_digest (void* state);
+
+/*
+These functions calculate the xxhash of an input provided in several small packets,
+as opposed to an input provided as a single block.
+
+It must be started with :
+void* XXHnn_init()
 The function returns a pointer which holds the state of calculation.
-If the pointer is NULL, allocation has failed, so no state can be tracked.

-

-The state pointer must be provided as "void* state" parameter for XXHnn_update().

-XXHnn_update() can be called as many times as necessary.

-The user must provide a valid (allocated) input.

-The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.

-Note that "len" is type "int", which means it is limited to 2^31-1.

-If your data is larger, it is recommended to chunk your data into blocks

-of size for example 2^30 (1GB) to avoid any "int" overflow issue.

-

-Finally, you can end the calculation anytime, by using XXHnn_digest().

-This function returns the final nn-bits hash.

-You must provide the same "void* state" parameter created by XXHnn_init().

-Memory will be freed by XXHnn_digest().

-*/

-

-

-int           XXH32_sizeofState(void);

-XXH_errorcode XXH32_resetState(void* state, unsigned int seed);

-

-#define       XXH32_SIZEOFSTATE 48

-typedef struct { long long ll[(XXH32_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH32_stateSpace_t;

-

-int           XXH64_sizeofState(void);

-XXH_errorcode XXH64_resetState(void* state, unsigned long long seed);

-

-#define       XXH64_SIZEOFSTATE 88

-typedef struct { long long ll[(XXH64_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH64_stateSpace_t;

-

-/*

-These functions allow user application to make its own allocation for state.

-

-XXHnn_sizeofState() is used to know how much space must be allocated for the xxHash nn-bits state.

-Note that the state must be aligned to access 'long long' fields. Memory must be allocated and referenced by a pointer.

-This pointer must then be provided as 'state' into XXHnn_resetState(), which initializes the state.

-

-For static allocation purposes (such as allocation on stack, or freestanding systems without malloc()),

-use the structure XXHnn_stateSpace_t, which will ensure that memory space is large enough and correctly aligned to access 'long long' fields.

-*/

-

-

-unsigned int       XXH32_intermediateDigest (void* state);

-unsigned long long XXH64_intermediateDigest (void* state);

-/*

-These functions do the same as XXHnn_digest(), generating a nn-bit hash,

-but preserve memory context.

-This way, it becomes possible to generate intermediate hashes, and then continue feeding data with XXHnn_update().

-To free memory context, use XXHnn_digest(), or free().

-*/

-

-

-#if defined (__cplusplus)

-}

-#endif

+If the pointer is NULL, allocation has failed, so no state can be tracked.
+
+The state pointer must be provided as "void* state" parameter for XXHnn_update().
+XXHnn_update() can be called as many times as necessary.
+The user must provide a valid (allocated) input.
+The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
+Note that "len" is type "int", which means it is limited to 2^31-1.
+If your data is larger, it is recommended to chunk your data into blocks
+of size for example 2^30 (1GB) to avoid any "int" overflow issue.
+
+Finally, you can end the calculation anytime, by using XXHnn_digest().
+This function returns the final nn-bits hash.
+You must provide the same "void* state" parameter created by XXHnn_init().
+Memory will be freed by XXHnn_digest().
+*/
+
+
+int           XXH32_sizeofState(void);
+XXH_errorcode XXH32_resetState(void* state, unsigned int seed);
+
+#define       XXH32_SIZEOFSTATE 48
+typedef struct { long long ll[(XXH32_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH32_stateSpace_t;
+
+int           XXH64_sizeofState(void);
+XXH_errorcode XXH64_resetState(void* state, unsigned long long seed);
+
+#define       XXH64_SIZEOFSTATE 88
+typedef struct { long long ll[(XXH64_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH64_stateSpace_t;
+
+/*
+These functions allow user application to make its own allocation for state.
+
+XXHnn_sizeofState() is used to know how much space must be allocated for the xxHash nn-bits state.
+Note that the state must be aligned to access 'long long' fields. Memory must be allocated and referenced by a pointer.
+This pointer must then be provided as 'state' into XXHnn_resetState(), which initializes the state.
+
+For static allocation purposes (such as allocation on stack, or freestanding systems without malloc()),
+use the structure XXHnn_stateSpace_t, which will ensure that memory space is large enough and correctly aligned to access 'long long' fields.
+*/
+
+
+unsigned int       XXH32_intermediateDigest (void* state);
+unsigned long long XXH64_intermediateDigest (void* state);
+/*
+These functions do the same as XXHnn_digest(), generating a nn-bit hash,
+but preserve memory context.
+This way, it becomes possible to generate intermediate hashes, and then continue feeding data with XXHnn_update().
+To free memory context, use XXHnn_digest(), or free().
+*/
+
+
+#if defined (__cplusplus)
+}
+#endif