Outgoing side of packet counter for link quality reporting. Also some cleanup and a cluster mode build fix.

10 files changed, 1053 insertions, 1046 deletions

diff --git a/node/Buffer.hpp b/node/Buffer.hpp
index 1a478894..37f39e7b 100644
--- a/node/Buffer.hpp
+++ b/node/Buffer.hpp
@@ -79,8 +79,7 @@ public:
 	inline const_reverse_iterator rbegin() const { return const_reverse_iterator(begin()); }
 	inline const_reverse_iterator rend() const { return const_reverse_iterator(end()); }
 
-	Buffer()
-		throw() :
+	Buffer() :
 		_l(0)
 	{
 	}
@@ -419,87 +418,70 @@ public:
 	/**
 	 * Set buffer data length to zero
 	 */
-	inline void clear()
-		throw()
-	{
-		_l = 0;
-	}
+	inline void clear() { _l = 0; }
 
 	/**
 	 * Zero buffer up to size()
 	 */
-	inline void zero()
-		throw()
-	{
-		memset(_b,0,_l);
-	}
+	inline void zero() { memset(_b,0,_l); }
 
 	/**
 	 * Zero unused capacity area
 	 */
-	inline void zeroUnused()
-		throw()
-	{
-		memset(_b + _l,0,C - _l);
-	}
+	inline void zeroUnused() { memset(_b + _l,0,C - _l); }
 
 	/**
 	 * Unconditionally and securely zero buffer's underlying memory
 	 */
-	inline void burn()
-		throw()
-	{
-		Utils::burn(_b,sizeof(_b));
-	}
+	inline void burn() { Utils::burn(_b,sizeof(_b)); }
 
 	/**
 	 * @return Constant pointer to data in buffer
 	 */
-	inline const void *data() const throw() { return _b; }
+	inline const void *data() const { return _b; }
+
+	/**
+	 * @return Non-constant pointer to data in buffer
+	 */
+	inline void *unsafeData() { return _b; }
 
 	/**
 	 * @return Size of data in buffer
 	 */
-	inline unsigned int size() const throw() { return _l; }
+	inline unsigned int size() const { return _l; }
 
 	/**
 	 * @return Capacity of buffer
 	 */
-	inline unsigned int capacity() const throw() { return C; }
+	inline unsigned int capacity() const { return C; }
 
 	template<unsigned int C2>
 	inline bool operator==(const Buffer<C2> &b) const
-		throw()
 	{
 		return ((_l == b._l)&&(!memcmp(_b,b._b,_l)));
 	}
 	template<unsigned int C2>
 	inline bool operator!=(const Buffer<C2> &b) const
-		throw()
 	{
 		return ((_l != b._l)||(memcmp(_b,b._b,_l)));
 	}
 	template<unsigned int C2>
 	inline bool operator<(const Buffer<C2> &b) const
-		throw()
 	{
 		return (memcmp(_b,b._b,std::min(_l,b._l)) < 0);
 	}
 	template<unsigned int C2>
 	inline bool operator>(const Buffer<C2> &b) const
-		throw()
 	{
 		return (b < *this);
 	}
 	template<unsigned int C2>
 	inline bool operator<=(const Buffer<C2> &b) const
-		throw()
 	{
 		return !(b < *this);
 	}
 	template<unsigned int C2>
 	inline bool operator>=(const Buffer<C2> &b) const
-		throw()
 	{
 		return !(*this < b);
 	}
diff --git a/node/Cluster.cpp b/node/Cluster.cpp
index 00122402..52e03ffe 100644
--- a/node/Cluster.cpp
+++ b/node/Cluster.cpp
@@ -255,7 +255,7 @@ void Cluster::handleIncomingStateMessage(const void *msg,unsigned int len)
 		// One-time-use Poly1305 key from first 32 bytes of Salsa20 keystream (as per DJB/NaCl "standard")
 		char polykey[ZT_POLY1305_KEY_LEN];
 		memset(polykey,0,sizeof(polykey));
-		s20.encrypt12(polykey,polykey,sizeof(polykey));
+		s20.crypt12(polykey,polykey,sizeof(polykey));
 
 		// Compute 16-byte MAC
 		char mac[ZT_POLY1305_MAC_LEN];
@@ -267,7 +267,7 @@ void Cluster::handleIncomingStateMessage(const void *msg,unsigned int len)
 
 		// Decrypt!
 		dmsg.setSize(len - 24);
-		s20.decrypt12(reinterpret_cast<const char *>(msg) + 24,const_cast<void *>(dmsg.data()),dmsg.size());
+		s20.crypt12(reinterpret_cast<const char *>(msg) + 24,const_cast<void *>(dmsg.data()),dmsg.size());
 	}
 
 	if (dmsg.size() < 4)
@@ -954,10 +954,10 @@ void Cluster::_flush(uint16_t memberId)
 		// One-time-use Poly1305 key from first 32 bytes of Salsa20 keystream (as per DJB/NaCl "standard")
 		char polykey[ZT_POLY1305_KEY_LEN];
 		memset(polykey,0,sizeof(polykey));
-		s20.encrypt12(polykey,polykey,sizeof(polykey));
+		s20.crypt12(polykey,polykey,sizeof(polykey));
 
 		// Encrypt m.q in place
-		s20.encrypt12(reinterpret_cast<const char *>(m.q.data()) + 24,const_cast<char *>(reinterpret_cast<const char *>(m.q.data())) + 24,m.q.size() - 24);
+		s20.crypt12(reinterpret_cast<const char *>(m.q.data()) + 24,const_cast<char *>(reinterpret_cast<const char *>(m.q.data())) + 24,m.q.size() - 24);
 
 		// Add MAC for authentication (encrypt-then-MAC)
 		char mac[ZT_POLY1305_MAC_LEN];
diff --git a/node/IncomingPacket.cpp b/node/IncomingPacket.cpp
index b5b2bcb3..85b06d50 100644
--- a/node/IncomingPacket.cpp
+++ b/node/IncomingPacket.cpp
@@ -243,7 +243,7 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *RR,const bool alreadyAut
 							outp.append((uint8_t)Packet::VERB_HELLO);
 							outp.append((uint64_t)pid);
 							outp.append((uint8_t)Packet::ERROR_IDENTITY_COLLISION);
-							outp.armor(key,true);
+							outp.armor(key,true,_path->nextOutgoingCounter());
 							_path->send(RR,outp.data(),outp.size(),RR->node->now());
 						} else {
 							TRACE("rejected HELLO from %s(%s): packet failed authentication",id.address().toString().c_str(),_path->address().toString().c_str());
@@ -405,7 +405,7 @@ bool IncomingPacket::_doHELLO(const RuntimeEnvironment *RR,const bool alreadyAut
 		RR->topology->appendCertificateOfRepresentation(outp);
 		outp.setAt(corSizeAt,(uint16_t)(outp.size() - (corSizeAt + 2)));
 
-		outp.armor(peer->key(),true);
+		outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 		_path->send(RR,outp.data(),outp.size(),now);
 
 		peer->setRemoteVersion(protoVersion,vMajor,vMinor,vRevision); // important for this to go first so received() knows the version
@@ -584,7 +584,7 @@ bool IncomingPacket::_doWHOIS(const RuntimeEnvironment *RR,const SharedPtr<Peer>
 		}
 
 		if (count > 0) {
-			outp.armor(peer->key(),true);
+			outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 			_path->send(RR,outp.data(),outp.size(),RR->node->now());
 		}
 
@@ -610,7 +610,7 @@ bool IncomingPacket::_doRENDEZVOUS(const RuntimeEnvironment *RR,const SharedPtr<
 					const InetAddress atAddr(field(ZT_PROTO_VERB_RENDEZVOUS_IDX_ADDRESS,addrlen),addrlen,port);
 					if (RR->node->shouldUsePathForZeroTierTraffic(with,_path->localAddress(),atAddr)) {
 						RR->node->putPacket(_path->localAddress(),atAddr,"ABRE",4,2); // send low-TTL junk packet to 'open' local NAT(s) and stateful firewalls
-						rendezvousWith->attemptToContactAt(_path->localAddress(),atAddr,RR->node->now(),false);
+						rendezvousWith->attemptToContactAt(_path->localAddress(),atAddr,RR->node->now(),false,0);
 						TRACE("RENDEZVOUS from %s says %s might be at %s, sent verification attempt",peer->address().toString().c_str(),with.toString().c_str(),atAddr.toString().c_str());
 					} else {
 						TRACE("RENDEZVOUS from %s says %s might be at %s, ignoring since path is not suitable",peer->address().toString().c_str(),with.toString().c_str(),atAddr.toString().c_str());
@@ -732,7 +732,7 @@ bool IncomingPacket::_doEXT_FRAME(const RuntimeEnvironment *RR,const SharedPtr<P
 				outp.append((uint8_t)Packet::VERB_EXT_FRAME);
 				outp.append((uint64_t)packetId());
 				outp.append((uint64_t)nwid);
-				outp.armor(peer->key(),true);
+				outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 				_path->send(RR,outp.data(),outp.size(),RR->node->now());
 			}
 
@@ -762,7 +762,7 @@ bool IncomingPacket::_doECHO(const RuntimeEnvironment *RR,const SharedPtr<Peer>
 		outp.append((uint64_t)pid);
 		if (size() > ZT_PACKET_IDX_PAYLOAD)
 			outp.append(reinterpret_cast<const unsigned char *>(data()) + ZT_PACKET_IDX_PAYLOAD,size() - ZT_PACKET_IDX_PAYLOAD);
-		outp.armor(peer->key(),true);
+		outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 		_path->send(RR,outp.data(),outp.size(),RR->node->now());
 
 		peer->received(_path,hops(),pid,Packet::VERB_ECHO,0,Packet::VERB_NOP,false);
@@ -957,7 +957,7 @@ bool IncomingPacket::_doNETWORK_CONFIG_REQUEST(const RuntimeEnvironment *RR,cons
 			outp.append(requestPacketId);
 			outp.append((unsigned char)Packet::ERROR_UNSUPPORTED_OPERATION);
 			outp.append(nwid);
-			outp.armor(peer->key(),true);
+			outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 			_path->send(RR,outp.data(),outp.size(),RR->node->now());
 		}
 
@@ -984,7 +984,7 @@ bool IncomingPacket::_doNETWORK_CONFIG(const RuntimeEnvironment *RR,const Shared
 				outp.append((uint64_t)packetId());
 				outp.append((uint64_t)network->id());
 				outp.append((uint64_t)configUpdateId);
-				outp.armor(peer->key(),true);
+				outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 				_path->send(RR,outp.data(),outp.size(),RR->node->now());
 			}
 		}
@@ -1033,7 +1033,7 @@ bool IncomingPacket::_doMULTICAST_GATHER(const RuntimeEnvironment *RR,const Shar
 			outp.append((uint32_t)mg.adi());
 			const unsigned int gatheredLocally = RR->mc->gather(peer->address(),nwid,mg,outp,gatherLimit);
 			if (gatheredLocally > 0) {
-				outp.armor(peer->key(),true);
+				outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 				_path->send(RR,outp.data(),outp.size(),RR->node->now());
 			}
 
@@ -1140,7 +1140,7 @@ bool IncomingPacket::_doMULTICAST_FRAME(const RuntimeEnvironment *RR,const Share
 				outp.append((uint32_t)to.adi());
 				outp.append((unsigned char)0x02); // flag 0x02 = contains gather results
 				if (RR->mc->gather(peer->address(),nwid,to,outp,gatherLimit)) {
-					outp.armor(peer->key(),true);
+					outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 					_path->send(RR,outp.data(),outp.size(),RR->node->now());
 				}
 			}
@@ -1198,7 +1198,7 @@ bool IncomingPacket::_doPUSH_DIRECT_PATHS(const RuntimeEnvironment *RR,const Sha
 					if ( ((flags & ZT_PUSH_DIRECT_PATHS_FLAG_FORGET_PATH) == 0) && (!redundant) && (RR->node->shouldUsePathForZeroTierTraffic(peer->address(),_path->localAddress(),a)) ) {
 						if (++countPerScope[(int)a.ipScope()][0] <= ZT_PUSH_DIRECT_PATHS_MAX_PER_SCOPE_AND_FAMILY) {
 							TRACE("attempting to contact %s at pushed direct path %s",peer->address().toString().c_str(),a.toString().c_str());
-							peer->attemptToContactAt(InetAddress(),a,now,false);
+							peer->attemptToContactAt(InetAddress(),a,now,false,0);
 						} else {
 							TRACE("ignoring contact for %s at %s -- too many per scope",peer->address().toString().c_str(),a.toString().c_str());
 						}
@@ -1217,7 +1217,7 @@ bool IncomingPacket::_doPUSH_DIRECT_PATHS(const RuntimeEnvironment *RR,const Sha
 					if ( ((flags & ZT_PUSH_DIRECT_PATHS_FLAG_FORGET_PATH) == 0) && (!redundant) && (RR->node->shouldUsePathForZeroTierTraffic(peer->address(),_path->localAddress(),a)) ) {
 						if (++countPerScope[(int)a.ipScope()][1] <= ZT_PUSH_DIRECT_PATHS_MAX_PER_SCOPE_AND_FAMILY) {
 							TRACE("attempting to contact %s at pushed direct path %s",peer->address().toString().c_str(),a.toString().c_str());
-							peer->attemptToContactAt(InetAddress(),a,now,false);
+							peer->attemptToContactAt(InetAddress(),a,now,false,0);
 						} else {
 							TRACE("ignoring contact for %s at %s -- too many per scope",peer->address().toString().c_str(),a.toString().c_str());
 						}
@@ -1447,7 +1447,7 @@ void IncomingPacket::_sendErrorNeedCredentials(const RuntimeEnvironment *RR,cons
 		outp.append(packetId());
 		outp.append((uint8_t)Packet::ERROR_NEED_MEMBERSHIP_CERTIFICATE);
 		outp.append(nwid);
-		outp.armor(peer->key(),true);
+		outp.armor(peer->key(),true,_path->nextOutgoingCounter());
 		_path->send(RR,outp.data(),outp.size(),now);
 	}
 }
diff --git a/node/Node.cpp b/node/Node.cpp
index 6dc89387..35940d27 100644
--- a/node/Node.cpp
+++ b/node/Node.cpp
@@ -180,7 +180,7 @@ public:
 				for(unsigned long k=0,ptr=(unsigned long)RR->node->prng();k<(unsigned long)upstreamStableEndpoints->size();++k) {
 					const InetAddress &addr = (*upstreamStableEndpoints)[ptr++ % upstreamStableEndpoints->size()];
 					if (addr.ss_family == AF_INET) {
-						p->sendHELLO(InetAddress(),addr,_now);
+						p->sendHELLO(InetAddress(),addr,_now,0);
 						contacted = true;
 						break;
 					}
@@ -190,7 +190,7 @@ public:
 				for(unsigned long k=0,ptr=(unsigned long)RR->node->prng();k<(unsigned long)upstreamStableEndpoints->size();++k) {
 					const InetAddress &addr = (*upstreamStableEndpoints)[ptr++ % upstreamStableEndpoints->size()];
 					if (addr.ss_family == AF_INET6) {
-						p->sendHELLO(InetAddress(),addr,_now);
+						p->sendHELLO(InetAddress(),addr,_now,0);
 						contacted = true;
 						break;
 					}
@@ -200,7 +200,7 @@ public:
 			if ((!contacted)&&(_bestCurrentUpstream)) {
 				const SharedPtr<Path> up(_bestCurrentUpstream->getBestPath(_now,true));
 				if (up)
-					p->sendHELLO(up->localAddress(),up->address(),_now);
+					p->sendHELLO(up->localAddress(),up->address(),_now,up->nextOutgoingCounter());
 			}
 
 			lastReceiveFromUpstream = std::max(p->lastReceive(),lastReceiveFromUpstream);
diff --git a/node/Packet.cpp b/node/Packet.cpp
index 790f4b09..82a5d7ea 100644
--- a/node/Packet.cpp
+++ b/node/Packet.cpp
@@ -65,9 +65,9 @@ namespace {
    modification, are permitted provided that the following conditions are
    met:
 
-       * Redistributions of source code must retain the above copyright
+	   * 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
+	   * 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.
@@ -85,8 +85,8 @@ namespace {
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
+	- LZ4 homepage : http://www.lz4.org
+	- LZ4 source repository : https://github.com/lz4/lz4
 */
 
 /* --- Dependency --- */
@@ -101,9 +101,9 @@ namespace {
 
   The LZ4 compression library provides in-memory compression and decompression functions.
   Compression can be done in:
-    - a single step (described as Simple Functions)
-    - a single step, reusing a context (described in Advanced Functions)
-    - unbounded multiple steps (described as Streaming compression)
+	- a single step (described as Simple Functions)
+	- a single step, reusing a context (described in Advanced Functions)
+	- unbounded multiple steps (described as Streaming compression)
 
   lz4.h provides block compression functions. It gives full buffer control to user.
   Decompressing an lz4-compressed block also requires metadata (such as compressed size).
@@ -164,28 +164,28 @@ namespace {
 *  Simple Functions
 **************************************/
 /*! LZ4_compress_default() :
-    Compresses 'sourceSize' bytes from buffer 'source'
-    into already allocated 'dest' buffer of size 'maxDestSize'.
-    Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
-    It also runs faster, so it's a recommended setting.
-    If the function cannot compress 'source' into a more limited 'dest' budget,
-    compression stops *immediately*, and the function result is zero.
-    As a consequence, 'dest' content is not valid.
-    This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
-        sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
-        maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
-        return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
-              or 0 if compression fails */
+	Compresses 'sourceSize' bytes from buffer 'source'
+	into already allocated 'dest' buffer of size 'maxDestSize'.
+	Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
+	It also runs faster, so it's a recommended setting.
+	If the function cannot compress 'source' into a more limited 'dest' budget,
+	compression stops *immediately*, and the function result is zero.
+	As a consequence, 'dest' content is not valid.
+	This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
+	    sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
+	    maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
+	    return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
+	          or 0 if compression fails */
 //LZ4LIB_API int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
 
 /*! LZ4_decompress_safe() :
-    compressedSize : is the precise full size of the compressed block.
-    maxDecompressedSize : is the size of destination buffer, which must be already allocated.
-    return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
-             If 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, including malicious data packets.
-             It never writes outside output buffer, nor reads outside input buffer.
+	compressedSize : is the precise full size of the compressed block.
+	maxDecompressedSize : is the size of destination buffer, which must be already allocated.
+	return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
+	         If 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, including malicious data packets.
+	         It never writes outside output buffer, nor reads outside input buffer.
 */
 LZ4LIB_API int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
 
@@ -198,33 +198,33 @@ LZ4LIB_API int LZ4_decompress_safe (const char* source, char* dest, int compress
 
 /*!
 LZ4_compressBound() :
-    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 (destination buffer size).
-    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
-    Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
-        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
-        return : maximum output size in a "worst case" scenario
-              or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
+	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 (destination buffer size).
+	Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
+	Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
+	    inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
+	    return : maximum output size in a "worst case" scenario
+	          or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
 */
 LZ4LIB_API int LZ4_compressBound(int inputSize);
 
 /*!
 LZ4_compress_fast() :
-    Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
-    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
-    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
-    An acceleration value of "1" is the same as regular LZ4_compress_default()
-    Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
+	Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
+	The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
+	It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
+	An acceleration value of "1" is the same as regular LZ4_compress_default()
+	Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
 */
 LZ4LIB_API int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
 
 
 /*!
 LZ4_compress_fast_extState() :
-    Same compression function, just using an externally allocated memory space to store compression state.
-    Use LZ4_sizeofState() to know how much memory must be allocated,
-    and allocate it on 8-bytes boundaries (using malloc() typically).
-    Then, provide it as 'void* state' to compression function.
+	Same compression function, just using an externally allocated memory space to store compression state.
+	Use LZ4_sizeofState() to know how much memory must be allocated,
+	and allocate it on 8-bytes boundaries (using malloc() typically).
+	Then, provide it as 'void* state' to compression function.
 */
 //LZ4LIB_API int LZ4_sizeofState(void);
 LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
@@ -232,42 +232,42 @@ LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* source, char
 
 /*!
 LZ4_compress_destSize() :
-    Reverse the logic, by compressing as much data as possible from 'source' buffer
-    into already allocated buffer 'dest' of size 'targetDestSize'.
-    This function either compresses the entire 'source' content into 'dest' if it's large enough,
-    or fill 'dest' buffer completely with as much data as possible from 'source'.
-        *sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
-                         New value is necessarily <= old value.
-        return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
-              or 0 if compression fails
+	Reverse the logic, by compressing as much data as possible from 'source' buffer
+	into already allocated buffer 'dest' of size 'targetDestSize'.
+	This function either compresses the entire 'source' content into 'dest' if it's large enough,
+	or fill 'dest' buffer completely with as much data as possible from 'source'.
+	    *sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
+	                     New value is necessarily <= old value.
+	    return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
+	          or 0 if compression fails
 */
 //LZ4LIB_API int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
 
 
 /*!
 LZ4_decompress_fast() :
-    originalSize : is the original and therefore uncompressed size
-    return : the number of bytes read from the source buffer (in other words, the compressed size)
-             If the source stream is detected malformed, the function will stop decoding and return a negative result.
-             Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
-    note : This function fully respect memory boundaries for properly formed compressed data.
-           It is a bit faster than LZ4_decompress_safe().
-           However, it does not provide any protection against intentionally modified data stream (malicious input).
-           Use this function in trusted environment only (data to decode comes from a trusted source).
+	originalSize : is the original and therefore uncompressed size
+	return : the number of bytes read from the source buffer (in other words, the compressed size)
+	         If the source stream is detected malformed, the function will stop decoding and return a negative result.
+	         Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
+	note : This function fully respect memory boundaries for properly formed compressed data.
+	       It is a bit faster than LZ4_decompress_safe().
+	       However, it does not provide any protection against intentionally modified data stream (malicious input).
+	       Use this function in trusted environment only (data to decode comes from a trusted source).
 */
 //LZ4LIB_API int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
 
 /*!
 LZ4_decompress_safe_partial() :
-    This function decompress a compressed block of size 'compressedSize' at position 'source'
-    into destination buffer 'dest' of size 'maxDecompressedSize'.
-    The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
-    reducing decompression time.
-    return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
-       Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
-             Always control how many bytes were decoded.
-             If the source stream is detected malformed, the function will stop decoding and return a negative result.
-             This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
+	This function decompress a compressed block of size 'compressedSize' at position 'source'
+	into destination buffer 'dest' of size 'maxDecompressedSize'.
+	The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
+	reducing decompression time.
+	return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
+	   Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
+	         Always control how many bytes were decoded.
+	         If the source stream is detected malformed, the function will stop decoding and return a negative result.
+	         This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
 */
 //LZ4LIB_API int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
 
@@ -336,20 +336,20 @@ typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* incomplete type (defin
 
 /*!
 LZ4_decompress_*_continue() :
-    These decoding functions allow decompression of multiple blocks in "streaming" mode.
-    Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
-    In the case of a ring buffers, decoding buffer must be either :
-    - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
-      In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
-    - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
-      maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
-      In which case, encoding and decoding buffers do not need to be synchronized,
-      and encoding ring buffer can have any size, including small ones ( < 64 KB).
-    - _At least_ 64 KB + 8 bytes + maxBlockSize.
-      In which case, encoding and decoding buffers do not need to be synchronized,
-      and encoding ring buffer can have any size, including larger than decoding buffer.
-    Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
-    and indicate where it is saved using LZ4_setStreamDecode()
+	These decoding functions allow decompression of multiple blocks in "streaming" mode.
+	Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
+	In the case of a ring buffers, decoding buffer must be either :
+	- Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
+	  In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
+	- Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
+	  maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
+	  In which case, encoding and decoding buffers do not need to be synchronized,
+	  and encoding ring buffer can have any size, including small ones ( < 64 KB).
+	- _At least_ 64 KB + 8 bytes + maxBlockSize.
+	  In which case, encoding and decoding buffers do not need to be synchronized,
+	  and encoding ring buffer can have any size, including larger than decoding buffer.
+	Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
+	and indicate where it is saved using LZ4_setStreamDecode()
 */
 //LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
 //LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
@@ -382,37 +382,37 @@ LZ4_decompress_*_continue() :
 //#include <stdint.h>
 
 typedef struct {
-    uint32_t hashTable[LZ4_HASH_SIZE_U32];
-    uint32_t currentOffset;
-    uint32_t initCheck;
-    const uint8_t* dictionary;
-    uint8_t* bufferStart;   /* obsolete, used for slideInputBuffer */
-    uint32_t dictSize;
+	uint32_t hashTable[LZ4_HASH_SIZE_U32];
+	uint32_t currentOffset;
+	uint32_t initCheck;
+	const uint8_t* dictionary;
+	uint8_t* bufferStart;   /* obsolete, used for slideInputBuffer */
+	uint32_t dictSize;
 } LZ4_stream_t_internal;
 
 typedef struct {
-    const uint8_t* externalDict;
-    size_t extDictSize;
-    const uint8_t* prefixEnd;
-    size_t prefixSize;
+	const uint8_t* externalDict;
+	size_t extDictSize;
+	const uint8_t* prefixEnd;
+	size_t prefixSize;
 } LZ4_streamDecode_t_internal;
 
 #else
 
 typedef struct {
-    unsigned int hashTable[LZ4_HASH_SIZE_U32];
-    unsigned int currentOffset;
-    unsigned int initCheck;
-    const unsigned char* dictionary;
-    unsigned char* bufferStart;   /* obsolete, used for slideInputBuffer */
-    unsigned int dictSize;
+	unsigned int hashTable[LZ4_HASH_SIZE_U32];
+	unsigned int currentOffset;
+	unsigned int initCheck;
+	const unsigned char* dictionary;
+	unsigned char* bufferStart;   /* obsolete, used for slideInputBuffer */
+	unsigned int dictSize;
 } LZ4_stream_t_internal;
 
 typedef struct {
-    const unsigned char* externalDict;
-    size_t extDictSize;
-    const unsigned char* prefixEnd;
-    size_t prefixSize;
+	const unsigned char* externalDict;
+	size_t extDictSize;
+	const unsigned char* prefixEnd;
+	size_t prefixSize;
 } LZ4_streamDecode_t_internal;
 
 #endif
@@ -428,8 +428,8 @@ typedef struct {
 #define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
 #define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
 union LZ4_stream_u {
-    unsigned long long table[LZ4_STREAMSIZE_U64];
-    LZ4_stream_t_internal internal_donotuse;
+	unsigned long long table[LZ4_STREAMSIZE_U64];
+	LZ4_stream_t_internal internal_donotuse;
 } ;  /* previously typedef'd to LZ4_stream_t */
 
 
@@ -444,8 +444,8 @@ union LZ4_stream_u {
 #define LZ4_STREAMDECODESIZE_U64  4
 #define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
 union LZ4_streamDecode_u {
-    unsigned long long table[LZ4_STREAMDECODESIZE_U64];
-    LZ4_streamDecode_t_internal internal_donotuse;
+	unsigned long long table[LZ4_STREAMDECODESIZE_U64];
+	LZ4_streamDecode_t_internal internal_donotuse;
 } ;   /* previously typedef'd to LZ4_streamDecode_t */
 
 /* lz4.c ------------------------------------------------------------------ */
@@ -460,9 +460,9 @@ union LZ4_streamDecode_u {
    modification, are permitted provided that the following conditions are
    met:
 
-       * Redistributions of source code must retain the above copyright
+	   * 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
+	   * 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.
@@ -480,8 +480,8 @@ union LZ4_streamDecode_u {
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
+	- LZ4 homepage : http://www.lz4.org
+	- LZ4 source repository : https://github.com/lz4/lz4
 */
 
 
@@ -617,8 +617,8 @@ typedef uintptr_t reg_t;
 **************************************/
 static unsigned LZ4_isLittleEndian(void)
 {
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
-    return one.c[0];
+	const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
+	return one.c[0];
 }
 
 #if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
@@ -648,27 +648,27 @@ static void LZ4_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = val
 
 static U16 LZ4_read16(const void* memPtr)
 {
-    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
+	U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
 }
 
 static U32 LZ4_read32(const void* memPtr)
 {
-    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
+	U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
 }
 
 static reg_t LZ4_read_ARCH(const void* memPtr)
 {
-    reg_t val; memcpy(&val, memPtr, sizeof(val)); return val;
+	reg_t val; memcpy(&val, memPtr, sizeof(val)); return val;
 }
 
 static void LZ4_write16(void* memPtr, U16 value)
 {
-    memcpy(memPtr, &value, sizeof(value));
+	memcpy(memPtr, &value, sizeof(value));
 }
 
 static void LZ4_write32(void* memPtr, U32 value)
 {
-    memcpy(memPtr, &value, sizeof(value));
+	memcpy(memPtr, &value, sizeof(value));
 }
 
 #endif /* LZ4_FORCE_MEMORY_ACCESS */
@@ -676,38 +676,38 @@ static void LZ4_write32(void* memPtr, U32 value)
 
 static U16 LZ4_readLE16(const void* memPtr)
 {
-    if (LZ4_isLittleEndian()) {
-        return LZ4_read16(memPtr);
-    } else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)((U16)p[0] + (p[1]<<8));
-    }
+	if (LZ4_isLittleEndian()) {
+	    return LZ4_read16(memPtr);
+	} else {
+	    const BYTE* p = (const BYTE*)memPtr;
+	    return (U16)((U16)p[0] + (p[1]<<8));
+	}
 }
 
 static void LZ4_writeLE16(void* memPtr, U16 value)
 {
-    if (LZ4_isLittleEndian()) {
-        LZ4_write16(memPtr, value);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE) value;
-        p[1] = (BYTE)(value>>8);
-    }
+	if (LZ4_isLittleEndian()) {
+	    LZ4_write16(memPtr, value);
+	} else {
+	    BYTE* p = (BYTE*)memPtr;
+	    p[0] = (BYTE) value;
+	    p[1] = (BYTE)(value>>8);
+	}
 }
 
 static void LZ4_copy8(void* dst, const void* src)
 {
-    memcpy(dst,src,8);
+	memcpy(dst,src,8);
 }
 
 /* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
 static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd)
 {
-    BYTE* d = (BYTE*)dstPtr;
-    const BYTE* s = (const BYTE*)srcPtr;
-    BYTE* const e = (BYTE*)dstEnd;
+	BYTE* d = (BYTE*)dstPtr;
+	const BYTE* s = (const BYTE*)srcPtr;
+	BYTE* const e = (BYTE*)dstEnd;
 
-    do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
+	do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
 }
 
 
@@ -745,78 +745,78 @@ static const int LZ4_minLength = (MFLIMIT+1);
 **************************************/
 static unsigned LZ4_NbCommonBytes (register reg_t val)
 {
-    if (LZ4_isLittleEndian()) {
-        if (sizeof(val)==8) {
+	if (LZ4_isLittleEndian()) {
+	    if (sizeof(val)==8) {
 #       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanForward64( &r, (U64)val );
-            return (int)(r>>3);
+	        unsigned long r = 0;
+	        _BitScanForward64( &r, (U64)val );
+	        return (int)(r>>3);
 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_ctzll((U64)val) >> 3);
+	        return (__builtin_ctzll((U64)val) >> 3);
 #       else
-            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
-            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
+	        static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
+	        return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
 #       endif
-        } else /* 32 bits */ {
+	    } else /* 32 bits */ {
 #       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r;
-            _BitScanForward( &r, (U32)val );
-            return (int)(r>>3);
+	        unsigned long r;
+	        _BitScanForward( &r, (U32)val );
+	        return (int)(r>>3);
 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_ctz((U32)val) >> 3);
+	        return (__builtin_ctz((U32)val) >> 3);
 #       else
-            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
-            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
+	        static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
+	        return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
 #       endif
-        }
-    } else   /* Big Endian CPU */ {
-        if (sizeof(val)==8) {
+	    }
+	} else   /* Big Endian CPU */ {
+	    if (sizeof(val)==8) {
 #       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanReverse64( &r, val );
-            return (unsigned)(r>>3);
+	        unsigned long r = 0;
+	        _BitScanReverse64( &r, val );
+	        return (unsigned)(r>>3);
 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_clzll((U64)val) >> 3);
+	        return (__builtin_clzll((U64)val) >> 3);
 #       else
-            unsigned r;
-            if (!(val>>32)) { r=4; } else { r=0; val>>=32; }
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-            r += (!val);
-            return r;
+	        unsigned r;
+	        if (!(val>>32)) { r=4; } else { r=0; val>>=32; }
+	        if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
+	        r += (!val);
+	        return r;
 #       endif
-        } else /* 32 bits */ {
+	    } else /* 32 bits */ {
 #       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanReverse( &r, (unsigned long)val );
-            return (unsigned)(r>>3);
+	        unsigned long r = 0;
+	        _BitScanReverse( &r, (unsigned long)val );
+	        return (unsigned)(r>>3);
 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_clz((U32)val) >> 3);
+	        return (__builtin_clz((U32)val) >> 3);
 #       else
-            unsigned r;
-            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
-            r += (!val);
-            return r;
+	        unsigned r;
+	        if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
+	        r += (!val);
+	        return r;
 #       endif
-        }
-    }
+	    }
+	}
 }
 
 #define STEPSIZE sizeof(reg_t)
 static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
 {
-    const BYTE* const pStart = pIn;
-
-    while (likely(pIn<pInLimit-(STEPSIZE-1))) {
-        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
-        pIn += LZ4_NbCommonBytes(diff);
-        return (unsigned)(pIn - pStart);
-    }
-
-    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (unsigned)(pIn - pStart);
+	const BYTE* const pStart = pIn;
+
+	while (likely(pIn<pInLimit-(STEPSIZE-1))) {
+	    reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
+	    if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
+	    pIn += LZ4_NbCommonBytes(diff);
+	    return (unsigned)(pIn - pStart);
+	}
+
+	if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
+	if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
+	if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
+	return (unsigned)(pIn - pStart);
 }
 
 
@@ -855,315 +855,315 @@ int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }
 ********************************/
 static U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
 {
-    if (tableType == byU16)
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
-    else
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
+	if (tableType == byU16)
+	    return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
+	else
+	    return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
 }
 
 static U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
 {
-    static const U64 prime5bytes = 889523592379ULL;
-    static const U64 prime8bytes = 11400714785074694791ULL;
-    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
-    if (LZ4_isLittleEndian())
-        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
-    else
-        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
+	static const U64 prime5bytes = 889523592379ULL;
+	static const U64 prime8bytes = 11400714785074694791ULL;
+	const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
+	if (LZ4_isLittleEndian())
+	    return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
+	else
+	    return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
 }
 
 FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
 {
-    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
-    return LZ4_hash4(LZ4_read32(p), tableType);
+	if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
+	return LZ4_hash4(LZ4_read32(p), tableType);
 }
 
 static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t const tableType, const BYTE* srcBase)
 {
-    switch (tableType)
-    {
-    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
-    }
+	switch (tableType)
+	{
+	case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
+	case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
+	case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
+	}
 }
 
 FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
 {
-    U32 const h = LZ4_hashPosition(p, tableType);
-    LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
+	U32 const h = LZ4_hashPosition(p, tableType);
+	LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
 }
 
 static const BYTE* LZ4_getPositionOnHash(U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase)
 {
-    if (tableType == byPtr) { const BYTE** hashTable = (const BYTE**) tableBase; return hashTable[h]; }
-    if (tableType == byU32) { const U32* const hashTable = (U32*) tableBase; return hashTable[h] + srcBase; }
-    { const U16* const hashTable = (U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
+	if (tableType == byPtr) { const BYTE** hashTable = (const BYTE**) tableBase; return hashTable[h]; }
+	if (tableType == byU32) { const U32* const hashTable = (U32*) tableBase; return hashTable[h] + srcBase; }
+	{ const U16* const hashTable = (U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
 }
 
 FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
 {
-    U32 const h = LZ4_hashPosition(p, tableType);
-    return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
+	U32 const h = LZ4_hashPosition(p, tableType);
+	return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
 }
 
 
 /** LZ4_compress_generic() :
-    inlined, to ensure branches are decided at compilation time */
+	inlined, to ensure branches are decided at compilation time */
 FORCE_INLINE int LZ4_compress_generic(
-                 LZ4_stream_t_internal* const cctx,
-                 const char* const source,
-                 char* const dest,
-                 const int inputSize,
-                 const int maxOutputSize,
-                 const limitedOutput_directive outputLimited,
-                 const tableType_t tableType,
-                 const dict_directive dict,
-                 const dictIssue_directive dictIssue,
-                 const U32 acceleration)
+	             LZ4_stream_t_internal* const cctx,
+	             const char* const source,
+	             char* const dest,
+	             const int inputSize,
+	             const int maxOutputSize,
+	             const limitedOutput_directive outputLimited,
+	             const tableType_t tableType,
+	             const dict_directive dict,
+	             const dictIssue_directive dictIssue,
+	             const U32 acceleration)
 {
-    const BYTE* ip = (const BYTE*) source;
-    const BYTE* base;
-    const BYTE* lowLimit;
-    const BYTE* const lowRefLimit = ip - cctx->dictSize;
-    const BYTE* const dictionary = cctx->dictionary;
-    const BYTE* const dictEnd = dictionary + cctx->dictSize;
-    const ptrdiff_t dictDelta = dictEnd - (const BYTE*)source;
-    const BYTE* anchor = (const BYTE*) source;
-    const BYTE* const iend = ip + inputSize;
-    const BYTE* const mflimit = iend - MFLIMIT;
-    const BYTE* const matchlimit = iend - LASTLITERALS;
-
-    BYTE* op = (BYTE*) dest;
-    BYTE* const olimit = op + maxOutputSize;
-
-    U32 forwardH;
-
-    /* Init conditions */
-    if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0;   /* Unsupported inputSize, too large (or negative) */
-    switch(dict)
-    {
-    case noDict:
-    default:
-        base = (const BYTE*)source;
-        lowLimit = (const BYTE*)source;
-        break;
-    case withPrefix64k:
-        base = (const BYTE*)source - cctx->currentOffset;
-        lowLimit = (const BYTE*)source - cctx->dictSize;
-        break;
-    case usingExtDict:
-        base = (const BYTE*)source - cctx->currentOffset;
-        lowLimit = (const BYTE*)source;
-        break;
-    }
-    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
-    if (inputSize<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
-
-    /* First Byte */
-    LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-    ip++; forwardH = LZ4_hashPosition(ip, tableType);
-
-    /* Main Loop */
-    for ( ; ; ) {
-        ptrdiff_t refDelta = 0;
-        const BYTE* match;
-        BYTE* token;
-
-        /* Find a match */
-        {   const BYTE* forwardIp = ip;
-            unsigned step = 1;
-            unsigned searchMatchNb = acceleration << LZ4_skipTrigger;
-            do {
-                U32 const h = forwardH;
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimit)) goto _last_literals;
-
-                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
-                if (dict==usingExtDict) {
-                    if (match < (const BYTE*)source) {
-                        refDelta = dictDelta;
-                        lowLimit = dictionary;
-                    } else {
-                        refDelta = 0;
-                        lowLimit = (const BYTE*)source;
-                }   }
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
-
-            } while ( ((dictIssue==dictSmall) ? (match < lowRefLimit) : 0)
-                || ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
-                || (LZ4_read32(match+refDelta) != LZ4_read32(ip)) );
-        }
-
-        /* Catch up */
-        while (((ip>anchor) & (match+refDelta > lowLimit)) && (unlikely(ip[-1]==match[refDelta-1]))) { ip--; match--; }
-
-        /* Encode Literals */
-        {   unsigned const litLength = (unsigned)(ip - anchor);
-            token = op++;
-            if ((outputLimited) &&  /* Check output buffer overflow */
-                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)))
-                return 0;
-            if (litLength >= RUN_MASK) {
-                int len = (int)litLength-RUN_MASK;
-                *token = (RUN_MASK<<ML_BITS);
-                for(; len >= 255 ; len-=255) *op++ = 255;
-                *op++ = (BYTE)len;
-            }
-            else *token = (BYTE)(litLength<<ML_BITS);
-
-            /* Copy Literals */
-            LZ4_wildCopy(op, anchor, op+litLength);
-            op+=litLength;
-        }
+	const BYTE* ip = (const BYTE*) source;
+	const BYTE* base;
+	const BYTE* lowLimit;
+	const BYTE* const lowRefLimit = ip - cctx->dictSize;
+	const BYTE* const dictionary = cctx->dictionary;
+	const BYTE* const dictEnd = dictionary + cctx->dictSize;
+	const ptrdiff_t dictDelta = dictEnd - (const BYTE*)source;
+	const BYTE* anchor = (const BYTE*) source;
+	const BYTE* const iend = ip + inputSize;
+	const BYTE* const mflimit = iend - MFLIMIT;
+	const BYTE* const matchlimit = iend - LASTLITERALS;
+
+	BYTE* op = (BYTE*) dest;
+	BYTE* const olimit = op + maxOutputSize;
+
+	U32 forwardH;
+
+	/* Init conditions */
+	if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0;   /* Unsupported inputSize, too large (or negative) */
+	switch(dict)
+	{
+	case noDict:
+	default:
+	    base = (const BYTE*)source;
+	    lowLimit = (const BYTE*)source;
+	    break;
+	case withPrefix64k:
+	    base = (const BYTE*)source - cctx->currentOffset;
+	    lowLimit = (const BYTE*)source - cctx->dictSize;
+	    break;
+	case usingExtDict:
+	    base = (const BYTE*)source - cctx->currentOffset;
+	    lowLimit = (const BYTE*)source;
+	    break;
+	}
+	if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
+	if (inputSize<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
+
+	/* First Byte */
+	LZ4_putPosition(ip, cctx->hashTable, tableType, base);
+	ip++; forwardH = LZ4_hashPosition(ip, tableType);
+
+	/* Main Loop */
+	for ( ; ; ) {
+	    ptrdiff_t refDelta = 0;
+	    const BYTE* match;
+	    BYTE* token;
+
+	    /* Find a match */
+	    {   const BYTE* forwardIp = ip;
+	        unsigned step = 1;
+	        unsigned searchMatchNb = acceleration << LZ4_skipTrigger;
+	        do {
+	            U32 const h = forwardH;
+	            ip = forwardIp;
+	            forwardIp += step;
+	            step = (searchMatchNb++ >> LZ4_skipTrigger);
+
+	            if (unlikely(forwardIp > mflimit)) goto _last_literals;
+
+	            match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
+	            if (dict==usingExtDict) {
+	                if (match < (const BYTE*)source) {
+	                    refDelta = dictDelta;
+	                    lowLimit = dictionary;
+	                } else {
+	                    refDelta = 0;
+	                    lowLimit = (const BYTE*)source;
+	            }   }
+	            forwardH = LZ4_hashPosition(forwardIp, tableType);
+	            LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
+
+	        } while ( ((dictIssue==dictSmall) ? (match < lowRefLimit) : 0)
+	            || ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
+	            || (LZ4_read32(match+refDelta) != LZ4_read32(ip)) );
+	    }
+
+	    /* Catch up */
+	    while (((ip>anchor) & (match+refDelta > lowLimit)) && (unlikely(ip[-1]==match[refDelta-1]))) { ip--; match--; }
+
+	    /* Encode Literals */
+	    {   unsigned const litLength = (unsigned)(ip - anchor);
+	        token = op++;
+	        if ((outputLimited) &&  /* Check output buffer overflow */
+	            (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)))
+	            return 0;
+	        if (litLength >= RUN_MASK) {
+	            int len = (int)litLength-RUN_MASK;
+	            *token = (RUN_MASK<<ML_BITS);
+	            for(; len >= 255 ; len-=255) *op++ = 255;
+	            *op++ = (BYTE)len;
+	        }
+	        else *token = (BYTE)(litLength<<ML_BITS);
+
+	        /* Copy Literals */
+	        LZ4_wildCopy(op, anchor, op+litLength);
+	        op+=litLength;
+	    }
 
 _next_match:
-        /* Encode Offset */
-        LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
-
-        /* Encode MatchLength */
-        {   unsigned matchCode;
-
-            if ((dict==usingExtDict) && (lowLimit==dictionary)) {
-                const BYTE* limit;
-                match += refDelta;
-                limit = ip + (dictEnd-match);
-                if (limit > matchlimit) limit = matchlimit;
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
-                ip += MINMATCH + matchCode;
-                if (ip==limit) {
-                    unsigned const more = LZ4_count(ip, (const BYTE*)source, matchlimit);
-                    matchCode += more;
-                    ip += more;
-                }
-            } else {
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
-                ip += MINMATCH + matchCode;
-            }
-
-            if ( outputLimited &&    /* Check output buffer overflow */
-                (unlikely(op + (1 + LASTLITERALS) + (matchCode>>8) > olimit)) )
-                return 0;
-            if (matchCode >= ML_MASK) {
-                *token += ML_MASK;
-                matchCode -= ML_MASK;
-                LZ4_write32(op, 0xFFFFFFFF);
-                while (matchCode >= 4*255) op+=4, LZ4_write32(op, 0xFFFFFFFF), matchCode -= 4*255;
-                op += matchCode / 255;
-                *op++ = (BYTE)(matchCode % 255);
-            } else
-                *token += (BYTE)(matchCode);
-        }
-
-        anchor = ip;
-
-        /* Test end of chunk */
-        if (ip > mflimit) break;
-
-        /* Fill table */
-        LZ4_putPosition(ip-2, cctx->hashTable, tableType, base);
-
-        /* Test next position */
-        match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
-        if (dict==usingExtDict) {
-            if (match < (const BYTE*)source) {
-                refDelta = dictDelta;
-                lowLimit = dictionary;
-            } else {
-                refDelta = 0;
-                lowLimit = (const BYTE*)source;
-        }   }
-        LZ4_putPosition(ip, cctx->hashTable, tableType, base);
-        if ( ((dictIssue==dictSmall) ? (match>=lowRefLimit) : 1)
-            && (match+MAX_DISTANCE>=ip)
-            && (LZ4_read32(match+refDelta)==LZ4_read32(ip)) )
-        { token=op++; *token=0; goto _next_match; }
-
-        /* Prepare next loop */
-        forwardH = LZ4_hashPosition(++ip, tableType);
-    }
+	    /* Encode Offset */
+	    LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
+
+	    /* Encode MatchLength */
+	    {   unsigned matchCode;
+
+	        if ((dict==usingExtDict) && (lowLimit==dictionary)) {
+	            const BYTE* limit;
+	            match += refDelta;
+	            limit = ip + (dictEnd-match);
+	            if (limit > matchlimit) limit = matchlimit;
+	            matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
+	            ip += MINMATCH + matchCode;
+	            if (ip==limit) {
+	                unsigned const more = LZ4_count(ip, (const BYTE*)source, matchlimit);
+	                matchCode += more;
+	                ip += more;
+	            }
+	        } else {
+	            matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
+	            ip += MINMATCH + matchCode;
+	        }
+
+	        if ( outputLimited &&    /* Check output buffer overflow */
+	            (unlikely(op + (1 + LASTLITERALS) + (matchCode>>8) > olimit)) )
+	            return 0;
+	        if (matchCode >= ML_MASK) {
+	            *token += ML_MASK;
+	            matchCode -= ML_MASK;
+	            LZ4_write32(op, 0xFFFFFFFF);
+	            while (matchCode >= 4*255) op+=4, LZ4_write32(op, 0xFFFFFFFF), matchCode -= 4*255;
+	            op += matchCode / 255;
+	            *op++ = (BYTE)(matchCode % 255);
+	        } else
+	            *token += (BYTE)(matchCode);
+	    }
+
+	    anchor = ip;
+
+	    /* Test end of chunk */
+	    if (ip > mflimit) break;
+
+	    /* Fill table */
+	    LZ4_putPosition(ip-2, cctx->hashTable, tableType, base);
+
+	    /* Test next position */
+	    match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
+	    if (dict==usingExtDict) {
+	        if (match < (const BYTE*)source) {
+	            refDelta = dictDelta;
+	            lowLimit = dictionary;
+	        } else {
+	            refDelta = 0;
+	            lowLimit = (const BYTE*)source;
+	    }   }
+	    LZ4_putPosition(ip, cctx->hashTable, tableType, base);
+	    if ( ((dictIssue==dictSmall) ? (match>=lowRefLimit) : 1)
+	        && (match+MAX_DISTANCE>=ip)
+	        && (LZ4_read32(match+refDelta)==LZ4_read32(ip)) )
+	    { token=op++; *token=0; goto _next_match; }
+
+	    /* Prepare next loop */
+	    forwardH = LZ4_hashPosition(++ip, tableType);
+	}
 
 _last_literals:
-    /* Encode Last Literals */
-    {   size_t const lastRun = (size_t)(iend - anchor);
-        if ( (outputLimited) &&  /* Check output buffer overflow */
-            ((op - (BYTE*)dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize) )
-            return 0;
-        if (lastRun >= RUN_MASK) {
-            size_t accumulator = lastRun - RUN_MASK;
-            *op++ = RUN_MASK << ML_BITS;
-            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRun<<ML_BITS);
-        }
-        memcpy(op, anchor, lastRun);
-        op += lastRun;
-    }
-
-    /* End */
-    return (int) (((char*)op)-dest);
+	/* Encode Last Literals */
+	{   size_t const lastRun = (size_t)(iend - anchor);
+	    if ( (outputLimited) &&  /* Check output buffer overflow */
+	        ((op - (BYTE*)dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize) )
+	        return 0;
+	    if (lastRun >= RUN_MASK) {
+	        size_t accumulator = lastRun - RUN_MASK;
+	        *op++ = RUN_MASK << ML_BITS;
+	        for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
+	        *op++ = (BYTE) accumulator;
+	    } else {
+	        *op++ = (BYTE)(lastRun<<ML_BITS);
+	    }
+	    memcpy(op, anchor, lastRun);
+	    op += lastRun;
+	}
+
+	/* End */
+	return (int) (((char*)op)-dest);
 }
 
 
 int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
 {
-    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
-    LZ4_resetStream((LZ4_stream_t*)state);
-    if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
-
-    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
-        if (inputSize < LZ4_64Klimit)
-            return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited,                        byU16, noDict, noDictIssue, acceleration);
-        else
-            return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
-    } else {
-        if (inputSize < LZ4_64Klimit)
-            return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput,                        byU16, noDict, noDictIssue, acceleration);
-        else
-            return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
-    }
+	LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
+	LZ4_resetStream((LZ4_stream_t*)state);
+	if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
+
+	if (maxOutputSize >= LZ4_compressBound(inputSize)) {
+	    if (inputSize < LZ4_64Klimit)
+	        return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited,                        byU16, noDict, noDictIssue, acceleration);
+	    else
+	        return LZ4_compress_generic(ctx, source, dest, inputSize,             0,    notLimited, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
+	} else {
+	    if (inputSize < LZ4_64Klimit)
+	        return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput,                        byU16, noDict, noDictIssue, acceleration);
+	    else
+	        return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
+	}
 }
 
 
 int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
 {
 #if (HEAPMODE)
-    void* ctxPtr = ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
+	void* ctxPtr = ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
 #else
-    LZ4_stream_t ctx;
-    void* const ctxPtr = &ctx;
+	LZ4_stream_t ctx;
+	void* const ctxPtr = &ctx;
 #endif
 
-    int const result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
+	int const result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
 
 #if (HEAPMODE)
-    FREEMEM(ctxPtr);
+	FREEMEM(ctxPtr);
 #endif
-    return result;
+	return result;
 }
 
 #if 0
 int LZ4_compress_default(const char* source, char* dest, int inputSize, int maxOutputSize)
 {
-    return LZ4_compress_fast(source, dest, inputSize, maxOutputSize, 1);
+	return LZ4_compress_fast(source, dest, inputSize, maxOutputSize, 1);
 }
 
 /* hidden debug function */
 /* strangely enough, gcc generates faster code when this function is uncommented, even if unused */
 int LZ4_compress_fast_force(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
 {
-    LZ4_stream_t ctx;
-    LZ4_resetStream(&ctx);
+	LZ4_stream_t ctx;
+	LZ4_resetStream(&ctx);
 
-    if (inputSize < LZ4_64Klimit)
-        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, byU16,                        noDict, noDictIssue, acceleration);
-    else
-        return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, sizeof(void*)==8 ? byU32 : byPtr, noDict, noDictIssue, acceleration);
+	if (inputSize < LZ4_64Klimit)
+	    return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, byU16,                        noDict, noDictIssue, acceleration);
+	else
+	    return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, sizeof(void*)==8 ? byU32 : byPtr, noDict, noDictIssue, acceleration);
 }
 #endif
 
@@ -1173,189 +1173,189 @@ int LZ4_compress_fast_force(const char* source, char* dest, int inputSize, int m
 
 #if 0
 static int LZ4_compress_destSize_generic(
-                       LZ4_stream_t_internal* const ctx,
-                 const char* const src,
-                       char* const dst,
-                       int*  const srcSizePtr,
-                 const int targetDstSize,
-                 const tableType_t tableType)
+	                   LZ4_stream_t_internal* const ctx,
+	             const char* const src,
+	                   char* const dst,
+	                   int*  const srcSizePtr,
+	             const int targetDstSize,
+	             const tableType_t tableType)
 {
-    const BYTE* ip = (const BYTE*) src;
-    const BYTE* base = (const BYTE*) src;
-    const BYTE* lowLimit = (const BYTE*) src;
-    const BYTE* anchor = ip;
-    const BYTE* const iend = ip + *srcSizePtr;
-    const BYTE* const mflimit = iend - MFLIMIT;
-    const BYTE* const matchlimit = iend - LASTLITERALS;
-
-    BYTE* op = (BYTE*) dst;
-    BYTE* const oend = op + targetDstSize;
-    BYTE* const oMaxLit = op + targetDstSize - 2 /* offset */ - 8 /* because 8+MINMATCH==MFLIMIT */ - 1 /* token */;
-    BYTE* const oMaxMatch = op + targetDstSize - (LASTLITERALS + 1 /* token */);
-    BYTE* const oMaxSeq = oMaxLit - 1 /* token */;
-
-    U32 forwardH;
-
-
-    /* Init conditions */
-    if (targetDstSize < 1) return 0;                                     /* Impossible to store anything */
-    if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;            /* Unsupported input size, too large (or negative) */
-    if ((tableType == byU16) && (*srcSizePtr>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
-    if (*srcSizePtr<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
-
-    /* First Byte */
-    *srcSizePtr = 0;
-    LZ4_putPosition(ip, ctx->hashTable, tableType, base);
-    ip++; forwardH = LZ4_hashPosition(ip, tableType);
-
-    /* Main Loop */
-    for ( ; ; ) {
-        const BYTE* match;
-        BYTE* token;
-
-        /* Find a match */
-        {   const BYTE* forwardIp = ip;
-            unsigned step = 1;
-            unsigned searchMatchNb = 1 << LZ4_skipTrigger;
-
-            do {
-                U32 h = forwardH;
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimit)) goto _last_literals;
-
-                match = LZ4_getPositionOnHash(h, ctx->hashTable, tableType, base);
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putPositionOnHash(ip, h, ctx->hashTable, tableType, base);
-
-            } while ( ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
-                || (LZ4_read32(match) != LZ4_read32(ip)) );
-        }
-
-        /* Catch up */
-        while ((ip>anchor) && (match > lowLimit) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
-
-        /* Encode Literal length */
-        {   unsigned litLength = (unsigned)(ip - anchor);
-            token = op++;
-            if (op + ((litLength+240)/255) + litLength > oMaxLit) {
-                /* Not enough space for a last match */
-                op--;
-                goto _last_literals;
-            }
-            if (litLength>=RUN_MASK) {
-                unsigned len = litLength - RUN_MASK;
-                *token=(RUN_MASK<<ML_BITS);
-                for(; len >= 255 ; len-=255) *op++ = 255;
-                *op++ = (BYTE)len;
-            }
-            else *token = (BYTE)(litLength<<ML_BITS);
-
-            /* Copy Literals */
-            LZ4_wildCopy(op, anchor, op+litLength);
-            op += litLength;
-        }
+	const BYTE* ip = (const BYTE*) src;
+	const BYTE* base = (const BYTE*) src;
+	const BYTE* lowLimit = (const BYTE*) src;
+	const BYTE* anchor = ip;
+	const BYTE* const iend = ip + *srcSizePtr;
+	const BYTE* const mflimit = iend - MFLIMIT;
+	const BYTE* const matchlimit = iend - LASTLITERALS;
+
+	BYTE* op = (BYTE*) dst;
+	BYTE* const oend = op + targetDstSize;
+	BYTE* const oMaxLit = op + targetDstSize - 2 /* offset */ - 8 /* because 8+MINMATCH==MFLIMIT */ - 1 /* token */;
+	BYTE* const oMaxMatch = op + targetDstSize - (LASTLITERALS + 1 /* token */);
+	BYTE* const oMaxSeq = oMaxLit - 1 /* token */;
+
+	U32 forwardH;
+
+
+	/* Init conditions */
+	if (targetDstSize < 1) return 0;                                     /* Impossible to store anything */
+	if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;            /* Unsupported input size, too large (or negative) */
+	if ((tableType == byU16) && (*srcSizePtr>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */
+	if (*srcSizePtr<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
+
+	/* First Byte */
+	*srcSizePtr = 0;
+	LZ4_putPosition(ip, ctx->hashTable, tableType, base);
+	ip++; forwardH = LZ4_hashPosition(ip, tableType);
+
+	/* Main Loop */
+	for ( ; ; ) {
+	    const BYTE* match;
+	    BYTE* token;
+
+	    /* Find a match */
+	    {   const BYTE* forwardIp = ip;
+	        unsigned step = 1;
+	        unsigned searchMatchNb = 1 << LZ4_skipTrigger;
+
+	        do {
+	            U32 h = forwardH;
+	            ip = forwardIp;
+	            forwardIp += step;
+	            step = (searchMatchNb++ >> LZ4_skipTrigger);
+
+	            if (unlikely(forwardIp > mflimit)) goto _last_literals;
+
+	            match = LZ4_getPositionOnHash(h, ctx->hashTable, tableType, base);
+	            forwardH = LZ4_hashPosition(forwardIp, tableType);
+	            LZ4_putPositionOnHash(ip, h, ctx->hashTable, tableType, base);
+
+	        } while ( ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
+	            || (LZ4_read32(match) != LZ4_read32(ip)) );
+	    }
+
+	    /* Catch up */
+	    while ((ip>anchor) && (match > lowLimit) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
+
+	    /* Encode Literal length */
+	    {   unsigned litLength = (unsigned)(ip - anchor);
+	        token = op++;
+	        if (op + ((litLength+240)/255) + litLength > oMaxLit) {
+	            /* Not enough space for a last match */
+	            op--;
+	            goto _last_literals;
+	        }
+	        if (litLength>=RUN_MASK) {
+	            unsigned len = litLength - RUN_MASK;
+	            *token=(RUN_MASK<<ML_BITS);
+	            for(; len >= 255 ; len-=255) *op++ = 255;
+	            *op++ = (BYTE)len;
+	        }
+	        else *token = (BYTE)(litLength<<ML_BITS);
+
+	        /* Copy Literals */
+	        LZ4_wildCopy(op, anchor, op+litLength);
+	        op += litLength;
+	    }
 
 _next_match:
-        /* Encode Offset */
-        LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
-
-        /* Encode MatchLength */
-        {   size_t matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
-
-            if (op + ((matchLength+240)/255) > oMaxMatch) {
-                /* Match description too long : reduce it */
-                matchLength = (15-1) + (oMaxMatch-op) * 255;
-            }
-            ip += MINMATCH + matchLength;
-
-            if (matchLength>=ML_MASK) {
-                *token += ML_MASK;
-                matchLength -= ML_MASK;
-                while (matchLength >= 255) { matchLength-=255; *op++ = 255; }
-                *op++ = (BYTE)matchLength;
-            }
-            else *token += (BYTE)(matchLength);
-        }
-
-        anchor = ip;
-
-        /* Test end of block */
-        if (ip > mflimit) break;
-        if (op > oMaxSeq) break;
-
-        /* Fill table */
-        LZ4_putPosition(ip-2, ctx->hashTable, tableType, base);
-
-        /* Test next position */
-        match = LZ4_getPosition(ip, ctx->hashTable, tableType, base);
-        LZ4_putPosition(ip, ctx->hashTable, tableType, base);
-        if ( (match+MAX_DISTANCE>=ip)
-            && (LZ4_read32(match)==LZ4_read32(ip)) )
-        { token=op++; *token=0; goto _next_match; }
-
-        /* Prepare next loop */
-        forwardH = LZ4_hashPosition(++ip, tableType);
-    }
+	    /* Encode Offset */
+	    LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
+
+	    /* Encode MatchLength */
+	    {   size_t matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
+
+	        if (op + ((matchLength+240)/255) > oMaxMatch) {
+	            /* Match description too long : reduce it */
+	            matchLength = (15-1) + (oMaxMatch-op) * 255;
+	        }
+	        ip += MINMATCH + matchLength;
+
+	        if (matchLength>=ML_MASK) {
+	            *token += ML_MASK;
+	            matchLength -= ML_MASK;
+	            while (matchLength >= 255) { matchLength-=255; *op++ = 255; }
+	            *op++ = (BYTE)matchLength;
+	        }
+	        else *token += (BYTE)(matchLength);
+	    }
+
+	    anchor = ip;
+
+	    /* Test end of block */
+	    if (ip > mflimit) break;
+	    if (op > oMaxSeq) break;
+
+	    /* Fill table */
+	    LZ4_putPosition(ip-2, ctx->hashTable, tableType, base);
+
+	    /* Test next position */
+	    match = LZ4_getPosition(ip, ctx->hashTable, tableType, base);
+	    LZ4_putPosition(ip, ctx->hashTable, tableType, base);
+	    if ( (match+MAX_DISTANCE>=ip)
+	        && (LZ4_read32(match)==LZ4_read32(ip)) )
+	    { token=op++; *token=0; goto _next_match; }
+
+	    /* Prepare next loop */
+	    forwardH = LZ4_hashPosition(++ip, tableType);
+	}
 
 _last_literals:
-    /* Encode Last Literals */
-    {   size_t lastRunSize = (size_t)(iend - anchor);
-        if (op + 1 /* token */ + ((lastRunSize+240)/255) /* litLength */ + lastRunSize /* literals */ > oend) {
-            /* adapt lastRunSize to fill 'dst' */
-            lastRunSize  = (oend-op) - 1;
-            lastRunSize -= (lastRunSize+240)/255;
-        }
-        ip = anchor + lastRunSize;
-
-        if (lastRunSize >= RUN_MASK) {
-            size_t accumulator = lastRunSize - RUN_MASK;
-            *op++ = RUN_MASK << ML_BITS;
-            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRunSize<<ML_BITS);
-        }
-        memcpy(op, anchor, lastRunSize);
-        op += lastRunSize;
-    }
-
-    /* End */
-    *srcSizePtr = (int) (((const char*)ip)-src);
-    return (int) (((char*)op)-dst);
+	/* Encode Last Literals */
+	{   size_t lastRunSize = (size_t)(iend - anchor);
+	    if (op + 1 /* token */ + ((lastRunSize+240)/255) /* litLength */ + lastRunSize /* literals */ > oend) {
+	        /* adapt lastRunSize to fill 'dst' */
+	        lastRunSize  = (oend-op) - 1;
+	        lastRunSize -= (lastRunSize+240)/255;
+	    }
+	    ip = anchor + lastRunSize;
+
+	    if (lastRunSize >= RUN_MASK) {
+	        size_t accumulator = lastRunSize - RUN_MASK;
+	        *op++ = RUN_MASK << ML_BITS;
+	        for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
+	        *op++ = (BYTE) accumulator;
+	    } else {
+	        *op++ = (BYTE)(lastRunSize<<ML_BITS);
+	    }
+	    memcpy(op, anchor, lastRunSize);
+	    op += lastRunSize;
+	}
+
+	/* End */
+	*srcSizePtr = (int) (((const char*)ip)-src);
+	return (int) (((char*)op)-dst);
 }
 
 static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
 {
-    LZ4_resetStream(state);
-
-    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
-        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
-    } else {
-        if (*srcSizePtr < LZ4_64Klimit)
-            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, byU16);
-        else
-            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, sizeof(void*)==8 ? byU32 : byPtr);
-    }
+	LZ4_resetStream(state);
+
+	if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
+	    return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
+	} else {
+	    if (*srcSizePtr < LZ4_64Klimit)
+	        return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, byU16);
+	    else
+	        return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, sizeof(void*)==8 ? byU32 : byPtr);
+	}
 }
 
 int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
 {
 #if (HEAPMODE)
-    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
+	LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
 #else
-    LZ4_stream_t ctxBody;
-    LZ4_stream_t* ctx = &ctxBody;
+	LZ4_stream_t ctxBody;
+	LZ4_stream_t* ctx = &ctxBody;
 #endif
 
-    int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
+	int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
 
 #if (HEAPMODE)
-    FREEMEM(ctx);
+	FREEMEM(ctx);
 #endif
-    return result;
+	return result;
 }
 #endif
 
@@ -1366,23 +1366,23 @@ int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targe
 #if 0
 LZ4_stream_t* LZ4_createStream(void)
 {
-    LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(8, LZ4_STREAMSIZE_U64);
-    LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal));    /* A compilation error here means LZ4_STREAMSIZE is not large enough */
-    LZ4_resetStream(lz4s);
-    return lz4s;
+	LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(8, LZ4_STREAMSIZE_U64);
+	LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal));    /* A compilation error here means LZ4_STREAMSIZE is not large enough */
+	LZ4_resetStream(lz4s);
+	return lz4s;
 }
 #endif
 
 void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
 {
-    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t));
+	MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t));
 }
 
 #if 0
 int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
 {
-    FREEMEM(LZ4_stream);
-    return (0);
+	FREEMEM(LZ4_stream);
+	return (0);
 }
 #endif
 
@@ -1390,117 +1390,117 @@ int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
 #define HASH_UNIT sizeof(reg_t)
 int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
 {
-    LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
-    const BYTE* p = (const BYTE*)dictionary;
-    const BYTE* const dictEnd = p + dictSize;
-    const BYTE* base;
-
-    if ((dict->initCheck) || (dict->currentOffset > 1 GB))  /* Uninitialized structure, or reuse overflow */
-        LZ4_resetStream(LZ4_dict);
-
-    if (dictSize < (int)HASH_UNIT) {
-        dict->dictionary = NULL;
-        dict->dictSize = 0;
-        return 0;
-    }
-
-    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
-    dict->currentOffset += 64 KB;
-    base = p - dict->currentOffset;
-    dict->dictionary = p;
-    dict->dictSize = (U32)(dictEnd - p);
-    dict->currentOffset += dict->dictSize;
-
-    while (p <= dictEnd-HASH_UNIT) {
-        LZ4_putPosition(p, dict->hashTable, byU32, base);
-        p+=3;
-    }
-
-    return dict->dictSize;
+	LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
+	const BYTE* p = (const BYTE*)dictionary;
+	const BYTE* const dictEnd = p + dictSize;
+	const BYTE* base;
+
+	if ((dict->initCheck) || (dict->currentOffset > 1 GB))  /* Uninitialized structure, or reuse overflow */
+	    LZ4_resetStream(LZ4_dict);
+
+	if (dictSize < (int)HASH_UNIT) {
+	    dict->dictionary = NULL;
+	    dict->dictSize = 0;
+	    return 0;
+	}
+
+	if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
+	dict->currentOffset += 64 KB;
+	base = p - dict->currentOffset;
+	dict->dictionary = p;
+	dict->dictSize = (U32)(dictEnd - p);
+	dict->currentOffset += dict->dictSize;
+
+	while (p <= dictEnd-HASH_UNIT) {
+	    LZ4_putPosition(p, dict->hashTable, byU32, base);
+	    p+=3;
+	}
+
+	return dict->dictSize;
 }
 
 static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src)
 {
-    if ((LZ4_dict->currentOffset > 0x80000000) ||
-        ((uptrval)LZ4_dict->currentOffset > (uptrval)src)) {   /* address space overflow */
-        /* rescale hash table */
-        U32 const delta = LZ4_dict->currentOffset - 64 KB;
-        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
-        int i;
-        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
-            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
-            else LZ4_dict->hashTable[i] -= delta;
-        }
-        LZ4_dict->currentOffset = 64 KB;
-        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
-        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
-    }
+	if ((LZ4_dict->currentOffset > 0x80000000) ||
+	    ((uptrval)LZ4_dict->currentOffset > (uptrval)src)) {   /* address space overflow */
+	    /* rescale hash table */
+	    U32 const delta = LZ4_dict->currentOffset - 64 KB;
+	    const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
+	    int i;
+	    for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
+	        if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
+	        else LZ4_dict->hashTable[i] -= delta;
+	    }
+	    LZ4_dict->currentOffset = 64 KB;
+	    if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
+	    LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
+	}
 }
 
 int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
 {
-    LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse;
-    const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
-
-    const BYTE* smallest = (const BYTE*) source;
-    if (streamPtr->initCheck) return 0;   /* Uninitialized structure detected */
-    if ((streamPtr->dictSize>0) && (smallest>dictEnd)) smallest = dictEnd;
-    LZ4_renormDictT(streamPtr, smallest);
-    if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
-
-    /* Check overlapping input/dictionary space */
-    {   const BYTE* sourceEnd = (const BYTE*) source + inputSize;
-        if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
-            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
-            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
-            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
-            streamPtr->dictionary = dictEnd - streamPtr->dictSize;
-        }
-    }
-
-    /* prefix mode : source data follows dictionary */
-    if (dictEnd == (const BYTE*)source) {
-        int result;
-        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
-            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, dictSmall, acceleration);
-        else
-            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, noDictIssue, acceleration);
-        streamPtr->dictSize += (U32)inputSize;
-        streamPtr->currentOffset += (U32)inputSize;
-        return result;
-    }
-
-    /* external dictionary mode */
-    {   int result;
-        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
-            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, dictSmall, acceleration);
-        else
-            result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, noDictIssue, acceleration);
-        streamPtr->dictionary = (const BYTE*)source;
-        streamPtr->dictSize = (U32)inputSize;
-        streamPtr->currentOffset += (U32)inputSize;
-        return result;
-    }
+	LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse;
+	const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
+
+	const BYTE* smallest = (const BYTE*) source;
+	if (streamPtr->initCheck) return 0;   /* Uninitialized structure detected */
+	if ((streamPtr->dictSize>0) && (smallest>dictEnd)) smallest = dictEnd;
+	LZ4_renormDictT(streamPtr, smallest);
+	if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
+
+	/* Check overlapping input/dictionary space */
+	{   const BYTE* sourceEnd = (const BYTE*) source + inputSize;
+	    if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
+	        streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
+	        if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
+	        if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
+	        streamPtr->dictionary = dictEnd - streamPtr->dictSize;
+	    }
+	}
+
+	/* prefix mode : source data follows dictionary */
+	if (dictEnd == (const BYTE*)source) {
+	    int result;
+	    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
+	        result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, dictSmall, acceleration);
+	    else
+	        result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, noDictIssue, acceleration);
+	    streamPtr->dictSize += (U32)inputSize;
+	    streamPtr->currentOffset += (U32)inputSize;
+	    return result;
+	}
+
+	/* external dictionary mode */
+	{   int result;
+	    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
+	        result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, dictSmall, acceleration);
+	    else
+	        result = LZ4_compress_generic(streamPtr, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, noDictIssue, acceleration);
+	    streamPtr->dictionary = (const BYTE*)source;
+	    streamPtr->dictSize = (U32)inputSize;
+	    streamPtr->currentOffset += (U32)inputSize;
+	    return result;
+	}
 }
 
 /* Hidden debug function, to force external dictionary mode */
 int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int inputSize)
 {
-    LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
-    int result;
-    const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
+	LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
+	int result;
+	const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
 
-    const BYTE* smallest = dictEnd;
-    if (smallest > (const BYTE*) source) smallest = (const BYTE*) source;
-    LZ4_renormDictT(streamPtr, smallest);
+	const BYTE* smallest = dictEnd;
+	if (smallest > (const BYTE*) source) smallest = (const BYTE*) source;
+	LZ4_renormDictT(streamPtr, smallest);
 
-    result = LZ4_compress_generic(streamPtr, source, dest, inputSize, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
+	result = LZ4_compress_generic(streamPtr, source, dest, inputSize, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
 
-    streamPtr->dictionary = (const BYTE*)source;
-    streamPtr->dictSize = (U32)inputSize;
-    streamPtr->currentOffset += (U32)inputSize;
+	streamPtr->dictionary = (const BYTE*)source;
+	streamPtr->dictSize = (U32)inputSize;
+	streamPtr->currentOffset += (U32)inputSize;
 
-    return result;
+	return result;
 }
 
 /*! LZ4_saveDict() :
@@ -1512,18 +1512,18 @@ int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char*
  */
 int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
 {
-    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
-    const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
+	LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
+	const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
 
-    if ((U32)dictSize > 64 KB) dictSize = 64 KB;   /* useless to define a dictionary > 64 KB */
-    if ((U32)dictSize > dict->dictSize) dictSize = dict->dictSize;
+	if ((U32)dictSize > 64 KB) dictSize = 64 KB;   /* useless to define a dictionary > 64 KB */
+	if ((U32)dictSize > dict->dictSize) dictSize = dict->dictSize;
 
-    memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
+	memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
 
-    dict->dictionary = (const BYTE*)safeBuffer;
-    dict->dictSize = (U32)dictSize;
+	dict->dictionary = (const BYTE*)safeBuffer;
+	dict->dictSize = (U32)dictSize;
 
-    return dictSize;
+	return dictSize;
 }
 
 #endif
@@ -1538,181 +1538,181 @@ int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
  *  in order to remove useless branches during compilation optimization.
  */
 FORCE_INLINE int LZ4_decompress_generic(
-                 const char* const source,
-                 char* const dest,
-                 int inputSize,
-                 int outputSize,         /* If endOnInput==endOnInputSize, this value is the max size of Output Buffer. */
-
-                 int endOnInput,         /* endOnOutputSize, endOnInputSize */
-                 int partialDecoding,    /* full, partial */
-                 int targetOutputSize,   /* only used if partialDecoding==partial */
-                 int dict,               /* noDict, withPrefix64k, usingExtDict */
-                 const BYTE* const lowPrefix,  /* == dest when no prefix */
-                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
-                 const size_t dictSize         /* note : = 0 if noDict */
-                 )
+	             const char* const source,
+	             char* const dest,
+	             int inputSize,
+	             int outputSize,         /* If endOnInput==endOnInputSize, this value is the max size of Output Buffer. */
+
+	             int endOnInput,         /* endOnOutputSize, endOnInputSize */
+	             int partialDecoding,    /* full, partial */
+	             int targetOutputSize,   /* only used if partialDecoding==partial */
+	             int dict,               /* noDict, withPrefix64k, usingExtDict */
+	             const BYTE* const lowPrefix,  /* == dest when no prefix */
+	             const BYTE* const dictStart,  /* only if dict==usingExtDict */
+	             const size_t dictSize         /* note : = 0 if noDict */
+	             )
 {
-    /* Local Variables */
-    const BYTE* ip = (const BYTE*) source;
-    const BYTE* const iend = ip + inputSize;
-
-    BYTE* op = (BYTE*) dest;
-    BYTE* const oend = op + outputSize;
-    BYTE* cpy;
-    BYTE* oexit = op + targetOutputSize;
-    const BYTE* const lowLimit = lowPrefix - dictSize;
-
-    const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
-    const unsigned dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};
-    const int dec64table[] = {0, 0, 0, -1, 0, 1, 2, 3};
-
-    const int safeDecode = (endOnInput==endOnInputSize);
-    const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
-
-
-    /* Special cases */
-    if ((partialDecoding) && (oexit > oend-MFLIMIT)) oexit = oend-MFLIMIT;                        /* targetOutputSize too high => decode everything */
-    if ((endOnInput) && (unlikely(outputSize==0))) return ((inputSize==1) && (*ip==0)) ? 0 : -1;  /* Empty output buffer */
-    if ((!endOnInput) && (unlikely(outputSize==0))) return (*ip==0?1:-1);
-
-    /* Main Loop : decode sequences */
-    while (1) {
-        size_t length;
-        const BYTE* match;
-        size_t offset;
-
-        /* get literal length */
-        unsigned const token = *ip++;
-        if ((length=(token>>ML_BITS)) == RUN_MASK) {
-            unsigned s;
-            do {
-                s = *ip++;
-                length += s;
-            } while ( likely(endOnInput ? ip<iend-RUN_MASK : 1) & (s==255) );
-            if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) goto _output_error;   /* overflow detection */
-            if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) goto _output_error;   /* overflow detection */
-        }
-
-        /* copy literals */
-        cpy = op+length;
-        if ( ((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) || (ip+length>iend-(2+1+LASTLITERALS))) )
-            || ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)) )
-        {
-            if (partialDecoding) {
-                if (cpy > oend) goto _output_error;                           /* Error : write attempt beyond end of output buffer */
-                if ((endOnInput) && (ip+length > iend)) goto _output_error;   /* Error : read attempt beyond end of input buffer */
-            } else {
-                if ((!endOnInput) && (cpy != oend)) goto _output_error;       /* Error : block decoding must stop exactly there */
-                if ((endOnInput) && ((ip+length != iend) || (cpy > oend))) goto _output_error;   /* Error : input must be consumed */
-            }
-            memcpy(op, ip, length);
-            ip += length;
-            op += length;
-            break;     /* Necessarily EOF, due to parsing restrictions */
-        }
-        LZ4_wildCopy(op, ip, cpy);
-        ip += length; op = cpy;
-
-        /* get offset */
-        offset = LZ4_readLE16(ip); ip+=2;
-        match = op - offset;
-        if ((checkOffset) && (unlikely(match < lowLimit))) goto _output_error;   /* Error : offset outside buffers */
-        LZ4_write32(op, (U32)offset);   /* costs ~1%; silence an msan warning when offset==0 */
-
-        /* get matchlength */
-        length = token & ML_MASK;
-        if (length == ML_MASK) {
-            unsigned s;
-            do {
-                s = *ip++;
-                if ((endOnInput) && (ip > iend-LASTLITERALS)) goto _output_error;
-                length += s;
-            } while (s==255);
-            if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
-        }
-        length += MINMATCH;
-
-        /* check external dictionary */
-        if ((dict==usingExtDict) && (match < lowPrefix)) {
-            if (unlikely(op+length > oend-LASTLITERALS)) goto _output_error;   /* doesn't respect parsing restriction */
-
-            if (length <= (size_t)(lowPrefix-match)) {
-                /* match can be copied as a single segment from external dictionary */
-                memmove(op, dictEnd - (lowPrefix-match), length);
-                op += length;
-            } else {
-                /* match encompass external dictionary and current block */
-                size_t const copySize = (size_t)(lowPrefix-match);
-                size_t const restSize = length - copySize;
-                memcpy(op, dictEnd - copySize, copySize);
-                op += copySize;
-                if (restSize > (size_t)(op-lowPrefix)) {  /* overlap copy */
-                    BYTE* const endOfMatch = op + restSize;
-                    const BYTE* copyFrom = lowPrefix;
-                    while (op < endOfMatch) *op++ = *copyFrom++;
-                } else {
-                    memcpy(op, lowPrefix, restSize);
-                    op += restSize;
-            }   }
-            continue;
-        }
-
-        /* copy match within block */
-        cpy = op + length;
-        if (unlikely(offset<8)) {
-            const int dec64 = dec64table[offset];
-            op[0] = match[0];
-            op[1] = match[1];
-            op[2] = match[2];
-            op[3] = match[3];
-            match += dec32table[offset];
-            memcpy(op+4, match, 4);
-            match -= dec64;
-        } else { LZ4_copy8(op, match); match+=8; }
-        op += 8;
-
-        if (unlikely(cpy>oend-12)) {
-            BYTE* const oCopyLimit = oend-(WILDCOPYLENGTH-1);
-            if (cpy > oend-LASTLITERALS) goto _output_error;    /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
-            if (op < oCopyLimit) {
-                LZ4_wildCopy(op, match, oCopyLimit);
-                match += oCopyLimit - op;
-                op = oCopyLimit;
-            }
-            while (op<cpy) *op++ = *match++;
-        } else {
-            LZ4_copy8(op, match);
-            if (length>16) LZ4_wildCopy(op+8, match+8, cpy);
-        }
-        op=cpy;   /* correction */
-    }
-
-    /* end of decoding */
-    if (endOnInput)
-       return (int) (((char*)op)-dest);     /* Nb of output bytes decoded */
-    else
-       return (int) (((const char*)ip)-source);   /* Nb of input bytes read */
-
-    /* Overflow error detected */
+	/* Local Variables */
+	const BYTE* ip = (const BYTE*) source;
+	const BYTE* const iend = ip + inputSize;
+
+	BYTE* op = (BYTE*) dest;
+	BYTE* const oend = op + outputSize;
+	BYTE* cpy;
+	BYTE* oexit = op + targetOutputSize;
+	const BYTE* const lowLimit = lowPrefix - dictSize;
+
+	const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
+	const unsigned dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};
+	const int dec64table[] = {0, 0, 0, -1, 0, 1, 2, 3};
+
+	const int safeDecode = (endOnInput==endOnInputSize);
+	const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
+
+
+	/* Special cases */
+	if ((partialDecoding) && (oexit > oend-MFLIMIT)) oexit = oend-MFLIMIT;                        /* targetOutputSize too high => decode everything */
+	if ((endOnInput) && (unlikely(outputSize==0))) return ((inputSize==1) && (*ip==0)) ? 0 : -1;  /* Empty output buffer */
+	if ((!endOnInput) && (unlikely(outputSize==0))) return (*ip==0?1:-1);
+
+	/* Main Loop : decode sequences */
+	while (1) {
+	    size_t length;
+	    const BYTE* match;
+	    size_t offset;
+
+	    /* get literal length */
+	    unsigned const token = *ip++;
+	    if ((length=(token>>ML_BITS)) == RUN_MASK) {
+	        unsigned s;
+	        do {
+	            s = *ip++;
+	            length += s;
+	        } while ( likely(endOnInput ? ip<iend-RUN_MASK : 1) & (s==255) );
+	        if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) goto _output_error;   /* overflow detection */
+	        if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) goto _output_error;   /* overflow detection */
+	    }
+
+	    /* copy literals */
+	    cpy = op+length;
+	    if ( ((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) || (ip+length>iend-(2+1+LASTLITERALS))) )
+	        || ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)) )
+	    {
+	        if (partialDecoding) {
+	            if (cpy > oend) goto _output_error;                           /* Error : write attempt beyond end of output buffer */
+	            if ((endOnInput) && (ip+length > iend)) goto _output_error;   /* Error : read attempt beyond end of input buffer */
+	        } else {
+	            if ((!endOnInput) && (cpy != oend)) goto _output_error;       /* Error : block decoding must stop exactly there */
+	            if ((endOnInput) && ((ip+length != iend) || (cpy > oend))) goto _output_error;   /* Error : input must be consumed */
+	        }
+	        memcpy(op, ip, length);
+	        ip += length;
+	        op += length;
+	        break;     /* Necessarily EOF, due to parsing restrictions */
+	    }
+	    LZ4_wildCopy(op, ip, cpy);
+	    ip += length; op = cpy;
+
+	    /* get offset */
+	    offset = LZ4_readLE16(ip); ip+=2;
+	    match = op - offset;
+	    if ((checkOffset) && (unlikely(match < lowLimit))) goto _output_error;   /* Error : offset outside buffers */
+	    LZ4_write32(op, (U32)offset);   /* costs ~1%; silence an msan warning when offset==0 */
+
+	    /* get matchlength */
+	    length = token & ML_MASK;
+	    if (length == ML_MASK) {
+	        unsigned s;
+	        do {
+	            s = *ip++;
+	            if ((endOnInput) && (ip > iend-LASTLITERALS)) goto _output_error;
+	            length += s;
+	        } while (s==255);
+	        if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
+	    }
+	    length += MINMATCH;
+
+	    /* check external dictionary */
+	    if ((dict==usingExtDict) && (match < lowPrefix)) {
+	        if (unlikely(op+length > oend-LASTLITERALS)) goto _output_error;   /* doesn't respect parsing restriction */
+
+	        if (length <= (size_t)(lowPrefix-match)) {
+	            /* match can be copied as a single segment from external dictionary */
+	            memmove(op, dictEnd - (lowPrefix-match), length);
+	            op += length;
+	        } else {
+	            /* match encompass external dictionary and current block */
+	            size_t const copySize = (size_t)(lowPrefix-match);
+	            size_t const restSize = length - copySize;
+	            memcpy(op, dictEnd - copySize, copySize);
+	            op += copySize;
+	            if (restSize > (size_t)(op-lowPrefix)) {  /* overlap copy */
+	                BYTE* const endOfMatch = op + restSize;
+	                const BYTE* copyFrom = lowPrefix;
+	                while (op < endOfMatch) *op++ = *copyFrom++;
+	            } else {
+	                memcpy(op, lowPrefix, restSize);
+	                op += restSize;
+	        }   }
+	        continue;
+	    }
+
+	    /* copy match within block */
+	    cpy = op + length;
+	    if (unlikely(offset<8)) {
+	        const int dec64 = dec64table[offset];
+	        op[0] = match[0];
+	        op[1] = match[1];
+	        op[2] = match[2];
+	        op[3] = match[3];
+	        match += dec32table[offset];
+	        memcpy(op+4, match, 4);
+	        match -= dec64;
+	    } else { LZ4_copy8(op, match); match+=8; }
+	    op += 8;
+
+	    if (unlikely(cpy>oend-12)) {
+	        BYTE* const oCopyLimit = oend-(WILDCOPYLENGTH-1);
+	        if (cpy > oend-LASTLITERALS) goto _output_error;    /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
+	        if (op < oCopyLimit) {
+	            LZ4_wildCopy(op, match, oCopyLimit);
+	            match += oCopyLimit - op;
+	            op = oCopyLimit;
+	        }
+	        while (op<cpy) *op++ = *match++;
+	    } else {
+	        LZ4_copy8(op, match);
+	        if (length>16) LZ4_wildCopy(op+8, match+8, cpy);
+	    }
+	    op=cpy;   /* correction */
+	}
+
+	/* end of decoding */
+	if (endOnInput)
+	   return (int) (((char*)op)-dest);     /* Nb of output bytes decoded */
+	else
+	   return (int) (((const char*)ip)-source);   /* Nb of input bytes read */
+
+	/* Overflow error detected */
 _output_error:
-    return (int) (-(((const char*)ip)-source))-1;
+	return (int) (-(((const char*)ip)-source))-1;
 }
 
 
 int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
 {
-    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, full, 0, noDict, (BYTE*)dest, NULL, 0);
+	return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, full, 0, noDict, (BYTE*)dest, NULL, 0);
 }
 
 #if 0
 int LZ4_decompress_safe_partial(const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize)
 {
-    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, partial, targetOutputSize, noDict, (BYTE*)dest, NULL, 0);
+	return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, partial, targetOutputSize, noDict, (BYTE*)dest, NULL, 0);
 }
 
 int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
 {
-    return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)(dest - 64 KB), NULL, 64 KB);
+	return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)(dest - 64 KB), NULL, 64 KB);
 }
 #endif
 
@@ -1726,14 +1726,14 @@ int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
  */
 LZ4_streamDecode_t* LZ4_createStreamDecode(void)
 {
-    LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOCATOR(1, sizeof(LZ4_streamDecode_t));
-    return lz4s;
+	LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOCATOR(1, sizeof(LZ4_streamDecode_t));
+	return lz4s;
 }
 
 int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
 {
-    FREEMEM(LZ4_stream);
-    return 0;
+	FREEMEM(LZ4_stream);
+	return 0;
 }
 
 /*!
@@ -1745,107 +1745,107 @@ int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
  */
 int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
 {
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    lz4sd->prefixSize = (size_t) dictSize;
-    lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
-    lz4sd->externalDict = NULL;
-    lz4sd->extDictSize  = 0;
-    return 1;
+	LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
+	lz4sd->prefixSize = (size_t) dictSize;
+	lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
+	lz4sd->externalDict = NULL;
+	lz4sd->extDictSize  = 0;
+	return 1;
 }
 
 /*
 *_continue() :
-    These decoding functions allow decompression of multiple blocks in "streaming" mode.
-    Previously decoded blocks must still be available at the memory position where they were decoded.
-    If it's not possible, save the relevant part of decoded data into a safe buffer,
-    and indicate where it stands using LZ4_setStreamDecode()
+	These decoding functions allow decompression of multiple blocks in "streaming" mode.
+	Previously decoded blocks must still be available at the memory position where they were decoded.
+	If it's not possible, save the relevant part of decoded data into a safe buffer,
+	and indicate where it stands using LZ4_setStreamDecode()
 */
 int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
 {
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    int result;
-
-    if (lz4sd->prefixEnd == (BYTE*)dest) {
-        result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                        endOnInputSize, full, 0,
-                                        usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += result;
-        lz4sd->prefixEnd  += result;
-    } else {
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                        endOnInputSize, full, 0,
-                                        usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = result;
-        lz4sd->prefixEnd  = (BYTE*)dest + result;
-    }
-
-    return result;
+	LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
+	int result;
+
+	if (lz4sd->prefixEnd == (BYTE*)dest) {
+	    result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
+	                                    endOnInputSize, full, 0,
+	                                    usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
+	    if (result <= 0) return result;
+	    lz4sd->prefixSize += result;
+	    lz4sd->prefixEnd  += result;
+	} else {
+	    lz4sd->extDictSize = lz4sd->prefixSize;
+	    lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
+	    result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
+	                                    endOnInputSize, full, 0,
+	                                    usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
+	    if (result <= 0) return result;
+	    lz4sd->prefixSize = result;
+	    lz4sd->prefixEnd  = (BYTE*)dest + result;
+	}
+
+	return result;
 }
 
 int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
 {
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    int result;
-
-    if (lz4sd->prefixEnd == (BYTE*)dest) {
-        result = LZ4_decompress_generic(source, dest, 0, originalSize,
-                                        endOnOutputSize, full, 0,
-                                        usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += originalSize;
-        lz4sd->prefixEnd  += originalSize;
-    } else {
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_generic(source, dest, 0, originalSize,
-                                        endOnOutputSize, full, 0,
-                                        usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = originalSize;
-        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
-    }
-
-    return result;
+	LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
+	int result;
+
+	if (lz4sd->prefixEnd == (BYTE*)dest) {
+	    result = LZ4_decompress_generic(source, dest, 0, originalSize,
+	                                    endOnOutputSize, full, 0,
+	                                    usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
+	    if (result <= 0) return result;
+	    lz4sd->prefixSize += originalSize;
+	    lz4sd->prefixEnd  += originalSize;
+	} else {
+	    lz4sd->extDictSize = lz4sd->prefixSize;
+	    lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
+	    result = LZ4_decompress_generic(source, dest, 0, originalSize,
+	                                    endOnOutputSize, full, 0,
+	                                    usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
+	    if (result <= 0) return result;
+	    lz4sd->prefixSize = originalSize;
+	    lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
+	}
+
+	return result;
 }
 
 
 /*
 Advanced decoding functions :
 *_usingDict() :
-    These decoding functions work the same as "_continue" ones,
-    the dictionary must be explicitly provided within parameters
+	These decoding functions work the same as "_continue" ones,
+	the dictionary must be explicitly provided within parameters
 */
 
 FORCE_INLINE int LZ4_decompress_usingDict_generic(const char* source, char* dest, int compressedSize, int maxOutputSize, int safe, const char* dictStart, int dictSize)
 {
-    if (dictSize==0)
-        return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest, NULL, 0);
-    if (dictStart+dictSize == dest) {
-        if (dictSize >= (int)(64 KB - 1))
-            return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, withPrefix64k, (BYTE*)dest-64 KB, NULL, 0);
-        return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest-dictSize, NULL, 0);
-    }
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
+	if (dictSize==0)
+	    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest, NULL, 0);
+	if (dictStart+dictSize == dest) {
+	    if (dictSize >= (int)(64 KB - 1))
+	        return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, withPrefix64k, (BYTE*)dest-64 KB, NULL, 0);
+	    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest-dictSize, NULL, 0);
+	}
+	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
 }
 
 int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
 {
-    return LZ4_decompress_usingDict_generic(source, dest, compressedSize, maxOutputSize, 1, dictStart, dictSize);
+	return LZ4_decompress_usingDict_generic(source, dest, compressedSize, maxOutputSize, 1, dictStart, dictSize);
 }
 
 int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
 {
-    return LZ4_decompress_usingDict_generic(source, dest, 0, originalSize, 0, dictStart, dictSize);
+	return LZ4_decompress_usingDict_generic(source, dest, 0, originalSize, 0, dictStart, dictSize);
 }
 
 /* debug function */
 int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
 {
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
+	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
 }
 
 #endif
@@ -1878,41 +1878,41 @@ int LZ4_sizeofStreamState() { return LZ4_STREAMSIZE; }
 
 static void LZ4_init(LZ4_stream_t* lz4ds, BYTE* base)
 {
-    MEM_INIT(lz4ds, 0, sizeof(LZ4_stream_t));
-    lz4ds->internal_donotuse.bufferStart = base;
+	MEM_INIT(lz4ds, 0, sizeof(LZ4_stream_t));
+	lz4ds->internal_donotuse.bufferStart = base;
 }
 
 int LZ4_resetStreamState(void* state, char* inputBuffer)
 {
-    if ((((uptrval)state) & 3) != 0) return 1;   /* Error : pointer is not aligned on 4-bytes boundary */
-    LZ4_init((LZ4_stream_t*)state, (BYTE*)inputBuffer);
-    return 0;
+	if ((((uptrval)state) & 3) != 0) return 1;   /* Error : pointer is not aligned on 4-bytes boundary */
+	LZ4_init((LZ4_stream_t*)state, (BYTE*)inputBuffer);
+	return 0;
 }
 
 void* LZ4_create (char* inputBuffer)
 {
-    LZ4_stream_t* lz4ds = (LZ4_stream_t*)ALLOCATOR(8, sizeof(LZ4_stream_t));
-    LZ4_init (lz4ds, (BYTE*)inputBuffer);
-    return lz4ds;
+	LZ4_stream_t* lz4ds = (LZ4_stream_t*)ALLOCATOR(8, sizeof(LZ4_stream_t));
+	LZ4_init (lz4ds, (BYTE*)inputBuffer);
+	return lz4ds;
 }
 
 char* LZ4_slideInputBuffer (void* LZ4_Data)
 {
-    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)LZ4_Data)->internal_donotuse;
-    int dictSize = LZ4_saveDict((LZ4_stream_t*)LZ4_Data, (char*)ctx->bufferStart, 64 KB);
-    return (char*)(ctx->bufferStart + dictSize);
+	LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)LZ4_Data)->internal_donotuse;
+	int dictSize = LZ4_saveDict((LZ4_stream_t*)LZ4_Data, (char*)ctx->bufferStart, 64 KB);
+	return (char*)(ctx->bufferStart + dictSize);
 }
 
 /* Obsolete streaming decompression functions */
 
 int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
 {
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
+	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
 }
 
 int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
 {
-    return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
+	return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
 }
 #endif
 
@@ -1928,7 +1928,6 @@ const unsigned char Packet::ZERO_KEY[32] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 #ifdef ZT_TRACE
 
 const char *Packet::verbString(Verb v)
-	throw()
 {
 	switch(v) {
 		case VERB_NOP: return "NOP";
@@ -1955,7 +1954,6 @@ const char *Packet::verbString(Verb v)
 }
 
 const char *Packet::errorString(ErrorCode e)
-	throw()
 {
 	switch(e) {
 		case ERROR_NONE: return "NONE";
@@ -1973,54 +1971,56 @@ const char *Packet::errorString(ErrorCode e)
 
 #endif // ZT_TRACE
 
-void Packet::armor(const void *key,bool encryptPayload)
+void Packet::armor(const void *key,bool encryptPayload,unsigned int counter)
 {
-	unsigned char mangledKey[32];
-	unsigned char macKey[32];
-	unsigned char mac[16];
-	const unsigned int payloadLen = size() - ZT_PACKET_IDX_VERB;
-	unsigned char *const payload = field(ZT_PACKET_IDX_VERB,payloadLen);
+	uint8_t mangledKey[32],macKey[32],mac[16];
+	uint8_t *const data = reinterpret_cast<uint8_t *>(unsafeData());
+
+	// Mask least significant 3 bits of packet ID with counter to embed packet send counter for QoS use
+	data[7] = (data[7] & 0xf8) | ((uint8_t)counter & 0x07);
 
 	// Set flag now, since it affects key mangle function
 	setCipher(encryptPayload ? ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012 : ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_NONE);
 
 	_salsa20MangleKey((const unsigned char *)key,mangledKey);
-	Salsa20 s20(mangledKey,256,field(ZT_PACKET_IDX_IV,8)/*,ZT_PROTO_SALSA20_ROUNDS*/);
+	Salsa20 s20(mangledKey,256,data + ZT_PACKET_IDX_IV);
 
 	// MAC key is always the first 32 bytes of the Salsa20 key stream
 	// This is the same construction DJB's NaCl library uses
 	s20.crypt12(ZERO_KEY,macKey,sizeof(macKey));
 
+	uint8_t *const payload = data + ZT_PACKET_IDX_VERB;
+	const unsigned int payloadLen = size() - ZT_PACKET_IDX_VERB;
 	if (encryptPayload)
 		s20.crypt12(payload,payload,payloadLen);
-
 	Poly1305::compute(mac,payload,payloadLen,macKey);
-	memcpy(field(ZT_PACKET_IDX_MAC,8),mac,8);
+	memcpy(data + ZT_PACKET_IDX_MAC,mac,8);
 }
 
 bool Packet::dearmor(const void *key)
 {
-	unsigned char mangledKey[32];
-	unsigned char macKey[32];
-	unsigned char mac[16];
+	uint8_t mangledKey[32],macKey[32],mac[16];
+	uint8_t *const data = reinterpret_cast<uint8_t *>(unsafeData());
 	const unsigned int payloadLen = size() - ZT_PACKET_IDX_VERB;
-	unsigned char *const payload = field(ZT_PACKET_IDX_VERB,payloadLen);
-	unsigned int cs = cipher();
+	unsigned char *const payload = data + ZT_PACKET_IDX_VERB;
+	const unsigned int cs = cipher();
 
 	if ((cs == ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_NONE)||(cs == ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012)) {
 		_salsa20MangleKey((const unsigned char *)key,mangledKey);
-		Salsa20 s20(mangledKey,256,field(ZT_PACKET_IDX_IV,8));
+		Salsa20 s20(mangledKey,256,data + ZT_PACKET_IDX_IV);
 
 		s20.crypt12(ZERO_KEY,macKey,sizeof(macKey));
 		Poly1305::compute(mac,payload,payloadLen,macKey);
-		if (!Utils::secureEq(mac,field(ZT_PACKET_IDX_MAC,8),8))
-			return false;
+		if (!Utils::secureEq(mac,data + ZT_PACKET_IDX_MAC,8))
+			return false; // MAC failed, packet is corrupt, modified, or is not from the sender
 
 		if (cs == ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012)
 			s20.crypt12(payload,payload,payloadLen);
 
 		return true;
-	} else return false; // unrecognized cipher suite
+	} else {
+		return false; // unrecognized cipher suite
+	}
 }
 
 void Packet::cryptField(const void *key,unsigned int start,unsigned int len)
@@ -2028,13 +2028,13 @@ void Packet::cryptField(const void *key,unsigned int start,unsigned int len)
 	unsigned char mangledKey[32];
 	unsigned char macKey[32];
 	_salsa20MangleKey((const unsigned char *)key,mangledKey);
-    mangledKey[0] ^= 0x7f;
-    mangledKey[1] ^= ((start >> 8) & 0xff);
-    mangledKey[2] ^= (start & 0xff); // slightly alter key for this use case as an added guard against key stream reuse
+	mangledKey[0] ^= 0x7f;
+	mangledKey[1] ^= ((start >> 8) & 0xff);
+	mangledKey[2] ^= (start & 0xff); // slightly alter key for this use case as an added guard against key stream reuse
 	Salsa20 s20(mangledKey,256,field(ZT_PACKET_IDX_IV,8));
 	s20.crypt12(ZERO_KEY,macKey,sizeof(macKey)); // discard the first 32 bytes of key stream (the ones use for MAC in armor()) as a precaution
-    unsigned char *const ptr = field(start,len);
-    s20.crypt12(ptr,ptr,len);
+	unsigned char *const ptr = field(start,len);
+	s20.crypt12(ptr,ptr,len);
 }
 
 bool Packet::compress()
diff --git a/node/Packet.hpp b/node/Packet.hpp
index 6482356a..2017ce8e 100644
--- a/node/Packet.hpp
+++ b/node/Packet.hpp
@@ -351,7 +351,7 @@ namespace ZeroTier {
  * ZeroTier packet
  *
  * Packet format:
- *   <[8] 64-bit random packet ID and crypto initialization vector>
+ *   <[8] 64-bit packet ID / crypto IV / packet counter>
  *   <[5] destination ZT address>
  *   <[5] source ZT address>
  *   <[1] flags/cipher/hops>
@@ -362,6 +362,14 @@ namespace ZeroTier {
  *
  * Packets smaller than 28 bytes are invalid and silently discarded.
  *
+ * The 64-bit packet ID is a strongly random value used as a crypto IV.
+ * Its least significant 3 bits are also used as a monotonically increasing
+ * (and looping) counter for sending packets to a particular recipient. This
+ * can be used for link quality monitoring and reporting and has no crypto
+ * impact as it does not increase the likelihood of an IV collision. (The
+ * crypto we use is not sensitive to the nature of the IV, only that it does
+ * not repeat.)
+ *
  * The flags/cipher/hops bit field is: FFCCCHHH where C is a 3-bit cipher
  * selection allowing up to 7 cipher suites, F is outside-envelope flags,
  * and H is hop count.
@@ -1102,10 +1110,8 @@ public:
 	};
 
 #ifdef ZT_TRACE
-	static const char *verbString(Verb v)
-		throw();
-	static const char *errorString(ErrorCode e)
-		throw();
+	static const char *verbString(Verb v);
+	static const char *errorString(ErrorCode e);
 #endif
 
 	template<unsigned int C2>
@@ -1303,6 +1309,12 @@ public:
 	/**
 	 * Get this packet's unique ID (the IV field interpreted as uint64_t)
 	 *
+	 * Note that the least significant 3 bits of this ID will change when armor()
+	 * is called to armor the packet for transport. This is because armor() will
+	 * mask the last 3 bits against the send counter for QoS monitoring use prior
+	 * to actually using the IV to encrypt and MAC the packet. Be aware of this
+	 * when grabbing the packetId of a new packet prior to armor/send.
+	 *
 	 * @return Packet ID
 	 */
 	inline uint64_t packetId() const { return at<uint64_t>(ZT_PACKET_IDX_IV); }
@@ -1337,8 +1349,9 @@ public:
 	 *
 	 * @param key 32-byte key
 	 * @param encryptPayload If true, encrypt packet payload, else just MAC
+	 * @param counter Packet send counter for destination peer -- only least significant 3 bits are used
 	 */
-	void armor(const void *key,bool encryptPayload);
+	void armor(const void *key,bool encryptPayload,unsigned int counter);
 
 	/**
 	 * Verify and (if encrypted) decrypt packet
diff --git a/node/Path.hpp b/node/Path.hpp
index 5993be69..626f2f4f 100644
--- a/node/Path.hpp
+++ b/node/Path.hpp
@@ -105,6 +105,7 @@ public:
 		_lastOut(0),
 		_lastIn(0),
 		_lastTrustEstablishedPacketReceived(0),
+		_outgoingPacketCounter(0),
 		_addr(),
 		_localAddress(),
 		_ipScope(InetAddress::IP_SCOPE_NONE)
@@ -115,6 +116,7 @@ public:
 		_lastOut(0),
 		_lastIn(0),
 		_lastTrustEstablishedPacketReceived(0),
+		_outgoingPacketCounter(0),
 		_addr(addr),
 		_localAddress(localAddress),
 		_ipScope(addr.ipScope())
@@ -241,10 +243,18 @@ public:
 	 */
 	inline uint64_t lastIn() const { return _lastIn; }
 
+	/**
+	 * Return and increment outgoing packet counter (used with Packet::armor())
+	 *
+	 * @return Next value that should be used for outgoing packet counter (only least significant 3 bits are used)
+	 */
+	inline unsigned int nextOutgoingCounter() { return _outgoingPacketCounter++; }
+
 private:
 	uint64_t _lastOut;
 	uint64_t _lastIn;
 	uint64_t _lastTrustEstablishedPacketReceived;
+	unsigned int _outgoingPacketCounter;
 	InetAddress _addr;
 	InetAddress _localAddress;
 	InetAddress::IpScope _ipScope; // memoize this since it's a computed value checked often
diff --git a/node/Peer.cpp b/node/Peer.cpp
index 25efab42..c4c8774e 100644
--- a/node/Peer.cpp
+++ b/node/Peer.cpp
@@ -101,7 +101,7 @@ void Peer::received(
 					outp.append(redirectTo.rawIpData(),16);
 				}
 				outp.append((uint16_t)redirectTo.port());
-				outp.armor(_key,true);
+				outp.armor(_key,true,path->nextOutgoingCounter());
 				path->send(RR,outp.data(),outp.size(),now);
 			} else {
 				// For older peers we use RENDEZVOUS to coax them into contacting us elsewhere.
@@ -116,7 +116,7 @@ void Peer::received(
 					outp.append((uint8_t)16);
 					outp.append(redirectTo.rawIpData(),16);
 				}
-				outp.armor(_key,true);
+				outp.armor(_key,true,path->nextOutgoingCounter());
 				path->send(RR,outp.data(),outp.size(),now);
 			}
 			suboptimalPath = true;
@@ -203,7 +203,7 @@ void Peer::received(
 #endif
 			} else {
 				TRACE("got %s via unknown path %s(%s), confirming...",Packet::verbString(verb),_id.address().toString().c_str(),path->address().toString().c_str());
-				attemptToContactAt(path->localAddress(),path->address(),now,true);
+				attemptToContactAt(path->localAddress(),path->address(),now,true,path->nextOutgoingCounter());
 				path->sent(now);
 			}
 		}
@@ -277,7 +277,7 @@ void Peer::received(
 
 					if (count) {
 						outp.setAt(ZT_PACKET_IDX_PAYLOAD,(uint16_t)count);
-						outp.armor(_key,true);
+						outp.armor(_key,true,path->nextOutgoingCounter());
 						path->send(RR,outp.data(),outp.size(),now);
 					}
 				}
@@ -342,7 +342,7 @@ SharedPtr<Path> Peer::getBestPath(uint64_t now,bool includeExpired)
 	}
 }
 
-void Peer::sendHELLO(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now)
+void Peer::sendHELLO(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now,unsigned int counter)
 {
 	Packet outp(_id.address(),RR->identity.address(),Packet::VERB_HELLO);
 
@@ -383,22 +383,22 @@ void Peer::sendHELLO(const InetAddress &localAddr,const InetAddress &atAddress,u
 	RR->node->expectReplyTo(outp.packetId());
 
 	if (atAddress) {
-		outp.armor(_key,false); // false == don't encrypt full payload, but add MAC
+		outp.armor(_key,false,counter); // false == don't encrypt full payload, but add MAC
 		RR->node->putPacket(localAddr,atAddress,outp.data(),outp.size());
 	} else {
 		RR->sw->send(outp,false); // false == don't encrypt full payload, but add MAC
 	}
 }
 
-void Peer::attemptToContactAt(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now,bool sendFullHello)
+void Peer::attemptToContactAt(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now,bool sendFullHello,unsigned int counter)
 {
 	if ( (!sendFullHello) && (_vProto >= 5) && (!((_vMajor == 1)&&(_vMinor == 1)&&(_vRevision == 0))) ) {
 		Packet outp(_id.address(),RR->identity.address(),Packet::VERB_ECHO);
 		RR->node->expectReplyTo(outp.packetId());
-		outp.armor(_key,true);
+		outp.armor(_key,true,counter);
 		RR->node->putPacket(localAddr,atAddress,outp.data(),outp.size());
 	} else {
-		sendHELLO(localAddr,atAddress,now);
+		sendHELLO(localAddr,atAddress,now,counter);
 	}
 }
 
@@ -408,7 +408,7 @@ void Peer::tryMemorizedPath(uint64_t now)
 		_lastTriedMemorizedPath = now;
 		InetAddress mp;
 		if (RR->node->externalPathLookup(_id.address(),-1,mp))
-			attemptToContactAt(InetAddress(),mp,now,true);
+			attemptToContactAt(InetAddress(),mp,now,true,0);
 	}
 }
 
@@ -430,7 +430,7 @@ bool Peer::doPingAndKeepalive(uint64_t now,int inetAddressFamily)
 
 	if (bestp >= 0) {
 		if ( ((now - _paths[bestp].lastReceive) >= ZT_PEER_PING_PERIOD) || (_paths[bestp].path->needsHeartbeat(now)) ) {
-			attemptToContactAt(_paths[bestp].path->localAddress(),_paths[bestp].path->address(),now,false);
+			attemptToContactAt(_paths[bestp].path->localAddress(),_paths[bestp].path->address(),now,false,_paths[bestp].path->nextOutgoingCounter());
 			_paths[bestp].path->sent(now);
 		}
 		return true;
@@ -454,7 +454,7 @@ void Peer::resetWithinScope(InetAddress::IpScope scope,int inetAddressFamily,uin
 	Mutex::Lock _l(_paths_m);
 	for(unsigned int p=0;p<_numPaths;++p) {
 		if ( (_paths[p].path->address().ss_family == inetAddressFamily) && (_paths[p].path->address().ipScope() == scope) ) {
-			attemptToContactAt(_paths[p].path->localAddress(),_paths[p].path->address(),now,false);
+			attemptToContactAt(_paths[p].path->localAddress(),_paths[p].path->address(),now,false,_paths[p].path->nextOutgoingCounter());
 			_paths[p].path->sent(now);
 			_paths[p].lastReceive = 0; // path will not be used unless it speaks again
 		}
diff --git a/node/Peer.hpp b/node/Peer.hpp
index a3ec0088..783f48b8 100644
--- a/node/Peer.hpp
+++ b/node/Peer.hpp
@@ -150,8 +150,9 @@ public:
 	 * @param localAddr Local address
 	 * @param atAddress Destination address
 	 * @param now Current time
+	 * @param counter Outgoing packet counter
 	 */
-	void sendHELLO(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now);
+	void sendHELLO(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now,unsigned int counter);
 
 	/**
 	 * Send ECHO (or HELLO for older peers) to this peer at the given address
@@ -162,8 +163,9 @@ public:
 	 * @param atAddress Destination address
 	 * @param now Current time
 	 * @param sendFullHello If true, always send a full HELLO instead of just an ECHO
+	 * @param counter Outgoing packet counter
 	 */
-	void attemptToContactAt(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now,bool sendFullHello);
+	void attemptToContactAt(const InetAddress &localAddr,const InetAddress &atAddress,uint64_t now,bool sendFullHello,unsigned int counter);
 
 	/**
 	 * Try a memorized or statically defined path if any are known
diff --git a/node/Switch.cpp b/node/Switch.cpp
index 346091a4..bf309e36 100644
--- a/node/Switch.cpp
+++ b/node/Switch.cpp
@@ -88,7 +88,7 @@ void Switch::onRemotePacket(const InetAddress &localAddr,const InetAddress &from
 				if ((now - _lastBeaconResponse) >= 2500) { // limit rate of responses
 					_lastBeaconResponse = now;
 					Packet outp(peer->address(),RR->identity.address(),Packet::VERB_NOP);
-					outp.armor(peer->key(),true);
+					outp.armor(peer->key(),true,path->nextOutgoingCounter());
 					path->send(RR,outp.data(),outp.size(),now);
 				}
 			}
@@ -777,7 +777,7 @@ bool Switch::_trySend(Packet &packet,bool encrypt)
 			if ((clusterMostRecentMemberId < 0)||(viaPath->lastIn() > clusterMostRecentTs)) {
 #endif
 				if ((now - viaPath->lastOut()) > std::max((now - viaPath->lastIn()) * 4,(uint64_t)ZT_PATH_MIN_REACTIVATE_INTERVAL)) {
-					peer->attemptToContactAt(viaPath->localAddress(),viaPath->address(),now,false);
+					peer->attemptToContactAt(viaPath->localAddress(),viaPath->address(),now,false,viaPath->nextOutgoingCounter());
 					viaPath->sent(now);
 				}
 #ifdef ZT_ENABLE_CLUSTER
@@ -825,14 +825,14 @@ bool Switch::_trySend(Packet &packet,bool encrypt)
 	if (trustedPathId) {
 		packet.setTrusted(trustedPathId);
 	} else {
-		packet.armor((clusterMostRecentMemberId >= 0) ? clusterPeerSecret : peer->key(),encrypt);
+		packet.armor((clusterMostRecentMemberId >= 0) ? clusterPeerSecret : peer->key(),encrypt,(viaPath) ? viaPath->nextOutgoingCounter() : 0);
 	}
 #else
 	const uint64_t trustedPathId = RR->topology->getOutboundPathTrust(viaPath->address());
 	if (trustedPathId) {
 		packet.setTrusted(trustedPathId);
 	} else {
-		packet.armor(peer->key(),encrypt);
+		packet.armor(peer->key(),encrypt,viaPath->nextOutgoingCounter());
 	}
 #endif