tidy up

10 files changed, 257 insertions, 230 deletions

diff --git a/b2sum/makefile b/b2sum/makefile
index 8558b2b..164cb26 100644
--- a/b2sum/makefile
+++ b/b2sum/makefile
@@ -2,8 +2,8 @@ PROG=b2sum
 PREFIX?=/usr/local
 MANDIR?=$(PREFIX)/man
 CC?=gcc
-CFLAGS?=-O3 -march=native -static -Werror=declaration-after-statement
-CFLAGS+=-std=c99 -I../sse -fopenmp
+CFLAGS?=-O3 -march=native -static
+CFLAGS+=-I../sse -fopenmp
 LIBS=
 #FILES=b2sum.c ../ref/blake2b-ref.c ../ref/blake2s-ref.c ../ref/blake2bp-ref.c ../ref/blake2sp-ref.c 
 FILES=b2sum.c ../sse/blake2b.c ../sse/blake2s.c ../sse/blake2bp.c ../sse/blake2sp.c 
diff --git a/ref/blake2-impl.h b/ref/blake2-impl.h
index 63a2394..8314380 100644
--- a/ref/blake2-impl.h
+++ b/ref/blake2-impl.h
@@ -19,7 +19,7 @@
 #include <stdint.h>
 #include <string.h>
 
-BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src )
+static uint32_t load32( const void *src )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   uint32_t w;
@@ -27,15 +27,14 @@ BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src )
   return w;
 #else
   const uint8_t *p = ( const uint8_t * )src;
-  uint32_t w = *p++;
-  w |= ( uint32_t )( *p++ ) <<  8;
-  w |= ( uint32_t )( *p++ ) << 16;
-  w |= ( uint32_t )( *p++ ) << 24;
-  return w;
+  return (( uint32_t )( p[0] ) <<  0) |
+         (( uint32_t )( p[1] ) <<  8) |
+         (( uint32_t )( p[2] ) << 16) |
+         (( uint32_t )( p[3] ) << 24) ;
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src )
+static uint64_t load64( const void *src )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   uint64_t w;
@@ -43,93 +42,91 @@ BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src )
   return w;
 #else
   const uint8_t *p = ( const uint8_t * )src;
-  uint64_t w = *p++;
-  w |= ( uint64_t )( *p++ ) <<  8;
-  w |= ( uint64_t )( *p++ ) << 16;
-  w |= ( uint64_t )( *p++ ) << 24;
-  w |= ( uint64_t )( *p++ ) << 32;
-  w |= ( uint64_t )( *p++ ) << 40;
-  w |= ( uint64_t )( *p++ ) << 48;
-  w |= ( uint64_t )( *p++ ) << 56;
-  return w;
+  return (( uint64_t )( p[0] ) <<  0) |
+         (( uint64_t )( p[1] ) <<  8) |
+         (( uint64_t )( p[2] ) << 16) |
+         (( uint64_t )( p[3] ) << 24) |
+         (( uint64_t )( p[4] ) << 32) |
+         (( uint64_t )( p[5] ) << 40) |
+         (( uint64_t )( p[6] ) << 48) |
+         (( uint64_t )( p[7] ) << 56) ;
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(void) store32( void *dst, uint32_t w )
+static void store32( void *dst, uint32_t w )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   memcpy(dst, &w, sizeof w);
 #else
   uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(void) store64( void *dst, uint64_t w )
+static void store64( void *dst, uint64_t w )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   memcpy(dst, &w, sizeof w);
 #else
   uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
+  p[4] = (uint8_t)(w >> 32);
+  p[5] = (uint8_t)(w >> 40);
+  p[6] = (uint8_t)(w >> 48);
+  p[7] = (uint8_t)(w >> 56);
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) load48( const void *src )
+static uint64_t load48( const void *src )
 {
   const uint8_t *p = ( const uint8_t * )src;
-  uint64_t w = *p++;
-  w |= ( uint64_t )( *p++ ) <<  8;
-  w |= ( uint64_t )( *p++ ) << 16;
-  w |= ( uint64_t )( *p++ ) << 24;
-  w |= ( uint64_t )( *p++ ) << 32;
-  w |= ( uint64_t )( *p++ ) << 40;
-  return w;
+  return (( uint64_t )( p[0] ) <<  0) |
+         (( uint64_t )( p[1] ) <<  8) |
+         (( uint64_t )( p[2] ) << 16) |
+         (( uint64_t )( p[3] ) << 24) |
+         (( uint64_t )( p[4] ) << 32) |
+         (( uint64_t )( p[5] ) << 40) ;
 }
 
-BLAKE2_LOCAL_INLINE(void) store48( void *dst, uint64_t w )
+static void store48( void *dst, uint64_t w )
 {
   uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
+  p[4] = (uint8_t)(w >> 32);
+  p[5] = (uint8_t)(w >> 40);
 }
 
-BLAKE2_LOCAL_INLINE(uint32_t) rotl32( const uint32_t w, const unsigned c )
+static uint32_t rotl32( const uint32_t w, const unsigned c )
 {
   return ( w << c ) | ( w >> ( 32 - c ) );
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) rotl64( const uint64_t w, const unsigned c )
+static uint64_t rotl64( const uint64_t w, const unsigned c )
 {
   return ( w << c ) | ( w >> ( 64 - c ) );
 }
 
-BLAKE2_LOCAL_INLINE(uint32_t) rotr32( const uint32_t w, const unsigned c )
+static uint32_t rotr32( const uint32_t w, const unsigned c )
 {
   return ( w >> c ) | ( w << ( 32 - c ) );
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) rotr64( const uint64_t w, const unsigned c )
+static uint64_t rotr64( const uint64_t w, const unsigned c )
 {
   return ( w >> c ) | ( w << ( 64 - c ) );
 }
 
 /* prevents compiler optimizing out memset() */
-BLAKE2_LOCAL_INLINE(void) secure_zero_memory(void *v, size_t n)
+static void secure_zero_memory(void *v, size_t n)
 {
   static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
   memset_v(v, 0, n);
diff --git a/ref/blake2.h b/ref/blake2.h
index 1a9fdf4..fd25987 100644
--- a/ref/blake2.h
+++ b/ref/blake2.h
@@ -19,12 +19,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#ifdef BLAKE2_NO_INLINE
-#define BLAKE2_LOCAL_INLINE(type) static type
-#endif
-
-#ifndef BLAKE2_LOCAL_INLINE
-#define BLAKE2_LOCAL_INLINE(type) static inline type
+#if defined(_MSC_VER)
+#define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop))
+#else
+#define BLAKE2_PACKED(x) x __attribute__((packed))
 #endif
 
 #if defined(__cplusplus)
@@ -86,23 +84,24 @@ extern "C" {
   } blake2bp_state;
 
 
-#pragma pack(push, 1)
-  typedef struct __blake2s_param
+  BLAKE2_PACKED(struct __blake2s_param
   {
     uint8_t  digest_length; /* 1 */
     uint8_t  key_length;    /* 2 */
     uint8_t  fanout;        /* 3 */
     uint8_t  depth;         /* 4 */
     uint32_t leaf_length;   /* 8 */
-    uint8_t  node_offset[6];// 14
+    uint8_t  node_offset[6];/* 14 */
     uint8_t  node_depth;    /* 15 */
     uint8_t  inner_length;  /* 16 */
     /* uint8_t  reserved[0]; */
     uint8_t  salt[BLAKE2S_SALTBYTES]; /* 24 */
     uint8_t  personal[BLAKE2S_PERSONALBYTES];  /* 32 */
-  } blake2s_param;
+  });
 
-  typedef struct __blake2b_param
+  typedef struct __blake2s_param blake2s_param;
+
+  BLAKE2_PACKED(struct __blake2b_param
   {
     uint8_t  digest_length; /* 1 */
     uint8_t  key_length;    /* 2 */
@@ -115,8 +114,15 @@ extern "C" {
     uint8_t  reserved[14];  /* 32 */
     uint8_t  salt[BLAKE2B_SALTBYTES]; /* 48 */
     uint8_t  personal[BLAKE2B_PERSONALBYTES];  /* 64 */
-  } blake2b_param;
-#pragma pack(pop)
+  });
+
+  typedef struct __blake2b_param blake2b_param;
+
+  /* Padded structs result in a compile-time error */
+  enum {
+    BLAKE2_DUMMY_1 = 1/(sizeof(blake2s_param) == BLAKE2S_OUTBYTES),
+    BLAKE2_DUMMY_2 = 1/(sizeof(blake2b_param) == BLAKE2B_OUTBYTES)
+  };
 
   /* Streaming API */
   int blake2s_init( blake2s_state *S, const uint8_t outlen );
@@ -148,10 +154,8 @@ extern "C" {
   int blake2sp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
   int blake2bp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
 
-  static inline int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
-  {
-    return blake2b( out, in, key, outlen, inlen, keylen );
-  }
+  /* This is simply an alias for blake2b */
+  int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
 
 #if defined(__cplusplus)
 }
diff --git a/ref/blake2b-ref.c b/ref/blake2b-ref.c
index ac91568..be2ec04 100644
--- a/ref/blake2b-ref.c
+++ b/ref/blake2b-ref.c
@@ -45,25 +45,25 @@ static const uint8_t blake2b_sigma[12][16] =
 };
 
 
-BLAKE2_LOCAL_INLINE(int) blake2b_set_lastnode( blake2b_state *S )
+static int blake2b_set_lastnode( blake2b_state *S )
 {
   S->f[1] = -1;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_clear_lastnode( blake2b_state *S )
+static int blake2b_clear_lastnode( blake2b_state *S )
 {
   S->f[1] = 0;
   return 0;
 }
 
 /* Some helper functions, not necessarily useful */
-BLAKE2_LOCAL_INLINE(int) blake2b_is_lastblock( const blake2b_state *S )
+static int blake2b_is_lastblock( const blake2b_state *S )
 {
   return S->f[0] != 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_set_lastblock( blake2b_state *S )
+static int blake2b_set_lastblock( blake2b_state *S )
 {
   if( S->last_node ) blake2b_set_lastnode( S );
 
@@ -71,7 +71,7 @@ BLAKE2_LOCAL_INLINE(int) blake2b_set_lastblock( blake2b_state *S )
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_clear_lastblock( blake2b_state *S )
+static int blake2b_clear_lastblock( blake2b_state *S )
 {
   if( S->last_node ) blake2b_clear_lastnode( S );
 
@@ -79,7 +79,7 @@ BLAKE2_LOCAL_INLINE(int) blake2b_clear_lastblock( blake2b_state *S )
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_increment_counter( blake2b_state *S, const uint64_t inc )
+static int blake2b_increment_counter( blake2b_state *S, const uint64_t inc )
 {
   S->t[0] += inc;
   S->t[1] += ( S->t[0] < inc );
@@ -89,65 +89,66 @@ BLAKE2_LOCAL_INLINE(int) blake2b_increment_counter( blake2b_state *S, const uint
 
 
 /* Parameter-related functions */
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_digest_length( blake2b_param *P, const uint8_t digest_length )
+static int blake2b_param_set_digest_length( blake2b_param *P, const uint8_t digest_length )
 {
   P->digest_length = digest_length;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_fanout( blake2b_param *P, const uint8_t fanout )
+static int blake2b_param_set_fanout( blake2b_param *P, const uint8_t fanout )
 {
   P->fanout = fanout;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_max_depth( blake2b_param *P, const uint8_t depth )
+static int blake2b_param_set_max_depth( blake2b_param *P, const uint8_t depth )
 {
   P->depth = depth;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_leaf_length( blake2b_param *P, const uint32_t leaf_length )
+static int blake2b_param_set_leaf_length( blake2b_param *P, const uint32_t leaf_length )
 {
   store32( &P->leaf_length, leaf_length );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_node_offset( blake2b_param *P, const uint64_t node_offset )
+static int blake2b_param_set_node_offset( blake2b_param *P, const uint64_t node_offset )
 {
   store64( &P->node_offset, node_offset );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_node_depth( blake2b_param *P, const uint8_t node_depth )
+static int blake2b_param_set_node_depth( blake2b_param *P, const uint8_t node_depth )
 {
   P->node_depth = node_depth;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_inner_length( blake2b_param *P, const uint8_t inner_length )
+static int blake2b_param_set_inner_length( blake2b_param *P, const uint8_t inner_length )
 {
   P->inner_length = inner_length;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_salt( blake2b_param *P, const uint8_t salt[BLAKE2B_SALTBYTES] )
+static int blake2b_param_set_salt( blake2b_param *P, const uint8_t salt[BLAKE2B_SALTBYTES] )
 {
   memcpy( P->salt, salt, BLAKE2B_SALTBYTES );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_param_set_personal( blake2b_param *P, const uint8_t personal[BLAKE2B_PERSONALBYTES] )
+static int blake2b_param_set_personal( blake2b_param *P, const uint8_t personal[BLAKE2B_PERSONALBYTES] )
 {
   memcpy( P->personal, personal, BLAKE2B_PERSONALBYTES );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2b_init0( blake2b_state *S )
+static int blake2b_init0( blake2b_state *S )
 {
+  int i;
   memset( S, 0, sizeof( blake2b_state ) );
 
-  for( int i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i];
+  for( i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i];
 
   return 0;
 }
@@ -156,11 +157,12 @@ BLAKE2_LOCAL_INLINE(int) blake2b_init0( blake2b_state *S )
 int blake2b_init_param( blake2b_state *S, const blake2b_param *P )
 {
   const uint8_t *p = ( const uint8_t * )( P );
+  size_t i;
 
   blake2b_init0( S );
 
   /* IV XOR ParamBlock */
-  for( size_t i = 0; i < 8; ++i )
+  for( i = 0; i < 8; ++i )
     S->h[i] ^= load64( p + sizeof( S->h[i] ) * i );
 
   return 0;
@@ -319,6 +321,7 @@ int blake2b_update( blake2b_state *S, const uint8_t *in, uint64_t inlen )
 int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen )
 {
   uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
+  int i;
 
   if( out == NULL || outlen == 0 || outlen > BLAKE2B_OUTBYTES )
     return -1;
@@ -339,7 +342,7 @@ int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen )
   memset( S->buf + S->buflen, 0, 2 * BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
   blake2b_compress( S, S->buf );
 
-  for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
+  for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
     store64( buffer + sizeof( S->h[i] ) * i, S->h[i] );
 
   memcpy( out, buffer, outlen );
@@ -376,6 +379,10 @@ int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen
   return 0;
 }
 
+int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) {
+  return blake2b(out, in, key, outlen, inlen, keylen);
+}
+
 #if defined(SUPERCOP)
 int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen )
 {
@@ -386,18 +393,19 @@ int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen
 #if defined(BLAKE2B_SELFTEST)
 #include <string.h>
 #include "blake2-kat.h"
-int main( int argc, char **argv )
+int main( void )
 {
   uint8_t key[BLAKE2B_KEYBYTES];
   uint8_t buf[KAT_LENGTH];
+  size_t i;
 
-  for( size_t i = 0; i < BLAKE2B_KEYBYTES; ++i )
+  for( i = 0; i < BLAKE2B_KEYBYTES; ++i )
     key[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
     buf[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
   {
     uint8_t hash[BLAKE2B_OUTBYTES];
     blake2b( hash, buf, key, BLAKE2B_OUTBYTES, i, BLAKE2B_KEYBYTES );
diff --git a/ref/blake2bp-ref.c b/ref/blake2bp-ref.c
index 28855e6..b3a3467 100644
--- a/ref/blake2bp-ref.c
+++ b/ref/blake2bp-ref.c
@@ -27,7 +27,7 @@
 
 #define PARALLELISM_DEGREE 4
 
-BLAKE2_LOCAL_INLINE(int) blake2bp_init_leaf( blake2b_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset )
+static int blake2bp_init_leaf( blake2b_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset )
 {
   blake2b_param P[1];
   P->digest_length = outlen;
@@ -44,7 +44,7 @@ BLAKE2_LOCAL_INLINE(int) blake2bp_init_leaf( blake2b_state *S, uint8_t outlen, u
   return blake2b_init_param( S, P );
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2bp_init_root( blake2b_state *S, uint8_t outlen, uint8_t keylen )
+static int blake2bp_init_root( blake2b_state *S, uint8_t outlen, uint8_t keylen )
 {
   blake2b_param P[1];
   P->digest_length = outlen;
@@ -64,6 +64,8 @@ BLAKE2_LOCAL_INLINE(int) blake2bp_init_root( blake2b_state *S, uint8_t outlen, u
 
 int blake2bp_init( blake2bp_state *S, const uint8_t outlen )
 {
+  size_t i;
+
   if( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1;
 
   memset( S->buf, 0, sizeof( S->buf ) );
@@ -72,7 +74,7 @@ int blake2bp_init( blake2bp_state *S, const uint8_t outlen )
   if( blake2bp_init_root( S->R, outlen, 0 ) < 0 )
     return -1;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     if( blake2bp_init_leaf( S->S[i], outlen, 0, i ) < 0 ) return -1;
 
   S->R->last_node = 1;
@@ -82,6 +84,8 @@ int blake2bp_init( blake2bp_state *S, const uint8_t outlen )
 
 int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen )
 {
+  size_t i;
+
   if( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1;
 
   if( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1;
@@ -92,7 +96,7 @@ int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key,
   if( blake2bp_init_root( S->R, outlen, keylen ) < 0 )
     return -1;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     if( blake2bp_init_leaf( S->S[i], outlen, keylen, i ) < 0 ) return -1;
 
   S->R->last_node = 1;
@@ -102,7 +106,7 @@ int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key,
     memset( block, 0, BLAKE2B_BLOCKBYTES );
     memcpy( block, key, keylen );
 
-    for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+    for( i = 0; i < PARALLELISM_DEGREE; ++i )
       blake2b_update( S->S[i], block, BLAKE2B_BLOCKBYTES );
 
     secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */
@@ -115,12 +119,13 @@ int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen )
 {
   size_t left = S->buflen;
   size_t fill = sizeof( S->buf ) - left;
+  size_t i;
 
   if( left && inlen >= fill )
   {
     memcpy( S->buf + left, in, fill );
 
-    for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+    for( i = 0; i < PARALLELISM_DEGREE; ++i )
       blake2b_update( S->S[i], S->buf + i * BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES );
 
     in += fill;
@@ -132,19 +137,19 @@ int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen )
   #pragma omp parallel shared(S), num_threads(PARALLELISM_DEGREE)
 #else
 
-  for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
 #endif
   {
 #if defined(_OPENMP)
-    size_t      id__ = omp_get_thread_num();
+    size_t      i = omp_get_thread_num();
 #endif
     uint64_t inlen__ = inlen;
     const uint8_t *in__ = ( const uint8_t * )in;
-    in__ += id__ * BLAKE2B_BLOCKBYTES;
+    in__ += i * BLAKE2B_BLOCKBYTES;
 
     while( inlen__ >= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES )
     {
-      blake2b_update( S->S[id__], in__, BLAKE2B_BLOCKBYTES );
+      blake2b_update( S->S[i], in__, BLAKE2B_BLOCKBYTES );
       in__ += PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES;
       inlen__ -= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES;
     }
@@ -163,8 +168,9 @@ int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen )
 int blake2bp_final( blake2bp_state *S, uint8_t *out, const uint8_t outlen )
 {
   uint8_t hash[PARALLELISM_DEGREE][BLAKE2B_OUTBYTES];
+  size_t i;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
   {
     if( S->buflen > i * BLAKE2B_BLOCKBYTES )
     {
@@ -178,10 +184,9 @@ int blake2bp_final( blake2bp_state *S, uint8_t *out, const uint8_t outlen )
     blake2b_final( S->S[i], hash[i], BLAKE2B_OUTBYTES );
   }
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     blake2b_update( S->R, hash[i], BLAKE2B_OUTBYTES );
 
-  
   return blake2b_final( S->R, out, outlen );
 }
 
@@ -190,6 +195,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
   uint8_t hash[PARALLELISM_DEGREE][BLAKE2B_OUTBYTES];
   blake2b_state S[PARALLELISM_DEGREE][1];
   blake2b_state FS[1];
+  size_t i;
 
   /* Verify parameters */
   if ( NULL == in && inlen > 0 ) return -1;
@@ -202,7 +208,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
 
   if( keylen > BLAKE2B_KEYBYTES ) return -1;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     if( blake2bp_init_leaf( S[i], outlen, keylen, i ) < 0 ) return -1;
 
   S[PARALLELISM_DEGREE - 1]->last_node = 1; /* mark last node */
@@ -213,7 +219,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
     memset( block, 0, BLAKE2B_BLOCKBYTES );
     memcpy( block, key, keylen );
 
-    for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+    for( i = 0; i < PARALLELISM_DEGREE; ++i )
       blake2b_update( S[i], block, BLAKE2B_BLOCKBYTES );
 
     secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */
@@ -223,31 +229,31 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
   #pragma omp parallel shared(S,hash), num_threads(PARALLELISM_DEGREE)
 #else
 
-  for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
 #endif
   {
 #if defined(_OPENMP)
-    size_t      id__ = omp_get_thread_num();
+    size_t      i = omp_get_thread_num();
 #endif
     uint64_t inlen__ = inlen;
     const uint8_t *in__ = ( const uint8_t * )in;
-    in__ += id__ * BLAKE2B_BLOCKBYTES;
+    in__ += i * BLAKE2B_BLOCKBYTES;
 
     while( inlen__ >= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES )
     {
-      blake2b_update( S[id__], in__, BLAKE2B_BLOCKBYTES );
+      blake2b_update( S[i], in__, BLAKE2B_BLOCKBYTES );
       in__ += PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES;
       inlen__ -= PARALLELISM_DEGREE * BLAKE2B_BLOCKBYTES;
     }
 
-    if( inlen__ > id__ * BLAKE2B_BLOCKBYTES )
+    if( inlen__ > i * BLAKE2B_BLOCKBYTES )
     {
-      const size_t left = inlen__ - id__ * BLAKE2B_BLOCKBYTES;
+      const size_t left = inlen__ - i * BLAKE2B_BLOCKBYTES;
       const size_t len = left <= BLAKE2B_BLOCKBYTES ? left : BLAKE2B_BLOCKBYTES;
-      blake2b_update( S[id__], in__, len );
+      blake2b_update( S[i], in__, len );
     }
 
-    blake2b_final( S[id__], hash[id__], BLAKE2B_OUTBYTES );
+    blake2b_final( S[i], hash[i], BLAKE2B_OUTBYTES );
   }
 
   if( blake2bp_init_root( FS, outlen, keylen ) < 0 )
@@ -255,7 +261,7 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
 
   FS->last_node = 1; /* Mark as last node */
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     blake2b_update( FS, hash[i], BLAKE2B_OUTBYTES );
 
   return blake2b_final( FS, out, outlen );;
@@ -264,18 +270,19 @@ int blake2bp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
 #if defined(BLAKE2BP_SELFTEST)
 #include <string.h>
 #include "blake2-kat.h"
-int main( int argc, char **argv )
+int main( void )
 {
   uint8_t key[BLAKE2B_KEYBYTES];
   uint8_t buf[KAT_LENGTH];
+  size_t i;
 
-  for( size_t i = 0; i < BLAKE2B_KEYBYTES; ++i )
+  for( i = 0; i < BLAKE2B_KEYBYTES; ++i )
     key[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
     buf[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
   {
     uint8_t hash[BLAKE2B_OUTBYTES];
     blake2bp( hash, buf, key, BLAKE2B_OUTBYTES, i, BLAKE2B_KEYBYTES );
diff --git a/ref/blake2s-ref.c b/ref/blake2s-ref.c
index 0e246c3..e24183c 100644
--- a/ref/blake2s-ref.c
+++ b/ref/blake2s-ref.c
@@ -40,25 +40,25 @@ static const uint8_t blake2s_sigma[10][16] =
   { 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 } ,
 };
 
-BLAKE2_LOCAL_INLINE(int) blake2s_set_lastnode( blake2s_state *S )
+static int blake2s_set_lastnode( blake2s_state *S )
 {
   S->f[1] = -1;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_clear_lastnode( blake2s_state *S )
+static int blake2s_clear_lastnode( blake2s_state *S )
 {
   S->f[1] = 0;
   return 0;
 }
 
 /* Some helper functions, not necessarily useful */
-BLAKE2_LOCAL_INLINE(int) blake2s_is_lastblock( const blake2s_state *S )
+static int blake2s_is_lastblock( const blake2s_state *S )
 {
   return S->f[0] != 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_set_lastblock( blake2s_state *S )
+static int blake2s_set_lastblock( blake2s_state *S )
 {
   if( S->last_node ) blake2s_set_lastnode( S );
 
@@ -66,7 +66,7 @@ BLAKE2_LOCAL_INLINE(int) blake2s_set_lastblock( blake2s_state *S )
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_clear_lastblock( blake2s_state *S )
+static int blake2s_clear_lastblock( blake2s_state *S )
 {
   if( S->last_node ) blake2s_clear_lastnode( S );
 
@@ -74,7 +74,7 @@ BLAKE2_LOCAL_INLINE(int) blake2s_clear_lastblock( blake2s_state *S )
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_increment_counter( blake2s_state *S, const uint32_t inc )
+static int blake2s_increment_counter( blake2s_state *S, const uint32_t inc )
 {
   S->t[0] += inc;
   S->t[1] += ( S->t[0] < inc );
@@ -82,65 +82,66 @@ BLAKE2_LOCAL_INLINE(int) blake2s_increment_counter( blake2s_state *S, const uint
 }
 
 /* Parameter-related functions */
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_digest_length( blake2s_param *P, const uint8_t digest_length )
+static int blake2s_param_set_digest_length( blake2s_param *P, const uint8_t digest_length )
 {
   P->digest_length = digest_length;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_fanout( blake2s_param *P, const uint8_t fanout )
+static int blake2s_param_set_fanout( blake2s_param *P, const uint8_t fanout )
 {
   P->fanout = fanout;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_max_depth( blake2s_param *P, const uint8_t depth )
+static int blake2s_param_set_max_depth( blake2s_param *P, const uint8_t depth )
 {
   P->depth = depth;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_leaf_length( blake2s_param *P, const uint32_t leaf_length )
+static int blake2s_param_set_leaf_length( blake2s_param *P, const uint32_t leaf_length )
 {
   store32( &P->leaf_length, leaf_length );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_node_offset( blake2s_param *P, const uint64_t node_offset )
+static int blake2s_param_set_node_offset( blake2s_param *P, const uint64_t node_offset )
 {
   store48( P->node_offset, node_offset );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_node_depth( blake2s_param *P, const uint8_t node_depth )
+static int blake2s_param_set_node_depth( blake2s_param *P, const uint8_t node_depth )
 {
   P->node_depth = node_depth;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_inner_length( blake2s_param *P, const uint8_t inner_length )
+static int blake2s_param_set_inner_length( blake2s_param *P, const uint8_t inner_length )
 {
   P->inner_length = inner_length;
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] )
+static int blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] )
 {
   memcpy( P->salt, salt, BLAKE2S_SALTBYTES );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] )
+static int blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] )
 {
   memcpy( P->personal, personal, BLAKE2S_PERSONALBYTES );
   return 0;
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2s_init0( blake2s_state *S )
+static int blake2s_init0( blake2s_state *S )
 {
+  int i;
   memset( S, 0, sizeof( blake2s_state ) );
 
-  for( int i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i];
+  for( i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i];
 
   return 0;
 }
@@ -148,12 +149,13 @@ BLAKE2_LOCAL_INLINE(int) blake2s_init0( blake2s_state *S )
 /* init2 xors IV with input parameter block */
 int blake2s_init_param( blake2s_state *S, const blake2s_param *P )
 {
+  size_t i;
   const uint32_t *p = ( const uint32_t * )( P );
 
   blake2s_init0( S );
 
   /* IV XOR ParamBlock */
-  for( size_t i = 0; i < 8; ++i )
+  for( i = 0; i < 8; ++i )
     S->h[i] ^= load32( &p[i] );
 
   return 0;
@@ -218,11 +220,12 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK
 {
   uint32_t m[16];
   uint32_t v[16];
+  size_t i;
 
-  for( size_t i = 0; i < 16; ++i )
+  for( i = 0; i < 16; ++i )
     m[i] = load32( block + i * sizeof( m[i] ) );
 
-  for( size_t i = 0; i < 8; ++i )
+  for( i = 0; i < 8; ++i )
     v[i] = S->h[i];
 
   v[ 8] = blake2s_IV[0];
@@ -266,7 +269,7 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK
   ROUND( 8 );
   ROUND( 9 );
 
-  for( size_t i = 0; i < 8; ++i )
+  for( i = 0; i < 8; ++i )
     S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
 
 #undef G
@@ -308,6 +311,7 @@ int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen )
 int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen )
 {
   uint8_t buffer[BLAKE2S_OUTBYTES] = {0};
+  int i;
 
   if( out == NULL || outlen == 0 || outlen > BLAKE2S_OUTBYTES )
     return -1;
@@ -329,9 +333,9 @@ int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen )
   memset( S->buf + S->buflen, 0, 2 * BLAKE2S_BLOCKBYTES - S->buflen ); /* Padding */
   blake2s_compress( S, S->buf );
 
-  for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
+  for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
     store32( buffer + sizeof( S->h[i] ) * i, S->h[i] );
-    
+
   memcpy( out, buffer, outlen );
   return 0;
 }
@@ -375,18 +379,19 @@ int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen
 #if defined(BLAKE2S_SELFTEST)
 #include <string.h>
 #include "blake2-kat.h"
-int main( int argc, char **argv )
+int main( void )
 {
   uint8_t key[BLAKE2S_KEYBYTES];
   uint8_t buf[KAT_LENGTH];
+  size_t i;
 
-  for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i )
+  for( i = 0; i < BLAKE2S_KEYBYTES; ++i )
     key[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
     buf[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
   {
     uint8_t hash[BLAKE2S_OUTBYTES];
     blake2s( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES );
diff --git a/ref/blake2sp-ref.c b/ref/blake2sp-ref.c
index 3775a2d..05d17f6 100644
--- a/ref/blake2sp-ref.c
+++ b/ref/blake2sp-ref.c
@@ -26,7 +26,7 @@
 
 #define PARALLELISM_DEGREE 8
 
-BLAKE2_LOCAL_INLINE(int) blake2sp_init_leaf( blake2s_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset )
+static int blake2sp_init_leaf( blake2s_state *S, uint8_t outlen, uint8_t keylen, uint64_t offset )
 {
   blake2s_param P[1];
   P->digest_length = outlen;
@@ -42,7 +42,7 @@ BLAKE2_LOCAL_INLINE(int) blake2sp_init_leaf( blake2s_state *S, uint8_t outlen, u
   return blake2s_init_param( S, P );
 }
 
-BLAKE2_LOCAL_INLINE(int) blake2sp_init_root( blake2s_state *S, uint8_t outlen, uint8_t keylen )
+static int blake2sp_init_root( blake2s_state *S, uint8_t outlen, uint8_t keylen )
 {
   blake2s_param P[1];
   P->digest_length = outlen;
@@ -61,6 +61,8 @@ BLAKE2_LOCAL_INLINE(int) blake2sp_init_root( blake2s_state *S, uint8_t outlen, u
 
 int blake2sp_init( blake2sp_state *S, const uint8_t outlen )
 {
+  size_t i;
+
   if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1;
 
   memset( S->buf, 0, sizeof( S->buf ) );
@@ -69,7 +71,7 @@ int blake2sp_init( blake2sp_state *S, const uint8_t outlen )
   if( blake2sp_init_root( S->R, outlen, 0 ) < 0 )
     return -1;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     if( blake2sp_init_leaf( S->S[i], outlen, 0, i ) < 0 ) return -1;
 
   S->R->last_node = 1;
@@ -79,6 +81,8 @@ int blake2sp_init( blake2sp_state *S, const uint8_t outlen )
 
 int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen )
 {
+  size_t i;
+
   if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1;
 
   if( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1;
@@ -89,7 +93,7 @@ int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key,
   if( blake2sp_init_root( S->R, outlen, keylen ) < 0 )
     return -1;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     if( blake2sp_init_leaf( S->S[i], outlen, keylen, i ) < 0 ) return -1;
 
   S->R->last_node = 1;
@@ -99,7 +103,7 @@ int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key,
     memset( block, 0, BLAKE2S_BLOCKBYTES );
     memcpy( block, key, keylen );
 
-    for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+    for( i = 0; i < PARALLELISM_DEGREE; ++i )
       blake2s_update( S->S[i], block, BLAKE2S_BLOCKBYTES );
 
     secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */
@@ -112,12 +116,13 @@ int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen )
 {
   size_t left = S->buflen;
   size_t fill = sizeof( S->buf ) - left;
+  size_t i;
 
   if( left && inlen >= fill )
   {
     memcpy( S->buf + left, in, fill );
 
-    for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+    for( i = 0; i < PARALLELISM_DEGREE; ++i )
       blake2s_update( S->S[i], S->buf + i * BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES );
 
     in += fill;
@@ -128,20 +133,19 @@ int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen )
 #if defined(_OPENMP)
   #pragma omp parallel shared(S), num_threads(PARALLELISM_DEGREE)
 #else
-
-  for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
 #endif
   {
 #if defined(_OPENMP)
-    size_t      id__ = omp_get_thread_num();
+    size_t      i = omp_get_thread_num();
 #endif
     uint64_t inlen__ = inlen;
     const uint8_t *in__ = ( const uint8_t * )in;
-    in__ += id__ * BLAKE2S_BLOCKBYTES;
+    in__ += i * BLAKE2S_BLOCKBYTES;
 
     while( inlen__ >= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES )
     {
-      blake2s_update( S->S[id__], in__, BLAKE2S_BLOCKBYTES );
+      blake2s_update( S->S[i], in__, BLAKE2S_BLOCKBYTES );
       in__ += PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES;
       inlen__ -= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES;
     }
@@ -161,8 +165,9 @@ int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen )
 int blake2sp_final( blake2sp_state *S, uint8_t *out, const uint8_t outlen )
 {
   uint8_t hash[PARALLELISM_DEGREE][BLAKE2S_OUTBYTES];
+  size_t i;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
   {
     if( S->buflen > i * BLAKE2S_BLOCKBYTES )
     {
@@ -176,7 +181,7 @@ int blake2sp_final( blake2sp_state *S, uint8_t *out, const uint8_t outlen )
     blake2s_final( S->S[i], hash[i], BLAKE2S_OUTBYTES );
   }
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     blake2s_update( S->R, hash[i], BLAKE2S_OUTBYTES );
 
   return blake2s_final( S->R, out, outlen );
@@ -188,6 +193,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
   uint8_t hash[PARALLELISM_DEGREE][BLAKE2S_OUTBYTES];
   blake2s_state S[PARALLELISM_DEGREE][1];
   blake2s_state FS[1];
+  size_t i;
 
   /* Verify parameters */
   if ( NULL == in && inlen > 0 ) return -1;
@@ -200,7 +206,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
 
   if( keylen > BLAKE2S_KEYBYTES ) return -1;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     if( blake2sp_init_leaf( S[i], outlen, keylen, i ) < 0 ) return -1;
 
   S[PARALLELISM_DEGREE - 1]->last_node = 1; /* mark last node */
@@ -211,7 +217,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
     memset( block, 0, BLAKE2S_BLOCKBYTES );
     memcpy( block, key, keylen );
 
-    for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+    for( i = 0; i < PARALLELISM_DEGREE; ++i )
       blake2s_update( S[i], block, BLAKE2S_BLOCKBYTES );
 
     secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */
@@ -221,31 +227,31 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
   #pragma omp parallel shared(S,hash), num_threads(PARALLELISM_DEGREE)
 #else
 
-  for( size_t id__ = 0; id__ < PARALLELISM_DEGREE; ++id__ )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
 #endif
   {
 #if defined(_OPENMP)
-    size_t      id__ = omp_get_thread_num();
+    size_t      i = omp_get_thread_num();
 #endif
     uint64_t inlen__ = inlen;
     const uint8_t *in__ = ( const uint8_t * )in;
-    in__ += id__ * BLAKE2S_BLOCKBYTES;
+    in__ += i * BLAKE2S_BLOCKBYTES;
 
     while( inlen__ >= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES )
     {
-      blake2s_update( S[id__], in__, BLAKE2S_BLOCKBYTES );
+      blake2s_update( S[i], in__, BLAKE2S_BLOCKBYTES );
       in__ += PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES;
       inlen__ -= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES;
     }
 
-    if( inlen__ > id__ * BLAKE2S_BLOCKBYTES )
+    if( inlen__ > i * BLAKE2S_BLOCKBYTES )
     {
-      const size_t left = inlen__ - id__ * BLAKE2S_BLOCKBYTES;
+      const size_t left = inlen__ - i * BLAKE2S_BLOCKBYTES;
       const size_t len = left <= BLAKE2S_BLOCKBYTES ? left : BLAKE2S_BLOCKBYTES;
-      blake2s_update( S[id__], in__, len );
+      blake2s_update( S[i], in__, len );
     }
 
-    blake2s_final( S[id__], hash[id__], BLAKE2S_OUTBYTES );
+    blake2s_final( S[i], hash[i], BLAKE2S_OUTBYTES );
   }
 
   if( blake2sp_init_root( FS, outlen, keylen ) < 0 )
@@ -253,7 +259,7 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
 
   FS->last_node = 1;
 
-  for( size_t i = 0; i < PARALLELISM_DEGREE; ++i )
+  for( i = 0; i < PARALLELISM_DEGREE; ++i )
     blake2s_update( FS, hash[i], BLAKE2S_OUTBYTES );
 
   return blake2s_final( FS, out, outlen );
@@ -264,18 +270,19 @@ int blake2sp( uint8_t *out, const void *in, const void *key, uint8_t outlen, uin
 #if defined(BLAKE2SP_SELFTEST)
 #include <string.h>
 #include "blake2-kat.h"
-int main( int argc, char **argv )
+int main( void )
 {
   uint8_t key[BLAKE2S_KEYBYTES];
   uint8_t buf[KAT_LENGTH];
+  size_t i;
 
-  for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i )
+  for( i = 0; i < BLAKE2S_KEYBYTES; ++i )
     key[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
     buf[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < KAT_LENGTH; ++i )
   {
     uint8_t hash[BLAKE2S_OUTBYTES];
     blake2sp( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES );
diff --git a/sse/blake2-impl.h b/sse/blake2-impl.h
index bbe3c0f..8314380 100644
--- a/sse/blake2-impl.h
+++ b/sse/blake2-impl.h
@@ -1,5 +1,5 @@
 /*
-   BLAKE2 reference source code package - optimized C implementations
+   BLAKE2 reference source code package - reference C implementations
   
    Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
    terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
@@ -19,7 +19,7 @@
 #include <stdint.h>
 #include <string.h>
 
-BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src )
+static uint32_t load32( const void *src )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   uint32_t w;
@@ -27,15 +27,14 @@ BLAKE2_LOCAL_INLINE(uint32_t) load32( const void *src )
   return w;
 #else
   const uint8_t *p = ( const uint8_t * )src;
-  uint32_t w = *p++;
-  w |= ( uint32_t )( *p++ ) <<  8;
-  w |= ( uint32_t )( *p++ ) << 16;
-  w |= ( uint32_t )( *p++ ) << 24;
-  return w;
+  return (( uint32_t )( p[0] ) <<  0) |
+         (( uint32_t )( p[1] ) <<  8) |
+         (( uint32_t )( p[2] ) << 16) |
+         (( uint32_t )( p[3] ) << 24) ;
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src )
+static uint64_t load64( const void *src )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   uint64_t w;
@@ -43,93 +42,91 @@ BLAKE2_LOCAL_INLINE(uint64_t) load64( const void *src )
   return w;
 #else
   const uint8_t *p = ( const uint8_t * )src;
-  uint64_t w = *p++;
-  w |= ( uint64_t )( *p++ ) <<  8;
-  w |= ( uint64_t )( *p++ ) << 16;
-  w |= ( uint64_t )( *p++ ) << 24;
-  w |= ( uint64_t )( *p++ ) << 32;
-  w |= ( uint64_t )( *p++ ) << 40;
-  w |= ( uint64_t )( *p++ ) << 48;
-  w |= ( uint64_t )( *p++ ) << 56;
-  return w;
+  return (( uint64_t )( p[0] ) <<  0) |
+         (( uint64_t )( p[1] ) <<  8) |
+         (( uint64_t )( p[2] ) << 16) |
+         (( uint64_t )( p[3] ) << 24) |
+         (( uint64_t )( p[4] ) << 32) |
+         (( uint64_t )( p[5] ) << 40) |
+         (( uint64_t )( p[6] ) << 48) |
+         (( uint64_t )( p[7] ) << 56) ;
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(void) store32( void *dst, uint32_t w )
+static void store32( void *dst, uint32_t w )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   memcpy(dst, &w, sizeof w);
 #else
   uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(void) store64( void *dst, uint64_t w )
+static void store64( void *dst, uint64_t w )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   memcpy(dst, &w, sizeof w);
 #else
   uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
+  p[4] = (uint8_t)(w >> 32);
+  p[5] = (uint8_t)(w >> 40);
+  p[6] = (uint8_t)(w >> 48);
+  p[7] = (uint8_t)(w >> 56);
 #endif
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) load48( const void *src )
+static uint64_t load48( const void *src )
 {
   const uint8_t *p = ( const uint8_t * )src;
-  uint64_t w = *p++;
-  w |= ( uint64_t )( *p++ ) <<  8;
-  w |= ( uint64_t )( *p++ ) << 16;
-  w |= ( uint64_t )( *p++ ) << 24;
-  w |= ( uint64_t )( *p++ ) << 32;
-  w |= ( uint64_t )( *p++ ) << 40;
-  return w;
+  return (( uint64_t )( p[0] ) <<  0) |
+         (( uint64_t )( p[1] ) <<  8) |
+         (( uint64_t )( p[2] ) << 16) |
+         (( uint64_t )( p[3] ) << 24) |
+         (( uint64_t )( p[4] ) << 32) |
+         (( uint64_t )( p[5] ) << 40) ;
 }
 
-BLAKE2_LOCAL_INLINE(void) store48( void *dst, uint64_t w )
+static void store48( void *dst, uint64_t w )
 {
   uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
+  p[4] = (uint8_t)(w >> 32);
+  p[5] = (uint8_t)(w >> 40);
 }
 
-BLAKE2_LOCAL_INLINE(uint32_t) rotl32( const uint32_t w, const unsigned c )
+static uint32_t rotl32( const uint32_t w, const unsigned c )
 {
   return ( w << c ) | ( w >> ( 32 - c ) );
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) rotl64( const uint64_t w, const unsigned c )
+static uint64_t rotl64( const uint64_t w, const unsigned c )
 {
   return ( w << c ) | ( w >> ( 64 - c ) );
 }
 
-BLAKE2_LOCAL_INLINE(uint32_t) rotr32( const uint32_t w, const unsigned c )
+static uint32_t rotr32( const uint32_t w, const unsigned c )
 {
   return ( w >> c ) | ( w << ( 32 - c ) );
 }
 
-BLAKE2_LOCAL_INLINE(uint64_t) rotr64( const uint64_t w, const unsigned c )
+static uint64_t rotr64( const uint64_t w, const unsigned c )
 {
   return ( w >> c ) | ( w << ( 64 - c ) );
 }
 
 /* prevents compiler optimizing out memset() */
-BLAKE2_LOCAL_INLINE(void) secure_zero_memory(void *v, size_t n)
+static void secure_zero_memory(void *v, size_t n)
 {
   static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
   memset_v(v, 0, n);
diff --git a/sse/blake2.h b/sse/blake2.h
index 1a9fdf4..31b5022 100644
--- a/sse/blake2.h
+++ b/sse/blake2.h
@@ -148,10 +148,8 @@ extern "C" {
   int blake2sp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
   int blake2bp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
 
-  static inline int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
-  {
-    return blake2b( out, in, key, outlen, inlen, keylen );
-  }
+  /* This is simply an alias for blake2b */
+  int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
 
 #if defined(__cplusplus)
 }
diff --git a/sse/blake2b.c b/sse/blake2b.c
index f9090a1..be465b1 100644
--- a/sse/blake2b.c
+++ b/sse/blake2b.c
@@ -410,6 +410,10 @@ int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen
   return 0;
 }
 
+int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) {
+  return blake2b(out, in, key, outlen, inlen, keylen);
+}
+
 #if defined(SUPERCOP)
 int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen )
 {