v3.11.1

Makefile.am

@@ -84,10 +84,14 @@ cpuminer_SOURCES = \
   algo/cubehash/cubehash_sse2.c\
   algo/cubehash/cube-hash-2way.c \
   algo/echo/sph_echo.c \
+  algo/echo/echo-hash-4way.c \
   algo/echo/aes_ni/hash.c\
   algo/gost/sph_gost.c \
+  algo/groestl/groestl-gate.c \
+  algo/groestl/groestl512-hash-4way.c \
   algo/groestl/sph_groestl.c \
   algo/groestl/groestl.c \
+  algo/groestl/groestl-4way.c \
   algo/groestl/myrgr-gate.c \
   algo/groestl/myrgr-4way.c \
   algo/groestl/myr-groestl.c \
@@ -116,7 +120,6 @@ cpuminer_SOURCES = \
   algo/keccak/keccak-hash-4way.c \
   algo/keccak/keccak-4way.c\
   algo/keccak/keccak-gate.c \
-  algo/keccak/sse2/keccak.c \
   algo/lanehash/lane.c \
   algo/luffa/sph_luffa.c \
   algo/luffa/luffa.c \
@@ -146,6 +149,7 @@ cpuminer_SOURCES = \
   algo/nist5/nist5-4way.c \
   algo/nist5/nist5.c \
   algo/nist5/zr5.c \
+  algo/panama/panama-hash-4way.c \
   algo/panama/sph_panama.c \
   algo/radiogatun/sph_radiogatun.c \
   algo/quark/quark-gate.c \
@@ -171,7 +175,6 @@ cpuminer_SOURCES = \
   algo/scrypt/scrypt.c \
   algo/scrypt/neoscrypt.c \
   algo/scrypt/pluck.c \
-  algo/scryptjane/scrypt-jane.c \
   algo/sha/sph_sha2.c \
   algo/sha/sph_sha2big.c \
   algo/sha/sha256-hash-4way.c \
@@ -187,6 +190,7 @@ cpuminer_SOURCES = \
   algo/shavite/sph_shavite.c \
   algo/shavite/sph-shavite-aesni.c \
   algo/shavite/shavite-hash-2way.c \
+  algo/shavite/shavite-hash-4way.c \
   algo/shavite/shavite.c \
   algo/simd/sph_simd.c \
   algo/simd/nist.c \

RELEASE_NOTES

@@ -7,9 +7,11 @@ Security warning
 ----------------
 
 Miner programs are often flagged as malware by antivirus programs. This is
-a false positive, they are flagged simply because they are cryptocurrency 
-miners. The source code is open for anyone to inspect. If you don't trust 
-the software, don't use it.
+usually a false positive, they are flagged simply because they are
+cryptocurrency miners. However, some malware has been spread using the
+cover that miners are known to be subject to false positives. Always be on
+alert. The source code of cpuminer-opt is open for anyone to inspect.
+If you don't trust the software don't download it.
 
 The cryptographic hashing code has been taken from trusted sources but has been
 modified for speed at the expense of accepted security practices. This
@@ -19,7 +21,7 @@ required.
 Compile Instructions
 --------------------
 
-See INSTALL_LINUX or INSTALL_WINDOWS fror compile instruuctions
+See INSTALL_LINUX or INSTALL_WINDOWS for compile instruuctions
 
 Requirements
 ------------
@@ -33,6 +35,40 @@ not supported. FreeBSD YMMV.
 Change Log
 ----------
 
+v3.11.1
+
+Faster panama for x25x AVX2 & AVX512.
+
+Fixed echo VAES for Xevan.
+
+Removed support for scryptjane algo.
+
+Reverted macro implemtations of hash functions to SPH reference code
+for SSE2 versions of algos.
+
+v3.11.0
+
+Fixed x25x AVX512 lane 4 invalid shares.
+
+AVX512 for hex, phi2.
+
+VAES optimzation for Intel Icelake CPUs for most algos recently optimized
+with AVX512, source code only.
+
+v3.10.7
+
+AVX512 for x25x, lbry, x13bcd (bcd).
+
+v3.10.6
+
+Added support for SSL stratum: stratum+tcps://
+
+Added job id reporting again, but leaner, suppressed with --quiet.
+
+AVX512 for x21s, x22i, lyra2z, allium.
+
+Fixed share overflow warnings mining lbry with Ryzen (SHA).
+
 v3.10.5
 
 AVX512 for x17, sonoa, xevan, hmq1725, lyra2rev3, lyra2rev2. 

algo-gate-api.c

@@ -206,7 +206,6 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
     case ALGO_QUARK:         register_quark_algo         ( gate ); break;
     case ALGO_QUBIT:         register_qubit_algo         ( gate ); break;
     case ALGO_SCRYPT:        register_scrypt_algo        ( gate ); break;
-    case ALGO_SCRYPTJANE:    register_scryptjane_algo    ( gate ); break;
     case ALGO_SHA256D:       register_sha256d_algo       ( gate ); break;
     case ALGO_SHA256Q:       register_sha256q_algo       ( gate ); break;
     case ALGO_SHA256T:       register_sha256t_algo       ( gate ); break;
@@ -317,6 +316,7 @@ const char* const algo_alias_map[][2] =
   { "argon2d-crds",      "argon2d250"   },
   { "argon2d-dyn",       "argon2d500"   },
   { "argon2d-uis",       "argon2d4096"  },
+  { "bcd",               "x13bcd"       },
   { "bitcore",           "timetravel10" },
   { "bitzeny",           "yescryptr8"   },
   { "blake256r8",        "blakecoin"    },

algo/blake/blake-hash-4way.h

@@ -104,7 +104,7 @@ typedef struct {
 typedef blake_8way_small_context blake256_8way_context;
 void blake256_8way_init(void *cc);
 void blake256_8way_update(void *cc, const void *data, size_t len);
-#define blake256_8way blake256_8way_update
+//#define blake256_8way blake256_8way_update
 void blake256_8way_close(void *cc, void *dst);
 
 // 14 rounds, blake, decred

algo/blake/blake256-hash-4way.c

@@ -842,7 +842,8 @@ blake32_4way_init( blake_4way_small_context *ctx, const uint32_t *iv,
 }
 
 static void
-blake32_4way( blake_4way_small_context *ctx, const void *data, size_t len )
+blake32_4way( blake_4way_small_context *ctx, const void *data,
+              size_t len )
 {
    __m128i *buf = (__m128i*)ctx->buf;
    size_t  bptr = ctx->ptr<<2;
@@ -1237,7 +1238,7 @@ blake256_4way_init(void *ctx)
 }
 
 void
-blake256_4way(void *ctx, const void *data, size_t len)
+blake256_4way_update(void *ctx, const void *data, size_t len)
 {
 	blake32_4way(ctx, data, len);
 }

algo/blake/blake2s-hash-4way.c

@@ -463,6 +463,38 @@ int blake2s_8way_final( blake2s_8way_state *S, void *out, uint8_t outlen )
    return 0;
 }
 
+// Update and final when inlen is a multiple of 64 bytes
+int blake2s_8way_full_blocks( blake2s_8way_state *S, void *out,
+                              const void *input, uint64_t inlen )
+{
+    __m256i *in = (__m256i*)input;
+    __m256i *buf = (__m256i*)S->buf;
+
+    while( inlen > BLAKE2S_BLOCKBYTES )
+    {
+       memcpy_256( buf, in, BLAKE2S_BLOCKBYTES >> 2 );
+       S->buflen = BLAKE2S_BLOCKBYTES;
+       inlen -= BLAKE2S_BLOCKBYTES;
+       S->t[0] += BLAKE2S_BLOCKBYTES;
+       S->t[1] += ( S->t[0] < BLAKE2S_BLOCKBYTES );
+       blake2s_8way_compress( S, buf );
+       S->buflen = 0;
+       in += ( BLAKE2S_BLOCKBYTES >> 2 );
+    }
+
+    // last block
+    memcpy_256( buf, in, BLAKE2S_BLOCKBYTES >> 2 );
+    S->buflen = BLAKE2S_BLOCKBYTES;
+    S->t[0] += S->buflen;
+    S->t[1] += ( S->t[0] < S->buflen );
+    if ( S->last_node )  S->f[1] = ~0U;
+    S->f[0] = ~0U;
+    blake2s_8way_compress( S, buf );
+
+    for ( int i = 0; i < 8; ++i )
+      casti_m256i( out, i ) = S->h[ i ];
+    return 0;
+}
 
 #endif // __AVX2__
 

algo/blake/blake2s-hash-4way.h

@@ -14,7 +14,6 @@
 #ifndef __BLAKE2S_HASH_4WAY_H__
 #define __BLAKE2S_HASH_4WAY_H__ 1
 
-//#if defined(__SSE4_2__)
 #if defined(__SSE2__)
 
 #include "simd-utils.h"
@@ -95,8 +94,8 @@ int blake2s_8way_init( blake2s_8way_state *S, const uint8_t outlen );
 int blake2s_8way_update( blake2s_8way_state *S, const void *in,
                          uint64_t inlen );
 int blake2s_8way_final( blake2s_8way_state *S, void *out, uint8_t outlen );
-//int blake2s_8way_full_blocks( blake2s_8way_state *S, void *out,
-//                              const void *input, uint64_t inlen );
+int blake2s_8way_full_blocks( blake2s_8way_state *S, void *out,
+                              const void *input, uint64_t inlen );
 
 #endif
 
@@ -132,6 +131,6 @@ int blake2s_16way_final( blake2s_16way_state *S, void *out, uint8_t outlen );
 }
 #endif
 
-#endif  // __SSE4_2__
+#endif  // __SSE2__
 
 #endif

algo/blake/sse2/blake.c

@@ -1,476 +0,0 @@
-/* $Id: blake.c 252 2011-06-07 17:55:14Z tp $ */
-/*
- * BLAKE implementation.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-#include <stddef.h>
-#include <string.h>
-#include <limits.h>
-
-#include "../sph_blake.h"
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#ifdef _MSC_VER
-#pragma warning (disable: 4146)
-#endif
-
-static const sph_u64 blkIV512[8] = {
-	SPH_C64(0x6A09E667F3BCC908), SPH_C64(0xBB67AE8584CAA73B),
-	SPH_C64(0x3C6EF372FE94F82B), SPH_C64(0xA54FF53A5F1D36F1),
-	SPH_C64(0x510E527FADE682D1), SPH_C64(0x9B05688C2B3E6C1F),
-	SPH_C64(0x1F83D9ABFB41BD6B), SPH_C64(0x5BE0CD19137E2179)
-};
-
-#define Z00   0
-#define Z01   1
-#define Z02   2
-#define Z03   3
-#define Z04   4
-#define Z05   5
-#define Z06   6
-#define Z07   7
-#define Z08   8
-#define Z09   9
-#define Z0A   A
-#define Z0B   B
-#define Z0C   C
-#define Z0D   D
-#define Z0E   E
-#define Z0F   F
-
-#define Z10   E
-#define Z11   A
-#define Z12   4
-#define Z13   8
-#define Z14   9
-#define Z15   F
-#define Z16   D
-#define Z17   6
-#define Z18   1
-#define Z19   C
-#define Z1A   0
-#define Z1B   2
-#define Z1C   B
-#define Z1D   7
-#define Z1E   5
-#define Z1F   3
-
-#define Z20   B
-#define Z21   8
-#define Z22   C
-#define Z23   0
-#define Z24   5
-#define Z25   2
-#define Z26   F
-#define Z27   D
-#define Z28   A
-#define Z29   E
-#define Z2A   3
-#define Z2B   6
-#define Z2C   7
-#define Z2D   1
-#define Z2E   9
-#define Z2F   4
-
-#define Z30   7
-#define Z31   9
-#define Z32   3
-#define Z33   1
-#define Z34   D
-#define Z35   C
-#define Z36   B
-#define Z37   E
-#define Z38   2
-#define Z39   6
-#define Z3A   5
-#define Z3B   A
-#define Z3C   4
-#define Z3D   0
-#define Z3E   F
-#define Z3F   8
-
-#define Z40   9
-#define Z41   0
-#define Z42   5
-#define Z43   7
-#define Z44   2
-#define Z45   4
-#define Z46   A
-#define Z47   F
-#define Z48   E
-#define Z49   1
-#define Z4A   B
-#define Z4B   C
-#define Z4C   6
-#define Z4D   8
-#define Z4E   3
-#define Z4F   D
-
-#define Z50   2
-#define Z51   C
-#define Z52   6
-#define Z53   A
-#define Z54   0
-#define Z55   B
-#define Z56   8
-#define Z57   3
-#define Z58   4
-#define Z59   D
-#define Z5A   7
-#define Z5B   5
-#define Z5C   F
-#define Z5D   E
-#define Z5E   1
-#define Z5F   9
-
-#define Z60   C
-#define Z61   5
-#define Z62   1
-#define Z63   F
-#define Z64   E
-#define Z65   D
-#define Z66   4
-#define Z67   A
-#define Z68   0
-#define Z69   7
-#define Z6A   6
-#define Z6B   3
-#define Z6C   9
-#define Z6D   2
-#define Z6E   8
-#define Z6F   B
-
-#define Z70   D
-#define Z71   B
-#define Z72   7
-#define Z73   E
-#define Z74   C
-#define Z75   1
-#define Z76   3
-#define Z77   9
-#define Z78   5
-#define Z79   0
-#define Z7A   F
-#define Z7B   4
-#define Z7C   8
-#define Z7D   6
-#define Z7E   2
-#define Z7F   A
-
-#define Z80   6
-#define Z81   F
-#define Z82   E
-#define Z83   9
-#define Z84   B
-#define Z85   3
-#define Z86   0
-#define Z87   8
-#define Z88   C
-#define Z89   2
-#define Z8A   D
-#define Z8B   7
-#define Z8C   1
-#define Z8D   4
-#define Z8E   A
-#define Z8F   5
-
-#define Z90   A
-#define Z91   2
-#define Z92   8
-#define Z93   4
-#define Z94   7
-#define Z95   6
-#define Z96   1
-#define Z97   5
-#define Z98   F
-#define Z99   B
-#define Z9A   9
-#define Z9B   E
-#define Z9C   3
-#define Z9D   C
-#define Z9E   D
-#define Z9F   0
-
-#define Mx(r, i)    Mx_(Z ## r ## i)
-#define Mx_(n)      Mx__(n)
-#define Mx__(n)     M ## n
-
-#define CSx(r, i)   CSx_(Z ## r ## i)
-#define CSx_(n)     CSx__(n)
-#define CSx__(n)    CS ## n
-
-#define CS0   SPH_C32(0x243F6A88)
-#define CS1   SPH_C32(0x85A308D3)
-#define CS2   SPH_C32(0x13198A2E)
-#define CS3   SPH_C32(0x03707344)
-#define CS4   SPH_C32(0xA4093822)
-#define CS5   SPH_C32(0x299F31D0)
-#define CS6   SPH_C32(0x082EFA98)
-#define CS7   SPH_C32(0xEC4E6C89)
-#define CS8   SPH_C32(0x452821E6)
-#define CS9   SPH_C32(0x38D01377)
-#define CSA   SPH_C32(0xBE5466CF)
-#define CSB   SPH_C32(0x34E90C6C)
-#define CSC   SPH_C32(0xC0AC29B7)
-#define CSD   SPH_C32(0xC97C50DD)
-#define CSE   SPH_C32(0x3F84D5B5)
-#define CSF   SPH_C32(0xB5470917)
-
-
-
-#define CBx(r, i)   CBx_(Z ## r ## i)
-#define CBx_(n)     CBx__(n)
-#define CBx__(n)    CB ## n
-
-#define CB0   SPH_C64(0x243F6A8885A308D3)
-#define CB1   SPH_C64(0x13198A2E03707344)
-#define CB2   SPH_C64(0xA4093822299F31D0)
-#define CB3   SPH_C64(0x082EFA98EC4E6C89)
-#define CB4   SPH_C64(0x452821E638D01377)
-#define CB5   SPH_C64(0xBE5466CF34E90C6C)
-#define CB6   SPH_C64(0xC0AC29B7C97C50DD)
-#define CB7   SPH_C64(0x3F84D5B5B5470917)
-#define CB8   SPH_C64(0x9216D5D98979FB1B)
-#define CB9   SPH_C64(0xD1310BA698DFB5AC)
-#define CBA   SPH_C64(0x2FFD72DBD01ADFB7)
-#define CBB   SPH_C64(0xB8E1AFED6A267E96)
-#define CBC   SPH_C64(0xBA7C9045F12C7F99)
-#define CBD   SPH_C64(0x24A19947B3916CF7)
-#define CBE   SPH_C64(0x0801F2E2858EFC16)
-#define CBF   SPH_C64(0x636920D871574E69)
-
-
-#define GS(m0, m1, c0, c1, a, b, c, d)   do { \
-		a = SPH_T32(a + b + (m0 ^ c1)); \
-		d = SPH_ROTR32(d ^ a, 16); \
-		c = SPH_T32(c + d); \
-		b = SPH_ROTR32(b ^ c, 12); \
-		a = SPH_T32(a + b + (m1 ^ c0)); \
-		d = SPH_ROTR32(d ^ a, 8); \
-		c = SPH_T32(c + d); \
-		b = SPH_ROTR32(b ^ c, 7); \
-	} while (0)
-
-#define ROUND_S(r)   do { \
-		GS(Mx(r, 0), Mx(r, 1), CSx(r, 0), CSx(r, 1), V0, V4, V8, VC); \
-		GS(Mx(r, 2), Mx(r, 3), CSx(r, 2), CSx(r, 3), V1, V5, V9, VD); \
-		GS(Mx(r, 4), Mx(r, 5), CSx(r, 4), CSx(r, 5), V2, V6, VA, VE); \
-		GS(Mx(r, 6), Mx(r, 7), CSx(r, 6), CSx(r, 7), V3, V7, VB, VF); \
-		GS(Mx(r, 8), Mx(r, 9), CSx(r, 8), CSx(r, 9), V0, V5, VA, VF); \
-		GS(Mx(r, A), Mx(r, B), CSx(r, A), CSx(r, B), V1, V6, VB, VC); \
-		GS(Mx(r, C), Mx(r, D), CSx(r, C), CSx(r, D), V2, V7, V8, VD); \
-		GS(Mx(r, E), Mx(r, F), CSx(r, E), CSx(r, F), V3, V4, V9, VE); \
-	} while (0)
-
-
-
-#define GB(m0, m1, c0, c1, a, b, c, d)   do { \
-		a = SPH_T64(a + b + (m0 ^ c1)); \
-		d = SPH_ROTR64(d ^ a, 32); \
-		c = SPH_T64(c + d); \
-		b = SPH_ROTR64(b ^ c, 25); \
-		a = SPH_T64(a + b + (m1 ^ c0)); \
-		d = SPH_ROTR64(d ^ a, 16); \
-		c = SPH_T64(c + d); \
-		b = SPH_ROTR64(b ^ c, 11); \
-	} while (0)
-
-#define ROUND_B(r)   do { \
-		GB(Mx(r, 0), Mx(r, 1), CBx(r, 0), CBx(r, 1), V0, V4, V8, VC); \
-		GB(Mx(r, 2), Mx(r, 3), CBx(r, 2), CBx(r, 3), V1, V5, V9, VD); \
-		GB(Mx(r, 4), Mx(r, 5), CBx(r, 4), CBx(r, 5), V2, V6, VA, VE); \
-		GB(Mx(r, 6), Mx(r, 7), CBx(r, 6), CBx(r, 7), V3, V7, VB, VF); \
-		GB(Mx(r, 8), Mx(r, 9), CBx(r, 8), CBx(r, 9), V0, V5, VA, VF); \
-		GB(Mx(r, A), Mx(r, B), CBx(r, A), CBx(r, B), V1, V6, VB, VC); \
-		GB(Mx(r, C), Mx(r, D), CBx(r, C), CBx(r, D), V2, V7, V8, VD); \
-		GB(Mx(r, E), Mx(r, F), CBx(r, E), CBx(r, F), V3, V4, V9, VE); \
-	} while (0)
-
-
-#define COMPRESS64   do { \
-                int b=0; \
-		sph_u64 M0, M1, M2, M3, M4, M5, M6, M7; \
-		sph_u64 M8, M9, MA, MB, MC, MD, ME, MF; \
-		sph_u64 V0, V1, V2, V3, V4, V5, V6, V7; \
-		sph_u64 V8, V9, VA, VB, VC, VD, VE, VF; \
-		V0 = blkH0, \
-		V1 = blkH1, \
-		V2 = blkH2, \
-		V3 = blkH3, \
-		V4 = blkH4, \
-		V5 = blkH5, \
-		V6 = blkH6, \
-		V7 = blkH7; \
-		V8 = blkS0 ^ CB0, \
-		V9 = blkS1 ^ CB1, \
-		VA = blkS2 ^ CB2, \
-		VB = blkS3 ^ CB3, \
-		VC = hashctA ^ CB4, \
-		VD = hashctA ^ CB5, \
-		VE = hashctB ^ CB6, \
-		VF = hashctB ^ CB7; \
-		M0 = sph_dec64be_aligned(buf +   0), \
-		M1 = sph_dec64be_aligned(buf +   8), \
-		M2 = sph_dec64be_aligned(buf +  16), \
-		M3 = sph_dec64be_aligned(buf +  24), \
-		M4 = sph_dec64be_aligned(buf +  32), \
-		M5 = sph_dec64be_aligned(buf +  40), \
-		M6 = sph_dec64be_aligned(buf +  48), \
-		M7 = sph_dec64be_aligned(buf +  56), \
-		M8 = sph_dec64be_aligned(buf +  64), \
-		M9 = sph_dec64be_aligned(buf +  72), \
-		MA = sph_dec64be_aligned(buf +  80), \
-		MB = sph_dec64be_aligned(buf +  88), \
-		MC = sph_dec64be_aligned(buf +  96), \
-		MD = sph_dec64be_aligned(buf + 104), \
-		ME = sph_dec64be_aligned(buf + 112), \
-		MF = sph_dec64be_aligned(buf + 120); \
-                /* loop once and a half */ \
-                /* save some space */ \
-                for (;;) { \
-		    ROUND_B(0); \
-		    ROUND_B(1); \
-		    ROUND_B(2); \
-		    ROUND_B(3); \
-		    ROUND_B(4); \
-		    ROUND_B(5); \
-                    if (b)  break; \
-                    b = 1; \
-		    ROUND_B(6); \
-		    ROUND_B(7); \
-		    ROUND_B(8); \
-		    ROUND_B(9); \
-                }; \
-		blkH0 ^= blkS0 ^ V0 ^ V8, \
-		blkH1 ^= blkS1 ^ V1 ^ V9, \
-		blkH2 ^= blkS2 ^ V2 ^ VA, \
-		blkH3 ^= blkS3 ^ V3 ^ VB, \
-		blkH4 ^= blkS0 ^ V4 ^ VC, \
-		blkH5 ^= blkS1 ^ V5 ^ VD, \
-		blkH6 ^= blkS2 ^ V6 ^ VE, \
-		blkH7 ^= blkS3 ^ V7 ^ VF; \
-	} while (0)
-/*
-*/
-#define DECL_BLK \
-	sph_u64 blkH0; \
-	sph_u64 blkH1; \
-	sph_u64 blkH2; \
-	sph_u64 blkH3; \
-	sph_u64 blkH4; \
-	sph_u64 blkH5; \
-	sph_u64 blkH6; \
-	sph_u64 blkH7; \
-	sph_u64 blkS0; \
-	sph_u64 blkS1; \
-	sph_u64 blkS2; \
-	sph_u64 blkS3; \
-
-/* load initial constants */
-#define BLK_I \
-do { \
-    blkH0 = SPH_C64(0x6A09E667F3BCC908); \
-    blkH1 = SPH_C64(0xBB67AE8584CAA73B); \
-    blkH2 = SPH_C64(0x3C6EF372FE94F82B); \
-    blkH3 = SPH_C64(0xA54FF53A5F1D36F1); \
-    blkH4 = SPH_C64(0x510E527FADE682D1); \
-    blkH5 = SPH_C64(0x9B05688C2B3E6C1F); \
-    blkH6 = SPH_C64(0x1F83D9ABFB41BD6B); \
-    blkH7 = SPH_C64(0x5BE0CD19137E2179); \
-    blkS0 = 0; \
-    blkS1 = 0; \
-    blkS2 = 0; \
-    blkS3 = 0; \
-    hashctB = SPH_T64(0- 1); \
-} while (0)
-
-/* copy in 80 for initial hash */
-#define BLK_W \
-do { \
-    memcpy(hashbuf, input, 80); \
-    hashctA = SPH_C64(0xFFFFFFFFFFFFFC00) + 80*8; \
-    hashptr = 80; \
-} while (0)
-
-/* copy in 64 for looped hash */
-#define BLK_U \
-do { \
-    memcpy(hashbuf, hash , 64); \
-    hashctA = SPH_C64(0xFFFFFFFFFFFFFC00) + 64*8; \
-    hashptr = 64; \
-} while (0)
-
-/* blake compress function */
-/* hash = blake512(loaded) */
-#define BLK_C \
-do { \
-    \
-    union { \
-        unsigned char buf[128]; \
-        sph_u64 dummy; \
-    } u; \
-    size_t ptr; \
-    unsigned bit_len; \
- \
-    ptr = hashptr; \
-    bit_len = ((unsigned)ptr << 3) + 0; \
-    u.buf[ptr] = ((0 & -(0x80)) | (0x80)) & 0xFF; \
-    memset(u.buf + ptr + 1, 0, 111 - ptr); \
-    u.buf[111] |= 1; \
-    sph_enc64be_aligned(u.buf + 112, 0); \
-    sph_enc64be_aligned(u.buf + 120, bit_len); \
-    do { \
-    const void *data = u.buf + ptr; \
-    unsigned char *buf; \
-    buf = hashbuf; \
-    size_t clen; \
-    clen = (sizeof(char)*128) - hashptr; \
-    memcpy(buf + hashptr, data, clen); \
-    hashctA = SPH_T64(hashctA + 1024); \
-    hashctB = SPH_T64(hashctB + 1); \
-    COMPRESS64; \
-    } while (0); \
-    /* end blake64(sc, u.buf + ptr, 128 - ptr); */ \
-    sph_enc64be((unsigned char*)(hash) + (0 << 3), blkH0), \
-    sph_enc64be((unsigned char*)(hash) + (1 << 3), blkH1); \
-    sph_enc64be((unsigned char*)(hash) + (2 << 3), blkH2), \
-    sph_enc64be((unsigned char*)(hash) + (3 << 3), blkH3); \
-    sph_enc64be((unsigned char*)(hash) + (4 << 3), blkH4), \
-    sph_enc64be((unsigned char*)(hash) + (5 << 3), blkH5); \
-    sph_enc64be((unsigned char*)(hash) + (6 << 3), blkH6), \
-    sph_enc64be((unsigned char*)(hash) + (7 << 3), blkH7); \
-} while (0) 
-
-
-#ifdef __cplusplus
-}
-#endif

algo/blake/sse2/blake/sse41/api.h

@@ -1,2 +0,0 @@
-#define CRYPTO_BYTES 64
-

algo/blake/sse2/blake/sse41/architectures

@@ -1,2 +0,0 @@
-amd64
-x86

algo/blake/sse2/blake/sse41/config.h

@@ -1,8 +0,0 @@
-#ifndef __BLAKE512_CONFIG_H__
-#define __BLAKE512_CONFIG_H__
-
-#define AVOID_BRANCHING 1
-//#define HAVE_XOP 1
-
-#endif
-

algo/blake/sse2/blake/sse41/hash.c

@@ -1,287 +0,0 @@
-
-#include "hash.h"
-/*
-#ifndef NOT_SUPERCOP
-
-#include "crypto_hash.h"
-#include "crypto_uint64.h"
-#include "crypto_uint32.h"
-#include "crypto_uint8.h"
-
-typedef crypto_uint64 u64;
-typedef crypto_uint32 u32;
-typedef crypto_uint8 u8; 
-
-#else
-
-typedef unsigned long long u64; 
-typedef unsigned int u32; 
-typedef unsigned char u8; 
-
-#endif
-*/
-#define U8TO32(p) \
-  (((u32)((p)[0]) << 24) | ((u32)((p)[1]) << 16) | \
-   ((u32)((p)[2]) <<  8) | ((u32)((p)[3])      ))
-#define U8TO64(p) \
-  (((u64)U8TO32(p) << 32) | (u64)U8TO32((p) + 4))
-#define U32TO8(p, v) \
-    (p)[0] = (u8)((v) >> 24); (p)[1] = (u8)((v) >> 16); \
-    (p)[2] = (u8)((v) >>  8); (p)[3] = (u8)((v)      ); 
-#define U64TO8(p, v) \
-    U32TO8((p),     (u32)((v) >> 32));	\
-    U32TO8((p) + 4, (u32)((v)      )); 
-/*
-typedef struct  
-{ 
-	__m128i h[4];
-  u64 s[4], t[2];
-  u32 buflen, nullt;
-  u8 buf[128];
-} state __attribute__ ((aligned (64)));
-*/
-static const u8 padding[129] =
-{ 
-	0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-};
-
-static inline int blake512_compress( hashState_blake * state, const u8 * datablock ) 
-{
-
-  __m128i row1l,row1h;
-  __m128i row2l,row2h;
-  __m128i row3l,row3h;
-  __m128i row4l,row4h;
-
-  const __m128i r16 = _mm_setr_epi8(2,3,4,5,6,7,0,1,10,11,12,13,14,15,8,9);
-  const __m128i u8to64 = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7);
-
-  __m128i m0, m1, m2, m3, m4, m5, m6, m7;
-  __m128i t0, t1, t2, t3, t4, t5, t6, t7;
-  __m128i b0, b1, b2, b3;
-
-  m0 = _mm_loadu_si128((__m128i*)(datablock +   0));
-  m1 = _mm_loadu_si128((__m128i*)(datablock +  16));
-  m2 = _mm_loadu_si128((__m128i*)(datablock +  32));
-  m3 = _mm_loadu_si128((__m128i*)(datablock +  48));
-  m4 = _mm_loadu_si128((__m128i*)(datablock +  64));
-  m5 = _mm_loadu_si128((__m128i*)(datablock +  80));
-  m6 = _mm_loadu_si128((__m128i*)(datablock +  96));
-  m7 = _mm_loadu_si128((__m128i*)(datablock + 112));
-
-  m0 = BSWAP64(m0);
-  m1 = BSWAP64(m1);
-  m2 = BSWAP64(m2);
-  m3 = BSWAP64(m3);
-  m4 = BSWAP64(m4);
-  m5 = BSWAP64(m5);
-  m6 = BSWAP64(m6);
-  m7 = BSWAP64(m7);
-
-  row1l = state->h[0];
-  row1h = state->h[1];
-  row2l = state->h[2];
-  row2h = state->h[3];
-  row3l = _mm_set_epi64x(0x13198A2E03707344ULL, 0x243F6A8885A308D3ULL);
-  row3h = _mm_set_epi64x(0x082EFA98EC4E6C89ULL, 0xA4093822299F31D0ULL);
-
-  row4l = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0x452821E638D01377ULL);
-  row4h = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0xC0AC29B7C97C50DDULL);
-
-#ifdef AVOID_BRANCHING
-  do
-  {
-    const __m128i mask = _mm_cmpeq_epi32(_mm_setzero_si128(), _mm_set1_epi32(state->nullt));
-    const __m128i xor1 = _mm_and_si128(_mm_set1_epi64x(state->t[0]), mask);
-    const __m128i xor2 = _mm_and_si128(_mm_set1_epi64x(state->t[1]), mask);
-    row4l = _mm_xor_si128(row4l, xor1);
-    row4h = _mm_xor_si128(row4h, xor2);
-  } while(0);
-#else
-  if(!state->nullt)
-  {
-  	row4l = _mm_xor_si128(row4l, _mm_set1_epi64x(state->t[0]));
-  	row4h = _mm_xor_si128(row4h, _mm_set1_epi64x(state->t[1]));
-  }
-#endif
-
-  ROUND( 0);
-  ROUND( 1);
-  ROUND( 2);
-  ROUND( 3);
-  ROUND( 4);
-  ROUND( 5);
-  ROUND( 6);
-  ROUND( 7);
-  ROUND( 8);
-  ROUND( 9);
-  ROUND(10);
-  ROUND(11);
-  ROUND(12);
-  ROUND(13);
-  ROUND(14);
-  ROUND(15);
-
-  row1l = _mm_xor_si128(row3l,row1l);
-  row1h = _mm_xor_si128(row3h,row1h);
-
-  state->h[0] = _mm_xor_si128(row1l, state->h[0]);
-  state->h[1] = _mm_xor_si128(row1h, state->h[1]);
-
-  row2l = _mm_xor_si128(row4l,row2l);
-  row2h = _mm_xor_si128(row4h,row2h);
-
-  state->h[2] = _mm_xor_si128(row2l, state->h[2]);
-  state->h[3] = _mm_xor_si128(row2h, state->h[3]);
-  
-  return 0;
-}
-
-static inline void blake512_init( hashState_blake * S, u64 databitlen )
-{
-  memset(S, 0, sizeof(hashState_blake));
-  S->h[0] = _mm_set_epi64x(0xBB67AE8584CAA73BULL, 0x6A09E667F3BCC908ULL);
-  S->h[1] = _mm_set_epi64x(0xA54FF53A5F1D36F1ULL, 0x3C6EF372FE94F82BULL);
-  S->h[2] = _mm_set_epi64x(0x9B05688C2B3E6C1FULL, 0x510E527FADE682D1ULL);
-  S->h[3] = _mm_set_epi64x(0x5BE0CD19137E2179ULL, 0x1F83D9ABFB41BD6BULL);
-  S->buflen = databitlen;
-}
-
-
-static void blake512_update( hashState_blake * S, const u8 * data, u64 datalen ) 
-{
-
-
-  int left = (S->buflen >> 3); 
-  int fill = 128 - left;
-
-  if( left && ( ((datalen >> 3) & 0x7F) >= fill ) ) {
-    memcpy( (void *) (S->buf + left), (void *) data, fill );
-    S->t[0] += 1024;
-    blake512_compress( S, S->buf );
-    data += fill;
-    datalen  -= (fill << 3);       
-    left = 0;
-  }
-
-  while( datalen >= 1024 ) {  
-    S->t[0] += 1024;
-    blake512_compress( S, data );
-    data += 128;
-    datalen  -= 1024;
-  }
-
-  if( datalen > 0 ) {
-    memcpy( (void *) (S->buf + left), (void *) data, ( datalen>>3 ) & 0x7F );
-    S->buflen = (left<<3) + datalen;
-  }
-  else S->buflen=0;
-}
-
-static inline void blake512_final( hashState_blake * S, u8 * digest ) 
-{
-
-  u8 msglen[16], zo=0x01,oo=0x81;
-  u64 lo=S->t[0] + S->buflen, hi = S->t[1];
-  if ( lo < S->buflen ) hi++;
-  U64TO8(  msglen + 0, hi );
-  U64TO8(  msglen + 8, lo );
-
-  if ( S->buflen == 888 ) /* one padding byte */
-  { 
-    S->t[0] -= 8; 
-    blake512_update( S, &oo, 8 );
-  }
-  else 
-  {
-    if ( S->buflen < 888 ) /* enough space to fill the block */
-    { 
-      if ( S->buflen == 0 ) S->nullt=1;
-      S->t[0] -= 888 - S->buflen;
-      blake512_update( S, padding, 888 - S->buflen );
-    }
-    else /* NOT enough space, need 2 compressions */ 
-    { 
-      S->t[0] -= 1024 - S->buflen; 
-      blake512_update( S, padding, 1024 - S->buflen );
-      S->t[0] -= 888;
-      blake512_update( S, padding+1, 888 );
-      S->nullt = 1;
-    }
-    blake512_update( S, &zo, 8 );
-    S->t[0] -= 8;
-  }
-  S->t[0] -= 128;
-  blake512_update( S, msglen, 128 );    
-
-  do
-  {
-    const __m128i u8to64 = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7);
-    _mm_storeu_si128((__m128i*)(digest +  0), BSWAP64(S->h[0]));
-    _mm_storeu_si128((__m128i*)(digest + 16), BSWAP64(S->h[1]));
-    _mm_storeu_si128((__m128i*)(digest + 32), BSWAP64(S->h[2]));
-    _mm_storeu_si128((__m128i*)(digest + 48), BSWAP64(S->h[3]));
-  } while(0);
-}
-
-/*
-int crypto_hash( unsigned char *out, const unsigned char *in, unsigned long long inlen ) 
-{
-
-  hashState_blake S;
-  blake512_init( &S );
-  blake512_update( &S, in, inlen*8 );
-  blake512_final( &S, out );
-  return 0;
-}
-*/
-/*
-#ifdef NOT_SUPERCOP
-
-int main() 
-{
-
-  int i, v;
-  u8 data[144], digest[64];
-  u8 test1[]= {0x97, 0x96, 0x15, 0x87, 0xF6, 0xD9, 0x70, 0xFA, 0xBA, 0x6D, 0x24, 0x78, 0x04, 0x5D, 0xE6, 0xD1, 
-	       0xFA, 0xBD, 0x09, 0xB6, 0x1A, 0xE5, 0x09, 0x32, 0x05, 0x4D, 0x52, 0xBC, 0x29, 0xD3, 0x1B, 0xE4, 
-	       0xFF, 0x91, 0x02, 0xB9, 0xF6, 0x9E, 0x2B, 0xBD, 0xB8, 0x3B, 0xE1, 0x3D, 0x4B, 0x9C, 0x06, 0x09, 
-	       0x1E, 0x5F, 0xA0, 0xB4, 0x8B, 0xD0, 0x81, 0xB6, 0x34, 0x05, 0x8B, 0xE0, 0xEC, 0x49, 0xBE, 0xB3};
-  u8 test2[]= {0x31, 0x37, 0x17, 0xD6, 0x08, 0xE9, 0xCF, 0x75, 0x8D, 0xCB, 0x1E, 0xB0, 0xF0, 0xC3, 0xCF, 0x9F, 
-	       0xC1, 0x50, 0xB2, 0xD5, 0x00, 0xFB, 0x33, 0xF5, 0x1C, 0x52, 0xAF, 0xC9, 0x9D, 0x35, 0x8A, 0x2F, 
-	       0x13, 0x74, 0xB8, 0xA3, 0x8B, 0xBA, 0x79, 0x74, 0xE7, 0xF6, 0xEF, 0x79, 0xCA, 0xB1, 0x6F, 0x22, 
-	       0xCE, 0x1E, 0x64, 0x9D, 0x6E, 0x01, 0xAD, 0x95, 0x89, 0xC2, 0x13, 0x04, 0x5D, 0x54, 0x5D, 0xDE};
-
-  for(i=0; i<144; ++i) data[i]=0;  
-
-  crypto_hash( digest, data, 1 );    
-  v=0;
-  for(i=0; i<64; ++i) {
-    printf("%02X", digest[i]);
-    if ( digest[i] != test1[i]) v=1;
-  }
-  if (v) printf("\nerror\n");
-  else  printf("\nok\n");
-
-  for(i=0; i<144; ++i) data[i]=0;  
-
-  crypto_hash( digest, data, 144 );    
-  v=0;
-  for(i=0; i<64; ++i) {
-    printf("%02X", digest[i]);
-    if ( digest[i] != test2[i]) v=1;
-  }
-  if (v) printf("\nerror\n");
-  else printf("\nok\n");
-
-  return 0;
-}
-
-#endif
-
-*/
-
-

algo/blake/sse2/blake/sse41/hash.h

@@ -1,74 +0,0 @@
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <x86intrin.h>
-
-#include "config.h"
-#include "rounds.h"
-/*
-#ifndef NOT_SUPERCOP
-
-#include "crypto_hash.h"
-#include "crypto_uint64.h"
-#include "crypto_uint32.h"
-#include "crypto_uint8.h"
-
-typedef crypto_uint64 u64;
-typedef crypto_uint32 u32;
-typedef crypto_uint8 u8; 
-
-#else
-*/
-typedef unsigned long long u64; 
-typedef unsigned int u32; 
-typedef unsigned char u8; 
-
-typedef struct  
-{ 
-	__m128i h[4];
-  u64 s[4], t[2];
-  u32 buflen, nullt;
-  u8 buf[128];
-} hashState_blake __attribute__ ((aligned (64)));
-/*
-#endif
-
-#define U8TO32(p) \
-  (((u32)((p)[0]) << 24) | ((u32)((p)[1]) << 16) | \
-   ((u32)((p)[2]) <<  8) | ((u32)((p)[3])      ))
-#define U8TO64(p) \
-  (((u64)U8TO32(p) << 32) | (u64)U8TO32((p) + 4))
-#define U32TO8(p, v) \
-    (p)[0] = (u8)((v) >> 24); (p)[1] = (u8)((v) >> 16); \
-    (p)[2] = (u8)((v) >>  8); (p)[3] = (u8)((v)      ); 
-#define U64TO8(p, v) \
-    U32TO8((p),     (u32)((v) >> 32));	\
-    U32TO8((p) + 4, (u32)((v)      )); 
-*/
-
-/*
-static const u8 padding[129] =
-{ 
-	0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-};
-
-*/
-static inline void blake512_init( hashState_blake * S, u64 datalen );
-
-
-static void blake512_update( hashState_blake * S, const u8 * data, u64 datalen ) ;
-
-static inline void blake512_final( hashState_blake * S, u8 * digest ) ;
-
-
-int crypto_hash( unsigned char *out, const unsigned char *in, unsigned long long inlen ) ;
-
-
-
-
-
-

algo/blake/sse2/blake/sse41/implementors

@@ -1,2 +0,0 @@
-Jean-Philippe Aumasson
-Samuel Neves

algo/blake/sse2/blake/sse41/rounds.h

@@ -1,871 +0,0 @@
-
-#ifndef __BLAKE512_ROUNDS_H__
-#define __BLAKE512_ROUNDS_H__
-
-#ifndef HAVE_XOP
-	#define BSWAP64(x) _mm_shuffle_epi8((x), u8to64)
-
-	#define _mm_roti_epi64(x, c) \
-	(-(c) == 32) ? _mm_shuffle_epi32((x), _MM_SHUFFLE(2,3,0,1))  \
-	: (-(c) == 16) ? _mm_shuffle_epi8((x), r16) \
-		: _mm_xor_si128(_mm_srli_epi64((x), -(c)), _mm_slli_epi64((x), 64-(-c))) 
-#else
-	#define BSWAP64(x) _mm_perm_epi8((x),(x),u8to64)
-#endif
-
-
-#define LOAD_MSG_0_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m0, m1); \
-t1 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x13198A2E03707344ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m2, m3); \
-t3 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0xBE5466CF34E90C6CULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_0_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m0, m1); \
-t1 = _mm_set_epi64x(0xA4093822299F31D0ULL, 0x243F6A8885A308D3ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m2, m3); \
-t3 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0x452821E638D01377ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_0_3(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m4, m5); \
-t1 = _mm_set_epi64x(0xB8E1AFED6A267E96ULL, 0xD1310BA698DFB5ACULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m6, m7); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0x24A19947B3916CF7ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_0_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m4, m5); \
-t1 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0x9216D5D98979FB1BULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m6, m7); \
-t3 = _mm_set_epi64x(0x801F2E2858EFC16ULL, 0xBA7C9045F12C7F99ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_1_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m7, m2); \
-t1 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x2FFD72DBD01ADFB7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m4, m6); \
-t3 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0x636920D871574E69ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_1_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m5, m4); \
-t1 = _mm_set_epi64x(0x452821E638D01377ULL, 0x801F2E2858EFC16ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m3, m7, 8); \
-t3 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0xD1310BA698DFB5ACULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_1_3(b0, b1) \
-do \
-{ \
-t0 = _mm_shuffle_epi32(m0, _MM_SHUFFLE(1,0,3,2)); \
-t1 = _mm_set_epi64x(0xA4093822299F31D0ULL, 0xBA7C9045F12C7F99ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m5, m2); \
-t3 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x3F84D5B5B5470917ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_1_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m6, m1); \
-t1 = _mm_set_epi64x(0x243F6A8885A308D3ULL, 0x13198A2E03707344ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m3, m1); \
-t3 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0xB8E1AFED6A267E96ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_2_1(b0, b1) \
-do \
-{ \
-t0 = _mm_alignr_epi8(m6, m5, 8); \
-t1 = _mm_set_epi64x(0x243F6A8885A308D3ULL, 0x9216D5D98979FB1BULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m2, m7); \
-t3 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0xA4093822299F31D0ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_2_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m4, m0); \
-t1 = _mm_set_epi64x(0xBA7C9045F12C7F99ULL, 0xB8E1AFED6A267E96ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m1, m6, 0xF0); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0xBE5466CF34E90C6CULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_2_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m5, m1, 0xF0); \
-t1 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0x801F2E2858EFC16ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m3, m4); \
-t3 = _mm_set_epi64x(0x452821E638D01377ULL, 0x13198A2E03707344ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_2_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m7, m3); \
-t1 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x2FFD72DBD01ADFB7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m2, m0, 8); \
-t3 = _mm_set_epi64x(0xD1310BA698DFB5ACULL, 0x3F84D5B5B5470917ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_3_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m3, m1); \
-t1 = _mm_set_epi64x(0x13198A2E03707344ULL, 0xD1310BA698DFB5ACULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m6, m5); \
-t3 = _mm_set_epi64x(0x801F2E2858EFC16ULL, 0xBA7C9045F12C7F99ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_3_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m4, m0); \
-t1 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x3F84D5B5B5470917ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m6, m7); \
-t3 = _mm_set_epi64x(0xB8E1AFED6A267E96ULL, 0x24A19947B3916CF7ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_3_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m1, m2, 0xF0); \
-t1 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0xC0AC29B7C97C50DDULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m2, m7, 0xF0); \
-t3 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x243F6A8885A308D3ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_3_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m3, m5); \
-t1 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0xA4093822299F31D0ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m0, m4); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0x452821E638D01377ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_4_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m4, m2); \
-t1 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0x243F6A8885A308D3ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m1, m5); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0x452821E638D01377ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_4_2(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m0, m3, 0xF0); \
-t1 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0xD1310BA698DFB5ACULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m2, m7, 0xF0); \
-t3 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0xA4093822299F31D0ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_4_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m7, m5, 0xF0); \
-t1 = _mm_set_epi64x(0xBA7C9045F12C7F99ULL, 0x13198A2E03707344ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m3, m1, 0xF0); \
-t3 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0x9216D5D98979FB1BULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_4_4(b0, b1) \
-do \
-{ \
-t0 = _mm_alignr_epi8(m6, m0, 8); \
-t1 = _mm_set_epi64x(0xB8E1AFED6A267E96ULL, 0x801F2E2858EFC16ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m4, m6, 0xF0); \
-t3 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0xC0AC29B7C97C50DDULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_5_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m1, m3); \
-t1 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0xBA7C9045F12C7F99ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m0, m4); \
-t3 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0xB8E1AFED6A267E96ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_5_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m6, m5); \
-t1 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0xA4093822299F31D0ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m5, m1); \
-t3 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x243F6A8885A308D3ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_5_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m2, m3, 0xF0); \
-t1 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0x24A19947B3916CF7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m7, m0); \
-t3 = _mm_set_epi64x(0xD1310BA698DFB5ACULL, 0x801F2E2858EFC16ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_5_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m6, m2); \
-t1 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0x452821E638D01377ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m7, m4, 0xF0); \
-t3 = _mm_set_epi64x(0x13198A2E03707344ULL, 0x636920D871574E69ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_6_1(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m6, m0, 0xF0); \
-t1 = _mm_set_epi64x(0x636920D871574E69ULL, 0xBE5466CF34E90C6CULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m7, m2); \
-t3 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0x24A19947B3916CF7ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_6_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m2, m7); \
-t1 = _mm_set_epi64x(0x13198A2E03707344ULL, 0xBA7C9045F12C7F99ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m5, m6, 8); \
-t3 = _mm_set_epi64x(0x452821E638D01377ULL, 0x801F2E2858EFC16ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_6_3(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m0, m3); \
-t1 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x3F84D5B5B5470917ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_shuffle_epi32(m4, _MM_SHUFFLE(1,0,3,2)); \
-t3 = _mm_set_epi64x(0xB8E1AFED6A267E96ULL, 0xA4093822299F31D0ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_6_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m3, m1); \
-t1 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0x243F6A8885A308D3ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m1, m5, 0xF0); \
-t3 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0xD1310BA698DFB5ACULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_7_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m6, m3); \
-t1 = _mm_set_epi64x(0x801F2E2858EFC16ULL, 0xB8E1AFED6A267E96ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m6, m1, 0xF0); \
-t3 = _mm_set_epi64x(0xD1310BA698DFB5ACULL, 0x13198A2E03707344ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_7_2(b0, b1) \
-do \
-{ \
-t0 = _mm_alignr_epi8(m7, m5, 8); \
-t1 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0x24A19947B3916CF7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m0, m4); \
-t3 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0xBA7C9045F12C7F99ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_7_3(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m2, m7); \
-t1 = _mm_set_epi64x(0x452821E638D01377ULL, 0x243F6A8885A308D3ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m4, m1); \
-t3 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0xC0AC29B7C97C50DDULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_7_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m0, m2); \
-t1 = _mm_set_epi64x(0x636920D871574E69ULL, 0xBE5466CF34E90C6CULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m3, m5); \
-t3 = _mm_set_epi64x(0xA4093822299F31D0ULL, 0x9216D5D98979FB1BULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_8_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m3, m7); \
-t1 = _mm_set_epi64x(0xD1310BA698DFB5ACULL, 0x636920D871574E69ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m0, m5, 8); \
-t3 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x82EFA98EC4E6C89ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_8_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m7, m4); \
-t1 = _mm_set_epi64x(0x801F2E2858EFC16ULL, 0xC0AC29B7C97C50DDULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m4, m1, 8); \
-t3 = _mm_set_epi64x(0x243F6A8885A308D3ULL, 0xB8E1AFED6A267E96ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_8_3(b0, b1) \
-do \
-{ \
-t0 = m6; \
-t1 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0xA4093822299F31D0ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m5, m0, 8); \
-t3 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0x452821E638D01377ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_8_4(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m1, m3, 0xF0); \
-t1 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0xBA7C9045F12C7F99ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = m2; \
-t3 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0x13198A2E03707344ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_9_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m5, m4); \
-t1 = _mm_set_epi64x(0x452821E638D01377ULL, 0xA4093822299F31D0ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m3, m0); \
-t3 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0xC0AC29B7C97C50DDULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_9_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m1, m2); \
-t1 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x2FFD72DBD01ADFB7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m3, m2, 0xF0); \
-t3 = _mm_set_epi64x(0x13198A2E03707344ULL, 0x3F84D5B5B5470917ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_9_3(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m7, m4); \
-t1 = _mm_set_epi64x(0x801F2E2858EFC16ULL, 0xB8E1AFED6A267E96ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m1, m6); \
-t3 = _mm_set_epi64x(0x243F6A8885A308D3ULL, 0xBA7C9045F12C7F99ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_9_4(b0, b1) \
-do \
-{ \
-t0 = _mm_alignr_epi8(m7, m5, 8); \
-t1 = _mm_set_epi64x(0xD1310BA698DFB5ACULL, 0x636920D871574E69ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m6, m0); \
-t3 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0x82EFA98EC4E6C89ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_10_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m0, m1); \
-t1 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x13198A2E03707344ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m2, m3); \
-t3 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0xBE5466CF34E90C6CULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_10_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m0, m1); \
-t1 = _mm_set_epi64x(0xA4093822299F31D0ULL, 0x243F6A8885A308D3ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m2, m3); \
-t3 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0x452821E638D01377ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_10_3(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m4, m5); \
-t1 = _mm_set_epi64x(0xB8E1AFED6A267E96ULL, 0xD1310BA698DFB5ACULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m6, m7); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0x24A19947B3916CF7ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_10_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m4, m5); \
-t1 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0x9216D5D98979FB1BULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m6, m7); \
-t3 = _mm_set_epi64x(0x801F2E2858EFC16ULL, 0xBA7C9045F12C7F99ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_11_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m7, m2); \
-t1 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x2FFD72DBD01ADFB7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m4, m6); \
-t3 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0x636920D871574E69ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_11_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m5, m4); \
-t1 = _mm_set_epi64x(0x452821E638D01377ULL, 0x801F2E2858EFC16ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m3, m7, 8); \
-t3 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0xD1310BA698DFB5ACULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_11_3(b0, b1) \
-do \
-{ \
-t0 = _mm_shuffle_epi32(m0, _MM_SHUFFLE(1,0,3,2)); \
-t1 = _mm_set_epi64x(0xA4093822299F31D0ULL, 0xBA7C9045F12C7F99ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m5, m2); \
-t3 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x3F84D5B5B5470917ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_11_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m6, m1); \
-t1 = _mm_set_epi64x(0x243F6A8885A308D3ULL, 0x13198A2E03707344ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m3, m1); \
-t3 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0xB8E1AFED6A267E96ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_12_1(b0, b1) \
-do \
-{ \
-t0 = _mm_alignr_epi8(m6, m5, 8); \
-t1 = _mm_set_epi64x(0x243F6A8885A308D3ULL, 0x9216D5D98979FB1BULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m2, m7); \
-t3 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0xA4093822299F31D0ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_12_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m4, m0); \
-t1 = _mm_set_epi64x(0xBA7C9045F12C7F99ULL, 0xB8E1AFED6A267E96ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m1, m6, 0xF0); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0xBE5466CF34E90C6CULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_12_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m5, m1, 0xF0); \
-t1 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0x801F2E2858EFC16ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m3, m4); \
-t3 = _mm_set_epi64x(0x452821E638D01377ULL, 0x13198A2E03707344ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_12_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m7, m3); \
-t1 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x2FFD72DBD01ADFB7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_alignr_epi8(m2, m0, 8); \
-t3 = _mm_set_epi64x(0xD1310BA698DFB5ACULL, 0x3F84D5B5B5470917ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_13_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m3, m1); \
-t1 = _mm_set_epi64x(0x13198A2E03707344ULL, 0xD1310BA698DFB5ACULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m6, m5); \
-t3 = _mm_set_epi64x(0x801F2E2858EFC16ULL, 0xBA7C9045F12C7F99ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_13_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m4, m0); \
-t1 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0x3F84D5B5B5470917ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m6, m7); \
-t3 = _mm_set_epi64x(0xB8E1AFED6A267E96ULL, 0x24A19947B3916CF7ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_13_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m1, m2, 0xF0); \
-t1 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0xC0AC29B7C97C50DDULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m2, m7, 0xF0); \
-t3 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x243F6A8885A308D3ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_13_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m3, m5); \
-t1 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0xA4093822299F31D0ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m0, m4); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0x452821E638D01377ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_14_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m4, m2); \
-t1 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0x243F6A8885A308D3ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m1, m5); \
-t3 = _mm_set_epi64x(0x636920D871574E69ULL, 0x452821E638D01377ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_14_2(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m0, m3, 0xF0); \
-t1 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0xD1310BA698DFB5ACULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m2, m7, 0xF0); \
-t3 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0xA4093822299F31D0ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_14_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m7, m5, 0xF0); \
-t1 = _mm_set_epi64x(0xBA7C9045F12C7F99ULL, 0x13198A2E03707344ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m3, m1, 0xF0); \
-t3 = _mm_set_epi64x(0x24A19947B3916CF7ULL, 0x9216D5D98979FB1BULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_14_4(b0, b1) \
-do \
-{ \
-t0 = _mm_alignr_epi8(m6, m0, 8); \
-t1 = _mm_set_epi64x(0xB8E1AFED6A267E96ULL, 0x801F2E2858EFC16ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m4, m6, 0xF0); \
-t3 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0xC0AC29B7C97C50DDULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_15_1(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m1, m3); \
-t1 = _mm_set_epi64x(0x2FFD72DBD01ADFB7ULL, 0xBA7C9045F12C7F99ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpacklo_epi64(m0, m4); \
-t3 = _mm_set_epi64x(0x82EFA98EC4E6C89ULL, 0xB8E1AFED6A267E96ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_15_2(b0, b1) \
-do \
-{ \
-t0 = _mm_unpacklo_epi64(m6, m5); \
-t1 = _mm_set_epi64x(0xC0AC29B7C97C50DDULL, 0xA4093822299F31D0ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m5, m1); \
-t3 = _mm_set_epi64x(0x9216D5D98979FB1BULL, 0x243F6A8885A308D3ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_15_3(b0, b1) \
-do \
-{ \
-t0 = _mm_blend_epi16(m2, m3, 0xF0); \
-t1 = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0x24A19947B3916CF7ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_unpackhi_epi64(m7, m0); \
-t3 = _mm_set_epi64x(0xD1310BA698DFB5ACULL, 0x801F2E2858EFC16ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-#define LOAD_MSG_15_4(b0, b1) \
-do \
-{ \
-t0 = _mm_unpackhi_epi64(m6, m2); \
-t1 = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0x452821E638D01377ULL); \
-b0 = _mm_xor_si128(t0, t1); \
-t2 = _mm_blend_epi16(m7, m4, 0xF0); \
-t3 = _mm_set_epi64x(0x13198A2E03707344ULL, 0x636920D871574E69ULL); \
-b1 = _mm_xor_si128(t2, t3); \
-} while(0) 
-
-
-
-
-
-
-#define G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1) \
-  row1l = _mm_add_epi64(_mm_add_epi64(row1l, b0), row2l); \
-  row1h = _mm_add_epi64(_mm_add_epi64(row1h, b1), row2h); \
-  \
-  row4l = _mm_xor_si128(row4l, row1l); \
-  row4h = _mm_xor_si128(row4h, row1h); \
-  \
-  row4l = _mm_roti_epi64(row4l, -32); \
-  row4h = _mm_roti_epi64(row4h, -32); \
-  \
-  row3l = _mm_add_epi64(row3l, row4l); \
-  row3h = _mm_add_epi64(row3h, row4h); \
-  \
-  row2l = _mm_xor_si128(row2l, row3l); \
-  row2h = _mm_xor_si128(row2h, row3h); \
-  \
-  row2l = _mm_roti_epi64(row2l, -25); \
-  row2h = _mm_roti_epi64(row2h, -25); \
-
-#define G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1) \
-  row1l = _mm_add_epi64(_mm_add_epi64(row1l, b0), row2l); \
-  row1h = _mm_add_epi64(_mm_add_epi64(row1h, b1), row2h); \
-  \
-  row4l = _mm_xor_si128(row4l, row1l); \
-  row4h = _mm_xor_si128(row4h, row1h); \
-  \
-  row4l = _mm_roti_epi64(row4l, -16); \
-  row4h = _mm_roti_epi64(row4h, -16); \
-  \
-  row3l = _mm_add_epi64(row3l, row4l); \
-  row3h = _mm_add_epi64(row3h, row4h); \
-  \
-  row2l = _mm_xor_si128(row2l, row3l); \
-  row2h = _mm_xor_si128(row2h, row3h); \
-  \
-  row2l = _mm_roti_epi64(row2l, -11); \
-  row2h = _mm_roti_epi64(row2h, -11); \
-
-
-#define DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h) \
-	t0 = _mm_alignr_epi8(row2h, row2l, 8); \
-	t1 = _mm_alignr_epi8(row2l, row2h, 8); \
-	row2l = t0; \
-	row2h = t1; \
-	\
-	t0 = row3l; \
-	row3l = row3h; \
-	row3h = t0;    \
-	\
-	t0 = _mm_alignr_epi8(row4h, row4l, 8); \
-	t1 = _mm_alignr_epi8(row4l, row4h, 8); \
-	row4l = t1; \
-	row4h = t0; 
-
-#define UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h) \
-	t0 = _mm_alignr_epi8(row2l, row2h, 8); \
-	t1 = _mm_alignr_epi8(row2h, row2l, 8); \
-	row2l = t0; \
-	row2h = t1; \
-	\
-	t0 = row3l; \
-	row3l = row3h; \
-	row3h = t0; \
-	\
-	t0 = _mm_alignr_epi8(row4l, row4h, 8); \
-	t1 = _mm_alignr_epi8(row4h, row4l, 8); \
-	row4l = t1; \
-	row4h = t0; 
-
-#define ROUND(r) \
-  LOAD_MSG_ ##r ##_1(b0, b1); \
-  G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
-  LOAD_MSG_ ##r ##_2(b0, b1); \
-  G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
-  DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
-  LOAD_MSG_ ##r ##_3(b0, b1); \
-  G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
-  LOAD_MSG_ ##r ##_4(b0, b1); \
-  G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
-  UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
-
-#endif
-

algo/bmw/bmw512-4way.c

@@ -41,7 +41,6 @@ int scanhash_bmw512_8way( struct work *work, uint32_t max_nonce,
 
       for ( int lane = 0; lane < 8; lane++ )
       if ( unlikely( hash7[ lane<<1 ] < Htarg ) )
-//      if ( ( ( hash7[ lane<<1 ] & 0xFFFFFF00 ) == 0 ) )
       {
           extr_lane_8x64( lane_hash, hash, lane, 256 );
           if ( fulltest( lane_hash, ptarget ) )
@@ -66,7 +65,7 @@ void bmw512hash_4way(void *state, const void *input)
 {
     bmw512_4way_context ctx;
     bmw512_4way_init( &ctx );
-    bmw512_4way( &ctx, input, 80 );
+    bmw512_4way_update( &ctx, input, 80 );
     bmw512_4way_close( &ctx, state );
 }
 

algo/bmw/sse2/bmw.c

@@ -1,519 +0,0 @@
-/* $Id: bmw.c 227 2010-06-16 17:28:38Z tp $ */
-/*
- * BMW implementation.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#include <stddef.h>
-#include <string.h>
-#include <limits.h>
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#include "../sph_bmw.h"
-
-#ifdef _MSC_VER
-#pragma warning (disable: 4146)
-#endif
-
-static const sph_u64 bmwIV512[] = {
-	SPH_C64(0x8081828384858687), SPH_C64(0x88898A8B8C8D8E8F),
-	SPH_C64(0x9091929394959697), SPH_C64(0x98999A9B9C9D9E9F),
-	SPH_C64(0xA0A1A2A3A4A5A6A7), SPH_C64(0xA8A9AAABACADAEAF),
-	SPH_C64(0xB0B1B2B3B4B5B6B7), SPH_C64(0xB8B9BABBBCBDBEBF),
-	SPH_C64(0xC0C1C2C3C4C5C6C7), SPH_C64(0xC8C9CACBCCCDCECF),
-	SPH_C64(0xD0D1D2D3D4D5D6D7), SPH_C64(0xD8D9DADBDCDDDEDF),
-	SPH_C64(0xE0E1E2E3E4E5E6E7), SPH_C64(0xE8E9EAEBECEDEEEF),
-	SPH_C64(0xF0F1F2F3F4F5F6F7), SPH_C64(0xF8F9FAFBFCFDFEFF)
-};
-
-#define XCAT(x, y)    XCAT_(x, y)
-#define XCAT_(x, y)   x ## y
-
-#define LPAR   (
-
-#define I16_16    0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15
-#define I16_17    1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16
-#define I16_18    2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17
-#define I16_19    3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18
-#define I16_20    4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
-#define I16_21    5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20
-#define I16_22    6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21
-#define I16_23    7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22
-#define I16_24    8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23
-#define I16_25    9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24
-#define I16_26   10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25
-#define I16_27   11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26
-#define I16_28   12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27
-#define I16_29   13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28
-#define I16_30   14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
-#define I16_31   15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30
-
-#define M16_16    0,  1,  3,  4,  7, 10, 11
-#define M16_17    1,  2,  4,  5,  8, 11, 12
-#define M16_18    2,  3,  5,  6,  9, 12, 13
-#define M16_19    3,  4,  6,  7, 10, 13, 14
-#define M16_20    4,  5,  7,  8, 11, 14, 15
-#define M16_21    5,  6,  8,  9, 12, 15, 16
-#define M16_22    6,  7,  9, 10, 13,  0,  1
-#define M16_23    7,  8, 10, 11, 14,  1,  2
-#define M16_24    8,  9, 11, 12, 15,  2,  3
-#define M16_25    9, 10, 12, 13,  0,  3,  4
-#define M16_26   10, 11, 13, 14,  1,  4,  5
-#define M16_27   11, 12, 14, 15,  2,  5,  6
-#define M16_28   12, 13, 15, 16,  3,  6,  7
-#define M16_29   13, 14,  0,  1,  4,  7,  8
-#define M16_30   14, 15,  1,  2,  5,  8,  9
-#define M16_31   15, 16,  2,  3,  6,  9, 10
-
-#define ss0(x)    (((x) >> 1) ^ SPH_T32((x) << 3) \
-                  ^ SPH_ROTL32(x,  4) ^ SPH_ROTL32(x, 19))
-#define ss1(x)    (((x) >> 1) ^ SPH_T32((x) << 2) \
-                  ^ SPH_ROTL32(x,  8) ^ SPH_ROTL32(x, 23))
-#define ss2(x)    (((x) >> 2) ^ SPH_T32((x) << 1) \
-                  ^ SPH_ROTL32(x, 12) ^ SPH_ROTL32(x, 25))
-#define ss3(x)    (((x) >> 2) ^ SPH_T32((x) << 2) \
-                  ^ SPH_ROTL32(x, 15) ^ SPH_ROTL32(x, 29))
-#define ss4(x)    (((x) >> 1) ^ (x))
-#define ss5(x)    (((x) >> 2) ^ (x))
-#define rs1(x)    SPH_ROTL32(x,  3)
-#define rs2(x)    SPH_ROTL32(x,  7)
-#define rs3(x)    SPH_ROTL32(x, 13)
-#define rs4(x)    SPH_ROTL32(x, 16)
-#define rs5(x)    SPH_ROTL32(x, 19)
-#define rs6(x)    SPH_ROTL32(x, 23)
-#define rs7(x)    SPH_ROTL32(x, 27)
-
-#define Ks(j)   SPH_T32((sph_u32)(j) * SPH_C32(0x05555555))
-
-#define add_elt_s(mf, hf, j0m, j1m, j3m, j4m, j7m, j10m, j11m, j16) \
-	(SPH_T32(SPH_ROTL32(mf(j0m), j1m) + SPH_ROTL32(mf(j3m), j4m) \
-		- SPH_ROTL32(mf(j10m), j11m) + Ks(j16)) ^ hf(j7m))
-
-#define expand1s_inner(qf, mf, hf, i16, \
-		i0, i1, i2, i3, i4, i5, i6, i7, i8, \
-		i9, i10, i11, i12, i13, i14, i15, \
-		i0m, i1m, i3m, i4m, i7m, i10m, i11m) \
-	SPH_T32(ss1(qf(i0)) + ss2(qf(i1)) + ss3(qf(i2)) + ss0(qf(i3)) \
-		+ ss1(qf(i4)) + ss2(qf(i5)) + ss3(qf(i6)) + ss0(qf(i7)) \
-		+ ss1(qf(i8)) + ss2(qf(i9)) + ss3(qf(i10)) + ss0(qf(i11)) \
-		+ ss1(qf(i12)) + ss2(qf(i13)) + ss3(qf(i14)) + ss0(qf(i15)) \
-		+ add_elt_s(mf, hf, i0m, i1m, i3m, i4m, i7m, i10m, i11m, i16))
-
-#define expand1s(qf, mf, hf, i16) \
-	expand1s_(qf, mf, hf, i16, I16_ ## i16, M16_ ## i16)
-#define expand1s_(qf, mf, hf, i16, ix, iy) \
-	expand1s_inner LPAR qf, mf, hf, i16, ix, iy)
-
-#define expand2s_inner(qf, mf, hf, i16, \
-		i0, i1, i2, i3, i4, i5, i6, i7, i8, \
-		i9, i10, i11, i12, i13, i14, i15, \
-		i0m, i1m, i3m, i4m, i7m, i10m, i11m) \
-	SPH_T32(qf(i0) + rs1(qf(i1)) + qf(i2) + rs2(qf(i3)) \
-		+ qf(i4) + rs3(qf(i5)) + qf(i6) + rs4(qf(i7)) \
-		+ qf(i8) + rs5(qf(i9)) + qf(i10) + rs6(qf(i11)) \
-		+ qf(i12) + rs7(qf(i13)) + ss4(qf(i14)) + ss5(qf(i15)) \
-		+ add_elt_s(mf, hf, i0m, i1m, i3m, i4m, i7m, i10m, i11m, i16))
-
-#define expand2s(qf, mf, hf, i16) \
-	expand2s_(qf, mf, hf, i16, I16_ ## i16, M16_ ## i16)
-#define expand2s_(qf, mf, hf, i16, ix, iy) \
-	expand2s_inner LPAR qf, mf, hf, i16, ix, iy)
-
-#if SPH_64
-
-#define sb0(x)    (((x) >> 1) ^ SPH_T64((x) << 3) \
-                  ^ SPH_ROTL64(x,  4) ^ SPH_ROTL64(x, 37))
-#define sb1(x)    (((x) >> 1) ^ SPH_T64((x) << 2) \
-                  ^ SPH_ROTL64(x, 13) ^ SPH_ROTL64(x, 43))
-#define sb2(x)    (((x) >> 2) ^ SPH_T64((x) << 1) \
-                  ^ SPH_ROTL64(x, 19) ^ SPH_ROTL64(x, 53))
-#define sb3(x)    (((x) >> 2) ^ SPH_T64((x) << 2) \
-                  ^ SPH_ROTL64(x, 28) ^ SPH_ROTL64(x, 59))
-#define sb4(x)    (((x) >> 1) ^ (x))
-#define sb5(x)    (((x) >> 2) ^ (x))
-#define rb1(x)    SPH_ROTL64(x,  5)
-#define rb2(x)    SPH_ROTL64(x, 11)
-#define rb3(x)    SPH_ROTL64(x, 27)
-#define rb4(x)    SPH_ROTL64(x, 32)
-#define rb5(x)    SPH_ROTL64(x, 37)
-#define rb6(x)    SPH_ROTL64(x, 43)
-#define rb7(x)    SPH_ROTL64(x, 53)
-
-#define Kb(j)   SPH_T64((sph_u64)(j) * SPH_C64(0x0555555555555555))
-
-#if 0
-
-static const sph_u64 Kb_tab[] = {
-	Kb(16), Kb(17), Kb(18), Kb(19), Kb(20), Kb(21), Kb(22), Kb(23),
-	Kb(24), Kb(25), Kb(26), Kb(27), Kb(28), Kb(29), Kb(30), Kb(31)
-};
-
-#define rol_off(mf, j, off) \
-	SPH_ROTL64(mf(((j) + (off)) & 15), (((j) + (off)) & 15) + 1)
-
-#define add_elt_b(mf, hf, j) \
-	(SPH_T64(rol_off(mf, j, 0) + rol_off(mf, j, 3) \
-		- rol_off(mf, j, 10) + Kb_tab[j]) ^ hf(((j) + 7) & 15))
-
-#define expand1b(qf, mf, hf, i) \
-	SPH_T64(sb1(qf((i) - 16)) + sb2(qf((i) - 15)) \
-		+ sb3(qf((i) - 14)) + sb0(qf((i) - 13)) \
-		+ sb1(qf((i) - 12)) + sb2(qf((i) - 11)) \
-		+ sb3(qf((i) - 10)) + sb0(qf((i) - 9)) \
-		+ sb1(qf((i) - 8)) + sb2(qf((i) - 7)) \
-		+ sb3(qf((i) - 6)) + sb0(qf((i) - 5)) \
-		+ sb1(qf((i) - 4)) + sb2(qf((i) - 3)) \
-		+ sb3(qf((i) - 2)) + sb0(qf((i) - 1)) \
-		+ add_elt_b(mf, hf, (i) - 16))
-
-#define expand2b(qf, mf, hf, i) \
-	SPH_T64(qf((i) - 16) + rb1(qf((i) - 15)) \
-		+ qf((i) - 14) + rb2(qf((i) - 13)) \
-		+ qf((i) - 12) + rb3(qf((i) - 11)) \
-		+ qf((i) - 10) + rb4(qf((i) - 9)) \
-		+ qf((i) - 8) + rb5(qf((i) - 7)) \
-		+ qf((i) - 6) + rb6(qf((i) - 5)) \
-		+ qf((i) - 4) + rb7(qf((i) - 3)) \
-		+ sb4(qf((i) - 2)) + sb5(qf((i) - 1)) \
-		+ add_elt_b(mf, hf, (i) - 16))
-
-#else
-
-#define add_elt_b(mf, hf, j0m, j1m, j3m, j4m, j7m, j10m, j11m, j16) \
-	(SPH_T64(SPH_ROTL64(mf(j0m), j1m) + SPH_ROTL64(mf(j3m), j4m) \
-		- SPH_ROTL64(mf(j10m), j11m) + Kb(j16)) ^ hf(j7m))
-
-#define expand1b_inner(qf, mf, hf, i16, \
-		i0, i1, i2, i3, i4, i5, i6, i7, i8, \
-		i9, i10, i11, i12, i13, i14, i15, \
-		i0m, i1m, i3m, i4m, i7m, i10m, i11m) \
-	SPH_T64(sb1(qf(i0)) + sb2(qf(i1)) + sb3(qf(i2)) + sb0(qf(i3)) \
-		+ sb1(qf(i4)) + sb2(qf(i5)) + sb3(qf(i6)) + sb0(qf(i7)) \
-		+ sb1(qf(i8)) + sb2(qf(i9)) + sb3(qf(i10)) + sb0(qf(i11)) \
-		+ sb1(qf(i12)) + sb2(qf(i13)) + sb3(qf(i14)) + sb0(qf(i15)) \
-		+ add_elt_b(mf, hf, i0m, i1m, i3m, i4m, i7m, i10m, i11m, i16))
-
-#define expand1b(qf, mf, hf, i16) \
-	expand1b_(qf, mf, hf, i16, I16_ ## i16, M16_ ## i16)
-#define expand1b_(qf, mf, hf, i16, ix, iy) \
-	expand1b_inner LPAR qf, mf, hf, i16, ix, iy)
-
-#define expand2b_inner(qf, mf, hf, i16, \
-		i0, i1, i2, i3, i4, i5, i6, i7, i8, \
-		i9, i10, i11, i12, i13, i14, i15, \
-		i0m, i1m, i3m, i4m, i7m, i10m, i11m) \
-	SPH_T64(qf(i0) + rb1(qf(i1)) + qf(i2) + rb2(qf(i3)) \
-		+ qf(i4) + rb3(qf(i5)) + qf(i6) + rb4(qf(i7)) \
-		+ qf(i8) + rb5(qf(i9)) + qf(i10) + rb6(qf(i11)) \
-		+ qf(i12) + rb7(qf(i13)) + sb4(qf(i14)) + sb5(qf(i15)) \
-		+ add_elt_b(mf, hf, i0m, i1m, i3m, i4m, i7m, i10m, i11m, i16))
-
-#define expand2b(qf, mf, hf, i16) \
-	expand2b_(qf, mf, hf, i16, I16_ ## i16, M16_ ## i16)
-#define expand2b_(qf, mf, hf, i16, ix, iy) \
-	expand2b_inner LPAR qf, mf, hf, i16, ix, iy)
-
-#endif
-
-#endif
-
-#define MAKE_W(tt, i0, op01, i1, op12, i2, op23, i3, op34, i4) \
-	tt((M(i0) ^ H(i0)) op01 (M(i1) ^ H(i1)) op12 (M(i2) ^ H(i2)) \
-	op23 (M(i3) ^ H(i3)) op34 (M(i4) ^ H(i4)))
-
-#define Ws0    MAKE_W(SPH_T32,  5, -,  7, +, 10, +, 13, +, 14)
-#define Ws1    MAKE_W(SPH_T32,  6, -,  8, +, 11, +, 14, -, 15)
-#define Ws2    MAKE_W(SPH_T32,  0, +,  7, +,  9, -, 12, +, 15)
-#define Ws3    MAKE_W(SPH_T32,  0, -,  1, +,  8, -, 10, +, 13)
-#define Ws4    MAKE_W(SPH_T32,  1, +,  2, +,  9, -, 11, -, 14)
-#define Ws5    MAKE_W(SPH_T32,  3, -,  2, +, 10, -, 12, +, 15)
-#define Ws6    MAKE_W(SPH_T32,  4, -,  0, -,  3, -, 11, +, 13)
-#define Ws7    MAKE_W(SPH_T32,  1, -,  4, -,  5, -, 12, -, 14)
-#define Ws8    MAKE_W(SPH_T32,  2, -,  5, -,  6, +, 13, -, 15)
-#define Ws9    MAKE_W(SPH_T32,  0, -,  3, +,  6, -,  7, +, 14)
-#define Ws10   MAKE_W(SPH_T32,  8, -,  1, -,  4, -,  7, +, 15)
-#define Ws11   MAKE_W(SPH_T32,  8, -,  0, -,  2, -,  5, +,  9)
-#define Ws12   MAKE_W(SPH_T32,  1, +,  3, -,  6, -,  9, +, 10)
-#define Ws13   MAKE_W(SPH_T32,  2, +,  4, +,  7, +, 10, +, 11)
-#define Ws14   MAKE_W(SPH_T32,  3, -,  5, +,  8, -, 11, -, 12)
-#define Ws15   MAKE_W(SPH_T32, 12, -,  4, -,  6, -,  9, +, 13)
-
-#define MAKE_Qas   do { \
-		qt[ 0] = SPH_T32(ss0(Ws0 ) + H( 1)); \
-		qt[ 1] = SPH_T32(ss1(Ws1 ) + H( 2)); \
-		qt[ 2] = SPH_T32(ss2(Ws2 ) + H( 3)); \
-		qt[ 3] = SPH_T32(ss3(Ws3 ) + H( 4)); \
-		qt[ 4] = SPH_T32(ss4(Ws4 ) + H( 5)); \
-		qt[ 5] = SPH_T32(ss0(Ws5 ) + H( 6)); \
-		qt[ 6] = SPH_T32(ss1(Ws6 ) + H( 7)); \
-		qt[ 7] = SPH_T32(ss2(Ws7 ) + H( 8)); \
-		qt[ 8] = SPH_T32(ss3(Ws8 ) + H( 9)); \
-		qt[ 9] = SPH_T32(ss4(Ws9 ) + H(10)); \
-		qt[10] = SPH_T32(ss0(Ws10) + H(11)); \
-		qt[11] = SPH_T32(ss1(Ws11) + H(12)); \
-		qt[12] = SPH_T32(ss2(Ws12) + H(13)); \
-		qt[13] = SPH_T32(ss3(Ws13) + H(14)); \
-		qt[14] = SPH_T32(ss4(Ws14) + H(15)); \
-		qt[15] = SPH_T32(ss0(Ws15) + H( 0)); \
-	} while (0)
-
-#define MAKE_Qbs   do { \
-		qt[16] = expand1s(Qs, M, H, 16); \
-		qt[17] = expand1s(Qs, M, H, 17); \
-		qt[18] = expand2s(Qs, M, H, 18); \
-		qt[19] = expand2s(Qs, M, H, 19); \
-		qt[20] = expand2s(Qs, M, H, 20); \
-		qt[21] = expand2s(Qs, M, H, 21); \
-		qt[22] = expand2s(Qs, M, H, 22); \
-		qt[23] = expand2s(Qs, M, H, 23); \
-		qt[24] = expand2s(Qs, M, H, 24); \
-		qt[25] = expand2s(Qs, M, H, 25); \
-		qt[26] = expand2s(Qs, M, H, 26); \
-		qt[27] = expand2s(Qs, M, H, 27); \
-		qt[28] = expand2s(Qs, M, H, 28); \
-		qt[29] = expand2s(Qs, M, H, 29); \
-		qt[30] = expand2s(Qs, M, H, 30); \
-		qt[31] = expand2s(Qs, M, H, 31); \
-	} while (0)
-
-#define MAKE_Qs   do { \
-		MAKE_Qas; \
-		MAKE_Qbs; \
-	} while (0)
-
-#define Qs(j)   (qt[j])
-
-#define Wb0    MAKE_W(SPH_T64,  5, -,  7, +, 10, +, 13, +, 14)
-#define Wb1    MAKE_W(SPH_T64,  6, -,  8, +, 11, +, 14, -, 15)
-#define Wb2    MAKE_W(SPH_T64,  0, +,  7, +,  9, -, 12, +, 15)
-#define Wb3    MAKE_W(SPH_T64,  0, -,  1, +,  8, -, 10, +, 13)
-#define Wb4    MAKE_W(SPH_T64,  1, +,  2, +,  9, -, 11, -, 14)
-#define Wb5    MAKE_W(SPH_T64,  3, -,  2, +, 10, -, 12, +, 15)
-#define Wb6    MAKE_W(SPH_T64,  4, -,  0, -,  3, -, 11, +, 13)
-#define Wb7    MAKE_W(SPH_T64,  1, -,  4, -,  5, -, 12, -, 14)
-#define Wb8    MAKE_W(SPH_T64,  2, -,  5, -,  6, +, 13, -, 15)
-#define Wb9    MAKE_W(SPH_T64,  0, -,  3, +,  6, -,  7, +, 14)
-#define Wb10   MAKE_W(SPH_T64,  8, -,  1, -,  4, -,  7, +, 15)
-#define Wb11   MAKE_W(SPH_T64,  8, -,  0, -,  2, -,  5, +,  9)
-#define Wb12   MAKE_W(SPH_T64,  1, +,  3, -,  6, -,  9, +, 10)
-#define Wb13   MAKE_W(SPH_T64,  2, +,  4, +,  7, +, 10, +, 11)
-#define Wb14   MAKE_W(SPH_T64,  3, -,  5, +,  8, -, 11, -, 12)
-#define Wb15   MAKE_W(SPH_T64, 12, -,  4, -,  6, -,  9, +, 13)
-
-#define MAKE_Qab   do { \
-		qt[ 0] = SPH_T64(sb0(Wb0 ) + H( 1)); \
-		qt[ 1] = SPH_T64(sb1(Wb1 ) + H( 2)); \
-		qt[ 2] = SPH_T64(sb2(Wb2 ) + H( 3)); \
-		qt[ 3] = SPH_T64(sb3(Wb3 ) + H( 4)); \
-		qt[ 4] = SPH_T64(sb4(Wb4 ) + H( 5)); \
-		qt[ 5] = SPH_T64(sb0(Wb5 ) + H( 6)); \
-		qt[ 6] = SPH_T64(sb1(Wb6 ) + H( 7)); \
-		qt[ 7] = SPH_T64(sb2(Wb7 ) + H( 8)); \
-		qt[ 8] = SPH_T64(sb3(Wb8 ) + H( 9)); \
-		qt[ 9] = SPH_T64(sb4(Wb9 ) + H(10)); \
-		qt[10] = SPH_T64(sb0(Wb10) + H(11)); \
-		qt[11] = SPH_T64(sb1(Wb11) + H(12)); \
-		qt[12] = SPH_T64(sb2(Wb12) + H(13)); \
-		qt[13] = SPH_T64(sb3(Wb13) + H(14)); \
-		qt[14] = SPH_T64(sb4(Wb14) + H(15)); \
-		qt[15] = SPH_T64(sb0(Wb15) + H( 0)); \
-	} while (0)
-
-#define MAKE_Qbb   do { \
-		qt[16] = expand1b(Qb, M, H, 16); \
-		qt[17] = expand1b(Qb, M, H, 17); \
-		qt[18] = expand2b(Qb, M, H, 18); \
-		qt[19] = expand2b(Qb, M, H, 19); \
-		qt[20] = expand2b(Qb, M, H, 20); \
-		qt[21] = expand2b(Qb, M, H, 21); \
-		qt[22] = expand2b(Qb, M, H, 22); \
-		qt[23] = expand2b(Qb, M, H, 23); \
-		qt[24] = expand2b(Qb, M, H, 24); \
-		qt[25] = expand2b(Qb, M, H, 25); \
-		qt[26] = expand2b(Qb, M, H, 26); \
-		qt[27] = expand2b(Qb, M, H, 27); \
-		qt[28] = expand2b(Qb, M, H, 28); \
-		qt[29] = expand2b(Qb, M, H, 29); \
-		qt[30] = expand2b(Qb, M, H, 30); \
-		qt[31] = expand2b(Qb, M, H, 31); \
-	} while (0)
-
-#define MAKE_Qb   do { \
-		MAKE_Qab; \
-		MAKE_Qbb; \
-	} while (0)
-
-#define Qb(j)   (qt[j])
-
-#define FOLD(type, mkQ, tt, rol, mf, qf, dhf)   do { \
-		type qt[32], xl, xh; \
-		mkQ; \
-		xl = qf(16) ^ qf(17) ^ qf(18) ^ qf(19) \
-			^ qf(20) ^ qf(21) ^ qf(22) ^ qf(23); \
-		xh = xl ^ qf(24) ^ qf(25) ^ qf(26) ^ qf(27) \
-			^ qf(28) ^ qf(29) ^ qf(30) ^ qf(31); \
-		dhf( 0) = tt(((xh <<  5) ^ (qf(16) >>  5) ^ mf( 0)) \
-			+ (xl ^ qf(24) ^ qf( 0))); \
-		dhf( 1) = tt(((xh >>  7) ^ (qf(17) <<  8) ^ mf( 1)) \
-			+ (xl ^ qf(25) ^ qf( 1))); \
-		dhf( 2) = tt(((xh >>  5) ^ (qf(18) <<  5) ^ mf( 2)) \
-			+ (xl ^ qf(26) ^ qf( 2))); \
-		dhf( 3) = tt(((xh >>  1) ^ (qf(19) <<  5) ^ mf( 3)) \
-			+ (xl ^ qf(27) ^ qf( 3))); \
-		dhf( 4) = tt(((xh >>  3) ^ (qf(20) <<  0) ^ mf( 4)) \
-			+ (xl ^ qf(28) ^ qf( 4))); \
-		dhf( 5) = tt(((xh <<  6) ^ (qf(21) >>  6) ^ mf( 5)) \
-			+ (xl ^ qf(29) ^ qf( 5))); \
-		dhf( 6) = tt(((xh >>  4) ^ (qf(22) <<  6) ^ mf( 6)) \
-			+ (xl ^ qf(30) ^ qf( 6))); \
-		dhf( 7) = tt(((xh >> 11) ^ (qf(23) <<  2) ^ mf( 7)) \
-			+ (xl ^ qf(31) ^ qf( 7))); \
-		dhf( 8) = tt(rol(dhf(4),  9) + (xh ^ qf(24) ^ mf( 8)) \
-			+ ((xl << 8) ^ qf(23) ^ qf( 8))); \
-		dhf( 9) = tt(rol(dhf(5), 10) + (xh ^ qf(25) ^ mf( 9)) \
-			+ ((xl >> 6) ^ qf(16) ^ qf( 9))); \
-		dhf(10) = tt(rol(dhf(6), 11) + (xh ^ qf(26) ^ mf(10)) \
-			+ ((xl << 6) ^ qf(17) ^ qf(10))); \
-		dhf(11) = tt(rol(dhf(7), 12) + (xh ^ qf(27) ^ mf(11)) \
-			+ ((xl << 4) ^ qf(18) ^ qf(11))); \
-		dhf(12) = tt(rol(dhf(0), 13) + (xh ^ qf(28) ^ mf(12)) \
-			+ ((xl >> 3) ^ qf(19) ^ qf(12))); \
-		dhf(13) = tt(rol(dhf(1), 14) + (xh ^ qf(29) ^ mf(13)) \
-			+ ((xl >> 4) ^ qf(20) ^ qf(13))); \
-		dhf(14) = tt(rol(dhf(2), 15) + (xh ^ qf(30) ^ mf(14)) \
-			+ ((xl >> 7) ^ qf(21) ^ qf(14))); \
-		dhf(15) = tt(rol(dhf(3), 16) + (xh ^ qf(31) ^ mf(15)) \
-			+ ((xl >> 2) ^ qf(22) ^ qf(15))); \
-	} while (0)
-
-#define FOLDs   FOLD(sph_u32, MAKE_Qs, SPH_T32, SPH_ROTL32, M, Qs, dH)
-
-#define FOLDb   FOLD(sph_u64, MAKE_Qb, SPH_T64, SPH_ROTL64, M, Qb, dH)
-
-#define DECL_BMW \
-    sph_u64 bmwH[16]; \
-
-/* load initial constants */
-#define BMW_I \
-do { \
-    memcpy(bmwH, bmwIV512, sizeof bmwH); \
-    hashptr = 0; \
-    hashctA = 0; \
-} while (0) 
-
-/* load hash for loop */
-#define BMW_U \
-do { \
-    const void *data = hash; \
-    size_t len = 64; \
-    unsigned char *buf; \
-    \
-    hashctA += (sph_u64)len << 3; \
-    buf = hashbuf; \
-    memcpy(buf, data, 64); \
-    hashptr = 64; \
-} while (0)  
-
-
-/* bmw512 hash loaded */
-/* hash = blake512(loaded) */
-#define BMW_C \
-do { \
-    void *dst = hash; \
-    size_t out_size_w64 = 8; \
-    unsigned char *data; \
-    sph_u64 *dh; \
-    unsigned char *out; \
-    size_t ptr, u, v; \
-    unsigned z; \
-    sph_u64 h1[16], h2[16], *h; \
-    data = hashbuf; \
-    ptr = hashptr; \
-    z = 0x80 >> 0; \
-    data[ptr ++] = ((0 & -z) | z) & 0xFF; \
-    memset(data + ptr, 0, (sizeof(char)*128) - 8 - ptr); \
-    sph_enc64le_aligned(data + (sizeof(char)*128) - 8, \
-    SPH_T64(hashctA + 0)); \
-    /* for break loop */ \
-    /* one copy of inline FOLD */ \
-    /* FOLD uses, */ \
-    /* uint64 *h, data */ \
-    /* uint64 dh, state */ \
-        h = bmwH; \
-        dh = h2; \
-    for (;;) { \
-        FOLDb; \
-        /* dh gets changed for 2nd run */ \
-        if (dh == h1) break; \
-        for (u = 0; u < 16; u ++) \
-        sph_enc64le_aligned(data + 8 * u, h2[u]); \
-        dh = h1; \
-        h = (sph_u64*)final_b; \
-    } \
-    /* end wrapped for break loop */ \
-    out = dst; \
-    for (u = 0, v = 16 - out_size_w64; u < out_size_w64; u ++, v ++) \
-    sph_enc64le(out + 8 * u, h1[v]); \
-} while (0) 
-
-/*
-static void
-compress_big(const unsigned char *data, const sph_u64 h[16], sph_u64 dh[16])
-{
-
-#define M(x)    sph_dec64le_aligned(data + 8 * (x))
-#define H(x)    (h[x])
-#define dH(x)   (dh[x])
-
-	FOLDb;
-
-#undef M
-#undef H
-#undef dH
-}
-*/
-
-static const sph_u64 final_b[16] = {
-	SPH_C64(0xaaaaaaaaaaaaaaa0), SPH_C64(0xaaaaaaaaaaaaaaa1),
-	SPH_C64(0xaaaaaaaaaaaaaaa2), SPH_C64(0xaaaaaaaaaaaaaaa3),
-	SPH_C64(0xaaaaaaaaaaaaaaa4), SPH_C64(0xaaaaaaaaaaaaaaa5),
-	SPH_C64(0xaaaaaaaaaaaaaaa6), SPH_C64(0xaaaaaaaaaaaaaaa7),
-	SPH_C64(0xaaaaaaaaaaaaaaa8), SPH_C64(0xaaaaaaaaaaaaaaa9),
-	SPH_C64(0xaaaaaaaaaaaaaaaa), SPH_C64(0xaaaaaaaaaaaaaaab),
-	SPH_C64(0xaaaaaaaaaaaaaaac), SPH_C64(0xaaaaaaaaaaaaaaad),
-	SPH_C64(0xaaaaaaaaaaaaaaae), SPH_C64(0xaaaaaaaaaaaaaaaf)
-};
-
-
-#ifdef __cplusplus
-}
-#endif

algo/bmw/sse2/sph_bmw.h

@@ -1,61 +0,0 @@
-/* $Id: sph_bmw.h 216 2010-06-08 09:46:57Z tp $ */
-/**
- * BMW interface. BMW (aka "Blue Midnight Wish") is a family of
- * functions which differ by their output size; this implementation
- * defines BMW for output sizes 224, 256, 384 and 512 bits.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- * 
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @file     sph_bmw.h
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#ifndef SPH_BMW_H__
-#define SPH_BMW_H__
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#include <stddef.h>
-#include "sph_types.h"
-
-#define SPH_SIZE_bmw512   512
-
-typedef struct {
-#ifndef DOXYGEN_IGNORE
-	sph_u64 bmwH[16];
-#endif
-} sph_bmw_big_context;
-
-typedef sph_bmw_big_context sph_bmw512_context;
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

algo/cubehash/cubehash_sse2.c

@@ -21,7 +21,27 @@ static void transform( cubehashParam *sp )
     int r;
     const int rounds = sp->rounds;
 
-#ifdef __AVX2__
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+    register __m512i x0, x1;
+
+    x0 = _mm512_load_si512( (__m512i*)sp->x     );
+    x1 = _mm512_load_si512( (__m512i*)sp->x + 1 );
+
+    for ( r = 0; r < rounds; ++r )
+    { 
+        x1 = _mm512_add_epi32( x0, x1 );
+        x0 = _mm512_xor_si512( mm512_rol_32( mm512_swap_256( x0 ), 7 ), x1 );
+        x1 = _mm512_add_epi32( x0, mm512_swap128_64( x1 ) );
+        x0 = _mm512_xor_si512( mm512_rol_32(
+                                         mm512_swap256_128( x0 ), 11 ), x1 );
+        x1 = mm512_swap64_32( x1 );
+    }
+
+    _mm512_store_si512( (__m512i*)sp->x,     x0 );
+    _mm512_store_si512( (__m512i*)sp->x + 1, x1 );
+
+#elif defined(__AVX2__)
 
     register __m256i x0, x1, x2, x3, y0, y1;
 

algo/echo/aes_ni/hash.c

@@ -179,53 +179,53 @@ void Compress(hashState_echo *ctx, const unsigned char *pmsg, unsigned int uBloc
 
    for(b = 0; b < uBlockCount; b++)
    {
-	ctx->k = _mm_add_epi64(ctx->k, ctx->const1536);
+   	ctx->k = _mm_add_epi64(ctx->k, ctx->const1536);
 
-	// load message
-	for(j = ctx->uHashSize / 256; j < 4; j++)
-	{
-	   for(i = 0; i < 4; i++)
+   	// load message
+	   for(j = ctx->uHashSize / 256; j < 4; j++)
 	   {
-		_state[i][j] = _mm_loadu_si128((__m128i*)pmsg + 4 * (j - (ctx->uHashSize / 256)) + i);
+	      for(i = 0; i < 4; i++)
+	      {
+		     _state[i][j] = _mm_load_si128((__m128i*)pmsg + 4 * (j - (ctx->uHashSize / 256)) + i);
+	      }
 	   }
-	}
 
-	// save state
-	SAVESTATE(_statebackup, _state);
+	   // save state
+	   SAVESTATE(_statebackup, _state);
 
-	k1 = ctx->k;
+	   k1 = ctx->k;
 
-	for(r = 0; r < ctx->uRounds / 2; r++)
-	{
-		ECHO_ROUND_UNROLL2;
-	}
+	   for(r = 0; r < ctx->uRounds / 2; r++)
+   	{
+	   	ECHO_ROUND_UNROLL2;
+	   }
 		
-	if(ctx->uHashSize == 256)
-	{
-	   for(i = 0; i < 4; i++)
+	   if(ctx->uHashSize == 256)
 	   {
-		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][1]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][2]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][3]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][0]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][1]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][2]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][3]);
+	      for(i = 0; i < 4; i++)
+	      {
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _state[i][1]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _state[i][2]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _state[i][3]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][0]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][1]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][2]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][3]);
+	      }
 	   }
-	}
-	else
-	{
-	   for(i = 0; i < 4; i++)
-	   {
-		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][2]);
-		_state[i][1] = _mm_xor_si128(_state[i][1], _state[i][3]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][0]);
-		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][2]);
-		_state[i][1] = _mm_xor_si128(_state[i][1], _statebackup[i][1]);
-		_state[i][1] = _mm_xor_si128(_state[i][1], _statebackup[i][3]);
-           }
-	}
-	pmsg += ctx->uBlockLength;
+	   else
+    	{
+	      for(i = 0; i < 4; i++)
+	      {
+      		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][2]);
+		      _state[i][1] = _mm_xor_si128(_state[i][1], _state[i][3]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][0]);
+		      _state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][2]);
+		      _state[i][1] = _mm_xor_si128(_state[i][1], _statebackup[i][1]);
+		      _state[i][1] = _mm_xor_si128(_state[i][1], _statebackup[i][3]);
+         }
+   	}
+	   pmsg += ctx->uBlockLength;
    }
 	SAVESTATE(ctx->state, _state);
 
@@ -390,13 +390,13 @@ HashReturn final_echo(hashState_echo *state, BitSequence *hashval)
 	}
 
 	// Store the hash value
-	_mm_storeu_si128((__m128i*)hashval + 0, state->state[0][0]);
-	_mm_storeu_si128((__m128i*)hashval + 1, state->state[1][0]);
+	_mm_store_si128((__m128i*)hashval + 0, state->state[0][0]);
+	_mm_store_si128((__m128i*)hashval + 1, state->state[1][0]);
 
 	if(state->uHashSize == 512)
 	{
-		_mm_storeu_si128((__m128i*)hashval + 2, state->state[2][0]);
-		_mm_storeu_si128((__m128i*)hashval + 3, state->state[3][0]);
+		_mm_store_si128((__m128i*)hashval + 2, state->state[2][0]);
+		_mm_store_si128((__m128i*)hashval + 3, state->state[3][0]);
 	}
 
 	return SUCCESS;
@@ -513,13 +513,13 @@ HashReturn update_final_echo( hashState_echo *state, BitSequence *hashval,
    }
 
    // Store the hash value
-   _mm_storeu_si128( (__m128i*)hashval + 0, state->state[0][0] );
-   _mm_storeu_si128( (__m128i*)hashval + 1, state->state[1][0] );
+   _mm_store_si128( (__m128i*)hashval + 0, state->state[0][0] );
+   _mm_store_si128( (__m128i*)hashval + 1, state->state[1][0] );
 
    if( state->uHashSize == 512 )
    {
-        _mm_storeu_si128( (__m128i*)hashval + 2, state->state[2][0] );
-        _mm_storeu_si128( (__m128i*)hashval + 3, state->state[3][0] );
+        _mm_store_si128( (__m128i*)hashval + 2, state->state[2][0] );
+        _mm_store_si128( (__m128i*)hashval + 3, state->state[3][0] );
 
    }
    return SUCCESS;

algo/echo/aes_ni/hash.c.test

@@ -0,0 +1,620 @@
+/*
+ * file        : echo_vperm.c
+ * version     : 1.0.208
+ * date        : 14.12.2010
+ * 
+ * - vperm and aes_ni implementations of hash function ECHO
+ * - implements NIST hash api
+ * - assumes that message lenght is multiple of 8-bits
+ * - _ECHO_VPERM_ must be defined if compiling with ../main.c
+ * -  define NO_AES_NI for aes_ni version
+ *
+ * Cagdas Calik
+ * ccalik@metu.edu.tr
+ * Institute of Applied Mathematics, Middle East Technical University, Turkey.
+ *
+ */
+#if defined(__AES__)
+
+#include <memory.h>
+#include "miner.h"
+#include "hash_api.h"
+//#include "vperm.h"
+#include <immintrin.h>
+/*
+#ifndef NO_AES_NI
+#include <wmmintrin.h>
+#else
+#include <tmmintrin.h>
+#endif
+*/
+
+MYALIGN const unsigned int _k_s0F[] = {0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F};
+MYALIGN const unsigned int _k_ipt[] = {0x5A2A7000, 0xC2B2E898, 0x52227808, 0xCABAE090, 0x317C4D00, 0x4C01307D, 0xB0FDCC81, 0xCD80B1FC};
+MYALIGN const unsigned int _k_opt[] = {0xD6B66000, 0xFF9F4929, 0xDEBE6808, 0xF7974121, 0x50BCEC00, 0x01EDBD51, 0xB05C0CE0, 0xE10D5DB1};
+MYALIGN const unsigned int _k_inv[] = {0x0D080180, 0x0E05060F, 0x0A0B0C02, 0x04070309, 0x0F0B0780, 0x01040A06, 0x02050809, 0x030D0E0C};
+MYALIGN const unsigned int _k_sb1[] = {0xCB503E00, 0xB19BE18F, 0x142AF544, 0xA5DF7A6E, 0xFAE22300, 0x3618D415, 0x0D2ED9EF, 0x3BF7CCC1};
+MYALIGN const unsigned int _k_sb2[] = {0x0B712400, 0xE27A93C6, 0xBC982FCD, 0x5EB7E955, 0x0AE12900, 0x69EB8840, 0xAB82234A, 0xC2A163C8};
+MYALIGN const unsigned int _k_sb3[] = {0xC0211A00, 0x53E17249, 0xA8B2DA89, 0xFB68933B, 0xF0030A00, 0x5FF35C55, 0xA6ACFAA5, 0xF956AF09};
+MYALIGN const unsigned int _k_sb4[] = {0x3FD64100, 0xE1E937A0, 0x49087E9F, 0xA876DE97, 0xC393EA00, 0x3D50AED7, 0x876D2914, 0xBA44FE79};
+MYALIGN const unsigned int _k_sb5[] = {0xF4867F00, 0x5072D62F, 0x5D228BDB, 0x0DA9A4F9, 0x3971C900, 0x0B487AC2, 0x8A43F0FB, 0x81B332B8};
+MYALIGN const unsigned int _k_sb7[] = {0xFFF75B00, 0xB20845E9, 0xE1BAA416, 0x531E4DAC, 0x3390E000, 0x62A3F282, 0x21C1D3B1, 0x43125170};
+MYALIGN const unsigned int _k_sbo[] = {0x6FBDC700, 0xD0D26D17, 0xC502A878, 0x15AABF7A, 0x5FBB6A00, 0xCFE474A5, 0x412B35FA, 0x8E1E90D1};
+MYALIGN const unsigned int _k_h63[] = {0x63636363, 0x63636363, 0x63636363, 0x63636363};
+MYALIGN const unsigned int _k_hc6[] = {0xc6c6c6c6, 0xc6c6c6c6, 0xc6c6c6c6, 0xc6c6c6c6};
+MYALIGN const unsigned int _k_h5b[] = {0x5b5b5b5b, 0x5b5b5b5b, 0x5b5b5b5b, 0x5b5b5b5b};
+MYALIGN const unsigned int _k_h4e[] = {0x4e4e4e4e, 0x4e4e4e4e, 0x4e4e4e4e, 0x4e4e4e4e};
+MYALIGN const unsigned int _k_h0e[] = {0x0e0e0e0e, 0x0e0e0e0e, 0x0e0e0e0e, 0x0e0e0e0e};
+MYALIGN const unsigned int _k_h15[] = {0x15151515, 0x15151515, 0x15151515, 0x15151515};
+MYALIGN const unsigned int _k_aesmix1[] = {0x0f0a0500, 0x030e0904, 0x07020d08, 0x0b06010c};
+MYALIGN const unsigned int _k_aesmix2[] = {0x000f0a05, 0x04030e09, 0x0807020d, 0x0c0b0601};
+MYALIGN const unsigned int _k_aesmix3[] = {0x05000f0a, 0x0904030e, 0x0d080702, 0x010c0b06};
+MYALIGN const unsigned int _k_aesmix4[] = {0x0a05000f, 0x0e090403, 0x020d0807, 0x06010c0b};
+
+
+MYALIGN const unsigned int 	const1[]		= {0x00000001, 0x00000000, 0x00000000, 0x00000000};
+MYALIGN const unsigned int	mul2mask[]		= {0x00001b00, 0x00000000, 0x00000000, 0x00000000};
+MYALIGN const unsigned int	lsbmask[]		= {0x01010101, 0x01010101, 0x01010101, 0x01010101};
+MYALIGN const unsigned int	invshiftrows[]	= {0x070a0d00, 0x0b0e0104, 0x0f020508, 0x0306090c};
+MYALIGN const unsigned int	zero[]			= {0x00000000, 0x00000000, 0x00000000, 0x00000000};
+MYALIGN const unsigned int	mul2ipt[]		= {0x728efc00, 0x6894e61a, 0x3fc3b14d, 0x25d9ab57, 0xfd5ba600, 0x2a8c71d7, 0x1eb845e3, 0xc96f9234};
+
+
+#define ECHO_SUBBYTES(state, i, j) \
+	state[i][j] = _mm_aesenc_si128(state[i][j], k1);\
+	state[i][j] = _mm_aesenc_si128(state[i][j], M128(zero));\
+	k1 = _mm_add_epi32(k1, M128(const1))
+
+#define ECHO_MIXBYTES(state1, state2, j, t1, t2, s2) \
+	s2 = _mm_add_epi8(state1[0][j], state1[0][j]);\
+	t1 = _mm_srli_epi16(state1[0][j], 7);\
+	t1 = _mm_and_si128(t1, M128(lsbmask));\
+	t2 = _mm_shuffle_epi8(M128(mul2mask), t1);\
+	s2 = _mm_xor_si128(s2, t2);\
+	state2[0][j] = s2;\
+	state2[1][j] = state1[0][j];\
+	state2[2][j] = state1[0][j];\
+	state2[3][j] = _mm_xor_si128(s2, state1[0][j]);\
+	s2 = _mm_add_epi8(state1[1][(j + 1) & 3], state1[1][(j + 1) & 3]);\
+	t1 = _mm_srli_epi16(state1[1][(j + 1) & 3], 7);\
+	t1 = _mm_and_si128(t1, M128(lsbmask));\
+	t2 = _mm_shuffle_epi8(M128(mul2mask), t1);\
+	s2 = _mm_xor_si128(s2, t2);\
+	state2[0][j] = _mm_xor_si128(state2[0][j], _mm_xor_si128(s2, state1[1][(j + 1) & 3]));\
+	state2[1][j] = _mm_xor_si128(state2[1][j], s2);\
+	state2[2][j] = _mm_xor_si128(state2[2][j], state1[1][(j + 1) & 3]);\
+	state2[3][j] = _mm_xor_si128(state2[3][j], state1[1][(j + 1) & 3]);\
+	s2 = _mm_add_epi8(state1[2][(j + 2) & 3], state1[2][(j + 2) & 3]);\
+	t1 = _mm_srli_epi16(state1[2][(j + 2) & 3], 7);\
+	t1 = _mm_and_si128(t1, M128(lsbmask));\
+	t2 = _mm_shuffle_epi8(M128(mul2mask), t1);\
+	s2 = _mm_xor_si128(s2, t2);\
+	state2[0][j] = _mm_xor_si128(state2[0][j], state1[2][(j + 2) & 3]);\
+	state2[1][j] = _mm_xor_si128(state2[1][j], _mm_xor_si128(s2, state1[2][(j + 2) & 3]));\
+	state2[2][j] = _mm_xor_si128(state2[2][j], s2);\
+	state2[3][j] = _mm_xor_si128(state2[3][j], state1[2][(j + 2) & 3]);\
+	s2 = _mm_add_epi8(state1[3][(j + 3) & 3], state1[3][(j + 3) & 3]);\
+	t1 = _mm_srli_epi16(state1[3][(j + 3) & 3], 7);\
+	t1 = _mm_and_si128(t1, M128(lsbmask));\
+	t2 = _mm_shuffle_epi8(M128(mul2mask), t1);\
+	s2 = _mm_xor_si128(s2, t2);\
+	state2[0][j] = _mm_xor_si128(state2[0][j], state1[3][(j + 3) & 3]);\
+	state2[1][j] = _mm_xor_si128(state2[1][j], state1[3][(j + 3) & 3]);\
+	state2[2][j] = _mm_xor_si128(state2[2][j], _mm_xor_si128(s2, state1[3][(j + 3) & 3]));\
+	state2[3][j] = _mm_xor_si128(state2[3][j], s2)
+
+
+#define ECHO_ROUND_UNROLL2 \
+	ECHO_SUBBYTES(_state, 0, 0);\
+	ECHO_SUBBYTES(_state, 1, 0);\
+	ECHO_SUBBYTES(_state, 2, 0);\
+	ECHO_SUBBYTES(_state, 3, 0);\
+	ECHO_SUBBYTES(_state, 0, 1);\
+	ECHO_SUBBYTES(_state, 1, 1);\
+	ECHO_SUBBYTES(_state, 2, 1);\
+	ECHO_SUBBYTES(_state, 3, 1);\
+	ECHO_SUBBYTES(_state, 0, 2);\
+	ECHO_SUBBYTES(_state, 1, 2);\
+	ECHO_SUBBYTES(_state, 2, 2);\
+	ECHO_SUBBYTES(_state, 3, 2);\
+	ECHO_SUBBYTES(_state, 0, 3);\
+	ECHO_SUBBYTES(_state, 1, 3);\
+	ECHO_SUBBYTES(_state, 2, 3);\
+	ECHO_SUBBYTES(_state, 3, 3);\
+	ECHO_MIXBYTES(_state, _state2, 0, t1, t2, s2);\
+	ECHO_MIXBYTES(_state, _state2, 1, t1, t2, s2);\
+	ECHO_MIXBYTES(_state, _state2, 2, t1, t2, s2);\
+	ECHO_MIXBYTES(_state, _state2, 3, t1, t2, s2);\
+	ECHO_SUBBYTES(_state2, 0, 0);\
+	ECHO_SUBBYTES(_state2, 1, 0);\
+	ECHO_SUBBYTES(_state2, 2, 0);\
+	ECHO_SUBBYTES(_state2, 3, 0);\
+	ECHO_SUBBYTES(_state2, 0, 1);\
+	ECHO_SUBBYTES(_state2, 1, 1);\
+	ECHO_SUBBYTES(_state2, 2, 1);\
+	ECHO_SUBBYTES(_state2, 3, 1);\
+	ECHO_SUBBYTES(_state2, 0, 2);\
+	ECHO_SUBBYTES(_state2, 1, 2);\
+	ECHO_SUBBYTES(_state2, 2, 2);\
+	ECHO_SUBBYTES(_state2, 3, 2);\
+	ECHO_SUBBYTES(_state2, 0, 3);\
+	ECHO_SUBBYTES(_state2, 1, 3);\
+	ECHO_SUBBYTES(_state2, 2, 3);\
+	ECHO_SUBBYTES(_state2, 3, 3);\
+	ECHO_MIXBYTES(_state2, _state, 0, t1, t2, s2);\
+	ECHO_MIXBYTES(_state2, _state, 1, t1, t2, s2);\
+	ECHO_MIXBYTES(_state2, _state, 2, t1, t2, s2);\
+	ECHO_MIXBYTES(_state2, _state, 3, t1, t2, s2)
+
+
+
+#define SAVESTATE(dst, src)\
+	dst[0][0] = src[0][0];\
+	dst[0][1] = src[0][1];\
+	dst[0][2] = src[0][2];\
+	dst[0][3] = src[0][3];\
+	dst[1][0] = src[1][0];\
+	dst[1][1] = src[1][1];\
+	dst[1][2] = src[1][2];\
+	dst[1][3] = src[1][3];\
+	dst[2][0] = src[2][0];\
+	dst[2][1] = src[2][1];\
+	dst[2][2] = src[2][2];\
+	dst[2][3] = src[2][3];\
+	dst[3][0] = src[3][0];\
+	dst[3][1] = src[3][1];\
+	dst[3][2] = src[3][2];\
+	dst[3][3] = src[3][3]
+
+
+void Compress(hashState_echo *ctx, const unsigned char *pmsg, unsigned int uBlockCount)
+{
+   unsigned int r, b, i, j;
+   __m128i t1, t2, s2, k1;
+   __m128i _state[4][4], _state2[4][4], _statebackup[4][4]; 
+
+   for(i = 0; i < 4; i++)
+	for(j = 0; j < ctx->uHashSize / 256; j++)
+		_state[i][j] = ctx->state[i][j];
+
+   for(b = 0; b < uBlockCount; b++)
+   {
+	ctx->k = _mm_add_epi64(ctx->k, ctx->const1536);
+
+	// load message
+	for(j = ctx->uHashSize / 256; j < 4; j++)
+	{
+	   for(i = 0; i < 4; i++)
+	   {
+		_state[i][j] = _mm_loadu_si128((__m128i*)pmsg + 4 * (j - (ctx->uHashSize / 256)) + i);
+	   }
+	}
+
+uint64_t *b = (uint64_t*)_state;
+//printf("Ss3: %016lx %016lx %016lx %016lx\n",b[0],b[1],b[2],b[3]);
+   
+	// save state
+	SAVESTATE(_statebackup, _state);
+
+	k1 = ctx->k;
+
+	for(r = 0; r < ctx->uRounds / 2; r++)
+	{
+		ECHO_ROUND_UNROLL2;
+	}
+
+//printf("Ss4: %016lx %016lx %016lx %016lx\n",b[0],b[1],b[2],b[3]);
+   
+   
+	if(ctx->uHashSize == 256)
+	{
+	   for(i = 0; i < 4; i++)
+	   {
+		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][1]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][2]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][3]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][0]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][1]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][2]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][3]);
+	   }
+	}
+	else
+	{
+	   for(i = 0; i < 4; i++)
+	   {
+		_state[i][0] = _mm_xor_si128(_state[i][0], _state[i][2]);
+		_state[i][1] = _mm_xor_si128(_state[i][1], _state[i][3]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][0]);
+		_state[i][0] = _mm_xor_si128(_state[i][0], _statebackup[i][2]);
+		_state[i][1] = _mm_xor_si128(_state[i][1], _statebackup[i][1]);
+		_state[i][1] = _mm_xor_si128(_state[i][1], _statebackup[i][3]);
+           }
+	}
+	pmsg += ctx->uBlockLength;
+   }
+	SAVESTATE(ctx->state, _state);
+
+}
+
+
+
+HashReturn init_echo(hashState_echo *ctx, int nHashSize)
+{
+	int i, j;
+
+        ctx->k = _mm_setzero_si128(); 
+	ctx->processed_bits = 0;
+	ctx->uBufferBytes = 0;
+
+	switch(nHashSize)
+	{
+		case 256:
+			ctx->uHashSize = 256;
+			ctx->uBlockLength = 192;
+			ctx->uRounds = 8;
+			ctx->hashsize = _mm_set_epi32(0, 0, 0, 0x00000100);
+			ctx->const1536 = _mm_set_epi32(0x00000000, 0x00000000, 0x00000000, 0x00000600);
+			break;
+
+		case 512:
+			ctx->uHashSize = 512;
+			ctx->uBlockLength = 128;
+			ctx->uRounds = 10;
+			ctx->hashsize = _mm_set_epi32(0, 0, 0, 0x00000200);
+			ctx->const1536 = _mm_set_epi32(0x00000000, 0x00000000, 0x00000000, 0x00000400);
+			break;
+
+		default:
+			return BAD_HASHBITLEN;
+	}
+
+
+	for(i = 0; i < 4; i++)
+		for(j = 0; j < nHashSize / 256; j++)
+			ctx->state[i][j] = ctx->hashsize;
+
+	for(i = 0; i < 4; i++)
+		for(j = nHashSize / 256; j < 4; j++)
+			ctx->state[i][j] = _mm_set_epi32(0, 0, 0, 0);
+
+	return SUCCESS;
+}
+
+HashReturn update_echo(hashState_echo *state, const BitSequence *data, DataLength databitlen)
+{
+	unsigned int uByteLength, uBlockCount, uRemainingBytes;
+
+	uByteLength = (unsigned int)(databitlen / 8);
+
+	if((state->uBufferBytes + uByteLength) >= state->uBlockLength)
+	{
+		if(state->uBufferBytes != 0)
+		{
+			// Fill the buffer
+			memcpy(state->buffer + state->uBufferBytes, (void*)data, state->uBlockLength - state->uBufferBytes);
+
+			// Process buffer
+			Compress(state, state->buffer, 1);
+			state->processed_bits += state->uBlockLength * 8;
+
+			data += state->uBlockLength - state->uBufferBytes;
+			uByteLength -= state->uBlockLength - state->uBufferBytes;
+		}
+
+		// buffer now does not contain any unprocessed bytes
+
+		uBlockCount = uByteLength / state->uBlockLength;
+		uRemainingBytes = uByteLength % state->uBlockLength;
+
+		if(uBlockCount > 0)
+		{
+			Compress(state, data, uBlockCount);
+
+			state->processed_bits += uBlockCount * state->uBlockLength * 8;
+			data += uBlockCount * state->uBlockLength;
+		}
+
+		if(uRemainingBytes > 0)
+		{
+			memcpy(state->buffer, (void*)data, uRemainingBytes);
+		}
+
+		state->uBufferBytes = uRemainingBytes;
+	}
+	else
+	{
+		memcpy(state->buffer + state->uBufferBytes, (void*)data, uByteLength);
+		state->uBufferBytes += uByteLength;
+	}
+
+	return SUCCESS;
+}
+
+HashReturn final_echo(hashState_echo *state, BitSequence *hashval)
+{
+	__m128i remainingbits;
+
+	// Add remaining bytes in the buffer
+	state->processed_bits += state->uBufferBytes * 8;
+
+	remainingbits = _mm_set_epi32(0, 0, 0, state->uBufferBytes * 8);
+
+	// Pad with 0x80
+	state->buffer[state->uBufferBytes++] = 0x80;
+	
+	// Enough buffer space for padding in this block?
+	if((state->uBlockLength - state->uBufferBytes) >= 18)
+	{
+		// Pad with zeros
+		memset(state->buffer + state->uBufferBytes, 0, state->uBlockLength - (state->uBufferBytes + 18));
+
+		// Hash size
+		*((unsigned short*)(state->buffer + state->uBlockLength - 18)) = state->uHashSize;
+
+		// Processed bits
+		*((DataLength*)(state->buffer + state->uBlockLength - 16)) = state->processed_bits;
+		*((DataLength*)(state->buffer + state->uBlockLength - 8)) = 0;
+
+		// Last block contains message bits?
+		if(state->uBufferBytes == 1)
+		{
+			state->k = _mm_xor_si128(state->k, state->k);
+			state->k = _mm_sub_epi64(state->k, state->const1536);
+		}
+		else
+		{
+			state->k = _mm_add_epi64(state->k, remainingbits);
+			state->k = _mm_sub_epi64(state->k, state->const1536);
+		}
+
+		// Compress
+		Compress(state, state->buffer, 1);
+	}
+	else
+	{
+		// Fill with zero and compress
+		memset(state->buffer + state->uBufferBytes, 0, state->uBlockLength - state->uBufferBytes);
+		state->k = _mm_add_epi64(state->k, remainingbits);
+		state->k = _mm_sub_epi64(state->k, state->const1536);
+		Compress(state, state->buffer, 1);
+
+		// Last block
+		memset(state->buffer, 0, state->uBlockLength - 18);
+
+		// Hash size
+		*((unsigned short*)(state->buffer + state->uBlockLength - 18)) = state->uHashSize;
+
+		// Processed bits
+		*((DataLength*)(state->buffer + state->uBlockLength - 16)) = state->processed_bits;
+		*((DataLength*)(state->buffer + state->uBlockLength - 8)) = 0;
+
+		// Compress the last block
+		state->k = _mm_xor_si128(state->k, state->k);
+		state->k = _mm_sub_epi64(state->k, state->const1536);
+		Compress(state, state->buffer, 1);
+	}
+
+	// Store the hash value
+	_mm_storeu_si128((__m128i*)hashval + 0, state->state[0][0]);
+	_mm_storeu_si128((__m128i*)hashval + 1, state->state[1][0]);
+
+	if(state->uHashSize == 512)
+	{
+		_mm_storeu_si128((__m128i*)hashval + 2, state->state[2][0]);
+		_mm_storeu_si128((__m128i*)hashval + 3, state->state[3][0]);
+	}
+
+	return SUCCESS;
+}
+
+HashReturn update_final_echo( hashState_echo *state, BitSequence *hashval,
+                              const BitSequence *data, DataLength databitlen )
+{
+   unsigned int uByteLength, uBlockCount, uRemainingBytes;
+
+   uByteLength = (unsigned int)(databitlen / 8);
+
+/*   
+   if( (state->uBufferBytes + uByteLength) >= state->uBlockLength )
+   {
+printf("full block\n");
+      if( state->uBufferBytes != 0 )
+        {
+           // Fill the buffer
+           memcpy( state->buffer + state->uBufferBytes,
+                   (void*)data, state->uBlockLength - state->uBufferBytes );
+
+           // Process buffer
+           Compress( state, state->buffer, 1 );
+           state->processed_bits += state->uBlockLength * 8;
+
+           data += state->uBlockLength - state->uBufferBytes;
+           uByteLength -= state->uBlockLength - state->uBufferBytes;
+        }
+
+        // buffer now does not contain any unprocessed bytes
+
+        uBlockCount = uByteLength / state->uBlockLength;
+        uRemainingBytes = uByteLength % state->uBlockLength;
+
+        if( uBlockCount > 0 )
+        {
+           Compress( state, data, uBlockCount );
+           state->processed_bits += uBlockCount * state->uBlockLength * 8;
+           data += uBlockCount * state->uBlockLength;
+        }
+
+        if( uRemainingBytes > 0 )
+        memcpy(state->buffer, (void*)data, uRemainingBytes);
+
+        state->uBufferBytes = uRemainingBytes;
+   }
+   else
+   {
+*/
+   memcpy( state->buffer + state->uBufferBytes, (void*)data, uByteLength );
+        state->uBufferBytes += uByteLength;
+//   }
+
+   __m128i remainingbits;
+
+   // Add remaining bytes in the buffer
+   state->processed_bits += state->uBufferBytes * 8;
+
+   remainingbits = _mm_set_epi32( 0, 0, 0, state->uBufferBytes * 8 );
+
+   // Pad with 0x80
+   state->buffer[state->uBufferBytes++] = 0x80;
+
+   // Enough buffer space for padding in this block?
+
+//   if( (state->uBlockLength - state->uBufferBytes) >= 18 )
+//   {
+        // Pad with zeros
+
+        memset( state->buffer + state->uBufferBytes, 0, state->uBlockLength - (state->uBufferBytes + 18) );
+
+        // Hash size
+        *( (unsigned short*)(state->buffer + state->uBlockLength - 18) ) = state->uHashSize;
+
+        // Processed bits
+        *( (DataLength*)(state->buffer + state->uBlockLength - 16) ) =
+                   state->processed_bits;
+        *( (DataLength*)(state->buffer + state->uBlockLength - 8) ) = 0;
+
+
+        // Last block contains message bits?
+        if( state->uBufferBytes == 1 )
+        {
+           state->k = _mm_xor_si128( state->k, state->k );
+           state->k = _mm_sub_epi64( state->k, state->const1536 );
+        }
+        else
+        {
+           state->k = _mm_add_epi64( state->k, remainingbits );
+           state->k = _mm_sub_epi64( state->k, state->const1536 );
+        }
+
+uint64_t *b = (uint64_t*)&state->k;
+/*
+printf("Sk: %016lx %016lx %016lx %016lx\n",b[0],b[1],b[2],b[3]);
+b = (uint64_t*)state->buffer;
+printf("Sb: %016lx %016lx %016lx %016lx\n",b[0],b[1],b[2],b[3]);
+printf("Sb: %016lx %016lx %016lx %016lx\n",b[4],b[5],b[6],b[7]);
+printf("Sb: %016lx %016lx %016lx %016lx\n",b[8],b[9],b[10],b[11]);
+printf("Sb: %016lx %016lx %016lx %016lx\n",b[12],b[13],b[14],b[15]);
+
+b = (uint64_t*)state->state;
+printf("Ss1: %016lx %016lx %016lx %016lx\n",b[0],b[1],b[2],b[3]);
+printf("Ss1: %016lx %016lx %016lx %016lx\n",b[4],b[5],b[6],b[7]);
+printf("Ss1: %016lx %016lx %016lx %016lx\n",b[8],b[9],b[10],b[11]);
+printf("Ss1: %016lx %016lx %016lx %016lx\n",b[12],b[13],b[14],b[15]);
+*/        
+        // Compress
+        Compress( state, state->buffer, 1 );
+
+//printf("Ss2: %016lx %016lx %016lx %016lx\n",b[0],b[1],b[2],b[3]);
+
+        
+/*
+   }
+   else
+   {
+        // Fill with zero and compress
+        memset( state->buffer + state->uBufferBytes, 0,
+                state->uBlockLength - state->uBufferBytes );
+        state->k = _mm_add_epi64( state->k, remainingbits );
+        state->k = _mm_sub_epi64( state->k, state->const1536 );
+        Compress( state, state->buffer, 1 );
+
+        // Last block
+        memset( state->buffer, 0, state->uBlockLength - 18 );
+
+        // Hash size
+        *( (unsigned short*)(state->buffer + state->uBlockLength - 18) ) =
+                 state->uHashSize;
+
+        // Processed bits
+        *( (DataLength*)(state->buffer + state->uBlockLength - 16) ) =
+                   state->processed_bits;
+        *( (DataLength*)(state->buffer + state->uBlockLength - 8) ) = 0;
+        // Compress the last block
+        state->k = _mm_xor_si128( state->k, state->k );
+        state->k = _mm_sub_epi64( state->k, state->const1536 );
+        Compress( state, state->buffer, 1) ;
+   }
+*/
+
+   // Store the hash value
+   _mm_storeu_si128( (__m128i*)hashval + 0, state->state[0][0] );
+   _mm_storeu_si128( (__m128i*)hashval + 1, state->state[1][0] );
+
+   if( state->uHashSize == 512 )
+   {
+        _mm_storeu_si128( (__m128i*)hashval + 2, state->state[2][0] );
+        _mm_storeu_si128( (__m128i*)hashval + 3, state->state[3][0] );
+
+   }
+   return SUCCESS;
+}
+
+
+HashReturn hash_echo(int hashbitlen, const BitSequence *data, DataLength databitlen, BitSequence *hashval)
+{
+	HashReturn hRet;
+	hashState_echo hs;
+
+	/////
+	/*
+	__m128i a, b, c, d, t[4], u[4], v[4];
+
+	a = _mm_set_epi32(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
+	b = _mm_set_epi32(0x1f1e1d1c, 0x1b1a1918, 0x17161514, 0x13121110);
+	c = _mm_set_epi32(0x2f2e2d2c, 0x2b2a2928, 0x27262524, 0x23222120);
+	d = _mm_set_epi32(0x3f3e3d3c, 0x3b3a3938, 0x37363534, 0x33323130);
+
+	t[0] = _mm_unpacklo_epi8(a, b);
+	t[1] = _mm_unpackhi_epi8(a, b);
+	t[2] = _mm_unpacklo_epi8(c, d);
+	t[3] = _mm_unpackhi_epi8(c, d);
+
+	u[0] = _mm_unpacklo_epi16(t[0], t[2]);
+	u[1] = _mm_unpackhi_epi16(t[0], t[2]);
+	u[2] = _mm_unpacklo_epi16(t[1], t[3]);
+	u[3] = _mm_unpackhi_epi16(t[1], t[3]);
+
+
+	t[0] = _mm_unpacklo_epi16(u[0], u[1]);
+	t[1] = _mm_unpackhi_epi16(u[0], u[1]);
+	t[2] = _mm_unpacklo_epi16(u[2], u[3]);
+	t[3] = _mm_unpackhi_epi16(u[2], u[3]);
+
+	u[0] = _mm_unpacklo_epi8(t[0], t[1]);
+	u[1] = _mm_unpackhi_epi8(t[0], t[1]);
+	u[2] = _mm_unpacklo_epi8(t[2], t[3]);
+	u[3] = _mm_unpackhi_epi8(t[2], t[3]);
+
+	a = _mm_unpacklo_epi8(u[0], u[1]);
+	b = _mm_unpackhi_epi8(u[0], u[1]);
+	c = _mm_unpacklo_epi8(u[2], u[3]);
+	d = _mm_unpackhi_epi8(u[2], u[3]);
+	*/
+	/////
+
+	hRet = init_echo(&hs, hashbitlen);
+	if(hRet != SUCCESS)
+		return hRet;
+
+	hRet = update_echo(&hs, data, databitlen);
+	if(hRet != SUCCESS)
+		return hRet;
+
+	hRet = final_echo(&hs, hashval);
+	if(hRet != SUCCESS)
+		return hRet;
+
+	return SUCCESS;
+}
+
+#endif

algo/echo/echo-hash-4way.c

@@ -0,0 +1,316 @@
+//#if 0
+#if defined(__VAES__) && defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#include "simd-utils.h"
+#include "echo-hash-4way.h"
+
+/*
+static const unsigned int mul2ipt[] __attribute__ ((aligned (64))) =
+{  
+   0x728efc00, 0x6894e61a, 0x3fc3b14d, 0x25d9ab57,
+   0xfd5ba600, 0x2a8c71d7, 0x1eb845e3, 0xc96f9234
+};
+*/
+// do these need to be reversed?
+
+#define mul2mask \
+   _mm512_set4_epi32( 0, 0, 0, 0x00001b00 ) 
+//   _mm512_set4_epi32( 0x00001b00, 0, 0, 0 )  
+
+#define lsbmask    m512_const1_32( 0x01010101 ) 
+
+#define ECHO_SUBBYTES( state, i, j ) \
+	state[i][j] = _mm512_aesenc_epi128( state[i][j], k1 ); \
+	state[i][j] = _mm512_aesenc_epi128( state[i][j], m512_zero ); \
+	k1 = _mm512_add_epi32( k1, m512_one_128 );
+
+#define ECHO_MIXBYTES( state1, state2, j, t1, t2, s2 ) do \
+{ \
+   const int j1 = ( (j)+1 ) & 3; \
+   const int j2 = ( (j)+2 ) & 3; \
+   const int j3 = ( (j)+3 ) & 3; \
+   s2 = _mm512_add_epi8( state1[ 0 ] [j ], state1[ 0 ][ j ] ); \
+	t1 = _mm512_srli_epi16( state1[ 0 ][ j ], 7 ); \
+	t1 = _mm512_and_si512( t1, lsbmask );\
+	t2 = _mm512_shuffle_epi8( mul2mask, t1 ); \
+	s2 = _mm512_xor_si512( s2, t2 ); \
+	state2[ 0 ] [j ] = s2; \
+	state2[ 1 ] [j ] = state1[ 0 ][ j ]; \
+	state2[ 2 ] [j ] = state1[ 0 ][ j ]; \
+	state2[ 3 ] [j ] = _mm512_xor_si512( s2, state1[ 0 ][ j ] );\
+	s2 = _mm512_add_epi8( state1[ 1 ][ j1 ], state1[ 1 ][ j1 ] ); \
+	t1 = _mm512_srli_epi16( state1[ 1 ][ j1 ], 7 ); \
+	t1 = _mm512_and_si512( t1, lsbmask ); \
+	t2 = _mm512_shuffle_epi8( mul2mask, t1 ); \
+	s2 = _mm512_xor_si512( s2, t2 );\
+	state2[ 0 ][ j ] = _mm512_xor_si512( state2[ 0 ][ j ], \
+                            _mm512_xor_si512( s2, state1[ 1 ][ j1 ] ) ); \
+	state2[ 1 ][ j ] = _mm512_xor_si512( state2[ 1 ][ j ], s2 ); \
+	state2[ 2 ][ j ] = _mm512_xor_si512( state2[ 2 ][ j ], state1[ 1 ][ j1 ] ); \
+	state2[ 3 ][ j ] = _mm512_xor_si512( state2[ 3 ][ j ], state1[ 1 ][ j1 ] ); \
+	s2 = _mm512_add_epi8( state1[ 2 ][ j2 ], state1[ 2 ][ j2 ] ); \
+	t1 = _mm512_srli_epi16( state1[ 2 ][ j2 ], 7 ); \
+	t1 = _mm512_and_si512( t1, lsbmask ); \
+	t2 = _mm512_shuffle_epi8( mul2mask, t1 ); \
+	s2 = _mm512_xor_si512( s2, t2 ); \
+	state2[ 0 ][ j ] = _mm512_xor_si512( state2[ 0 ][ j ], state1[ 2 ][ j2 ] ); \
+	state2[ 1 ][ j ] = _mm512_xor_si512( state2[ 1 ][ j ], \
+                            _mm512_xor_si512( s2, state1[ 2 ][ j2 ] ) ); \
+	state2[ 2 ][ j ] = _mm512_xor_si512( state2[ 2 ][ j ], s2 ); \
+	state2[ 3 ][ j ] = _mm512_xor_si512( state2[ 3][ j ], state1[ 2 ][ j2 ] ); \
+	s2 = _mm512_add_epi8( state1[ 3 ][ j3 ], state1[ 3 ][ j3 ] ); \
+	t1 = _mm512_srli_epi16( state1[ 3 ][ j3 ], 7 ); \
+	t1 = _mm512_and_si512( t1, lsbmask ); \
+	t2 = _mm512_shuffle_epi8( mul2mask, t1 ); \
+	s2 = _mm512_xor_si512( s2, t2 ); \
+	state2[ 0 ][ j ] = _mm512_xor_si512( state2[ 0 ][ j ], state1[ 3 ][ j3 ] ); \
+	state2[ 1 ][ j ] = _mm512_xor_si512( state2[ 1 ][ j ], state1[ 3 ][ j3 ] ); \
+	state2[ 2 ][ j ] = _mm512_xor_si512( state2[ 2 ][ j ], \
+                            _mm512_xor_si512( s2, state1[ 3 ][ j3] ) ); \
+	state2[ 3 ][ j ] = _mm512_xor_si512( state2[ 3 ][ j ], s2 ); \
+} while(0)
+
+#define ECHO_ROUND_UNROLL2 \
+	ECHO_SUBBYTES(_state, 0, 0);\
+   ECHO_SUBBYTES(_state, 1, 0);\
+	ECHO_SUBBYTES(_state, 2, 0);\
+	ECHO_SUBBYTES(_state, 3, 0);\
+	ECHO_SUBBYTES(_state, 0, 1);\
+	ECHO_SUBBYTES(_state, 1, 1);\
+	ECHO_SUBBYTES(_state, 2, 1);\
+	ECHO_SUBBYTES(_state, 3, 1);\
+	ECHO_SUBBYTES(_state, 0, 2);\
+	ECHO_SUBBYTES(_state, 1, 2);\
+	ECHO_SUBBYTES(_state, 2, 2);\
+	ECHO_SUBBYTES(_state, 3, 2);\
+	ECHO_SUBBYTES(_state, 0, 3);\
+	ECHO_SUBBYTES(_state, 1, 3);\
+	ECHO_SUBBYTES(_state, 2, 3);\
+	ECHO_SUBBYTES(_state, 3, 3);\
+	ECHO_MIXBYTES(_state, _state2, 0, t1, t2, s2);\
+	ECHO_MIXBYTES(_state, _state2, 1, t1, t2, s2);\
+	ECHO_MIXBYTES(_state, _state2, 2, t1, t2, s2);\
+	ECHO_MIXBYTES(_state, _state2, 3, t1, t2, s2);\
+	ECHO_SUBBYTES(_state2, 0, 0);\
+	ECHO_SUBBYTES(_state2, 1, 0);\
+	ECHO_SUBBYTES(_state2, 2, 0);\
+	ECHO_SUBBYTES(_state2, 3, 0);\
+	ECHO_SUBBYTES(_state2, 0, 1);\
+	ECHO_SUBBYTES(_state2, 1, 1);\
+	ECHO_SUBBYTES(_state2, 2, 1);\
+	ECHO_SUBBYTES(_state2, 3, 1);\
+	ECHO_SUBBYTES(_state2, 0, 2);\
+	ECHO_SUBBYTES(_state2, 1, 2);\
+	ECHO_SUBBYTES(_state2, 2, 2);\
+	ECHO_SUBBYTES(_state2, 3, 2);\
+	ECHO_SUBBYTES(_state2, 0, 3);\
+	ECHO_SUBBYTES(_state2, 1, 3);\
+	ECHO_SUBBYTES(_state2, 2, 3);\
+	ECHO_SUBBYTES(_state2, 3, 3);\
+	ECHO_MIXBYTES(_state2, _state, 0, t1, t2, s2);\
+	ECHO_MIXBYTES(_state2, _state, 1, t1, t2, s2);\
+	ECHO_MIXBYTES(_state2, _state, 2, t1, t2, s2);\
+	ECHO_MIXBYTES(_state2, _state, 3, t1, t2, s2)
+
+#define SAVESTATE(dst, src)\
+	dst[0][0] = src[0][0];\
+	dst[0][1] = src[0][1];\
+	dst[0][2] = src[0][2];\
+	dst[0][3] = src[0][3];\
+	dst[1][0] = src[1][0];\
+	dst[1][1] = src[1][1];\
+	dst[1][2] = src[1][2];\
+	dst[1][3] = src[1][3];\
+	dst[2][0] = src[2][0];\
+	dst[2][1] = src[2][1];\
+	dst[2][2] = src[2][2];\
+	dst[2][3] = src[2][3];\
+	dst[3][0] = src[3][0];\
+	dst[3][1] = src[3][1];\
+	dst[3][2] = src[3][2];\
+	dst[3][3] = src[3][3]
+
+// blockcount always 1
+void echo_4way_compress( echo_4way_context *ctx, const __m512i *pmsg,
+               unsigned int uBlockCount )
+{
+  unsigned int r, b, i, j;
+  __m512i t1, t2, s2, k1;
+  __m512i _state[4][4], _state2[4][4], _statebackup[4][4]; 
+
+  _state[ 0 ][ 0 ] = ctx->state[ 0 ][ 0 ];
+  _state[ 0 ][ 1 ] = ctx->state[ 0 ][ 1 ];
+  _state[ 0 ][ 2 ] = ctx->state[ 0 ][ 2 ];
+  _state[ 0 ][ 3 ] = ctx->state[ 0 ][ 3 ];
+  _state[ 1 ][ 0 ] = ctx->state[ 1 ][ 0 ];
+  _state[ 1 ][ 1 ] = ctx->state[ 1 ][ 1 ];
+  _state[ 1 ][ 2 ] = ctx->state[ 1 ][ 2 ];
+  _state[ 1 ][ 3 ] = ctx->state[ 1 ][ 3 ];
+  _state[ 2 ][ 0 ] = ctx->state[ 2 ][ 0 ];
+  _state[ 2 ][ 1 ] = ctx->state[ 2 ][ 1 ];
+  _state[ 2 ][ 2 ] = ctx->state[ 2 ][ 2 ];
+  _state[ 2 ][ 3 ] = ctx->state[ 2 ][ 3 ];
+  _state[ 3 ][ 0 ] = ctx->state[ 3 ][ 0 ];
+  _state[ 3 ][ 1 ] = ctx->state[ 3 ][ 1 ];
+  _state[ 3 ][ 2 ] = ctx->state[ 3 ][ 2 ];
+  _state[ 3 ][ 3 ] = ctx->state[ 3 ][ 3 ];
+
+  for ( b = 0; b < uBlockCount; b++ )
+  {
+    ctx->k = _mm512_add_epi64( ctx->k, ctx->const1536 );
+
+    for( j = ctx->uHashSize / 256; j < 4; j++ )
+    {
+      for ( i = 0; i < 4; i++ )
+	   {
+        _state[ i ][ j ] = _mm512_load_si512( 
+                     pmsg + 4 * (j - (ctx->uHashSize / 256)) + i );
+	   }
+	 }
+    
+    // save state
+	 SAVESTATE( _statebackup, _state );
+
+	 k1 = ctx->k;
+
+	 for ( r = 0; r < ctx->uRounds / 2; r++ )
+	 {
+		ECHO_ROUND_UNROLL2;
+	 }
+		
+	 if ( ctx->uHashSize == 256 )
+	 {
+	   for ( i = 0; i < 4; i++ )
+	   {
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _state[ i ][ 1 ] );
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _state[ i ][ 2 ] );
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _state[ i ][ 3 ] );
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _statebackup[ i ][ 0 ] );
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _statebackup[ i ][ 1 ] );
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _statebackup[ i ][ 2 ] ) ;
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _statebackup[ i ][ 3 ] );
+	   }
+	 }
+	 else
+	 {
+	   for ( i = 0; i < 4; i++ )
+	   {
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _state[ i ][ 2 ] );
+		   _state[ i ][ 1 ] = _mm512_xor_si512( _state[ i ][ 1 ],
+                                              _state[ i ][ 3 ] );
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ][ 0 ],
+                                              _statebackup[ i ][ 0 ] );
+		   _state[ i ][ 0 ] = _mm512_xor_si512( _state[ i ] [0 ],
+                                              _statebackup[ i ][ 2 ] );
+		   _state[ i ][ 1 ] = _mm512_xor_si512( _state[ i ][ 1 ],
+                                              _statebackup[ i ][ 1 ] );
+		   _state[ i ][ 1 ] = _mm512_xor_si512( _state[ i ][ 1 ],
+                                              _statebackup[ i ][ 3 ] );
+      }
+	 }
+    pmsg += ctx->uBlockLength;
+  }
+  SAVESTATE(ctx->state, _state);
+
+}
+
+int echo_4way_init( echo_4way_context *ctx, int nHashSize )
+{
+	int i, j;
+
+   ctx->k = m512_zero; 
+	ctx->processed_bits = 0;
+	ctx->uBufferBytes = 0;
+
+	switch( nHashSize )
+	{
+		case 256:
+			ctx->uHashSize = 256;
+			ctx->uBlockLength = 192;
+			ctx->uRounds = 8;
+			ctx->hashsize = _mm512_set4_epi32( 0, 0, 0, 0x100 );
+			ctx->const1536 = _mm512_set4_epi32( 0, 0, 0, 0x600 );
+			break;
+
+		case 512:
+			ctx->uHashSize = 512;
+			ctx->uBlockLength = 128;
+			ctx->uRounds = 10;
+			ctx->hashsize = _mm512_set4_epi32( 0, 0, 0, 0x200 );
+			ctx->const1536 = _mm512_set4_epi32( 0, 0, 0, 0x400);
+			break;
+
+		default:
+			return 1;
+	}
+
+	for( i = 0; i < 4; i++ )
+		for( j = 0; j < nHashSize / 256; j++ )
+			ctx->state[ i ][ j ] = ctx->hashsize;
+
+	for( i = 0; i < 4; i++ )
+		for( j = nHashSize / 256; j < 4; j++ )
+			ctx->state[ i ][ j ] = m512_zero;
+
+	return 0;
+}
+
+int echo_4way_update_close( echo_4way_context *state, void *hashval,
+                              const void *data, int databitlen )
+{
+// bytelen is either 32 (maybe), 64 or 80 or 128!
+// all are less than full block.
+
+   int vlen = databitlen / 128;  // * 4 lanes / 128 bits per lane
+   const int vblen = state->uBlockLength / 16; //  16 bytes per lane
+   __m512i remainingbits;
+
+   if ( databitlen == 1024 )
+   {
+      echo_4way_compress( state, data, 1 );
+      state->processed_bits = 1024;
+      remainingbits = m512_const2_64( 0, -1024 );
+      vlen = 0;
+   }
+   else
+   {
+      vlen = databitlen / 128;  // * 4 lanes / 128 bits per lane
+      memcpy_512( state->buffer, data, vlen );
+      state->processed_bits += (unsigned int)( databitlen );
+      remainingbits = _mm512_set4_epi32( 0, 0, 0, databitlen );
+
+   }
+
+   state->buffer[ vlen ] = _mm512_set4_epi32( 0, 0, 0, 0x80 );
+   memset_zero_512( state->buffer + vlen + 1, vblen - vlen - 2 );
+   state->buffer[ vblen-2 ] =
+                _mm512_set4_epi32( (uint32_t)state->uHashSize << 16, 0, 0, 0 );
+   state->buffer[ vblen-1 ] =
+                   _mm512_set4_epi64( 0, state->processed_bits,
+                                      0, state->processed_bits );  
+
+   state->k = _mm512_add_epi64( state->k, remainingbits );
+   state->k = _mm512_sub_epi64( state->k, state->const1536 );
+
+   echo_4way_compress( state, state->buffer, 1 );
+
+   _mm512_store_si512( (__m512i*)hashval + 0, state->state[ 0 ][ 0] );
+   _mm512_store_si512( (__m512i*)hashval + 1, state->state[ 1 ][ 0] );
+
+   if ( state->uHashSize == 512 )
+   {
+      _mm512_store_si512( (__m512i*)hashval + 2, state->state[ 2 ][ 0 ] );
+      _mm512_store_si512( (__m512i*)hashval + 3, state->state[ 3 ][ 0 ] );
+   }
+   return 0;
+}
+
+#endif

algo/echo/echo-hash-4way.h

@@ -0,0 +1,36 @@
+#if !defined(ECHO_HASH_4WAY_H__)
+#define ECHO_HASH_4WAY_H__ 1
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#include "simd-utils.h"
+
+typedef struct
+{
+   __m512i    state[4][4];
+   __m512i    buffer[ 4 * 192 / 16 ];  // 4x128 interleaved 192 bytes
+   __m512i    k;
+   __m512i    hashsize;
+   __m512i    const1536;
+
+   unsigned int   uRounds;
+   unsigned int   uHashSize;
+   unsigned int   uBlockLength;
+   unsigned int   uBufferBytes;
+   unsigned int   processed_bits;
+
+} echo_4way_context __attribute__ ((aligned (64)));
+
+int echo_4way_init( echo_4way_context *state, int hashbitlen );
+
+
+int echo_4way_update( echo_4way_context *state, const void *data,
+    unsigned int databitlen);
+
+int echo_close( echo_4way_context *state, void *hashval );
+
+int echo_4way_update_close( echo_4way_context *state, void *hashval,
+                              const void *data, int databitlen );
+
+#endif 
+#endif

algo/groestl/aes_ni/groestl-intr-aes.h

@@ -73,7 +73,7 @@ __m128i ALL_FF;
   b5 = a7;\
   a6 = _mm_xor_si128(a6, a7);\
   a7 = _mm_xor_si128(a7, b6);\
-  \
+   \
   /* build y4 y5 y6 ... in regs xmm8, xmm9, xmm10 by adding t_i*/\
   b0 = _mm_xor_si128(b0, a4);\
   b6 = _mm_xor_si128(b6, a4);\
@@ -195,7 +195,7 @@ __m128i ALL_FF;
   for(round_counter = 0; round_counter < 14; round_counter+=2) {\
     /* AddRoundConstant P1024 */\
     xmm8 = _mm_xor_si128(xmm8, (ROUND_CONST_P[round_counter]));\
-    /* ShiftBytes P1024 + pre-AESENCLAST */\
+     /* ShiftBytes P1024 + pre-AESENCLAST */\
     xmm8  = _mm_shuffle_epi8(xmm8,  (SUBSH_MASK[0]));\
     xmm9  = _mm_shuffle_epi8(xmm9,  (SUBSH_MASK[1]));\
     xmm10 = _mm_shuffle_epi8(xmm10, (SUBSH_MASK[2]));\
@@ -209,7 +209,6 @@ __m128i ALL_FF;
     \
     /* AddRoundConstant P1024 */\
     xmm0 = _mm_xor_si128(xmm0, (ROUND_CONST_P[round_counter+1]));\
-    /* ShiftBytes P1024 + pre-AESENCLAST */\
     xmm0 = _mm_shuffle_epi8(xmm0, (SUBSH_MASK[0]));\
     xmm1 = _mm_shuffle_epi8(xmm1, (SUBSH_MASK[1]));\
     xmm2 = _mm_shuffle_epi8(xmm2, (SUBSH_MASK[2]));\
@@ -218,7 +217,6 @@ __m128i ALL_FF;
     xmm5 = _mm_shuffle_epi8(xmm5, (SUBSH_MASK[5]));\
     xmm6 = _mm_shuffle_epi8(xmm6, (SUBSH_MASK[6]));\
     xmm7 = _mm_shuffle_epi8(xmm7, (SUBSH_MASK[7]));\
-    /* SubBytes + MixBytes */\
     SUBMIX(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
   }\
 }

algo/groestl/aes_ni/groestl-version.h

@@ -9,6 +9,7 @@
 
 //#ifndef NO_AES_NI
 
+// Not to be confused with AVX512VAES
 #define VAES
 // #define VAVX
 // #define VVPERM

algo/groestl/aes_ni/hash-groestl.c

@@ -230,6 +230,7 @@ HashReturn_gr update_and_final_groestl( hashState_groestl* ctx, void* output,
 
    // digest final padding block and do output transform
    TF1024( ctx->chaining, ctx->buffer );
+
    OF1024( ctx->chaining );
 
    // store hash result in output 

algo/groestl/groestl-4way.c

@@ -0,0 +1,64 @@
+#include "groestl-gate.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#if defined(GROESTL_4WAY_VAES)
+
+#include "groestl512-hash-4way.h"
+
+void groestl_4way_hash( void *output, const void *input )
+{
+     uint32_t hash[16*4] __attribute__ ((aligned (128)));
+     groestl512_4way_context ctx;
+
+     groestl512_4way_init( &ctx, 64 );
+     groestl512_4way_update_close( &ctx, hash, input, 640 );
+
+     groestl512_4way_init( &ctx, 64 );
+     groestl512_4way_update_close( &ctx, hash, hash, 512 );
+
+     dintrlv_4x128( output, output+32, output+64, output+96, hash, 256 );
+ }
+
+int scanhash_groestl_4way( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+     uint32_t hash[8*4] __attribute__ ((aligned (128)));
+     uint32_t vdata[24*4] __attribute__ ((aligned (64)));
+     uint32_t *pdata = work->data;
+     uint32_t *ptarget = work->target;
+     uint32_t n = pdata[19];
+     const uint32_t first_nonce = pdata[19];
+     const uint32_t last_nonce = max_nonce - 4;
+     uint32_t *noncep = vdata + 64+3;   // 4*16 + 3
+     int thr_id = mythr->id;
+     const uint32_t Htarg = ptarget[7];
+
+     mm512_bswap32_intrlv80_4x128( vdata, pdata );
+
+     do
+     {
+        be32enc( noncep,    n   );
+        be32enc( noncep+ 4, n+1 );
+        be32enc( noncep+ 8, n+2 );
+        be32enc( noncep+12, n+3 );
+
+        groestl_4way_hash( hash, vdata );
+        pdata[19] = n;
+
+        for ( int lane = 0; lane < 4; lane++ )
+        if ( ( hash+(lane<<3) )[7] < Htarg )
+        if ( fulltest( hash+(lane<<3), ptarget) && !opt_benchmark )
+        {
+           pdata[19] = n + lane;
+           submit_lane_solution( work, hash+(lane<<3), mythr, lane );
+        }
+        n += 4;
+     } while ( ( n < last_nonce ) && !work_restart[thr_id].restart );
+     *hashes_done = n - first_nonce;
+     return 0;
+}
+
+#endif

algo/groestl/groestl-gate.c

@@ -0,0 +1,23 @@
+#include "groestl-gate.h"
+
+bool register_dmd_gr_algo( algo_gate_t *gate )
+{
+#if defined (GROESTL_4WAY_VAES)
+  gate->scanhash  = (void*)&scanhash_groestl_4way;
+  gate->hash      = (void*)&groestl_4way_hash;
+#else
+  init_groestl_ctx();
+  gate->scanhash  = (void*)&scanhash_groestl;
+  gate->hash      = (void*)&groestlhash;
+#endif
+  gate->optimizations = AES_OPT | VAES_OPT;
+  return true;
+};
+
+bool register_groestl_algo( algo_gate_t* gate )
+{
+    register_dmd_gr_algo( gate );
+    gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
+    return true;
+};
+

algo/groestl/groestl-gate.h

@@ -0,0 +1,31 @@
+#ifndef GROESTL_GATE_H__
+#define GROESTL_GATE_H__ 1
+
+#include "algo-gate-api.h"
+#include <stdint.h>
+
+#if defined(__VAES__) && defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define GROESTL_4WAY_VAES 1
+#endif
+
+bool register_dmd_gr_algo( algo_gate_t* gate );
+
+bool register_groestl_algo( algo_gate_t* gate );
+
+#if defined(GROESTL_4WAY_VAES)
+
+void groestl_4way_hash( void *state, const void *input );
+int scanhash_groestl_4way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#else
+
+void groestlhash( void *state, const void *input );
+int scanhash_groestl( struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done, struct thr_info *mythr );
+void init_groestl_ctx();
+
+#endif
+
+#endif
+

algo/groestl/groestl.c

@@ -1,5 +1,4 @@
-#include "algo-gate-api.h"
-
+#include "groestl-gate.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
@@ -78,15 +77,12 @@ int scanhash_groestl( struct work *work, uint32_t max_nonce,
 		groestlhash(hash, endiandata);
 
 		if (hash[7] <= Htarg )
-                   if ( fulltest(hash, ptarget))
-                   {
+      if ( fulltest(hash, ptarget) && !opt_benchmark )
+      {
 			pdata[19] = nonce;
-			*hashes_done = pdata[19] - first_nonce;
-			return 1;
-	           }
-         
+         submit_solution( work, hash, mythr );
+	   }
 		nonce++;
-
 	} while (nonce < max_nonce && !work_restart[thr_id].restart);
 
 	pdata[19] = nonce;
@@ -94,20 +90,3 @@ int scanhash_groestl( struct work *work, uint32_t max_nonce,
 	return 0;
 }
 
-bool register_dmd_gr_algo( algo_gate_t* gate )
-{
-    init_groestl_ctx();
-    gate->optimizations   = SSE2_OPT | AES_OPT;
-    gate->scanhash        = (void*)&scanhash_groestl;
-    gate->hash            = (void*)&groestlhash;
-    opt_target_factor = 256.0;
-    return true;
-};
-
-bool register_groestl_algo( algo_gate_t* gate )
-{
-    register_dmd_gr_algo( gate );
-    gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
-    return true;
-};
-

algo/groestl/groestl256-hash-4way.c

@@ -0,0 +1,280 @@
+/* hash.c     Aug 2011
+ *
+ * Groestl implementation for different versions.
+ * Author: Krystian Matusiewicz, Günther A. Roland, Martin Schläffer
+ *
+ * This code is placed in the public domain
+ */
+
+#include <memory.h>
+#include "hash-groestl256.h"
+#include "miner.h"
+#include "simd-utils.h"
+
+#ifndef NO_AES_NI
+
+#include "groestl-version.h"
+
+#ifdef TASM
+  #ifdef VAES
+    #include "groestl256-asm-aes.h"
+  #else
+    #ifdef VAVX
+      #include "groestl256-asm-avx.h"
+    #else
+      #ifdef VVPERM
+        #include "groestl256-asm-vperm.h"
+      #else
+        #error NO VERSION SPECIFIED (-DV[AES/AVX/VVPERM])
+      #endif
+    #endif
+  #endif
+#else
+  #ifdef TINTR
+    #ifdef VAES
+      #include "groestl256-intr-aes.h"
+    #else
+      #ifdef VAVX
+        #include "groestl256-intr-avx.h"
+      #else
+        #ifdef VVPERM
+          #include "groestl256-intr-vperm.h"
+        #else
+          #error NO VERSION SPECIFIED (-DV[AES/AVX/VVPERM])
+        #endif
+      #endif
+    #endif
+  #else
+    #error NO TYPE SPECIFIED (-DT[ASM/INTR])
+  #endif
+#endif
+
+/* initialise context */
+HashReturn_gr init_groestl256( hashState_groestl256* ctx, int hashlen )
+{
+  int i;
+
+  ctx->hashlen = hashlen;
+  SET_CONSTANTS();
+
+  if (ctx->chaining == NULL || ctx->buffer == NULL)
+    return FAIL_GR;
+
+  for ( i = 0; i < SIZE256; i++ )
+  {
+     ctx->chaining[i] = _mm_setzero_si128();
+     ctx->buffer[i]   = _mm_setzero_si128();
+  }
+  ((u64*)ctx->chaining)[COLS-1] = U64BIG((u64)LENGTH);
+  INIT256( ctx->chaining );
+  ctx->buf_ptr = 0;
+  ctx->rem_ptr = 0;
+
+  return SUCCESS_GR;
+}
+
+
+HashReturn_gr reinit_groestl256(hashState_groestl256* ctx)
+ {
+  int i;
+
+  if (ctx->chaining == NULL || ctx->buffer == NULL)
+    return FAIL_GR;
+
+  for ( i = 0; i < SIZE256; i++ )
+  {
+     ctx->chaining[i] = _mm_setzero_si128();
+     ctx->buffer[i]   = _mm_setzero_si128();
+  }
+  ((u64*)ctx->chaining)[COLS-1] = U64BIG((u64)LENGTH);
+  INIT256(ctx->chaining);
+  ctx->buf_ptr = 0;
+  ctx->rem_ptr = 0;
+
+  return SUCCESS_GR;
+}
+
+// Use this only for midstate and never for cryptonight
+HashReturn_gr update_groestl256( hashState_groestl256* ctx, const void* input,
+                                 DataLength_gr databitlen )
+{
+   __m128i* in = (__m128i*)input;
+   const int len = (int)databitlen / 128;  // bits to __m128i
+   const int blocks = len / SIZE256;    // __M128i to blocks
+   int rem = ctx->rem_ptr;
+   int i;
+
+   ctx->blk_count = blocks;
+   ctx->databitlen = databitlen;
+
+   // digest any full blocks 
+   for ( i = 0; i < blocks; i++ )
+       TF512( ctx->chaining, &in[ i * SIZE256 ] );
+   // adjust buf_ptr to last block
+   ctx->buf_ptr = blocks * SIZE256;
+
+   // Copy any remainder to buffer
+   for ( i = 0; i < len % SIZE256; i++ )
+       ctx->buffer[ rem + i ] = in[ ctx->buf_ptr + i ];
+   // adjust rem_ptr for new data
+   ctx->rem_ptr += i;
+
+   return SUCCESS_GR;
+}
+
+// don't use this at all
+HashReturn_gr final_groestl256( hashState_groestl256* ctx, void* output )
+{
+   const int len = (int)ctx->databitlen / 128;  // bits to __m128i 
+   const int blocks = ctx->blk_count + 1;       // adjust for final block
+   const int rem_ptr = ctx->rem_ptr;      // end of data start of padding
+   const int hashlen_m128i = ctx->hashlen / 16;  // bytes to __m128i
+   const int hash_offset = SIZE256 - hashlen_m128i;  // where in buffer
+   int i;
+
+   // first pad byte = 0x80, last pad byte = block count
+   // everything in between is zero
+
+   if ( rem_ptr == len - 1 )
+   {
+       // all padding at once
+       ctx->buffer[rem_ptr] = _mm_set_epi8( blocks,0,0,0, 0,0,0,0,
+                                                  0,0,0,0, 0,0,0,0x80 );
+   }
+   else
+   {
+       // add first padding
+       ctx->buffer[rem_ptr] = _mm_set_epi8( 0,0,0,0, 0,0,0,0,
+                                            0,0,0,0, 0,0,0,0x80 );
+       // add zero padding
+       for ( i = rem_ptr + 1; i < SIZE256 - 1; i++ )
+           ctx->buffer[i] = _mm_setzero_si128();
+       // add length padding
+       // cheat since we know the block count is trivial, good if block < 256
+       ctx->buffer[i] = _mm_set_epi8( blocks,0,0,0, 0,0,0,0,
+                                           0,0,0,0, 0,0,0,0 );
+   }
+
+   // digest final padding block and do output transform
+   TF512( ctx->chaining, ctx->buffer );
+   OF512( ctx->chaining );
+
+   // store hash result in output 
+   for ( i = 0; i < hashlen_m128i; i++ )
+      casti_m128i( output, i ) = ctx->chaining[ hash_offset + i];
+
+   return SUCCESS_GR;
+}
+
+HashReturn_gr update_and_final_groestl256( hashState_groestl256* ctx,
+                   void* output, const void* input, DataLength_gr databitlen )
+{
+   const int len = (int)databitlen / 128;
+   const int hashlen_m128i = ctx->hashlen / 16;   // bytes to __m128i
+   const int hash_offset = SIZE256 - hashlen_m128i;
+   int rem = ctx->rem_ptr;
+   int blocks = len / SIZE256;
+   __m128i* in = (__m128i*)input;
+   int i;
+
+   // --- update ---
+
+   // digest any full blocks, process directly from input 
+   for ( i = 0; i < blocks; i++ )
+      TF512( ctx->chaining, &in[ i * SIZE256 ] );
+   ctx->buf_ptr = blocks * SIZE256;
+
+   // cryptonight has 200 byte input, an odd number of __m128i
+   // remainder is only 8 bytes, ie u64.
+   if ( databitlen % 128 !=0 )
+   {
+      // must be cryptonight, copy 64 bits of data
+      *(uint64_t*)(ctx->buffer) = *(uint64_t*)(&in[ ctx->buf_ptr ] );
+      i = -1; // signal for odd length
+   }
+   else   
+   { 
+      // Copy any remaining data to buffer for final transform
+      for ( i = 0; i < len % SIZE256; i++ )
+          ctx->buffer[ rem + i ] = in[ ctx->buf_ptr + i ];
+      i += rem;   // use i as rem_ptr in final
+   }
+
+   //--- final ---
+
+   // adjust for final block
+   blocks++;
+
+   if ( i == len - 1 )
+   {
+       // all padding at once
+       ctx->buffer[i] = _mm_set_epi8( blocks,blocks>>8,0,0, 0,0,0,0,
+                                           0,        0,0,0, 0,0,0,0x80 );
+   }
+   else
+   {
+      if ( i == -1 )
+      {
+         // cryptonight odd length
+         ((uint64_t*)ctx->buffer)[ 1 ] = 0x80ull;
+         // finish the block with zero and length padding as normal
+         i = 0;
+       }
+       else
+       {
+          // add first padding
+          ctx->buffer[i] = _mm_set_epi8( 0,0,0,0, 0,0,0,0,
+                                         0,0,0,0, 0,0,0,0x80 );
+       }
+       // add zero padding
+       for ( i += 1; i < SIZE256 - 1; i++ )
+           ctx->buffer[i] = _mm_setzero_si128();
+       // add length padding
+       // cheat since we know the block count is trivial, good if block < 256
+       ctx->buffer[i] = _mm_set_epi8( blocks,blocks>>8,0,0, 0,0,0,0,
+                                           0,        0,0,0, 0,0,0,0 );
+   }
+
+   // digest final padding block and do output transform
+   TF512( ctx->chaining, ctx->buffer );
+   OF512( ctx->chaining );
+
+   // store hash result in output 
+   for ( i = 0; i < hashlen_m128i; i++ )
+      casti_m128i( output, i ) = ctx->chaining[ hash_offset + i ];
+
+   return SUCCESS_GR;
+}
+
+/* hash bit sequence */
+HashReturn_gr hash_groestl256(int hashbitlen,
+                const BitSequence_gr* data,
+                DataLength_gr databitlen,
+                BitSequence_gr* hashval) {
+  HashReturn_gr ret;
+  hashState_groestl256 context;
+
+  /* initialise */
+  if ((ret = init_groestl256(&context, hashbitlen/8)) != SUCCESS_GR)
+    return ret;
+
+  /* process message */
+  if ((ret = update_groestl256(&context, data, databitlen)) != SUCCESS_GR)
+    return ret;
+
+  /* finalise */
+  ret = final_groestl256(&context, hashval);
+
+  return ret;
+}
+
+/* eBash API */
+//#ifdef crypto_hash_BYTES
+//int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen)
+//{
+//  if (hash_groestl(crypto_hash_BYTES * 8, in, inlen * 8,out) == SUCCESS_GR) return 0;
+//  return -1;
+//}
+//#endif
+
+#endif

algo/groestl/groestl256-hash-4way.h

@@ -0,0 +1,121 @@
+/* hash.h     Aug 2011
+ *
+ * Groestl implementation for different versions.
+ * Author: Krystian Matusiewicz, Günther A. Roland, Martin Schläffer
+ *
+ * This code is placed in the public domain
+ */
+
+#ifndef __hash_h
+#define __hash_h
+
+#include <immintrin.h>
+#include <stdio.h>
+#if defined(_WIN64) || defined(__WINDOWS__)
+#include <windows.h>
+#endif
+#include <stdlib.h>
+
+/* eBash API begin */
+/*
+#include "crypto_hash.h"
+#ifdef crypto_hash_BYTES
+
+#include <crypto_uint8.h>
+#include <crypto_uint32.h>
+#include <crypto_uint64.h>
+typedef crypto_uint8 u8;
+typedef crypto_uint32 u32;
+typedef crypto_uint64 u64;
+#endif
+ */
+/* eBash API end */
+
+//#define LENGTH (512)
+
+#include "brg_endian.h"
+#define NEED_UINT_64T
+#include "algo/sha/brg_types.h"
+
+#ifdef IACA_TRACE
+  #include IACA_MARKS
+#endif
+
+#define LENGTH (256)
+
+/* some sizes (number of bytes) */
+#define ROWS (8)
+#define LENGTHFIELDLEN (ROWS)
+#define COLS512 (8)
+//#define COLS1024 (16)
+#define SIZE_512 ((ROWS)*(COLS512))
+//#define SIZE1024 ((ROWS)*(COLS1024))
+#define ROUNDS512 (10)
+//#define ROUNDS1024 (14)
+
+//#if LENGTH<=256
+#define COLS (COLS512)
+//#define SIZE (SIZE512)
+#define ROUNDS (ROUNDS512)
+//#else
+//#define COLS (COLS1024)
+//#define SIZE (SIZE1024)
+//#define ROUNDS (ROUNDS1024)
+//#endif
+
+#define ROTL64(a,n) ((((a)<<(n))|((a)>>(64-(n))))&li_64(ffffffffffffffff))
+
+#if (PLATFORM_BYTE_ORDER == IS_BIG_ENDIAN)
+#define EXT_BYTE(var,n) ((u8)((u64)(var) >> (8*(7-(n)))))
+#define U64BIG(a) (a)
+#endif /* IS_BIG_ENDIAN */
+
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+#define EXT_BYTE(var,n) ((u8)((u64)(var) >> (8*n)))
+#define U64BIG(a) \
+  ((ROTL64(a, 8) & li_64(000000FF000000FF)) | \
+   (ROTL64(a,24) & li_64(0000FF000000FF00)) | \
+   (ROTL64(a,40) & li_64(00FF000000FF0000)) | \
+   (ROTL64(a,56) & li_64(FF000000FF000000)))
+#endif /* IS_LITTLE_ENDIAN */
+
+typedef unsigned char BitSequence_gr;
+typedef unsigned long long DataLength_gr;
+typedef enum
+{
+    SUCCESS_GR = 0,
+    FAIL_GR = 1,
+    BAD_HASHBITLEN_GR = 2
+} HashReturn_gr;
+
+#define SIZE256 (SIZE_512/16)
+
+typedef struct {
+  __attribute__ ((aligned (32))) __m128i chaining[SIZE256];
+  __attribute__ ((aligned (32))) __m128i buffer[SIZE256];
+//  __attribute__ ((aligned (32))) u64 chaining[SIZE/8];      /* actual state */
+//  __attribute__ ((aligned (32))) BitSequence_gr buffer[SIZE];  /* data buffer */
+//  u64 block_counter;        /* message block counter */
+  int hashlen;              // bytes
+  int blk_count;
+  int buf_ptr;              /* data buffer pointer */
+  int rem_ptr;
+  int databitlen;
+} hashState_groestl256;
+
+HashReturn_gr init_groestl256( hashState_groestl256*, int );
+
+HashReturn_gr reinit_groestl256( hashState_groestl256* );
+
+HashReturn_gr update_groestl256( hashState_groestl256*, const void*,
+                              DataLength_gr );
+
+HashReturn_gr final_groestl256( hashState_groestl256*, void* );
+
+HashReturn_gr hash_groestli256( int, const BitSequence_gr*, DataLength_gr,
+                            BitSequence_gr* );
+
+HashReturn_gr update_and_final_groestl256( hashState_groestl256*, void*,
+                                           const void*, DataLength_gr );
+
+#endif /* __hash_h */

algo/groestl/groestl256-intr-4way.h

@@ -0,0 +1,492 @@
+/* groestl-intr-aes.h     Aug 2011
+ *
+ * Groestl implementation with intrinsics using ssse3, sse4.1, and aes
+ * instructions.
+ * Author: Günther A. Roland, Martin Schläffer, Krystian Matusiewicz
+ *
+ * This code is placed in the public domain
+ */
+
+#include <smmintrin.h>
+#include <wmmintrin.h>
+#include "hash-groestl256.h"
+
+/* global constants  */
+__m128i ROUND_CONST_Lx;
+__m128i ROUND_CONST_L0[ROUNDS512];
+__m128i ROUND_CONST_L7[ROUNDS512];
+//__m128i ROUND_CONST_P[ROUNDS1024];
+//__m128i ROUND_CONST_Q[ROUNDS1024];
+__m128i TRANSP_MASK;
+__m128i SUBSH_MASK[8];
+__m128i ALL_1B;
+__m128i ALL_FF;
+
+
+#define tos(a)    #a
+#define tostr(a)  tos(a)
+
+
+/* xmm[i] will be multiplied by 2
+ * xmm[j] will be lost
+ * xmm[k] has to be all 0x1b */
+#define MUL2(i, j, k){\
+  j = _mm_xor_si128(j, j);\
+  j = _mm_cmpgt_epi8(j, i);\
+  i = _mm_add_epi8(i, i);\
+  j = _mm_and_si128(j, k);\
+  i = _mm_xor_si128(i, j);\
+} 
+
+ /**/
+
+/* Yet another implementation of MixBytes.
+   This time we use the formulae (3) from the paper "Byte Slicing Groestl".
+   Input: a0, ..., a7
+   Output: b0, ..., b7 = MixBytes(a0,...,a7).
+   but we use the relations:
+   t_i = a_i + a_{i+3}
+   x_i = t_i + t_{i+3}
+   y_i = t_i + t+{i+2} + a_{i+6}
+   z_i = 2*x_i
+   w_i = z_i + y_{i+4}
+   v_i = 2*w_i
+   b_i = v_{i+3} + y_{i+4}
+   We keep building b_i in registers xmm8..xmm15 by first building y_{i+4} there
+   and then adding v_i computed in the meantime in registers xmm0..xmm7.
+   We almost fit into 16 registers, need only 3 spills to memory.
+   This implementation costs 7.7 c/b giving total speed on SNB: 10.7c/b.
+   K. Matusiewicz, 2011/05/29 */
+#define MixBytes(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7){\
+  /* t_i = a_i + a_{i+1} */\
+  b6 = a0;\
+  b7 = a1;\
+  a0 = _mm_xor_si128(a0, a1);\
+  b0 = a2;\
+  a1 = _mm_xor_si128(a1, a2);\
+  b1 = a3;\
+  a2 = _mm_xor_si128(a2, a3);\
+  b2 = a4;\
+  a3 = _mm_xor_si128(a3, a4);\
+  b3 = a5;\
+  a4 = _mm_xor_si128(a4, a5);\
+  b4 = a6;\
+  a5 = _mm_xor_si128(a5, a6);\
+  b5 = a7;\
+  a6 = _mm_xor_si128(a6, a7);\
+  a7 = _mm_xor_si128(a7, b6);\
+  \
+  /* build y4 y5 y6 ... in regs xmm8, xmm9, xmm10 by adding t_i*/\
+  b0 = _mm_xor_si128(b0, a4);\
+  b6 = _mm_xor_si128(b6, a4);\
+  b1 = _mm_xor_si128(b1, a5);\
+  b7 = _mm_xor_si128(b7, a5);\
+  b2 = _mm_xor_si128(b2, a6);\
+  b0 = _mm_xor_si128(b0, a6);\
+  /* spill values y_4, y_5 to memory */\
+  TEMP0 = b0;\
+  b3 = _mm_xor_si128(b3, a7);\
+  b1 = _mm_xor_si128(b1, a7);\
+  TEMP1 = b1;\
+  b4 = _mm_xor_si128(b4, a0);\
+  b2 = _mm_xor_si128(b2, a0);\
+  /* save values t0, t1, t2 to xmm8, xmm9 and memory */\
+  b0 = a0;\
+  b5 = _mm_xor_si128(b5, a1);\
+  b3 = _mm_xor_si128(b3, a1);\
+  b1 = a1;\
+  b6 = _mm_xor_si128(b6, a2);\
+  b4 = _mm_xor_si128(b4, a2);\
+  TEMP2 = a2;\
+  b7 = _mm_xor_si128(b7, a3);\
+  b5 = _mm_xor_si128(b5, a3);\
+  \
+  /* compute x_i = t_i + t_{i+3} */\
+  a0 = _mm_xor_si128(a0, a3);\
+  a1 = _mm_xor_si128(a1, a4);\
+  a2 = _mm_xor_si128(a2, a5);\
+  a3 = _mm_xor_si128(a3, a6);\
+  a4 = _mm_xor_si128(a4, a7);\
+  a5 = _mm_xor_si128(a5, b0);\
+  a6 = _mm_xor_si128(a6, b1);\
+  a7 = _mm_xor_si128(a7, TEMP2);\
+  \
+  /* compute z_i : double x_i using temp xmm8 and 1B xmm9 */\
+  /* compute w_i : add y_{i+4} */\
+  b1 = ALL_1B;\
+  MUL2(a0, b0, b1);\
+  a0 = _mm_xor_si128(a0, TEMP0);\
+  MUL2(a1, b0, b1);\
+  a1 = _mm_xor_si128(a1, TEMP1);\
+  MUL2(a2, b0, b1);\
+  a2 = _mm_xor_si128(a2, b2);\
+  MUL2(a3, b0, b1);\
+  a3 = _mm_xor_si128(a3, b3);\
+  MUL2(a4, b0, b1);\
+  a4 = _mm_xor_si128(a4, b4);\
+  MUL2(a5, b0, b1);\
+  a5 = _mm_xor_si128(a5, b5);\
+  MUL2(a6, b0, b1);\
+  a6 = _mm_xor_si128(a6, b6);\
+  MUL2(a7, b0, b1);\
+  a7 = _mm_xor_si128(a7, b7);\
+  \
+  /* compute v_i : double w_i      */\
+  /* add to y_4 y_5 .. v3, v4, ... */\
+  MUL2(a0, b0, b1);\
+  b5 = _mm_xor_si128(b5, a0);\
+  MUL2(a1, b0, b1);\
+  b6 = _mm_xor_si128(b6, a1);\
+  MUL2(a2, b0, b1);\
+  b7 = _mm_xor_si128(b7, a2);\
+  MUL2(a5, b0, b1);\
+  b2 = _mm_xor_si128(b2, a5);\
+  MUL2(a6, b0, b1);\
+  b3 = _mm_xor_si128(b3, a6);\
+  MUL2(a7, b0, b1);\
+  b4 = _mm_xor_si128(b4, a7);\
+  MUL2(a3, b0, b1);\
+  MUL2(a4, b0, b1);\
+  b0 = TEMP0;\
+  b1 = TEMP1;\
+  b0 = _mm_xor_si128(b0, a3);\
+  b1 = _mm_xor_si128(b1, a4);\
+}/*MixBytes*/
+
+#define SET_CONSTANTS(){\
+   ALL_1B = _mm_set_epi32(0x1b1b1b1b, 0x1b1b1b1b, 0x1b1b1b1b, 0x1b1b1b1b);\
+  TRANSP_MASK = _mm_set_epi32(0x0f070b03, 0x0e060a02, 0x0d050901, 0x0c040800);\
+  SUBSH_MASK[0] = _mm_set_epi32(0x03060a0d, 0x08020509, 0x0c0f0104, 0x070b0e00);\
+  SUBSH_MASK[1] = _mm_set_epi32(0x04070c0f, 0x0a03060b, 0x0e090205, 0x000d0801);\
+  SUBSH_MASK[2] = _mm_set_epi32(0x05000e09, 0x0c04070d, 0x080b0306, 0x010f0a02);\
+  SUBSH_MASK[3] = _mm_set_epi32(0x0601080b, 0x0e05000f, 0x0a0d0407, 0x02090c03);\
+  SUBSH_MASK[4] = _mm_set_epi32(0x0702090c, 0x0f060108, 0x0b0e0500, 0x030a0d04);\
+  SUBSH_MASK[5] = _mm_set_epi32(0x00030b0e, 0x0907020a, 0x0d080601, 0x040c0f05);\
+  SUBSH_MASK[6] = _mm_set_epi32(0x01040d08, 0x0b00030c, 0x0f0a0702, 0x050e0906);\
+  SUBSH_MASK[7] = _mm_set_epi32(0x02050f0a, 0x0d01040e, 0x090c0003, 0x06080b07);\
+  for(i = 0; i < ROUNDS512; i++)\
+  {\
+    ROUND_CONST_L0[i] = _mm_set_epi32(0xffffffff, 0xffffffff, 0x70605040 ^ (i * 0x01010101), 0x30201000 ^ (i * 0x01010101));\
+    ROUND_CONST_L7[i] = _mm_set_epi32(0x8f9fafbf ^ (i * 0x01010101), 0xcfdfefff ^ (i * 0x01010101), 0x00000000, 0x00000000);\
+  }\
+  ROUND_CONST_Lx = _mm_set_epi32(0xffffffff, 0xffffffff, 0x00000000, 0x00000000);\
+}while(0); \
+
+/* one round
+ * i = round number
+ * a0-a7 = input rows
+ * b0-b7 = output rows
+ */
+#define ROUND(i, a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7){\
+  /* AddRoundConstant */\
+  b1 = ROUND_CONST_Lx;\
+  a0 = _mm_xor_si128(a0, (ROUND_CONST_L0[i]));\
+  a1 = _mm_xor_si128(a1, b1);\
+  a2 = _mm_xor_si128(a2, b1);\
+  a3 = _mm_xor_si128(a3, b1);\
+  a4 = _mm_xor_si128(a4, b1);\
+  a5 = _mm_xor_si128(a5, b1);\
+  a6 = _mm_xor_si128(a6, b1);\
+  a7 = _mm_xor_si128(a7, (ROUND_CONST_L7[i]));\
+  \
+  /* ShiftBytes + SubBytes (interleaved) */\
+  b0 = _mm_xor_si128(b0,  b0);\
+  a0 = _mm_shuffle_epi8(a0, (SUBSH_MASK[0]));\
+  a0 = _mm_aesenclast_si128(a0, b0);\
+  a1 = _mm_shuffle_epi8(a1, (SUBSH_MASK[1]));\
+  a1 = _mm_aesenclast_si128(a1, b0);\
+  a2 = _mm_shuffle_epi8(a2, (SUBSH_MASK[2]));\
+  a2 = _mm_aesenclast_si128(a2, b0);\
+  a3 = _mm_shuffle_epi8(a3, (SUBSH_MASK[3]));\
+  a3 = _mm_aesenclast_si128(a3, b0);\
+  a4 = _mm_shuffle_epi8(a4, (SUBSH_MASK[4]));\
+  a4 = _mm_aesenclast_si128(a4, b0);\
+  a5 = _mm_shuffle_epi8(a5, (SUBSH_MASK[5]));\
+  a5 = _mm_aesenclast_si128(a5, b0);\
+  a6 = _mm_shuffle_epi8(a6, (SUBSH_MASK[6]));\
+  a6 = _mm_aesenclast_si128(a6, b0);\
+  a7 = _mm_shuffle_epi8(a7, (SUBSH_MASK[7]));\
+  a7 = _mm_aesenclast_si128(a7, b0);\
+  \
+  /* MixBytes */\
+  MixBytes(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7);\
+\
+}
+
+/* 10 rounds, P and Q in parallel */
+#define ROUNDS_P_Q(){\
+  ROUND(0, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);\
+  ROUND(1, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
+  ROUND(2, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);\
+  ROUND(3, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
+  ROUND(4, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);\
+  ROUND(5, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
+  ROUND(6, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);\
+  ROUND(7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
+  ROUND(8, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);\
+  ROUND(9, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
+}
+
+/* Matrix Transpose Step 1
+ * input is a 512-bit state with two columns in one xmm
+ * output is a 512-bit state with two rows in one xmm
+ * inputs: i0-i3
+ * outputs: i0, o1-o3
+ * clobbers: t0
+ */
+#define Matrix_Transpose_A(i0, i1, i2, i3, o1, o2, o3, t0){\
+  t0 = TRANSP_MASK;\
+  \
+  i0 = _mm_shuffle_epi8(i0, t0);\
+  i1 = _mm_shuffle_epi8(i1, t0);\
+  i2 = _mm_shuffle_epi8(i2, t0);\
+  i3 = _mm_shuffle_epi8(i3, t0);\
+  \
+  o1 = i0;\
+  t0 = i2;\
+  \
+  i0 = _mm_unpacklo_epi16(i0, i1);\
+  o1 = _mm_unpackhi_epi16(o1, i1);\
+  i2 = _mm_unpacklo_epi16(i2, i3);\
+  t0 = _mm_unpackhi_epi16(t0, i3);\
+  \
+  i0 = _mm_shuffle_epi32(i0, 216);\
+  o1 = _mm_shuffle_epi32(o1, 216);\
+  i2 = _mm_shuffle_epi32(i2, 216);\
+  t0 = _mm_shuffle_epi32(t0, 216);\
+  \
+  o2 = i0;\
+  o3 = o1;\
+  \
+  i0 = _mm_unpacklo_epi32(i0, i2);\
+  o1 = _mm_unpacklo_epi32(o1, t0);\
+  o2 = _mm_unpackhi_epi32(o2, i2);\
+  o3 = _mm_unpackhi_epi32(o3, t0);\
+}/**/
+
+/* Matrix Transpose Step 2
+ * input are two 512-bit states with two rows in one xmm
+ * output are two 512-bit states with one row of each state in one xmm
+ * inputs: i0-i3 = P, i4-i7 = Q
+ * outputs: (i0, o1-o7) = (P|Q)
+ * possible reassignments: (output reg = input reg)
+ * * i1 -> o3-7
+ * * i2 -> o5-7
+ * * i3 -> o7
+ * * i4 -> o3-7
+ * * i5 -> o6-7
+ */
+#define Matrix_Transpose_B(i0, i1, i2, i3, i4, i5, i6, i7, o1, o2, o3, o4, o5, o6, o7){\
+  o1 = i0;\
+  o2 = i1;\
+  i0 = _mm_unpacklo_epi64(i0, i4);\
+  o1 = _mm_unpackhi_epi64(o1, i4);\
+  o3 = i1;\
+  o4 = i2;\
+  o2 = _mm_unpacklo_epi64(o2, i5);\
+  o3 = _mm_unpackhi_epi64(o3, i5);\
+  o5 = i2;\
+  o6 = i3;\
+  o4 = _mm_unpacklo_epi64(o4, i6);\
+  o5 = _mm_unpackhi_epi64(o5, i6);\
+  o7 = i3;\
+  o6 = _mm_unpacklo_epi64(o6, i7);\
+  o7 = _mm_unpackhi_epi64(o7, i7);\
+}/**/
+
+/* Matrix Transpose Inverse Step 2
+ * input are two 512-bit states with one row of each state in one xmm
+ * output are two 512-bit states with two rows in one xmm
+ * inputs: i0-i7 = (P|Q)
+ * outputs: (i0, i2, i4, i6) = P, (o0-o3) = Q
+ */
+#define Matrix_Transpose_B_INV(i0, i1, i2, i3, i4, i5, i6, i7, o0, o1, o2, o3){\
+  o0 = i0;\
+  i0 = _mm_unpacklo_epi64(i0, i1);\
+  o0 = _mm_unpackhi_epi64(o0, i1);\
+  o1 = i2;\
+  i2 = _mm_unpacklo_epi64(i2, i3);\
+  o1 = _mm_unpackhi_epi64(o1, i3);\
+  o2 = i4;\
+  i4 = _mm_unpacklo_epi64(i4, i5);\
+  o2 = _mm_unpackhi_epi64(o2, i5);\
+  o3 = i6;\
+  i6 = _mm_unpacklo_epi64(i6, i7);\
+  o3 = _mm_unpackhi_epi64(o3, i7);\
+}/**/
+
+/* Matrix Transpose Output Step 2
+ * input is one 512-bit state with two rows in one xmm
+ * output is one 512-bit state with one row in the low 64-bits of one xmm
+ * inputs: i0,i2,i4,i6 = S
+ * outputs: (i0-7) = (0|S)
+ */
+#define Matrix_Transpose_O_B(i0, i1, i2, i3, i4, i5, i6, i7, t0){\
+  t0 = _mm_xor_si128(t0, t0);\
+  i1 = i0;\
+  i3 = i2;\
+  i5 = i4;\
+  i7 = i6;\
+  i0 = _mm_unpacklo_epi64(i0, t0);\
+  i1 = _mm_unpackhi_epi64(i1, t0);\
+  i2 = _mm_unpacklo_epi64(i2, t0);\
+  i3 = _mm_unpackhi_epi64(i3, t0);\
+  i4 = _mm_unpacklo_epi64(i4, t0);\
+  i5 = _mm_unpackhi_epi64(i5, t0);\
+  i6 = _mm_unpacklo_epi64(i6, t0);\
+  i7 = _mm_unpackhi_epi64(i7, t0);\
+}/**/
+
+/* Matrix Transpose Output Inverse Step 2
+ * input is one 512-bit state with one row in the low 64-bits of one xmm
+ * output is one 512-bit state with two rows in one xmm
+ * inputs: i0-i7 = (0|S)
+ * outputs: (i0, i2, i4, i6) = S
+ */
+#define Matrix_Transpose_O_B_INV(i0, i1, i2, i3, i4, i5, i6, i7){\
+  i0 = _mm_unpacklo_epi64(i0, i1);\
+  i2 = _mm_unpacklo_epi64(i2, i3);\
+  i4 = _mm_unpacklo_epi64(i4, i5);\
+  i6 = _mm_unpacklo_epi64(i6, i7);\
+}/**/
+
+
+void INIT256( __m128i* chaining )
+{
+  static __m128i xmm0, /*xmm1,*/ xmm2, /*xmm3, xmm4, xmm5,*/ xmm6, xmm7;
+  static __m128i /*xmm8, xmm9, xmm10, xmm11,*/ xmm12, xmm13, xmm14, xmm15;
+
+  /* load IV into registers xmm12 - xmm15 */
+  xmm12 = chaining[0];
+  xmm13 = chaining[1];
+  xmm14 = chaining[2];
+  xmm15 = chaining[3];
+
+  /* transform chaining value from column ordering into row ordering */
+  /* we put two rows (64 bit) of the IV into one 128-bit XMM register */
+  Matrix_Transpose_A(xmm12, xmm13, xmm14, xmm15, xmm2, xmm6, xmm7, xmm0);
+
+  /* store transposed IV */
+  chaining[0] = xmm12;
+  chaining[1] = xmm2;
+  chaining[2] = xmm6;
+  chaining[3] = xmm7;
+}
+
+void TF512( __m128i* chaining, __m128i* message )
+{
+  static __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+  static __m128i xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15;
+  static __m128i TEMP0;
+  static __m128i TEMP1;
+  static __m128i TEMP2;
+
+#ifdef IACA_TRACE
+  IACA_START;
+#endif
+
+  /* load message into registers xmm12 - xmm15 */
+  xmm12 = message[0];
+  xmm13 = message[1];
+  xmm14 = message[2];
+  xmm15 = message[3];
+
+  /* transform message M from column ordering into row ordering */
+  /* we first put two rows (64 bit) of the message into one 128-bit xmm register */
+  Matrix_Transpose_A(xmm12, xmm13, xmm14, xmm15, xmm2, xmm6, xmm7, xmm0);
+
+  /* load previous chaining value */
+  /* we first put two rows (64 bit) of the CV into one 128-bit xmm register */
+  xmm8 = chaining[0];
+  xmm0 = chaining[1];
+  xmm4 = chaining[2];
+  xmm5 = chaining[3];
+
+  /* xor message to CV get input of P */
+  /* result: CV+M in xmm8, xmm0, xmm4, xmm5 */
+  xmm8 = _mm_xor_si128(xmm8, xmm12);
+  xmm0 = _mm_xor_si128(xmm0, xmm2);
+  xmm4 = _mm_xor_si128(xmm4, xmm6);
+  xmm5 = _mm_xor_si128(xmm5, xmm7);
+
+  /* there are now 2 rows of the Groestl state (P and Q) in each xmm register */
+  /* unpack to get 1 row of P (64 bit) and Q (64 bit) into one xmm register */
+  /* result: the 8 rows of P and Q in xmm8 - xmm12 */
+  Matrix_Transpose_B(xmm8, xmm0, xmm4, xmm5, xmm12, xmm2, xmm6, xmm7, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);
+
+  /* compute the two permutations P and Q in parallel */
+  ROUNDS_P_Q();
+
+  /* unpack again to get two rows of P or two rows of Q in one xmm register */
+  Matrix_Transpose_B_INV(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3);
+
+  /* xor output of P and Q */
+  /* result: P(CV+M)+Q(M) in xmm0...xmm3 */
+  xmm0 = _mm_xor_si128(xmm0, xmm8);
+  xmm1 = _mm_xor_si128(xmm1, xmm10);
+  xmm2 = _mm_xor_si128(xmm2, xmm12);
+  xmm3 = _mm_xor_si128(xmm3, xmm14);
+
+  /* xor CV (feed-forward) */
+  /* result: P(CV+M)+Q(M)+CV in xmm0...xmm3 */
+  xmm0 = _mm_xor_si128(xmm0, (chaining[0]));
+  xmm1 = _mm_xor_si128(xmm1, (chaining[1]));
+  xmm2 = _mm_xor_si128(xmm2, (chaining[2]));
+  xmm3 = _mm_xor_si128(xmm3, (chaining[3]));
+
+  /* store CV */
+  chaining[0] = xmm0;
+  chaining[1] = xmm1;
+  chaining[2] = xmm2;
+  chaining[3] = xmm3;
+
+#ifdef IACA_TRACE
+  IACA_END;
+#endif
+  return;
+}
+
+void OF512( __m128i* chaining )
+{
+  static __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+  static __m128i xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15;
+  static __m128i TEMP0;
+  static __m128i TEMP1;
+  static __m128i TEMP2;
+
+  /* load CV into registers xmm8, xmm10, xmm12, xmm14 */
+  xmm8 = chaining[0];
+  xmm10 = chaining[1];
+  xmm12 = chaining[2];
+  xmm14 = chaining[3];
+
+  /* there are now 2 rows of the CV in one xmm register */
+  /* unpack to get 1 row of P (64 bit) into one half of an xmm register */
+  /* result: the 8 input rows of P in xmm8 - xmm15 */
+  Matrix_Transpose_O_B(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0);
+
+  /* compute the permutation P */
+  /* result: the output of P(CV) in xmm8 - xmm15 */
+  ROUNDS_P_Q();
+
+  /* unpack again to get two rows of P in one xmm register */
+  /* result: P(CV) in xmm8, xmm10, xmm12, xmm14 */
+  Matrix_Transpose_O_B_INV(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);
+
+  /* xor CV to P output (feed-forward) */
+  /* result: P(CV)+CV in xmm8, xmm10, xmm12, xmm14 */
+  xmm8 = _mm_xor_si128(xmm8,  (chaining[0]));
+  xmm10 = _mm_xor_si128(xmm10, (chaining[1]));
+  xmm12 = _mm_xor_si128(xmm12, (chaining[2]));
+  xmm14 = _mm_xor_si128(xmm14, (chaining[3]));
+
+  /* transform state back from row ordering into column ordering */
+  /* result: final hash value in xmm9, xmm11 */
+  Matrix_Transpose_A(xmm8, xmm10, xmm12, xmm14, xmm4, xmm9, xmm11, xmm0);
+
+  /* we only need to return the truncated half of the state */
+  chaining[2] = xmm9;
+  chaining[3] = xmm11;
+}
+
+

algo/groestl/groestl512-hash-4way.c

@@ -0,0 +1,114 @@
+/* hash.c     Aug 2011
+ * groestl512-hash-4way https://github.com/JayDDee/cpuminer-opt  2019-12.
+ *
+ * Groestl implementation for different versions.
+ * Author: Krystian Matusiewicz, Günther A. Roland, Martin Schläffer
+ *
+ * This code is placed in the public domain
+ */
+
+// Optimized for hash and data length that are integrals of __m128i 
+
+
+#include <memory.h>
+#include "groestl512-intr-4way.h"
+#include "miner.h"
+#include "simd-utils.h"
+
+#if defined(__VAES__)
+
+#define ROTL64(a,n) \
+   ( ( ( (a)<<(n) ) | ( (a) >> (64-(n)) ) ) & 0xffffffffffffffff )
+     
+#define U64BIG(a) \
+  ( ( ROTL64(a, 8) & 0x000000FF000000FF ) | \
+    ( ROTL64(a,24) & 0x0000FF000000FF00 ) | \
+    ( ROTL64(a,40) & 0x00FF000000FF0000 ) | \
+    ( ROTL64(a,56) & 0xFF000000FF000000 ) )
+
+int groestl512_4way_init( groestl512_4way_context* ctx, uint64_t hashlen )
+{
+  int i;
+
+  ctx->hashlen = hashlen;
+  SET_CONSTANTS();
+
+  if (ctx->chaining == NULL || ctx->buffer == NULL)
+    return 1;
+
+  for ( i = 0; i < SIZE512; i++ )
+  {
+     ctx->chaining[i] = m512_zero;
+     ctx->buffer[i]   = m512_zero;
+  }
+
+  uint64_t len = U64BIG((uint64_t)LENGTH);
+  ctx->chaining[ COLS/2 -1 ] = _mm512_set4_epi64( len, 0, len, 0 );
+  INIT_4way(ctx->chaining);
+  ctx->buf_ptr = 0;
+  ctx->rem_ptr = 0;
+
+  return 0;
+}
+
+int groestl512_4way_update_close( groestl512_4way_context* ctx, void* output,
+                                const void* input, uint64_t databitlen )
+{
+   const int len = (int)databitlen / 128;
+   const int hashlen_m128i = ctx->hashlen / 16;   // bytes to __m128i
+   const int hash_offset = SIZE512 - hashlen_m128i;
+   int rem = ctx->rem_ptr;
+   int blocks = len / SIZE512;
+   __m512i* in = (__m512i*)input;
+   int i;
+
+   // --- update ---
+
+   // digest any full blocks, process directly from input 
+   for ( i = 0; i < blocks; i++ )
+      TF1024_4way( ctx->chaining, &in[ i * SIZE512 ] );
+   ctx->buf_ptr = blocks * SIZE512;
+
+   // copy any remaining data to buffer, it may already contain data
+   // from a previous update for a midstate precalc
+   for ( i = 0; i < len % SIZE512; i++ )
+       ctx->buffer[ rem + i ] = in[ ctx->buf_ptr + i ];
+   i += rem;    // use i as rem_ptr in final
+
+   //--- final ---
+
+   blocks++;      // adjust for final block
+
+   if ( i == SIZE512 - 1 )
+   {        
+       // only 1 vector left in buffer, all padding at once
+       ctx->buffer[i] = m512_const1_128( _mm_set_epi8(
+                      blocks, blocks>>8,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0x80 ) );
+   }   
+   else
+   {
+       // add first padding
+       ctx->buffer[i] = m512_const4_64( 0, 0x80, 0, 0x80 );
+       // add zero padding
+       for ( i += 1; i < SIZE512 - 1; i++ )
+           ctx->buffer[i] = m512_zero;
+
+       // add length padding, second last byte is zero unless blocks > 255
+       ctx->buffer[i] = m512_const1_128( _mm_set_epi8(
+                   blocks, blocks>>8, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 ) );
+   }
+
+// digest final padding block and do output transform
+   TF1024_4way( ctx->chaining, ctx->buffer );
+
+   OF1024_4way( ctx->chaining );
+
+   // store hash result in output 
+   for ( i = 0; i < hashlen_m128i; i++ )
+      casti_m512i( output, i ) = ctx->chaining[ hash_offset + i ];
+
+   return 0;
+}
+
+#endif   // VAES
+

algo/groestl/groestl512-hash-4way.h

@@ -0,0 +1,94 @@
+/* hash.h     Aug 2011
+ *
+ * Groestl implementation for different versions.
+ * Author: Krystian Matusiewicz, Günther A. Roland, Martin Schläffer
+ *
+ * This code is placed in the public domain
+ */
+
+#if !defined(GROESTL512_HASH_4WAY_H__)
+#define GROESTL512_HASH_4WAY_H__ 1
+
+#include "simd-utils.h"
+#include <immintrin.h>
+#include <stdint.h>
+#include <stdio.h>
+#if defined(_WIN64) || defined(__WINDOWS__)
+#include <windows.h>
+#endif
+#include <stdlib.h>
+
+#define LENGTH (512)
+
+//#include "brg_endian.h"
+//#define NEED_UINT_64T
+//#include "algo/sha/brg_types.h"
+
+/* some sizes (number of bytes) */
+#define ROWS (8)
+#define LENGTHFIELDLEN (ROWS)
+//#define COLS512 (8)
+#define COLS1024 (16)
+//#define SIZE512 ((ROWS)*(COLS512))
+#define SIZE_1024 ((ROWS)*(COLS1024))
+//#define ROUNDS512 (10)
+#define ROUNDS1024 (14)
+
+//#if LENGTH<=256
+//#define COLS (COLS512)
+//#define SIZE (SIZE512)
+//#define ROUNDS (ROUNDS512)
+//#else
+#define COLS (COLS1024)
+//#define SIZE (SIZE1024)
+#define ROUNDS (ROUNDS1024)
+//#endif
+
+/*
+#define ROTL64(a,n) ((((a)<<(n))|((a)>>(64-(n))))&li_64(ffffffffffffffff))
+
+#if (PLATFORM_BYTE_ORDER == IS_BIG_ENDIAN)
+#define EXT_BYTE(var,n) ((u8)((u64)(var) >> (8*(7-(n)))))
+#define U64BIG(a) (a)
+#endif // IS_BIG_ENDIAN 
+
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+#define EXT_BYTE(var,n) ((u8)((u64)(var) >> (8*n)))
+#define U64BIG(a) \
+  ((ROTL64(a, 8) & li_64(000000FF000000FF)) | \
+   (ROTL64(a,24) & li_64(0000FF000000FF00)) | \
+   (ROTL64(a,40) & li_64(00FF000000FF0000)) | \
+   (ROTL64(a,56) & li_64(FF000000FF000000)))
+#endif // IS_LITTLE_ENDIAN 
+
+typedef unsigned char BitSequence_gr;
+typedef unsigned long long DataLength_gr;
+typedef enum { SUCCESS_GR = 0, FAIL_GR = 1, BAD_HASHBITLEN_GR = 2} HashReturn_gr;
+*/
+
+#define SIZE512 (SIZE_1024/16)
+
+typedef struct {
+  __attribute__ ((aligned (128))) __m512i chaining[SIZE512];
+  __attribute__ ((aligned (64))) __m512i buffer[SIZE512];
+  int hashlen;       // byte
+  int blk_count;     // SIZE_m128i
+  int buf_ptr;       // __m128i offset
+  int rem_ptr;
+  int databitlen;    // bits
+} groestl512_4way_context;
+
+
+int groestl512_4way_init( groestl512_4way_context*, uint64_t );
+
+//int reinit_groestl( hashState_groestl* );
+
+int groestl512_4way_update( groestl512_4way_context*, const void*,
+                              uint64_t );
+
+int groestl512_4way_close( groestl512_4way_context*, void* );
+
+int groestl512_4way_update_close( groestl512_4way_context*,  void*,
+                                        const void*, uint64_t );
+
+#endif /* __hash_h */

algo/groestl/groestl512-intr-4way.h

@@ -0,0 +1,654 @@
+/* groestl-intr-aes.h     Aug 2011
+ *
+ * Groestl implementation with intrinsics using ssse3, sse4.1, and aes
+ * instructions.
+ * Author: Günther A. Roland, Martin Schläffer, Krystian Matusiewicz
+ *
+ * This code is placed in the public domain
+ */
+
+
+#if !defined(GROESTL512_INTR_4WAY_H__)
+#define GROESTL512_INTR_4WAY_H__ 1
+      
+#include "groestl512-hash-4way.h"
+
+#if defined(__VAES__)
+
+/* global constants  */
+__m512i ROUND_CONST_Lx;
+//__m128i ROUND_CONST_L0[ROUNDS512];
+//__m128i ROUND_CONST_L7[ROUNDS512];
+__m512i ROUND_CONST_P[ROUNDS1024];
+__m512i ROUND_CONST_Q[ROUNDS1024];
+__m512i TRANSP_MASK;
+__m512i SUBSH_MASK[8];
+__m512i ALL_1B;
+__m512i ALL_FF;
+
+#define tos(a)    #a
+#define tostr(a)  tos(a)
+
+/* xmm[i] will be multiplied by 2
+ * xmm[j] will be lost
+ * xmm[k] has to be all 0x1b */
+#define MUL2(i, j, k){\
+  j = _mm512_xor_si512(j, j);\
+  j = _mm512_movm_epi8( _mm512_cmpgt_epi8_mask(j, i) );\
+  i = _mm512_add_epi8(i, i);\
+  j = _mm512_and_si512(j, k);\
+  i = _mm512_xor_si512(i, j);\
+} 
+
+ /**/
+
+/* Yet another implementation of MixBytes.
+   This time we use the formulae (3) from the paper "Byte Slicing Groestl".
+   Input: a0, ..., a7
+   Output: b0, ..., b7 = MixBytes(a0,...,a7).
+   but we use the relations:
+   t_i = a_i + a_{i+3}
+   x_i = t_i + t_{i+3}
+   y_i = t_i + t+{i+2} + a_{i+6}
+   z_i = 2*x_i
+   w_i = z_i + y_{i+4}
+   v_i = 2*w_i
+   b_i = v_{i+3} + y_{i+4}
+   We keep building b_i in registers xmm8..xmm15 by first building y_{i+4} there
+   and then adding v_i computed in the meantime in registers xmm0..xmm7.
+   We almost fit into 16 registers, need only 3 spills to memory.
+   This implementation costs 7.7 c/b giving total speed on SNB: 10.7c/b.
+   K. Matusiewicz, 2011/05/29 */
+#define MixBytes(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7){\
+  /* t_i = a_i + a_{i+1} */\
+  b6 = a0;\
+  b7 = a1;\
+  a0 = _mm512_xor_si512(a0, a1);\
+  b0 = a2;\
+  a1 = _mm512_xor_si512(a1, a2);\
+  b1 = a3;\
+  a2 = _mm512_xor_si512(a2, a3);\
+  b2 = a4;\
+  a3 = _mm512_xor_si512(a3, a4);\
+  b3 = a5;\
+  a4 = _mm512_xor_si512(a4, a5);\
+  b4 = a6;\
+  a5 = _mm512_xor_si512(a5, a6);\
+  b5 = a7;\
+  a6 = _mm512_xor_si512(a6, a7);\
+  a7 = _mm512_xor_si512(a7, b6);\
+  \
+  /* build y4 y5 y6 ... in regs xmm8, xmm9, xmm10 by adding t_i*/\
+  b0 = _mm512_xor_si512(b0, a4);\
+  b6 = _mm512_xor_si512(b6, a4);\
+  b1 = _mm512_xor_si512(b1, a5);\
+  b7 = _mm512_xor_si512(b7, a5);\
+  b2 = _mm512_xor_si512(b2, a6);\
+  b0 = _mm512_xor_si512(b0, a6);\
+  /* spill values y_4, y_5 to memory */\
+  TEMP0 = b0;\
+  b3 = _mm512_xor_si512(b3, a7);\
+  b1 = _mm512_xor_si512(b1, a7);\
+  TEMP1 = b1;\
+  b4 = _mm512_xor_si512(b4, a0);\
+  b2 = _mm512_xor_si512(b2, a0);\
+  /* save values t0, t1, t2 to xmm8, xmm9 and memory */\
+  b0 = a0;\
+  b5 = _mm512_xor_si512(b5, a1);\
+  b3 = _mm512_xor_si512(b3, a1);\
+  b1 = a1;\
+  b6 = _mm512_xor_si512(b6, a2);\
+  b4 = _mm512_xor_si512(b4, a2);\
+  TEMP2 = a2;\
+  b7 = _mm512_xor_si512(b7, a3);\
+  b5 = _mm512_xor_si512(b5, a3);\
+  \
+  /* compute x_i = t_i + t_{i+3} */\
+  a0 = _mm512_xor_si512(a0, a3);\
+  a1 = _mm512_xor_si512(a1, a4);\
+  a2 = _mm512_xor_si512(a2, a5);\
+  a3 = _mm512_xor_si512(a3, a6);\
+  a4 = _mm512_xor_si512(a4, a7);\
+  a5 = _mm512_xor_si512(a5, b0);\
+  a6 = _mm512_xor_si512(a6, b1);\
+  a7 = _mm512_xor_si512(a7, TEMP2);\
+  \
+  /* compute z_i : double x_i using temp xmm8 and 1B xmm9 */\
+  /* compute w_i : add y_{i+4} */\
+  b1 = ALL_1B;\
+  MUL2(a0, b0, b1);\
+  a0 = _mm512_xor_si512(a0, TEMP0);\
+  MUL2(a1, b0, b1);\
+  a1 = _mm512_xor_si512(a1, TEMP1);\
+  MUL2(a2, b0, b1);\
+  a2 = _mm512_xor_si512(a2, b2);\
+  MUL2(a3, b0, b1);\
+  a3 = _mm512_xor_si512(a3, b3);\
+  MUL2(a4, b0, b1);\
+  a4 = _mm512_xor_si512(a4, b4);\
+  MUL2(a5, b0, b1);\
+  a5 = _mm512_xor_si512(a5, b5);\
+  MUL2(a6, b0, b1);\
+  a6 = _mm512_xor_si512(a6, b6);\
+  MUL2(a7, b0, b1);\
+  a7 = _mm512_xor_si512(a7, b7);\
+  \
+  /* compute v_i : double w_i      */\
+  /* add to y_4 y_5 .. v3, v4, ... */\
+  MUL2(a0, b0, b1);\
+  b5 = _mm512_xor_si512(b5, a0);\
+  MUL2(a1, b0, b1);\
+  b6 = _mm512_xor_si512(b6, a1);\
+  MUL2(a2, b0, b1);\
+  b7 = _mm512_xor_si512(b7, a2);\
+  MUL2(a5, b0, b1);\
+  b2 = _mm512_xor_si512(b2, a5);\
+  MUL2(a6, b0, b1);\
+  b3 = _mm512_xor_si512(b3, a6);\
+  MUL2(a7, b0, b1);\
+  b4 = _mm512_xor_si512(b4, a7);\
+  MUL2(a3, b0, b1);\
+  MUL2(a4, b0, b1);\
+  b0 = TEMP0;\
+  b1 = TEMP1;\
+  b0 = _mm512_xor_si512(b0, a3);\
+  b1 = _mm512_xor_si512(b1, a4);\
+}/*MixBytes*/
+
+// calculate the round constants seperately and load at startup
+
+#define SET_CONSTANTS(){\
+  ALL_FF = _mm512_set1_epi32( 0xffffffff );\
+  ALL_1B = _mm512_set1_epi32( 0x1b1b1b1b );\
+  TRANSP_MASK   = _mm512_set_epi32( \
+                         0x3f373b33, 0x3e363a32, 0x3d353931, 0x3c343830, \
+                         0x2f272b23, 0x2e262a22, 0x2d252921, 0x2c242820, \
+                         0x1f171b13, 0x1e161a12, 0x1d151911, 0x1c141810, \
+                         0x0f070b03, 0x0e060a02, 0x0d050901, 0x0c040800 ); \
+  SUBSH_MASK[0] = _mm512_set_epi32( \
+                         0x3336393c, 0x3f323538, 0x3b3e3134, 0x373a3d30, \
+                         0x2326292c, 0x2f222528, 0x2b2e2124, 0x272a2d20, \
+                         0x1316191c, 0x1f121518, 0x1b1e1114, 0x171a1d10, \
+                         0x0306090c, 0x0f020508, 0x0b0e0104, 0x070a0d00 ); \
+  SUBSH_MASK[1] = _mm512_set_epi32( \
+                         0x34373a3d, 0x30333639, 0x3c3f3235, 0x383b3e31, \
+                         0x24272a2d, 0x20232629, 0x2c2f2225, 0x282b2e21, \
+                         0x14171a1d, 0x10131619, 0x1c1f1215, 0x181b1e11, \
+                         0x04070a0d, 0x00030609, 0x0c0f0205, 0x080b0e01 ); \
+  SUBSH_MASK[2] = _mm512_set_epi32( \
+                         0x35383b3e, 0x3134373a, 0x3d303336, 0x393c3f32, \
+                         0x25282b2e, 0x2124272a, 0x2d202326, 0x292c2f22, \
+                         0x15181b1e, 0x1114171a, 0x1d101316, 0x191c1f12, \
+                         0x05080b0e, 0x0104070a, 0x0d000306, 0x090c0f02 ); \
+  SUBSH_MASK[3] = _mm512_set_epi32( \
+                         0x36393c3f, 0x3235383b, 0x3e313437, 0x3a3d3033, \
+                         0x26292c2f, 0x2225282b, 0x2e212427, 0x2a2d2023, \
+                         0x16191c1f, 0x1215181b, 0x1e111417, 0x1a1d1013, \
+                         0x06090c0f, 0x0205080b, 0x0e010407, 0x0a0d0003 ); \
+  SUBSH_MASK[4] = _mm512_set_epi32( \
+                         0x373a3d30, 0x3336393c, 0x3f323538, 0x3b3e3134, \
+                         0x272a2d20, 0x2326292c, 0x2f222528, 0x2b2e2124, \
+                         0x171a1d10, 0x1316191c, 0x1f121518, 0x1b1e1114, \
+                         0x070a0d00, 0x0306090c, 0x0f020508, 0x0b0e0104 ); \
+  SUBSH_MASK[5] = _mm512_set_epi32( \
+                         0x383b3e31, 0x34373a3d, 0x30333639, 0x3c3f3235, \
+                         0x282b2e21, 0x24272a2d, 0x20232629, 0x2c2f2225, \
+                         0x181b1e11, 0x14171a1d, 0x10131619, 0x1c1f1215, \
+                         0x080b0e01, 0x04070a0d, 0x00030609, 0x0c0f0205 ); \
+  SUBSH_MASK[6] = _mm512_set_epi32( \
+                         0x393c3f32, 0x35383b3e, 0x3134373a, 0x3d303336, \
+                         0x292c2f22, 0x25282b2e, 0x2124272a, 0x2d202326, \
+                         0x191c1f12, 0x15181b1e, 0x1114171a, 0x1d101316, \
+                         0x090c0f02, 0x05080b0e, 0x0104070a, 0x0d000306 ); \
+  SUBSH_MASK[7] = _mm512_set_epi32( \
+                         0x3e313437, 0x3a3d3033, 0x36393c3f, 0x3235383b, \
+                         0x2e212427, 0x2a2d2023, 0x26292c2f, 0x2225282b, \
+                         0x1e111417, 0x1a1d1013, 0x16191c1f, 0x1215181b, \
+                         0x0e010407, 0x0a0d0003, 0x06090c0f, 0x0205080b ); \
+  for( i = 0; i < ROUNDS1024; i++ ) \
+  { \
+    ROUND_CONST_P[i] = _mm512_set4_epi32( 0xf0e0d0c0 ^ (i * 0x01010101), \
+                                          0xb0a09080 ^ (i * 0x01010101), \
+                                          0x70605040 ^ (i * 0x01010101), \
+                                          0x30201000 ^ (i * 0x01010101) ); \
+    ROUND_CONST_Q[i] = _mm512_set4_epi32( 0x0f1f2f3f ^ (i * 0x01010101), \
+                                          0x4f5f6f7f ^ (i * 0x01010101), \
+                                          0x8f9fafbf ^ (i * 0x01010101), \
+                                          0xcfdfefff ^ (i * 0x01010101));\
+  } \
+}while(0);\
+
+/* one round
+ * a0-a7 = input rows
+ * b0-b7 = output rows
+ */
+#define SUBMIX(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7){\
+  /* SubBytes */\
+  b0 = _mm512_xor_si512( b0, b0 );\
+  a0 = _mm512_aesenclast_epi128( a0, b0 );\
+  a1 = _mm512_aesenclast_epi128( a1, b0 );\
+  a2 = _mm512_aesenclast_epi128( a2, b0 );\
+  a3 = _mm512_aesenclast_epi128( a3, b0 );\
+  a4 = _mm512_aesenclast_epi128( a4, b0 );\
+  a5 = _mm512_aesenclast_epi128( a5, b0 );\
+  a6 = _mm512_aesenclast_epi128( a6, b0 );\
+  a7 = _mm512_aesenclast_epi128( a7, b0 );\
+  /* MixBytes */\
+  MixBytes(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7);\
+}
+
+#define ROUNDS_P(){\
+  uint8_t round_counter = 0;\
+  for ( round_counter = 0; round_counter < 14; round_counter += 2 ) \
+  { \
+    /* AddRoundConstant P1024 */\
+    xmm8 = _mm512_xor_si512( xmm8, ( ROUND_CONST_P[ round_counter ] ) );\
+    /* ShiftBytes P1024 + pre-AESENCLAST */\
+    xmm8  = _mm512_shuffle_epi8( xmm8,  ( SUBSH_MASK[0] ) );\
+    xmm9  = _mm512_shuffle_epi8( xmm9,  ( SUBSH_MASK[1] ) );\
+    xmm10 = _mm512_shuffle_epi8( xmm10, ( SUBSH_MASK[2] ) );\
+    xmm11 = _mm512_shuffle_epi8( xmm11, ( SUBSH_MASK[3] ) );\
+    xmm12 = _mm512_shuffle_epi8( xmm12, ( SUBSH_MASK[4] ) );\
+    xmm13 = _mm512_shuffle_epi8( xmm13, ( SUBSH_MASK[5] ) );\
+    xmm14 = _mm512_shuffle_epi8( xmm14, ( SUBSH_MASK[6] ) );\
+    xmm15 = _mm512_shuffle_epi8( xmm15, ( SUBSH_MASK[7] ) );\
+    /* SubBytes + MixBytes */\
+    SUBMIX(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);\
+    \
+     /* AddRoundConstant P1024 */\
+    xmm0 = _mm512_xor_si512( xmm0, ( ROUND_CONST_P[ round_counter+1 ] ) );\
+    /* ShiftBytes P1024 + pre-AESENCLAST */\
+    xmm0 = _mm512_shuffle_epi8( xmm0, ( SUBSH_MASK[0] ) );\
+    xmm1 = _mm512_shuffle_epi8( xmm1, ( SUBSH_MASK[1] ) );\
+    xmm2 = _mm512_shuffle_epi8( xmm2, ( SUBSH_MASK[2] ) );\
+    xmm3 = _mm512_shuffle_epi8( xmm3, ( SUBSH_MASK[3] ) );\
+    xmm4 = _mm512_shuffle_epi8( xmm4, ( SUBSH_MASK[4] ) );\
+    xmm5 = _mm512_shuffle_epi8( xmm5, ( SUBSH_MASK[5] ) );\
+    xmm6 = _mm512_shuffle_epi8( xmm6, ( SUBSH_MASK[6] ) );\
+    xmm7 = _mm512_shuffle_epi8( xmm7, ( SUBSH_MASK[7] ) );\
+    /* SubBytes + MixBytes */\
+     SUBMIX(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
+  }\
+}
+
+#define ROUNDS_Q(){\
+  uint8_t round_counter = 0;\
+  for ( round_counter = 0; round_counter < 14; round_counter += 2) \
+  { \
+    /* AddRoundConstant Q1024 */\
+    xmm1 = ALL_FF;\
+    xmm8  = _mm512_xor_si512( xmm8,  xmm1 );\
+    xmm9  = _mm512_xor_si512( xmm9,  xmm1 );\
+    xmm10 = _mm512_xor_si512( xmm10, xmm1 );\
+    xmm11 = _mm512_xor_si512( xmm11, xmm1 );\
+    xmm12 = _mm512_xor_si512( xmm12, xmm1 );\
+    xmm13 = _mm512_xor_si512( xmm13, xmm1 );\
+    xmm14 = _mm512_xor_si512( xmm14, xmm1 );\
+    xmm15 = _mm512_xor_si512( xmm15, ( ROUND_CONST_Q[ round_counter ] ) );\
+    /* ShiftBytes Q1024 + pre-AESENCLAST */\
+    xmm8  = _mm512_shuffle_epi8( xmm8,  ( SUBSH_MASK[1] ) );\
+    xmm9  = _mm512_shuffle_epi8( xmm9,  ( SUBSH_MASK[3] ) );\
+    xmm10 = _mm512_shuffle_epi8( xmm10, ( SUBSH_MASK[5] ) );\
+    xmm11 = _mm512_shuffle_epi8( xmm11, ( SUBSH_MASK[7] ) );\
+    xmm12 = _mm512_shuffle_epi8( xmm12, ( SUBSH_MASK[0] ) );\
+    xmm13 = _mm512_shuffle_epi8( xmm13, ( SUBSH_MASK[2] ) );\
+    xmm14 = _mm512_shuffle_epi8( xmm14, ( SUBSH_MASK[4] ) );\
+    xmm15 = _mm512_shuffle_epi8( xmm15, ( SUBSH_MASK[6] ) );\
+    /* SubBytes + MixBytes */\
+    SUBMIX(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);\
+    \
+    /* AddRoundConstant Q1024 */\
+    xmm9 = ALL_FF;\
+    xmm0 = _mm512_xor_si512( xmm0, xmm9 );\
+    xmm1 = _mm512_xor_si512( xmm1, xmm9 );\
+    xmm2 = _mm512_xor_si512( xmm2, xmm9 );\
+    xmm3 = _mm512_xor_si512( xmm3, xmm9 );\
+    xmm4 = _mm512_xor_si512( xmm4, xmm9 );\
+    xmm5 = _mm512_xor_si512( xmm5, xmm9 );\
+    xmm6 = _mm512_xor_si512( xmm6, xmm9 );\
+    xmm7 = _mm512_xor_si512( xmm7, ( ROUND_CONST_Q[ round_counter+1 ] ) );\
+    /* ShiftBytes Q1024 + pre-AESENCLAST */\
+    xmm0 = _mm512_shuffle_epi8( xmm0, ( SUBSH_MASK[1] ) );\
+    xmm1 = _mm512_shuffle_epi8( xmm1, ( SUBSH_MASK[3] ) );\
+    xmm2 = _mm512_shuffle_epi8( xmm2, ( SUBSH_MASK[5] ) );\
+    xmm3 = _mm512_shuffle_epi8( xmm3, ( SUBSH_MASK[7] ) );\
+    xmm4 = _mm512_shuffle_epi8( xmm4, ( SUBSH_MASK[0] ) );\
+    xmm5 = _mm512_shuffle_epi8( xmm5, ( SUBSH_MASK[2] ) );\
+    xmm6 = _mm512_shuffle_epi8( xmm6, ( SUBSH_MASK[4] ) );\
+    xmm7 = _mm512_shuffle_epi8( xmm7, ( SUBSH_MASK[6] ) );\
+    /* SubBytes + MixBytes */\
+    SUBMIX(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15);\
+  }\
+}
+
+/* Matrix Transpose
+ * input is a 1024-bit state with two columns in one xmm
+ * output is a 1024-bit state with two rows in one xmm
+ * inputs: i0-i7
+ * outputs: i0-i7
+ * clobbers: t0-t7
+ */
+#define Matrix_Transpose(i0, i1, i2, i3, i4, i5, i6, i7, t0, t1, t2, t3, t4, t5, t6, t7){\
+  t0 = TRANSP_MASK;\
+\
+  i6 = _mm512_shuffle_epi8(i6, t0);\
+  i0 = _mm512_shuffle_epi8(i0, t0);\
+  i1 = _mm512_shuffle_epi8(i1, t0);\
+  i2 = _mm512_shuffle_epi8(i2, t0);\
+  i3 = _mm512_shuffle_epi8(i3, t0);\
+  t1 = i2;\
+  i4 = _mm512_shuffle_epi8(i4, t0);\
+  i5 = _mm512_shuffle_epi8(i5, t0);\
+  t2 = i4;\
+  t3 = i6;\
+  i7 = _mm512_shuffle_epi8(i7, t0);\
+\
+  /* continue with unpack using 4 temp registers */\
+  t0 = i0;\
+  t2 = _mm512_unpackhi_epi16(t2, i5);\
+  i4 = _mm512_unpacklo_epi16(i4, i5);\
+  t3 = _mm512_unpackhi_epi16(t3, i7);\
+  i6 = _mm512_unpacklo_epi16(i6, i7);\
+  t0 = _mm512_unpackhi_epi16(t0, i1);\
+  t1 = _mm512_unpackhi_epi16(t1, i3);\
+  i2 = _mm512_unpacklo_epi16(i2, i3);\
+  i0 = _mm512_unpacklo_epi16(i0, i1);\
+\
+  /* shuffle with immediate */\
+  t0 = _mm512_shuffle_epi32(t0, 216);\
+  t1 = _mm512_shuffle_epi32(t1, 216);\
+  t2 = _mm512_shuffle_epi32(t2, 216);\
+  t3 = _mm512_shuffle_epi32(t3, 216);\
+  i0 = _mm512_shuffle_epi32(i0, 216);\
+  i2 = _mm512_shuffle_epi32(i2, 216);\
+  i4 = _mm512_shuffle_epi32(i4, 216);\
+  i6 = _mm512_shuffle_epi32(i6, 216);\
+\
+  /* continue with unpack */\
+  t4 = i0;\
+  i0 = _mm512_unpacklo_epi32(i0, i2);\
+  t4 = _mm512_unpackhi_epi32(t4, i2);\
+  t5 = t0;\
+  t0 = _mm512_unpacklo_epi32(t0, t1);\
+  t5 = _mm512_unpackhi_epi32(t5, t1);\
+  t6 = i4;\
+  i4 = _mm512_unpacklo_epi32(i4, i6);\
+  t7 = t2;\
+  t6 = _mm512_unpackhi_epi32(t6, i6);\
+  i2 = t0;\
+  t2 = _mm512_unpacklo_epi32(t2, t3);\
+  i3 = t0;\
+  t7 = _mm512_unpackhi_epi32(t7, t3);\
+\
+  /* there are now 2 rows in each xmm */\
+  /* unpack to get 1 row of CV in each xmm */\
+  i1 = i0;\
+  i1 = _mm512_unpackhi_epi64(i1, i4);\
+  i0 = _mm512_unpacklo_epi64(i0, i4);\
+  i4 = t4;\
+  i3 = _mm512_unpackhi_epi64(i3, t2);\
+  i5 = t4;\
+  i2 = _mm512_unpacklo_epi64(i2, t2);\
+  i6 = t5;\
+  i5 = _mm512_unpackhi_epi64(i5, t6);\
+  i7 = t5;\
+  i4 = _mm512_unpacklo_epi64(i4, t6);\
+  i7 = _mm512_unpackhi_epi64(i7, t7);\
+  i6 = _mm512_unpacklo_epi64(i6, t7);\
+  /* transpose done */\
+}/**/
+
+/* Matrix Transpose Inverse
+ * input is a 1024-bit state with two rows in one xmm
+ * output is a 1024-bit state with two columns in one xmm
+ * inputs: i0-i7
+ * outputs: (i0, o0, i1, i3, o1, o2, i5, i7)
+ * clobbers: t0-t4
+ */
+#define Matrix_Transpose_INV(i0, i1, i2, i3, i4, i5, i6, i7, o0, o1, o2, t0, t1, t2, t3, t4){\
+  /*  transpose matrix to get output format */\
+  o1 = i0;\
+  i0 = _mm512_unpacklo_epi64(i0, i1);\
+  o1 = _mm512_unpackhi_epi64(o1, i1);\
+  t0 = i2;\
+  i2 = _mm512_unpacklo_epi64(i2, i3);\
+  t0 = _mm512_unpackhi_epi64(t0, i3);\
+  t1 = i4;\
+  i4 = _mm512_unpacklo_epi64(i4, i5);\
+  t1 = _mm512_unpackhi_epi64(t1, i5);\
+  t2 = i6;\
+  o0 = TRANSP_MASK;\
+  i6 = _mm512_unpacklo_epi64(i6, i7);\
+  t2 = _mm512_unpackhi_epi64(t2, i7);\
+  /* load transpose mask into a register, because it will be used 8 times */\
+  i0 = _mm512_shuffle_epi8(i0, o0);\
+  i2 = _mm512_shuffle_epi8(i2, o0);\
+  i4 = _mm512_shuffle_epi8(i4, o0);\
+  i6 = _mm512_shuffle_epi8(i6, o0);\
+  o1 = _mm512_shuffle_epi8(o1, o0);\
+  t0 = _mm512_shuffle_epi8(t0, o0);\
+  t1 = _mm512_shuffle_epi8(t1, o0);\
+  t2 = _mm512_shuffle_epi8(t2, o0);\
+  /* continue with unpack using 4 temp registers */\
+  t3 = i4;\
+  o2 = o1;\
+  o0 = i0;\
+  t4 = t1;\
+  \
+  t3 = _mm512_unpackhi_epi16(t3, i6);\
+  i4 = _mm512_unpacklo_epi16(i4, i6);\
+  o0 = _mm512_unpackhi_epi16(o0, i2);\
+  i0 = _mm512_unpacklo_epi16(i0, i2);\
+  o2 = _mm512_unpackhi_epi16(o2, t0);\
+  o1 = _mm512_unpacklo_epi16(o1, t0);\
+  t4 = _mm512_unpackhi_epi16(t4, t2);\
+  t1 = _mm512_unpacklo_epi16(t1, t2);\
+  /* shuffle with immediate */\
+  i4 = _mm512_shuffle_epi32(i4, 216);\
+  t3 = _mm512_shuffle_epi32(t3, 216);\
+  o1 = _mm512_shuffle_epi32(o1, 216);\
+  o2 = _mm512_shuffle_epi32(o2, 216);\
+  i0 = _mm512_shuffle_epi32(i0, 216);\
+  o0 = _mm512_shuffle_epi32(o0, 216);\
+  t1 = _mm512_shuffle_epi32(t1, 216);\
+  t4 = _mm512_shuffle_epi32(t4, 216);\
+  /* continue with unpack */\
+  i1 = i0;\
+  i3 = o0;\
+  i5 = o1;\
+  i7 = o2;\
+  i0 = _mm512_unpacklo_epi32(i0, i4);\
+  i1 = _mm512_unpackhi_epi32(i1, i4);\
+  o0 = _mm512_unpacklo_epi32(o0, t3);\
+  i3 = _mm512_unpackhi_epi32(i3, t3);\
+  o1 = _mm512_unpacklo_epi32(o1, t1);\
+  i5 = _mm512_unpackhi_epi32(i5, t1);\
+  o2 = _mm512_unpacklo_epi32(o2, t4);\
+  i7 = _mm512_unpackhi_epi32(i7, t4);\
+  /* transpose done */\
+}/**/
+
+
+void INIT_4way( __m512i* chaining )
+{
+  static __m512i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+  static __m512i xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15;
+
+  /* load IV into registers xmm8 - xmm15 */
+  xmm8 = chaining[0];
+  xmm9 = chaining[1];
+  xmm10 = chaining[2];
+  xmm11 = chaining[3];
+  xmm12 = chaining[4];
+  xmm13 = chaining[5];
+  xmm14 = chaining[6];
+  xmm15 = chaining[7];
+
+  /* transform chaining value from column ordering into row ordering */
+  Matrix_Transpose(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+
+  /* store transposed IV */
+  chaining[0] = xmm8;
+  chaining[1] = xmm9;
+  chaining[2] = xmm10;
+  chaining[3] = xmm11;
+  chaining[4] = xmm12;
+  chaining[5] = xmm13;
+  chaining[6] = xmm14;
+  chaining[7] = xmm15;
+}
+
+void TF1024_4way( __m512i* chaining, const __m512i* message )
+{
+  static __m512i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+  static __m512i xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15;
+  static __m512i QTEMP[8];
+  static __m512i TEMP0;
+  static __m512i TEMP1;
+  static __m512i TEMP2;
+
+  /* load message into registers xmm8 - xmm15 (Q = message) */
+  xmm8 = message[0];
+  xmm9 = message[1];
+  xmm10 = message[2];
+  xmm11 = message[3];
+  xmm12 = message[4];
+  xmm13 = message[5];
+  xmm14 = message[6];
+  xmm15 = message[7];
+
+  /* transform message M from column ordering into row ordering */
+  Matrix_Transpose(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
+
+  /* store message M (Q input) for later */
+  QTEMP[0] = xmm8;
+  QTEMP[1] = xmm9;
+  QTEMP[2] = xmm10;
+  QTEMP[3] = xmm11;
+  QTEMP[4] = xmm12;
+  QTEMP[5] = xmm13;
+  QTEMP[6] = xmm14;
+  QTEMP[7] = xmm15;
+
+  /* xor CV to message to get P input */
+  /* result: CV+M in xmm8...xmm15 */
+  xmm8 = _mm512_xor_si512( xmm8,  (chaining[0]) );
+  xmm9 = _mm512_xor_si512( xmm9,  (chaining[1]) );
+  xmm10 = _mm512_xor_si512( xmm10, (chaining[2]) );
+  xmm11 = _mm512_xor_si512( xmm11, (chaining[3]) );
+  xmm12 = _mm512_xor_si512( xmm12, (chaining[4]) );
+  xmm13 = _mm512_xor_si512( xmm13, (chaining[5]) );
+  xmm14 = _mm512_xor_si512( xmm14, (chaining[6]) );
+  xmm15 = _mm512_xor_si512( xmm15, (chaining[7]) );
+
+  /* compute permutation P */
+  /* result: P(CV+M) in xmm8...xmm15 */
+  ROUNDS_P();
+
+  /* xor CV to P output (feed-forward) */
+  /* result: P(CV+M)+CV in xmm8...xmm15 */
+  xmm8 = _mm512_xor_si512( xmm8,  (chaining[0]) );
+  xmm9 = _mm512_xor_si512( xmm9,  (chaining[1]) );
+  xmm10 = _mm512_xor_si512( xmm10, (chaining[2]) );
+  xmm11 = _mm512_xor_si512( xmm11, (chaining[3]) );
+  xmm12 = _mm512_xor_si512( xmm12, (chaining[4]) );
+  xmm13 = _mm512_xor_si512( xmm13, (chaining[5]) );
+  xmm14 = _mm512_xor_si512( xmm14, (chaining[6]) );
+  xmm15 = _mm512_xor_si512( xmm15, (chaining[7]) );
+
+  /* store P(CV+M)+CV */
+  chaining[0] = xmm8;
+  chaining[1] = xmm9;
+  chaining[2] = xmm10;
+  chaining[3] = xmm11;
+  chaining[4] = xmm12;
+  chaining[5] = xmm13;
+  chaining[6] = xmm14;
+  chaining[7] = xmm15;
+
+  /* load message M (Q input) into xmm8-15 */
+  xmm8 = QTEMP[0];
+  xmm9 = QTEMP[1];
+  xmm10 = QTEMP[2];
+  xmm11 = QTEMP[3];
+  xmm12 = QTEMP[4];
+  xmm13 = QTEMP[5];
+  xmm14 = QTEMP[6];
+  xmm15 = QTEMP[7];
+
+  /* compute permutation Q */
+  /* result: Q(M) in xmm8...xmm15 */
+  ROUNDS_Q();
+
+  /* xor Q output */
+  /* result: P(CV+M)+CV+Q(M) in xmm8...xmm15 */
+  xmm8 = _mm512_xor_si512( xmm8,  (chaining[0]) );
+  xmm9 = _mm512_xor_si512( xmm9,  (chaining[1]) );
+  xmm10 = _mm512_xor_si512( xmm10, (chaining[2]) );
+  xmm11 = _mm512_xor_si512( xmm11, (chaining[3]) );
+  xmm12 = _mm512_xor_si512( xmm12, (chaining[4]) );
+  xmm13 = _mm512_xor_si512( xmm13, (chaining[5]) );
+  xmm14 = _mm512_xor_si512( xmm14, (chaining[6]) );
+  xmm15 = _mm512_xor_si512( xmm15, (chaining[7]) );
+
+  /* store CV */
+  chaining[0] = xmm8;
+  chaining[1] = xmm9;
+  chaining[2] = xmm10;
+  chaining[3] = xmm11;
+  chaining[4] = xmm12;
+  chaining[5] = xmm13;
+  chaining[6] = xmm14;
+  chaining[7] = xmm15;
+
+  return;
+}
+
+void OF1024_4way( __m512i* chaining )
+{
+  static __m512i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+  static __m512i xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15;
+  static __m512i TEMP0;
+  static __m512i TEMP1;
+  static __m512i TEMP2;
+
+  /* load CV into registers xmm8 - xmm15 */
+  xmm8 = chaining[0];
+  xmm9 = chaining[1];
+  xmm10 = chaining[2];
+  xmm11 = chaining[3];
+  xmm12 = chaining[4];
+  xmm13 = chaining[5];
+  xmm14 = chaining[6];
+  xmm15 = chaining[7];
+
+  /* compute permutation P */
+  /* result: P(CV) in xmm8...xmm15 */
+  ROUNDS_P();
+
+  /* xor CV to P output (feed-forward) */
+  /* result: P(CV)+CV in xmm8...xmm15 */
+  xmm8 = _mm512_xor_si512( xmm8,  (chaining[0]) );
+  xmm9 = _mm512_xor_si512( xmm9,  (chaining[1]) );
+  xmm10 = _mm512_xor_si512( xmm10, (chaining[2]) );
+  xmm11 = _mm512_xor_si512( xmm11, (chaining[3]) );
+  xmm12 = _mm512_xor_si512( xmm12, (chaining[4]) );
+  xmm13 = _mm512_xor_si512( xmm13, (chaining[5]) );
+  xmm14 = _mm512_xor_si512( xmm14, (chaining[6]) );
+  xmm15 = _mm512_xor_si512( xmm15, (chaining[7]) );
+
+  /* transpose CV back from row ordering to column ordering */
+  /* result: final hash value in xmm0, xmm6, xmm13, xmm15 */
+  Matrix_Transpose_INV(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm4, xmm0, xmm6, xmm1, xmm2, xmm3, xmm5, xmm7);
+
+  /* we only need to return the truncated half of the state */
+  chaining[4] = xmm0;
+  chaining[5] = xmm6;
+  chaining[6] = xmm13;
+  chaining[7] = xmm15;
+
+  return;
+}
+
+#endif  // VAES
+#endif  // GROESTL512_INTR_4WAY_H__

algo/groestl/myrgr-4way.c

@@ -1,14 +1,159 @@
 #include "myrgr-gate.h"
-
-#if defined(MYRGR_4WAY)
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
-
 #include "aes_ni/hash-groestl.h"
 #include "algo/sha/sha-hash-4way.h"
+#if defined(__VAES__)
+  #include "groestl512-hash-4way.h"
+#endif
+
+#if defined(MYRGR_8WAY)
+
+typedef struct {
+#if defined(__VAES__)
+   groestl512_4way_context groestl;
+#else
+   hashState_groestl       groestl;
+#endif
+   sha256_8way_context     sha;
+} myrgr_8way_ctx_holder;
+
+myrgr_8way_ctx_holder myrgr_8way_ctx;
+
+void init_myrgr_8way_ctx()
+{
+#if defined(__VAES__)
+     groestl512_4way_init( &myrgr_8way_ctx.groestl, 64 );
+#else
+     init_groestl( &myrgr_8way_ctx.groestl, 64 );
+#endif
+     sha256_8way_init( &myrgr_8way_ctx.sha );
+}
+
+void myriad_8way_hash( void *output, const void *input )
+{
+     uint32_t vhash[16*8] __attribute__ ((aligned (128)));
+     uint32_t vhashA[20*8] __attribute__ ((aligned (64)));
+     uint32_t vhashB[20*8] __attribute__ ((aligned (64)));
+     myrgr_8way_ctx_holder ctx;
+     memcpy( &ctx, &myrgr_8way_ctx, sizeof(myrgr_8way_ctx) );
+
+#if defined(__VAES__)
+
+     rintrlv_8x64_4x128( vhashA, vhashB, input, 640 );
+     groestl512_4way_update_close( &ctx.groestl, vhashA, vhashA, 640 );
+     groestl512_4way_update_close( &ctx.groestl, vhashB, vhashB, 640 );
+
+     uint32_t hash0[20] __attribute__ ((aligned (64)));
+     uint32_t hash1[20] __attribute__ ((aligned (64)));
+     uint32_t hash2[20] __attribute__ ((aligned (64)));
+     uint32_t hash3[20] __attribute__ ((aligned (64)));
+     uint32_t hash4[20] __attribute__ ((aligned (64)));
+     uint32_t hash5[20] __attribute__ ((aligned (64)));
+     uint32_t hash6[20] __attribute__ ((aligned (64)));
+     uint32_t hash7[20] __attribute__ ((aligned (64)));
+
+//     rintrlv_4x128_8x32( vhash, vhashA, vhashB, 512 );
+     dintrlv_4x128_512( hash0, hash1, hash2, hash3, vhashA );
+     dintrlv_4x128_512( hash4, hash5, hash6, hash7, vhashB );
+     intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5,
+                       hash6, hash7 );
+
+#else
+
+     uint32_t hash0[20] __attribute__ ((aligned (64)));
+     uint32_t hash1[20] __attribute__ ((aligned (64)));
+     uint32_t hash2[20] __attribute__ ((aligned (64)));
+     uint32_t hash3[20] __attribute__ ((aligned (64)));
+     uint32_t hash4[20] __attribute__ ((aligned (64)));
+     uint32_t hash5[20] __attribute__ ((aligned (64)));  
+     uint32_t hash6[20] __attribute__ ((aligned (64)));
+     uint32_t hash7[20] __attribute__ ((aligned (64)));
+
+     dintrlv_8x64( hash0, hash1, hash2, hash3,
+                   hash4, hash5, hash6, hash7, input, 640 );
+
+     update_and_final_groestl( &ctx.groestl, (char*)hash0, (char*)hash0, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+     update_and_final_groestl( &ctx.groestl, (char*)hash1, (char*)hash1, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+     update_and_final_groestl( &ctx.groestl, (char*)hash2, (char*)hash2, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+     update_and_final_groestl( &ctx.groestl, (char*)hash3, (char*)hash3, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+     update_and_final_groestl( &ctx.groestl, (char*)hash4, (char*)hash4, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+     update_and_final_groestl( &ctx.groestl, (char*)hash5, (char*)hash5, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+     update_and_final_groestl( &ctx.groestl, (char*)hash6, (char*)hash6, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+     update_and_final_groestl( &ctx.groestl, (char*)hash7, (char*)hash7, 640 );
+     memcpy( &ctx.groestl, &myrgr_4way_ctx.groestl, sizeof(hashState_groestl) );
+
+     intrlv_8x32( vhash, hash0, hash1, hash2, hash3,
+                         hash4, hash5, hash6, hash7, 512 );
+
+#endif
+
+     sha256_8way_update( &ctx.sha, vhash, 64 );
+     sha256_8way_close( &ctx.sha, output );
+}
+
+int scanhash_myriad_8way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[8*8] __attribute__ ((aligned (128)));
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[7<<3]);
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 8;
+   uint32_t n = first_nonce;
+   uint32_t *noncep = vdata + 64+3;   // 4*16 + 3
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+
+   if ( opt_benchmark )
+      ( (uint32_t*)ptarget )[7] = 0x0000ff;
+
+   mm512_bswap32_intrlv80_4x128( vdata, pdata );
+
+   do
+   {
+      be32enc( noncep,    n   );
+      be32enc( noncep+ 8, n+1 );
+      be32enc( noncep+16, n+2 );
+      be32enc( noncep+24, n+3 );
+      be32enc( noncep+32, n+4 );
+      be32enc( noncep+40, n+5 );
+      be32enc( noncep+48, n+6 );
+      be32enc( noncep+64, n+7 );
+
+      myriad_8way_hash( hash, vdata );
+      pdata[19] = n;
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( hash7[ lane ] <= Htarg )
+      {
+         extr_lane_8x32( lane_hash, hash, lane, 256 );
+         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+         {
+            pdata[19] = n + lane;
+            submit_lane_solution( work, lane_hash, mythr, lane );
+         }
+      }
+      n += 8;
+   } while ( (n < last_nonce) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+#elif defined(MYRGR_4WAY)
 
 typedef struct {
     hashState_groestl       groestl;
@@ -45,7 +190,7 @@ void myriad_4way_hash( void *output, const void *input )
 
      intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
 
-     sha256_4way( &ctx.sha, vhash, 64 );
+     sha256_4way_update( &ctx.sha, vhash, 64 );
      sha256_4way_close( &ctx.sha, output );
 }
 

algo/groestl/myrgr-gate.c

@@ -2,16 +2,22 @@
 
 bool register_myriad_algo( algo_gate_t* gate )
 {
-#if defined (MYRGR_4WAY)
+#if defined (MYRGR_8WAY)
+  init_myrgr_8way_ctx();
+  gate->scanhash  = (void*)&scanhash_myriad_8way;
+  gate->hash      = (void*)&myriad_8way_hash;
+  gate->optimizations = AES_OPT | AVX2_OPT | VAES_OPT;
+#elif defined (MYRGR_4WAY)
   init_myrgr_4way_ctx();
   gate->scanhash  = (void*)&scanhash_myriad_4way;
   gate->hash      = (void*)&myriad_4way_hash;
+  gate->optimizations = AES_OPT | SSE2_OPT | AVX2_OPT | VAES_OPT;
 #else
   init_myrgr_ctx();
   gate->scanhash  = (void*)&scanhash_myriad;
   gate->hash      = (void*)&myriad_hash;
+  gate->optimizations = AES_OPT | SSE2_OPT | AVX2_OPT | SHA_OPT | VAES_OPT;
 #endif
-  gate->optimizations = AES_OPT | AVX2_OPT;
   return true;
 };
 

algo/groestl/myrgr-gate.h

@@ -1,30 +1,35 @@
 #ifndef MYRGR_GATE_H__
-#define MYRGR_GATE_H__
+#define MYRGR_GATE_H__ 1
 
 #include "algo-gate-api.h"
 #include <stdint.h>
 
-#if defined(__AVX2__) && defined(__AES__) && !defined(__SHA__)
-  #define MYRGR_4WAY
+#if defined(__VAES__) && defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define MYRGR_8WAY 1
+#elif defined(__AVX2__) && defined(__AES__) && !defined(__SHA__)
+  #define MYRGR_4WAY 1
 #endif
 
-#if defined(MYRGR_4WAY)
+#if defined(MYRGR_8WAY)
+
+void myriad_8way_hash( void *state, const void *input );
+int scanhash_myriad_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+void init_myrgr_8way_ctx();
+
+#elif defined(MYRGR_4WAY)
 
 void myriad_4way_hash( void *state, const void *input );
-
 int scanhash_myriad_4way( struct work *work, uint32_t max_nonce,
                          uint64_t *hashes_done, struct thr_info *mythr );
-
 void init_myrgr_4way_ctx();
 
-#endif
+#else
 
 void myriad_hash( void *state, const void *input );
-
 int scanhash_myriad( struct work *work, uint32_t max_nonce,
                     uint64_t *hashes_done, struct thr_info *mythr );
-
 void init_myrgr_ctx();
 
 #endif
-
+#endif

algo/hamsi/hamsi-hash-4way.c

@@ -1171,7 +1171,8 @@ void hamsi512_4way_init( hamsi_4way_big_context *sc )
    sc->h[7] = m256_const1_64( 0x6769756d2042656c );
 }
 
-void hamsi512_4way( hamsi_4way_big_context *sc, const void *data, size_t len )
+void hamsi512_4way_update( hamsi_4way_big_context *sc, const void *data,
+      size_t len )
 {
    __m256i *vdata = (__m256i*)data;
 

algo/hamsi/hamsi-hash-4way.h

@@ -62,7 +62,7 @@ typedef hamsi_4way_big_context hamsi512_4way_context;
 void hamsi512_4way_init( hamsi512_4way_context *sc );
 void hamsi512_4way_update( hamsi512_4way_context *sc, const void *data,
       size_t len );
-#define hamsi512_4way hamsi512_4way_update
+//#define hamsi512_4way hamsi512_4way_update
 void hamsi512_4way_close( hamsi512_4way_context *sc, void *dst );
 
 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)

algo/haval/haval-4way-helper.c

@@ -38,7 +38,7 @@
 #define SPH_XCAT_(a, b)   a ## b
 
 static void
-SPH_XCAT(SPH_XCAT(haval, PASSES), _4way)
+SPH_XCAT(SPH_XCAT(haval, PASSES), _4way_update)
 ( haval_4way_context *sc, const void *data, size_t len )
 {
    __m128i *vdata = (__m128i*)data;

algo/haval/haval-hash-4way.c

@@ -479,9 +479,9 @@ haval ## xxx ## _ ## y ## _4way_init(void *cc) \
 } \
  \
 void \
-haval ## xxx ## _ ## y ## _4way (void *cc, const void *data, size_t len) \
+haval ## xxx ## _ ## y ## _4way_update (void *cc, const void *data, size_t len) \
 { \
-	haval ## y ## _4way(cc, data, len); \
+	haval ## y ## _4way_update(cc, data, len); \
 } \
  \
 void \

algo/haval/haval-hash-4way.h

@@ -85,7 +85,7 @@ typedef haval_4way_context haval256_5_4way_context;
 void haval256_5_4way_init( void *cc );
 
 void haval256_5_4way_update( void *cc, const void *data, size_t len );
-#define haval256_5_4way haval256_5_4way_update
+//#define haval256_5_4way haval256_5_4way_update
 
 void haval256_5_4way_close( void *cc, void *dst );
 

algo/heavy/bastion.c

@@ -16,7 +16,6 @@
 #include "algo/echo/sph_echo.h"
 #include "algo/hamsi/sph_hamsi.h"
 #include "algo/luffa/luffa_for_sse2.h"
-#include "algo/skein/sse2/skein.c"
 
 #ifndef NO_AES_NI
   #include "algo/echo/aes_ni/hash_api.h"
@@ -35,12 +34,13 @@ void bastionhash(void *output, const void *input)
 	sph_fugue512_context ctx_fugue;
 	sph_whirlpool_context ctx_whirlpool;
 	sph_shabal512_context ctx_shabal;
-	sph_hamsi512_context ctx_hamsi;
+   sph_hamsi512_context ctx_hamsi;
+	sph_skein512_context ctx_skein;
 
-        unsigned char hashbuf[128] __attribute__ ((aligned (16)));
-        sph_u64 hashctA;
+//        unsigned char hashbuf[128] __attribute__ ((aligned (16)));
+//        sph_u64 hashctA;
 //        sph_u64 hashctB;
-        size_t hashptr;
+//        size_t hashptr;
 
 	HEFTY1(input, 80, hash);
 
@@ -56,10 +56,9 @@ void bastionhash(void *output, const void *input)
 		sph_fugue512(&ctx_fugue, hash, 64);
 		sph_fugue512_close(&ctx_fugue, hash);
 	} else {
-                DECL_SKN;
-                SKN_I;
-                SKN_U;
-                SKN_C;
+   sph_skein512_init( &ctx_skein );
+   sph_skein512( &ctx_skein, hash, 64 );
+   sph_skein512_close( &ctx_skein, hash );
 	}
 
 	sph_whirlpool_init(&ctx_whirlpool);
@@ -95,10 +94,9 @@ void bastionhash(void *output, const void *input)
 	sph_shabal512(&ctx_shabal, hash, 64);
 	sph_shabal512_close(&ctx_shabal, hash);
 
-        DECL_SKN;
-        SKN_I;
-        SKN_U;
-        SKN_C;
+   sph_skein512_init( &ctx_skein );
+   sph_skein512( &ctx_skein, hash, 64 );
+   sph_skein512_close( &ctx_skein, hash );
 
 	if (hash[0] & 0x8)
 	{

algo/jh/jh-hash-4way.h

@@ -103,14 +103,12 @@ typedef jh_4way_context jh512_4way_context;
 void jh256_4way_init( jh_4way_context *sc);
 
 void jh256_4way_update(void *cc, const void *data, size_t len);
-#define jh256_4way jh256_4way_update
 
 void jh256_4way_close(void *cc, void *dst);
 
 void jh512_4way_init( jh_4way_context *sc );
 
 void jh512_4way_update(void *cc, const void *data, size_t len);
-#define jh512_4way jh512_4way_update
 
 void jh512_4way_close(void *cc, void *dst);
 

algo/jh/jha-4way.c

@@ -33,7 +33,7 @@ void jha_hash_4way( void *out, const void *input )
     keccak512_4way_context ctx_keccak;
 
     keccak512_4way_init( &ctx_keccak );
-    keccak512_4way( &ctx_keccak, input, 80 );
+    keccak512_4way_update( &ctx_keccak, input, 80 );
     keccak512_4way_close( &ctx_keccak, vhash );
 
     // Heavy & Light Pair Loop
@@ -58,7 +58,7 @@ void jha_hash_4way( void *out, const void *input )
        intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
 
        skein512_4way_init( &ctx_skein );
-       skein512_4way( &ctx_skein, vhash, 64 );
+       skein512_4way_update( &ctx_skein, vhash, 64 );
        skein512_4way_close( &ctx_skein, vhashB );
 
        for ( int i = 0; i < 8; i++ )
@@ -69,7 +69,7 @@ void jha_hash_4way( void *out, const void *input )
        blake512_4way_close( &ctx_blake, vhashA );
 
        jh512_4way_init( &ctx_jh );
-       jh512_4way( &ctx_jh, vhash, 64 );
+       jh512_4way_update( &ctx_jh, vhash, 64 );
        jh512_4way_close( &ctx_jh, vhashB );
 
        for ( int i = 0; i < 8; i++ )

algo/jh/sse2/jh_sse2_opt32.h

@@ -1,465 +0,0 @@
-/* This program gives the optimized SSE2 bitslice implementation of JH for 32-bit platform (with 8 128-bit XMM registers).
-
-   -----------------------------------------
-   Performance:
-
-   Microprocessor: Intel CORE 2 processor (Core 2 Duo Mobile T6600 2.2GHz)
-   Operating System: 32-bit Ubuntu 10.04 (Linux kernel 2.6.32-22-generic)
-   Speed for long message:
-   1) 23.6 cycles/byte   compiler: Intel C++ Compiler 11.1   compilation option: icc -O2
-   2) 24.1 cycles/byte   compiler: gcc 4.4.3                 compilation option: gcc -msse2 -O3
-
-   ------------------------------------------
-   Comparing with the original JH sse2 code for 32-bit platform, the following modifications are made:
-   a) The Sbox implementation follows exactly the description given in the document
-   b) Data alignment definition is improved so that the code can be compiled by GCC, Intel C++ compiler and Microsoft Visual C compiler
-   c) Using y0,y1,..,y7 variables in Function F8 for performance improvement (local variable in function F8 so that compiler can optimize the code easily)
-   d) Removed a number of intermediate variables from the program (so as to given compiler more freedom to optimize the code)
-   e) Using "for" loop to implement 42 rounds (with 7 rounds in each loop), so as to reduce the code size.
-   ------------------------------------------
-
-   Last Modified: January 16, 2011
-*/
-
-
-
-#include <emmintrin.h>
-#include <string.h>
-
-typedef unsigned int  uint32;
-typedef __m128i  word128;     /*word128 defines a 128-bit SSE2 word*/
-
-typedef unsigned char BitSequence;
-typedef unsigned long long DataLength;
-typedef enum {SUCCESS = 0, FAIL = 1, BAD_HASHLEN = 2} HashReturn;
-
-/*define data alignment for different C compilers*/
-#if defined(__GNUC__)
-      #define DATA_ALIGN16(x) x __attribute__ ((aligned(16)))
-#else
-      #define DATA_ALIGN16(x) __declspec(align(16)) x
-#endif
-
-typedef struct {
-      int hashbitlen;	                  /*the message digest size*/
-      unsigned long long databitlen;      /*the message size in bits*/
-      unsigned long long datasize_in_buffer;           /*the size of the message remained in buffer; assumed to be multiple of 8bits except for the last partial block at the end of the message*/
-      word128  x0,x1,x2,x3,x4,x5,x6,x7;   /*1024-bit state;*/
-      unsigned char buffer[64];           /*512-bit message block;*/
-} hashState;
-
-/*The initial hash value H(0)*/
-DATA_ALIGN16(const unsigned char JH224_H0[128])={0x2d,0xfe,0xdd,0x62,0xf9,0x9a,0x98,0xac,0xae,0x7c,0xac,0xd6,0x19,0xd6,0x34,0xe7,0xa4,0x83,0x10,0x5,0xbc,0x30,0x12,0x16,0xb8,0x60,0x38,0xc6,0xc9,0x66,0x14,0x94,0x66,0xd9,0x89,0x9f,0x25,0x80,0x70,0x6f,0xce,0x9e,0xa3,0x1b,0x1d,0x9b,0x1a,0xdc,0x11,0xe8,0x32,0x5f,0x7b,0x36,0x6e,0x10,0xf9,0x94,0x85,0x7f,0x2,0xfa,0x6,0xc1,0x1b,0x4f,0x1b,0x5c,0xd8,0xc8,0x40,0xb3,0x97,0xf6,0xa1,0x7f,0x6e,0x73,0x80,0x99,0xdc,0xdf,0x93,0xa5,0xad,0xea,0xa3,0xd3,0xa4,0x31,0xe8,0xde,0xc9,0x53,0x9a,0x68,0x22,0xb4,0xa9,0x8a,0xec,0x86,0xa1,0xe4,0xd5,0x74,0xac,0x95,0x9c,0xe5,0x6c,0xf0,0x15,0x96,0xd,0xea,0xb5,0xab,0x2b,0xbf,0x96,0x11,0xdc,0xf0,0xdd,0x64,0xea,0x6e};
-DATA_ALIGN16(const unsigned char JH256_H0[128])={0xeb,0x98,0xa3,0x41,0x2c,0x20,0xd3,0xeb,0x92,0xcd,0xbe,0x7b,0x9c,0xb2,0x45,0xc1,0x1c,0x93,0x51,0x91,0x60,0xd4,0xc7,0xfa,0x26,0x0,0x82,0xd6,0x7e,0x50,0x8a,0x3,0xa4,0x23,0x9e,0x26,0x77,0x26,0xb9,0x45,0xe0,0xfb,0x1a,0x48,0xd4,0x1a,0x94,0x77,0xcd,0xb5,0xab,0x26,0x2,0x6b,0x17,0x7a,0x56,0xf0,0x24,0x42,0xf,0xff,0x2f,0xa8,0x71,0xa3,0x96,0x89,0x7f,0x2e,0x4d,0x75,0x1d,0x14,0x49,0x8,0xf7,0x7d,0xe2,0x62,0x27,0x76,0x95,0xf7,0x76,0x24,0x8f,0x94,0x87,0xd5,0xb6,0x57,0x47,0x80,0x29,0x6c,0x5c,0x5e,0x27,0x2d,0xac,0x8e,0xd,0x6c,0x51,0x84,0x50,0xc6,0x57,0x5,0x7a,0xf,0x7b,0xe4,0xd3,0x67,0x70,0x24,0x12,0xea,0x89,0xe3,0xab,0x13,0xd3,0x1c,0xd7,0x69};
-DATA_ALIGN16(const unsigned char JH384_H0[128])={0x48,0x1e,0x3b,0xc6,0xd8,0x13,0x39,0x8a,0x6d,0x3b,0x5e,0x89,0x4a,0xde,0x87,0x9b,0x63,0xfa,0xea,0x68,0xd4,0x80,0xad,0x2e,0x33,0x2c,0xcb,0x21,0x48,0xf,0x82,0x67,0x98,0xae,0xc8,0x4d,0x90,0x82,0xb9,0x28,0xd4,0x55,0xea,0x30,0x41,0x11,0x42,0x49,0x36,0xf5,0x55,0xb2,0x92,0x48,0x47,0xec,0xc7,0x25,0xa,0x93,0xba,0xf4,0x3c,0xe1,0x56,0x9b,0x7f,0x8a,0x27,0xdb,0x45,0x4c,0x9e,0xfc,0xbd,0x49,0x63,0x97,0xaf,0xe,0x58,0x9f,0xc2,0x7d,0x26,0xaa,0x80,0xcd,0x80,0xc0,0x8b,0x8c,0x9d,0xeb,0x2e,0xda,0x8a,0x79,0x81,0xe8,0xf8,0xd5,0x37,0x3a,0xf4,0x39,0x67,0xad,0xdd,0xd1,0x7a,0x71,0xa9,0xb4,0xd3,0xbd,0xa4,0x75,0xd3,0x94,0x97,0x6c,0x3f,0xba,0x98,0x42,0x73,0x7f};
-DATA_ALIGN16(const unsigned char JH512_H0[128])={0x6f,0xd1,0x4b,0x96,0x3e,0x0,0xaa,0x17,0x63,0x6a,0x2e,0x5,0x7a,0x15,0xd5,0x43,0x8a,0x22,0x5e,0x8d,0xc,0x97,0xef,0xb,0xe9,0x34,0x12,0x59,0xf2,0xb3,0xc3,0x61,0x89,0x1d,0xa0,0xc1,0x53,0x6f,0x80,0x1e,0x2a,0xa9,0x5,0x6b,0xea,0x2b,0x6d,0x80,0x58,0x8e,0xcc,0xdb,0x20,0x75,0xba,0xa6,0xa9,0xf,0x3a,0x76,0xba,0xf8,0x3b,0xf7,0x1,0x69,0xe6,0x5,0x41,0xe3,0x4a,0x69,0x46,0xb5,0x8a,0x8e,0x2e,0x6f,0xe6,0x5a,0x10,0x47,0xa7,0xd0,0xc1,0x84,0x3c,0x24,0x3b,0x6e,0x71,0xb1,0x2d,0x5a,0xc1,0x99,0xcf,0x57,0xf6,0xec,0x9d,0xb1,0xf8,0x56,0xa7,0x6,0x88,0x7c,0x57,0x16,0xb1,0x56,0xe3,0xc2,0xfc,0xdf,0xe6,0x85,0x17,0xfb,0x54,0x5a,0x46,0x78,0xcc,0x8c,0xdd,0x4b};
-
-/*42 round constants, each round constant is 32-byte (256-bit)*/
-DATA_ALIGN16(const unsigned char E8_bitslice_roundconstant[42][32])={
-{0x72,0xd5,0xde,0xa2,0xdf,0x15,0xf8,0x67,0x7b,0x84,0x15,0xa,0xb7,0x23,0x15,0x57,0x81,0xab,0xd6,0x90,0x4d,0x5a,0x87,0xf6,0x4e,0x9f,0x4f,0xc5,0xc3,0xd1,0x2b,0x40},
-{0xea,0x98,0x3a,0xe0,0x5c,0x45,0xfa,0x9c,0x3,0xc5,0xd2,0x99,0x66,0xb2,0x99,0x9a,0x66,0x2,0x96,0xb4,0xf2,0xbb,0x53,0x8a,0xb5,0x56,0x14,0x1a,0x88,0xdb,0xa2,0x31},
-{0x3,0xa3,0x5a,0x5c,0x9a,0x19,0xe,0xdb,0x40,0x3f,0xb2,0xa,0x87,0xc1,0x44,0x10,0x1c,0x5,0x19,0x80,0x84,0x9e,0x95,0x1d,0x6f,0x33,0xeb,0xad,0x5e,0xe7,0xcd,0xdc},
-{0x10,0xba,0x13,0x92,0x2,0xbf,0x6b,0x41,0xdc,0x78,0x65,0x15,0xf7,0xbb,0x27,0xd0,0xa,0x2c,0x81,0x39,0x37,0xaa,0x78,0x50,0x3f,0x1a,0xbf,0xd2,0x41,0x0,0x91,0xd3},
-{0x42,0x2d,0x5a,0xd,0xf6,0xcc,0x7e,0x90,0xdd,0x62,0x9f,0x9c,0x92,0xc0,0x97,0xce,0x18,0x5c,0xa7,0xb,0xc7,0x2b,0x44,0xac,0xd1,0xdf,0x65,0xd6,0x63,0xc6,0xfc,0x23},
-{0x97,0x6e,0x6c,0x3,0x9e,0xe0,0xb8,0x1a,0x21,0x5,0x45,0x7e,0x44,0x6c,0xec,0xa8,0xee,0xf1,0x3,0xbb,0x5d,0x8e,0x61,0xfa,0xfd,0x96,0x97,0xb2,0x94,0x83,0x81,0x97},
-{0x4a,0x8e,0x85,0x37,0xdb,0x3,0x30,0x2f,0x2a,0x67,0x8d,0x2d,0xfb,0x9f,0x6a,0x95,0x8a,0xfe,0x73,0x81,0xf8,0xb8,0x69,0x6c,0x8a,0xc7,0x72,0x46,0xc0,0x7f,0x42,0x14},
-{0xc5,0xf4,0x15,0x8f,0xbd,0xc7,0x5e,0xc4,0x75,0x44,0x6f,0xa7,0x8f,0x11,0xbb,0x80,0x52,0xde,0x75,0xb7,0xae,0xe4,0x88,0xbc,0x82,0xb8,0x0,0x1e,0x98,0xa6,0xa3,0xf4},
-{0x8e,0xf4,0x8f,0x33,0xa9,0xa3,0x63,0x15,0xaa,0x5f,0x56,0x24,0xd5,0xb7,0xf9,0x89,0xb6,0xf1,0xed,0x20,0x7c,0x5a,0xe0,0xfd,0x36,0xca,0xe9,0x5a,0x6,0x42,0x2c,0x36},
-{0xce,0x29,0x35,0x43,0x4e,0xfe,0x98,0x3d,0x53,0x3a,0xf9,0x74,0x73,0x9a,0x4b,0xa7,0xd0,0xf5,0x1f,0x59,0x6f,0x4e,0x81,0x86,0xe,0x9d,0xad,0x81,0xaf,0xd8,0x5a,0x9f},
-{0xa7,0x5,0x6,0x67,0xee,0x34,0x62,0x6a,0x8b,0xb,0x28,0xbe,0x6e,0xb9,0x17,0x27,0x47,0x74,0x7,0x26,0xc6,0x80,0x10,0x3f,0xe0,0xa0,0x7e,0x6f,0xc6,0x7e,0x48,0x7b},
-{0xd,0x55,0xa,0xa5,0x4a,0xf8,0xa4,0xc0,0x91,0xe3,0xe7,0x9f,0x97,0x8e,0xf1,0x9e,0x86,0x76,0x72,0x81,0x50,0x60,0x8d,0xd4,0x7e,0x9e,0x5a,0x41,0xf3,0xe5,0xb0,0x62},
-{0xfc,0x9f,0x1f,0xec,0x40,0x54,0x20,0x7a,0xe3,0xe4,0x1a,0x0,0xce,0xf4,0xc9,0x84,0x4f,0xd7,0x94,0xf5,0x9d,0xfa,0x95,0xd8,0x55,0x2e,0x7e,0x11,0x24,0xc3,0x54,0xa5},
-{0x5b,0xdf,0x72,0x28,0xbd,0xfe,0x6e,0x28,0x78,0xf5,0x7f,0xe2,0xf,0xa5,0xc4,0xb2,0x5,0x89,0x7c,0xef,0xee,0x49,0xd3,0x2e,0x44,0x7e,0x93,0x85,0xeb,0x28,0x59,0x7f},
-{0x70,0x5f,0x69,0x37,0xb3,0x24,0x31,0x4a,0x5e,0x86,0x28,0xf1,0x1d,0xd6,0xe4,0x65,0xc7,0x1b,0x77,0x4,0x51,0xb9,0x20,0xe7,0x74,0xfe,0x43,0xe8,0x23,0xd4,0x87,0x8a},
-{0x7d,0x29,0xe8,0xa3,0x92,0x76,0x94,0xf2,0xdd,0xcb,0x7a,0x9,0x9b,0x30,0xd9,0xc1,0x1d,0x1b,0x30,0xfb,0x5b,0xdc,0x1b,0xe0,0xda,0x24,0x49,0x4f,0xf2,0x9c,0x82,0xbf},
-{0xa4,0xe7,0xba,0x31,0xb4,0x70,0xbf,0xff,0xd,0x32,0x44,0x5,0xde,0xf8,0xbc,0x48,0x3b,0xae,0xfc,0x32,0x53,0xbb,0xd3,0x39,0x45,0x9f,0xc3,0xc1,0xe0,0x29,0x8b,0xa0},
-{0xe5,0xc9,0x5,0xfd,0xf7,0xae,0x9,0xf,0x94,0x70,0x34,0x12,0x42,0x90,0xf1,0x34,0xa2,0x71,0xb7,0x1,0xe3,0x44,0xed,0x95,0xe9,0x3b,0x8e,0x36,0x4f,0x2f,0x98,0x4a},
-{0x88,0x40,0x1d,0x63,0xa0,0x6c,0xf6,0x15,0x47,0xc1,0x44,0x4b,0x87,0x52,0xaf,0xff,0x7e,0xbb,0x4a,0xf1,0xe2,0xa,0xc6,0x30,0x46,0x70,0xb6,0xc5,0xcc,0x6e,0x8c,0xe6},
-{0xa4,0xd5,0xa4,0x56,0xbd,0x4f,0xca,0x0,0xda,0x9d,0x84,0x4b,0xc8,0x3e,0x18,0xae,0x73,0x57,0xce,0x45,0x30,0x64,0xd1,0xad,0xe8,0xa6,0xce,0x68,0x14,0x5c,0x25,0x67},
-{0xa3,0xda,0x8c,0xf2,0xcb,0xe,0xe1,0x16,0x33,0xe9,0x6,0x58,0x9a,0x94,0x99,0x9a,0x1f,0x60,0xb2,0x20,0xc2,0x6f,0x84,0x7b,0xd1,0xce,0xac,0x7f,0xa0,0xd1,0x85,0x18},
-{0x32,0x59,0x5b,0xa1,0x8d,0xdd,0x19,0xd3,0x50,0x9a,0x1c,0xc0,0xaa,0xa5,0xb4,0x46,0x9f,0x3d,0x63,0x67,0xe4,0x4,0x6b,0xba,0xf6,0xca,0x19,0xab,0xb,0x56,0xee,0x7e},
-{0x1f,0xb1,0x79,0xea,0xa9,0x28,0x21,0x74,0xe9,0xbd,0xf7,0x35,0x3b,0x36,0x51,0xee,0x1d,0x57,0xac,0x5a,0x75,0x50,0xd3,0x76,0x3a,0x46,0xc2,0xfe,0xa3,0x7d,0x70,0x1},
-{0xf7,0x35,0xc1,0xaf,0x98,0xa4,0xd8,0x42,0x78,0xed,0xec,0x20,0x9e,0x6b,0x67,0x79,0x41,0x83,0x63,0x15,0xea,0x3a,0xdb,0xa8,0xfa,0xc3,0x3b,0x4d,0x32,0x83,0x2c,0x83},
-{0xa7,0x40,0x3b,0x1f,0x1c,0x27,0x47,0xf3,0x59,0x40,0xf0,0x34,0xb7,0x2d,0x76,0x9a,0xe7,0x3e,0x4e,0x6c,0xd2,0x21,0x4f,0xfd,0xb8,0xfd,0x8d,0x39,0xdc,0x57,0x59,0xef},
-{0x8d,0x9b,0xc,0x49,0x2b,0x49,0xeb,0xda,0x5b,0xa2,0xd7,0x49,0x68,0xf3,0x70,0xd,0x7d,0x3b,0xae,0xd0,0x7a,0x8d,0x55,0x84,0xf5,0xa5,0xe9,0xf0,0xe4,0xf8,0x8e,0x65},
-{0xa0,0xb8,0xa2,0xf4,0x36,0x10,0x3b,0x53,0xc,0xa8,0x7,0x9e,0x75,0x3e,0xec,0x5a,0x91,0x68,0x94,0x92,0x56,0xe8,0x88,0x4f,0x5b,0xb0,0x5c,0x55,0xf8,0xba,0xbc,0x4c},
-{0xe3,0xbb,0x3b,0x99,0xf3,0x87,0x94,0x7b,0x75,0xda,0xf4,0xd6,0x72,0x6b,0x1c,0x5d,0x64,0xae,0xac,0x28,0xdc,0x34,0xb3,0x6d,0x6c,0x34,0xa5,0x50,0xb8,0x28,0xdb,0x71},
-{0xf8,0x61,0xe2,0xf2,0x10,0x8d,0x51,0x2a,0xe3,0xdb,0x64,0x33,0x59,0xdd,0x75,0xfc,0x1c,0xac,0xbc,0xf1,0x43,0xce,0x3f,0xa2,0x67,0xbb,0xd1,0x3c,0x2,0xe8,0x43,0xb0},
-{0x33,0xa,0x5b,0xca,0x88,0x29,0xa1,0x75,0x7f,0x34,0x19,0x4d,0xb4,0x16,0x53,0x5c,0x92,0x3b,0x94,0xc3,0xe,0x79,0x4d,0x1e,0x79,0x74,0x75,0xd7,0xb6,0xee,0xaf,0x3f},
-{0xea,0xa8,0xd4,0xf7,0xbe,0x1a,0x39,0x21,0x5c,0xf4,0x7e,0x9,0x4c,0x23,0x27,0x51,0x26,0xa3,0x24,0x53,0xba,0x32,0x3c,0xd2,0x44,0xa3,0x17,0x4a,0x6d,0xa6,0xd5,0xad},
-{0xb5,0x1d,0x3e,0xa6,0xaf,0xf2,0xc9,0x8,0x83,0x59,0x3d,0x98,0x91,0x6b,0x3c,0x56,0x4c,0xf8,0x7c,0xa1,0x72,0x86,0x60,0x4d,0x46,0xe2,0x3e,0xcc,0x8,0x6e,0xc7,0xf6},
-{0x2f,0x98,0x33,0xb3,0xb1,0xbc,0x76,0x5e,0x2b,0xd6,0x66,0xa5,0xef,0xc4,0xe6,0x2a,0x6,0xf4,0xb6,0xe8,0xbe,0xc1,0xd4,0x36,0x74,0xee,0x82,0x15,0xbc,0xef,0x21,0x63},
-{0xfd,0xc1,0x4e,0xd,0xf4,0x53,0xc9,0x69,0xa7,0x7d,0x5a,0xc4,0x6,0x58,0x58,0x26,0x7e,0xc1,0x14,0x16,0x6,0xe0,0xfa,0x16,0x7e,0x90,0xaf,0x3d,0x28,0x63,0x9d,0x3f},
-{0xd2,0xc9,0xf2,0xe3,0x0,0x9b,0xd2,0xc,0x5f,0xaa,0xce,0x30,0xb7,0xd4,0xc,0x30,0x74,0x2a,0x51,0x16,0xf2,0xe0,0x32,0x98,0xd,0xeb,0x30,0xd8,0xe3,0xce,0xf8,0x9a},
-{0x4b,0xc5,0x9e,0x7b,0xb5,0xf1,0x79,0x92,0xff,0x51,0xe6,0x6e,0x4,0x86,0x68,0xd3,0x9b,0x23,0x4d,0x57,0xe6,0x96,0x67,0x31,0xcc,0xe6,0xa6,0xf3,0x17,0xa,0x75,0x5},
-{0xb1,0x76,0x81,0xd9,0x13,0x32,0x6c,0xce,0x3c,0x17,0x52,0x84,0xf8,0x5,0xa2,0x62,0xf4,0x2b,0xcb,0xb3,0x78,0x47,0x15,0x47,0xff,0x46,0x54,0x82,0x23,0x93,0x6a,0x48},
-{0x38,0xdf,0x58,0x7,0x4e,0x5e,0x65,0x65,0xf2,0xfc,0x7c,0x89,0xfc,0x86,0x50,0x8e,0x31,0x70,0x2e,0x44,0xd0,0xb,0xca,0x86,0xf0,0x40,0x9,0xa2,0x30,0x78,0x47,0x4e},
-{0x65,0xa0,0xee,0x39,0xd1,0xf7,0x38,0x83,0xf7,0x5e,0xe9,0x37,0xe4,0x2c,0x3a,0xbd,0x21,0x97,0xb2,0x26,0x1,0x13,0xf8,0x6f,0xa3,0x44,0xed,0xd1,0xef,0x9f,0xde,0xe7},
-{0x8b,0xa0,0xdf,0x15,0x76,0x25,0x92,0xd9,0x3c,0x85,0xf7,0xf6,0x12,0xdc,0x42,0xbe,0xd8,0xa7,0xec,0x7c,0xab,0x27,0xb0,0x7e,0x53,0x8d,0x7d,0xda,0xaa,0x3e,0xa8,0xde},
-{0xaa,0x25,0xce,0x93,0xbd,0x2,0x69,0xd8,0x5a,0xf6,0x43,0xfd,0x1a,0x73,0x8,0xf9,0xc0,0x5f,0xef,0xda,0x17,0x4a,0x19,0xa5,0x97,0x4d,0x66,0x33,0x4c,0xfd,0x21,0x6a},
-{0x35,0xb4,0x98,0x31,0xdb,0x41,0x15,0x70,0xea,0x1e,0xf,0xbb,0xed,0xcd,0x54,0x9b,0x9a,0xd0,0x63,0xa1,0x51,0x97,0x40,0x72,0xf6,0x75,0x9d,0xbf,0x91,0x47,0x6f,0xe2}};
-
-
-void F8(hashState *state);  /* the compression function F8 */
-
-/*The API functions*/
-HashReturn Init(hashState *state, int hashbitlen);
-HashReturn Update(hashState *state, const BitSequence *data, DataLength databitlen);
-HashReturn Final(hashState *state, BitSequence *hashval);
-HashReturn Hash(int hashbitlen, const BitSequence *data,DataLength databitlen, BitSequence *hashval);
-
-/*The following defines operations on 128-bit word(s)*/
-#define CONSTANT(b)   _mm_set1_epi8((b))          /*set each byte in a 128-bit register to be "b"*/
-
-#define XOR(x,y)      _mm_xor_si128((x),(y))      /*XOR(x,y) = x ^ y, where x and y are two 128-bit word*/
-#define AND(x,y)      _mm_and_si128((x),(y))      /*AND(x,y) = x & y, where x and y are two 128-bit word*/
-#define ANDNOT(x,y)   _mm_andnot_si128((x),(y))   /*ANDNOT(x,y) = (!x) & y, where x and y are two 128-bit word*/
-#define OR(x,y)       _mm_or_si128((x),(y))       /*OR(x,y)  = x | y, where x and y are two 128-bit word*/
-
-#define SHR1(x)       _mm_srli_epi16((x), 1)      /*SHR1(x)  = x >> 1, where x is a 128 bit word*/
-#define SHR2(x)       _mm_srli_epi16((x), 2)      /*SHR2(x)  = x >> 2, where x is a 128 bit word*/
-#define SHR4(x)       _mm_srli_epi16((x), 4)      /*SHR4(x)  = x >> 4, where x is a 128 bit word*/
-#define SHR8(x)       _mm_slli_epi16((x), 8)      /*SHR8(x)  = x >> 8, where x is a 128 bit word*/
-#define SHR16(x)      _mm_slli_epi32((x), 16)     /*SHR16(x) = x >> 16, where x is a 128 bit word*/
-#define SHR32(x)      _mm_slli_epi64((x), 32)     /*SHR32(x) = x >> 32, where x is a 128 bit word*/
-#define SHR64(x)      _mm_slli_si128((x), 8)      /*SHR64(x) = x >> 64, where x is a 128 bit word*/
-
-#define SHL1(x)       _mm_slli_epi16((x), 1)      /*SHL1(x)  = x << 1, where x is a 128 bit word*/
-#define SHL2(x)       _mm_slli_epi16((x), 2)	  /*SHL2(x)  = x << 2, where x is a 128 bit word*/
-#define SHL4(x)       _mm_slli_epi16((x), 4)	  /*SHL4(x)  = x << 4, where x is a 128 bit word*/
-#define SHL8(x)       _mm_srli_epi16((x), 8)	  /*SHL8(x)  = x << 8, where x is a 128 bit word*/
-#define SHL16(x)      _mm_srli_epi32((x), 16)	  /*SHL16(x) = x << 16, where x is a 128 bit word*/
-#define SHL32(x)      _mm_srli_epi64((x), 32)	  /*SHL32(x) = x << 32, where x is a 128 bit word*/
-#define SHL64(x)      _mm_srli_si128((x), 8)	  /*SHL64(x) = x << 64, where x is a 128 bit word*/
-
-#define SWAP1(x)      OR(SHR1(AND((x),CONSTANT(0xaa))),SHL1(AND((x),CONSTANT(0x55))))  /*swapping bit 2i with bit 2i+1 of the 128-bit x */
-#define SWAP2(x)      OR(SHR2(AND((x),CONSTANT(0xcc))),SHL2(AND((x),CONSTANT(0x33))))  /*swapping bit 4i||4i+1 with bit 4i+2||4i+3 of the 128-bit x */
-#define SWAP4(x)      OR(SHR4(AND((x),CONSTANT(0xf0))),SHL4(AND((x),CONSTANT(0xf))))   /*swapping bits 8i||8i+1||8i+2||8i+3 with bits 8i+4||8i+5||8i+6||8i+7 of the 128-bit x */
-#define SWAP8(x)      OR(SHR8(x),SHL8(x))                          /*swapping bits 16i||16i+1||...||16i+7 with bits 16i+8||16i+9||...||16i+15 of the 128-bit x */
-#define SWAP16(x)     OR(SHR16(x),SHL16(x))                        /*swapping bits 32i||32i+1||...||32i+15 with bits 32i+16||32i+17||...||32i+31 of the 128-bit x */
-#define SWAP32(x)     _mm_shuffle_epi32((x),_MM_SHUFFLE(2,3,0,1))  /*swapping bits 64i||64i+1||...||64i+31 with bits 64i+32||64i+33||...||64i+63 of the 128-bit x*/
-#define SWAP64(x)     _mm_shuffle_epi32((x),_MM_SHUFFLE(1,0,3,2))  /*swapping bits 128i||128i+1||...||128i+63 with bits 128i+64||128i+65||...||128i+127 of the 128-bit x*/
-
-#define STORE(x,p)    _mm_store_si128((__m128i *)(p), (x))         /*store the 128-bit word x into memeory address p, where p is the multile of 16 bytes*/
-#define LOAD(p)       _mm_load_si128((__m128i *)(p))               /*load 16 bytes from the memory address p, return a 128-bit word, where p is the multile of 16 bytes*/
-
-/*The MDS code*/
-#define L(m0,m1,m2,m3,m4,m5,m6,m7)     \
-      (m4) = XOR((m4),(m1));           \
-      (m5) = XOR((m5),(m2));           \
-      (m6) = XOR(XOR((m6),(m3)),(m0)); \
-      (m7) = XOR((m7),(m0));           \
-      (m0) = XOR((m0),(m5));           \
-      (m1) = XOR((m1),(m6));           \
-      (m2) = XOR(XOR((m2),(m7)),(m4)); \
-      (m3) = XOR((m3),(m4));
-
-/*The Sbox, it implements S0 and S1, selected by a constant bit*/
-#define S(m0,m1,m2,m3,c0)              \
-      m3 = XOR(m3,CONSTANT(0xff));     \
-      m0 = XOR(m0,ANDNOT(m2,c0));      \
-      temp0 = XOR(c0,AND(m0,m1));      \
-      m0 = XOR(m0,AND(m3,m2));         \
-      m3 = XOR(m3,ANDNOT(m1,m2));      \
-      m1 = XOR(m1,AND(m0,m2));         \
-      m2 = XOR(m2,ANDNOT(m3,m0));      \
-      m0 = XOR(m0,OR(m1,m3));          \
-      m3 = XOR(m3,AND(m1,m2));         \
-      m2 = XOR(m2,temp0);              \
-      m1 = XOR(m1,AND(temp0,m0));
-
-/* The linear transform of the (7i+0)th round*/
-#define lineartransform_R00(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                                          \
-      L(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bit 2i with bit 2i+1 for m4,m5,m6 and m7 */ \
-      m4 = SWAP1(m4); m5 = SWAP1(m5); m6 = SWAP1(m6); m7 = SWAP1(m7);
-
-/* The linear transform of the (7i+1)th round*/
-#define lineartransform_R01(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                                          \
-      L(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bit 4i||4i+1 with bit 4i+2||4i+3 for m4,m5,m6 and m7 */  \
-      m4 = SWAP2(m4); m5 = SWAP2(m5); m6 = SWAP2(m6); m7 = SWAP2(m7);
-
-/* The linear transform of the (7i+2)th round*/
-#define lineartransform_R02(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                        \
-      L(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bits 8i||8i+1||8i+2||8i+3 with bits 8i+4||8i+5||8i+6||8i+7 for m4,m5,m6 and m7*/      \
-      m4 = SWAP4(m4); m5 = SWAP4(m5); m6 = SWAP4(m6); m7 = SWAP4(m7);
-
-/* The linear transform of the (7i+3)th round*/
-#define lineartransform_R03(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                        \
-      L(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bits 16i||16i+1||...||16i+7 with bits 16i+8||16i+9||...||16i+15 for m4,m5,m6 and m7*/  \
-      m4 = SWAP8(m4); m5 = SWAP8(m5); m6 = SWAP8(m6); m7 = SWAP8(m7);
-
-/* The linear transform of the (7i+4)th round*/
-#define lineartransform_R04(m0,m1,m2,m3,m4,m5,m6,m7)  \
-      /*MDS layer*/                 \
-      L(m0,m1,m2,m3,m4,m5,m6,m7);                     \
-      /*swapping bits 32i||32i+1||...||32i+15 with bits 32i+16||32i+17||...||32i+31 for m0,m1,m2 and m3*/  \
-      m4 = SWAP16(m4); m5 = SWAP16(m5); m6 = SWAP16(m6); m7 = SWAP16(m7);
-
-/* The linear transform of the (7i+5)th round -- faster*/
-#define lineartransform_R05(m0,m1,m2,m3,m4,m5,m6,m7)  \
-      /*MDS layer*/                 \
-      L(m0,m1,m2,m3,m4,m5,m6,m7);                     \
-      /*swapping bits 64i||64i+1||...||64i+31 with bits 64i+32||64i+33||...||64i+63 for m0,m1,m2 and m3*/  \
-      m4 = SWAP32(m4); m5 = SWAP32(m5); m6 = SWAP32(m6); m7 = SWAP32(m7);
-
-/* The linear transform of the (7i+6)th round -- faster*/
-#define lineartransform_R06(m0,m1,m2,m3,m4,m5,m6,m7)  \
-      /*MDS layer*/                 \
-      L(m0,m1,m2,m3,m4,m5,m6,m7);                     \
-      /*swapping bits 128i||128i+1||...||128i+63 with bits 128i+64||128i+65||...||128i+127 for m0,m1,m2 and m3*/  \
-      m4 = SWAP64(m4); m5 = SWAP64(m5); m6 = SWAP64(m6); m7 = SWAP64(m7);
-
-/*the round function of E8 */
-#define round_function(nn,r)                                  \
-      S(y0,y2,y4,y6, LOAD(E8_bitslice_roundconstant[r]) );    \
-      S(y1,y3,y5,y7, LOAD(E8_bitslice_roundconstant[r]+16) ); \
-      lineartransform_R##nn(y0,y2,y4,y6,y1,y3,y5,y7);
-
-/*the compression function F8 */
-void F8(hashState *state)
-{
-      uint32 i;
-      word128  y0,y1,y2,y3,y4,y5,y6,y7;
-      word128  temp0;
-
-      y0 = state->x0;
-      y1 = state->x1;
-      y2 = state->x2;
-      y3 = state->x3;
-      y4 = state->x4;
-      y5 = state->x5;
-      y6 = state->x6;
-      y7 = state->x7;
-
-      /*xor the 512-bit message with the fist half of the 1024-bit hash state*/
-
-      y0 = XOR(y0, LOAD(state->buffer));
-      y1 = XOR(y1, LOAD(state->buffer+16));
-      y2 = XOR(y2, LOAD(state->buffer+32));
-      y3 = XOR(y3, LOAD(state->buffer+48));
-
-      /*perform 42 rounds*/
-      for (i = 0; i < 42; i = i+7) {
-            round_function(00,i);
-            round_function(01,i+1);
-            round_function(02,i+2);
-            round_function(03,i+3);
-            round_function(04,i+4);
-            round_function(05,i+5);
-            round_function(06,i+6);
-      }
-
-      /*xor the 512-bit message with the second half of the 1024-bit hash state*/
-
-      y4 = XOR(y4, LOAD(state->buffer));
-      y5 = XOR(y5, LOAD(state->buffer+16));
-      y6 = XOR(y6, LOAD(state->buffer+32));
-      y7 = XOR(y7, LOAD(state->buffer+48));
-
-      state->x0 = y0;
-      state->x1 = y1;
-      state->x2 = y2;
-      state->x3 = y3;
-      state->x4 = y4;
-      state->x5 = y5;
-      state->x6 = y6;
-      state->x7 = y7;
-}
-
-/*before hashing a message, initialize the hash state as H0 */
-HashReturn Init(hashState *state, int hashbitlen)
-{
-
-      state->databitlen = 0;
-      state->datasize_in_buffer = 0;
-
-      state->hashbitlen = hashbitlen;
-
-      /*initialize the initial hash value of JH*/
-      /*load the intital hash value into state*/
-
-      switch(hashbitlen)
-      {
-          case 224:
-              state->x0 = LOAD(JH224_H0);
-              state->x1 = LOAD(JH224_H0+16);
-              state->x2 = LOAD(JH224_H0+32);
-              state->x3 = LOAD(JH224_H0+48);
-              state->x4 = LOAD(JH224_H0+64);
-              state->x5 = LOAD(JH224_H0+80);
-              state->x6 = LOAD(JH224_H0+96);
-              state->x7 = LOAD(JH224_H0+112);
-              break;
-
-          case 256:
-              state->x0 = LOAD(JH256_H0);
-              state->x1 = LOAD(JH256_H0+16);
-              state->x2 = LOAD(JH256_H0+32);
-              state->x3 = LOAD(JH256_H0+48);
-              state->x4 = LOAD(JH256_H0+64);
-              state->x5 = LOAD(JH256_H0+80);
-              state->x6 = LOAD(JH256_H0+96);
-              state->x7 = LOAD(JH256_H0+112);
-              break;
-
-          case 384:
-              state->x0 = LOAD(JH384_H0);
-              state->x1 = LOAD(JH384_H0+16);
-              state->x2 = LOAD(JH384_H0+32);
-              state->x3 = LOAD(JH384_H0+48);
-              state->x4 = LOAD(JH384_H0+64);
-              state->x5 = LOAD(JH384_H0+80);
-              state->x6 = LOAD(JH384_H0+96);
-              state->x7 = LOAD(JH384_H0+112);
-              break;
-
-          case 512:
-              state->x0 = LOAD(JH512_H0);
-              state->x1 = LOAD(JH512_H0+16);
-              state->x2 = LOAD(JH512_H0+32);
-              state->x3 = LOAD(JH512_H0+48);
-              state->x4 = LOAD(JH512_H0+64);
-              state->x5 = LOAD(JH512_H0+80);
-              state->x6 = LOAD(JH512_H0+96);
-              state->x7 = LOAD(JH512_H0+112);
-              break;
-      }
-
-      return(SUCCESS);
-}
-
-/*hash each 512-bit message block, except the last partial block*/
-HashReturn Update(hashState *state, const BitSequence *data, DataLength databitlen)
-{
-      DataLength index; /*the starting address of the data to be compressed*/
-
-      state->databitlen += databitlen;
-      index = 0;
-
-      /*if there is remaining data in the buffer, fill it to a full message block first*/
-      /*we assume that the size of the data in the buffer is the multiple of 8 bits if it is not at the end of a message*/
-
-      /*There is data in the buffer, but the incoming data is insufficient for a full block*/
-      if ( (state->datasize_in_buffer > 0 ) && (( state->datasize_in_buffer + databitlen) < 512)  ) {
-            if ( (databitlen & 7) == 0 ) {
-                 memcpy(state->buffer + (state->datasize_in_buffer >> 3), data, 64-(state->datasize_in_buffer >> 3)) ;
-		    }
-            else memcpy(state->buffer + (state->datasize_in_buffer >> 3), data, 64-(state->datasize_in_buffer >> 3)+1) ;
-            state->datasize_in_buffer += databitlen;
-            databitlen = 0;
-      }
-
-      /*There is data in the buffer, and the incoming data is sufficient for a full block*/
-      if ( (state->datasize_in_buffer > 0 ) && (( state->datasize_in_buffer + databitlen) >= 512)  ) {
-	        memcpy( state->buffer + (state->datasize_in_buffer >> 3), data, 64-(state->datasize_in_buffer >> 3) ) ;
-	        index = 64-(state->datasize_in_buffer >> 3);
-	        databitlen = databitlen - (512 - state->datasize_in_buffer);
-	        F8(state);
-	        state->datasize_in_buffer = 0;
-      }
-
-      /*hash the remaining full message blocks*/
-      for ( ; databitlen >= 512; index = index+64, databitlen = databitlen - 512) {
-            memcpy(state->buffer, data+index, 64);
-            F8(state);
-      }
-
-      /*store the partial block into buffer, assume that -- if part of the last byte is not part of the message, then that part consists of 0 bits*/
-      if ( databitlen > 0) {
-            if ((databitlen & 7) == 0)
-                  memcpy(state->buffer, data+index, (databitlen & 0x1ff) >> 3);
-            else
-                  memcpy(state->buffer, data+index, ((databitlen & 0x1ff) >> 3)+1);
-            state->datasize_in_buffer = databitlen;
-      }
-
-      return(SUCCESS);
-}
-
-/*pad the message, process the padded block(s), truncate the hash value H to obtain the message digest*/
-HashReturn Final(hashState *state, BitSequence *hashval)
-{
-	  unsigned int i;
-      DATA_ALIGN16(unsigned char t[64]);
-
-      if ( (state->databitlen & 0x1ff) == 0 )
-      {
-          /*pad the message when databitlen is multiple of 512 bits, then process the padded block*/
-          memset(state->buffer,0,64);
-          state->buffer[0] = 0x80;
-          state->buffer[63] = state->databitlen & 0xff;
-          state->buffer[62] = (state->databitlen >> 8) & 0xff;
-          state->buffer[61] = (state->databitlen >> 16) & 0xff;
-          state->buffer[60] = (state->databitlen >> 24) & 0xff;
-          state->buffer[59] = (state->databitlen >> 32) & 0xff;
-          state->buffer[58] = (state->databitlen >> 40) & 0xff;
-          state->buffer[57] = (state->databitlen >> 48) & 0xff;
-          state->buffer[56] = (state->databitlen >> 56) & 0xff;
-          F8(state);
-      }
-      else  {
-		  /*set the rest of the bytes in the buffer to 0*/
-	      if ( (state->datasize_in_buffer & 7) == 0)
-	           for (i = (state->databitlen & 0x1ff) >> 3; i < 64; i++)  state->buffer[i] = 0;
-		  else
-               for (i = ((state->databitlen & 0x1ff) >> 3)+1; i < 64; i++)  state->buffer[i] = 0;
-
-          /*pad and process the partial block when databitlen is not multiple of 512 bits, then hash the padded blocks*/
-          state->buffer[((state->databitlen & 0x1ff) >> 3)] |= 1 << (7- (state->databitlen & 7));
-          F8(state);
-          memset(state->buffer,0,64);
-          state->buffer[63] = state->databitlen & 0xff;
-          state->buffer[62] = (state->databitlen >> 8) & 0xff;
-          state->buffer[61] = (state->databitlen >> 16) & 0xff;
-          state->buffer[60] = (state->databitlen >> 24) & 0xff;
-          state->buffer[59] = (state->databitlen >> 32) & 0xff;
-          state->buffer[58] = (state->databitlen >> 40) & 0xff;
-          state->buffer[57] = (state->databitlen >> 48) & 0xff;
-          state->buffer[56] = (state->databitlen >> 56) & 0xff;
-          F8(state);
-      }
-
-      /*truncting the final hash value to generate the message digest*/
-
-      STORE(state->x4,t);
-      STORE(state->x5,t+16);
-      STORE(state->x6,t+32);
-      STORE(state->x7,t+48);
-
-      switch (state->hashbitlen)
-      {
-          case 224: memcpy(hashval,t+36,28); break;
-          case 256: memcpy(hashval,t+32,32); break;
-          case 384: memcpy(hashval,t+16,48); break;
-          case 512: memcpy(hashval,t,64);    break;
-      }
-
-      return(SUCCESS);
-}
-
-/* hash a message,
-   three inputs: message digest size in bits (hashbitlen); message (data); message length in bits (databitlen)
-   one output:   message digest (hashval)
-*/
-HashReturn Hash(int hashbitlen, const BitSequence *data,DataLength databitlen, BitSequence *hashval)
-{
-      hashState state;
-
-      if ( hashbitlen == 224 || hashbitlen == 256 || hashbitlen == 384 || hashbitlen == 512 )
-      {
-          Init(&state, hashbitlen);
-          Update(&state, data, databitlen);
-          Final(&state, hashval);
-          return SUCCESS;
-      }
-      else
-          return(BAD_HASHLEN);
-}

algo/jh/sse2/jh_sse2_opt64.h

@@ -1,357 +0,0 @@
-/*This program gives the optimized SSE2 bitslice implementation of JH for 64-bit platform (with 16 128-bit XMM registers).
-
-   --------------------------------
-   Performance
-
-   Microprocessor: Intel CORE 2 processor (Core 2 Duo Mobile T6600 2.2GHz)
-   Operating System: 64-bit Ubuntu 10.04 (Linux kernel 2.6.32-22-generic)
-   Speed for long message:
-   1) 19.9 cycles/byte   compiler: Intel C++ Compiler 11.1   compilation option: icc -O3
-   2) 20.9 cycles/byte   compiler: gcc 4.4.3                 compilation option: gcc -msse2 -O3
-
-   --------------------------------
-   Compare with the original JH sse2 code (October 2008) for 64-bit platform, we made the modifications:
-   a) The Sbox implementation follows exactly the description given in the document
-   b) Data alignment definition is improved so that the code can be compiled by GCC, Intel C++ compiler and Microsoft Visual C compiler
-   c) Using y0,y1,..,y7 variables in Function F8 for performance improvement (local variable in function F8 so that compiler can optimize the code easily)
-   d) Removed a number of intermediate variables from the program (so as to given compiler more freedom to optimize the code)
-   e) Using "for" loop to implement 42 rounds (with 7 rounds in each loop), so as to reduce the code size.
-
-   --------------------------------
-   Last Modified: January 16, 2011
-*/
-
-
-#include <emmintrin.h>
-#include <stdint.h>
-#include <string.h>
-#include "algo/sha/sha3-defs.h"
-
-typedef __m128i  word128;   /*word128 defines a 128-bit SSE2 word*/
-typedef enum {jhSUCCESS = 0, jhFAIL = 1, jhBAD_HASHLEN = 2} jhReturn;
-
-/*define data alignment for different C compilers*/
-#if defined(__GNUC__)
-      #define DATA_ALIGN16(x) x __attribute__ ((aligned(16)))
-#else
-      #define DATA_ALIGN16(x) __declspec(align(16)) x
-#endif
-
-typedef struct {
-      DataLength jhbitlen;	                /*the message digest size*/
-      DataLength databitlen;    /*the message size in bits*/
-      DataLength datasize_in_buffer;           /*the size of the message remained in buffer; assumed to be multiple of 8bits except for the last partial block at the end of the message*/
-      word128  x0,x1,x2,x3,x4,x5,x6,x7; /*1024-bit state;*/
-      unsigned char buffer[64];         /*512-bit message block;*/
-} jhState;
-
-#define DECL_JH \
-    word128 jhSx0,jhSx1,jhSx2,jhSx3,jhSx4,jhSx5,jhSx6,jhSx7; \
-    unsigned char jhSbuffer[64];
-
-
-/*The initial hash value H(0)*/
-static DATA_ALIGN16(const unsigned char JH512_H0[128])={0x6f,0xd1,0x4b,0x96,0x3e,0x0,0xaa,0x17,0x63,0x6a,0x2e,0x5,0x7a,0x15,0xd5,0x43,0x8a,0x22,0x5e,0x8d,0xc,0x97,0xef,0xb,0xe9,0x34,0x12,0x59,0xf2,0xb3,0xc3,0x61,0x89,0x1d,0xa0,0xc1,0x53,0x6f,0x80,0x1e,0x2a,0xa9,0x5,0x6b,0xea,0x2b,0x6d,0x80,0x58,0x8e,0xcc,0xdb,0x20,0x75,0xba,0xa6,0xa9,0xf,0x3a,0x76,0xba,0xf8,0x3b,0xf7,0x1,0x69,0xe6,0x5,0x41,0xe3,0x4a,0x69,0x46,0xb5,0x8a,0x8e,0x2e,0x6f,0xe6,0x5a,0x10,0x47,0xa7,0xd0,0xc1,0x84,0x3c,0x24,0x3b,0x6e,0x71,0xb1,0x2d,0x5a,0xc1,0x99,0xcf,0x57,0xf6,0xec,0x9d,0xb1,0xf8,0x56,0xa7,0x6,0x88,0x7c,0x57,0x16,0xb1,0x56,0xe3,0xc2,0xfc,0xdf,0xe6,0x85,0x17,0xfb,0x54,0x5a,0x46,0x78,0xcc,0x8c,0xdd,0x4b};
-
-/*42 round constants, each round constant is 32-byte (256-bit)*/
-static DATA_ALIGN16(const unsigned char jhE8_bitslice_roundconstant[42][32])={
-{0x72,0xd5,0xde,0xa2,0xdf,0x15,0xf8,0x67,0x7b,0x84,0x15,0xa,0xb7,0x23,0x15,0x57,0x81,0xab,0xd6,0x90,0x4d,0x5a,0x87,0xf6,0x4e,0x9f,0x4f,0xc5,0xc3,0xd1,0x2b,0x40},
-{0xea,0x98,0x3a,0xe0,0x5c,0x45,0xfa,0x9c,0x3,0xc5,0xd2,0x99,0x66,0xb2,0x99,0x9a,0x66,0x2,0x96,0xb4,0xf2,0xbb,0x53,0x8a,0xb5,0x56,0x14,0x1a,0x88,0xdb,0xa2,0x31},
-{0x3,0xa3,0x5a,0x5c,0x9a,0x19,0xe,0xdb,0x40,0x3f,0xb2,0xa,0x87,0xc1,0x44,0x10,0x1c,0x5,0x19,0x80,0x84,0x9e,0x95,0x1d,0x6f,0x33,0xeb,0xad,0x5e,0xe7,0xcd,0xdc},
-{0x10,0xba,0x13,0x92,0x2,0xbf,0x6b,0x41,0xdc,0x78,0x65,0x15,0xf7,0xbb,0x27,0xd0,0xa,0x2c,0x81,0x39,0x37,0xaa,0x78,0x50,0x3f,0x1a,0xbf,0xd2,0x41,0x0,0x91,0xd3},
-{0x42,0x2d,0x5a,0xd,0xf6,0xcc,0x7e,0x90,0xdd,0x62,0x9f,0x9c,0x92,0xc0,0x97,0xce,0x18,0x5c,0xa7,0xb,0xc7,0x2b,0x44,0xac,0xd1,0xdf,0x65,0xd6,0x63,0xc6,0xfc,0x23},
-{0x97,0x6e,0x6c,0x3,0x9e,0xe0,0xb8,0x1a,0x21,0x5,0x45,0x7e,0x44,0x6c,0xec,0xa8,0xee,0xf1,0x3,0xbb,0x5d,0x8e,0x61,0xfa,0xfd,0x96,0x97,0xb2,0x94,0x83,0x81,0x97},
-{0x4a,0x8e,0x85,0x37,0xdb,0x3,0x30,0x2f,0x2a,0x67,0x8d,0x2d,0xfb,0x9f,0x6a,0x95,0x8a,0xfe,0x73,0x81,0xf8,0xb8,0x69,0x6c,0x8a,0xc7,0x72,0x46,0xc0,0x7f,0x42,0x14},
-{0xc5,0xf4,0x15,0x8f,0xbd,0xc7,0x5e,0xc4,0x75,0x44,0x6f,0xa7,0x8f,0x11,0xbb,0x80,0x52,0xde,0x75,0xb7,0xae,0xe4,0x88,0xbc,0x82,0xb8,0x0,0x1e,0x98,0xa6,0xa3,0xf4},
-{0x8e,0xf4,0x8f,0x33,0xa9,0xa3,0x63,0x15,0xaa,0x5f,0x56,0x24,0xd5,0xb7,0xf9,0x89,0xb6,0xf1,0xed,0x20,0x7c,0x5a,0xe0,0xfd,0x36,0xca,0xe9,0x5a,0x6,0x42,0x2c,0x36},
-{0xce,0x29,0x35,0x43,0x4e,0xfe,0x98,0x3d,0x53,0x3a,0xf9,0x74,0x73,0x9a,0x4b,0xa7,0xd0,0xf5,0x1f,0x59,0x6f,0x4e,0x81,0x86,0xe,0x9d,0xad,0x81,0xaf,0xd8,0x5a,0x9f},
-{0xa7,0x5,0x6,0x67,0xee,0x34,0x62,0x6a,0x8b,0xb,0x28,0xbe,0x6e,0xb9,0x17,0x27,0x47,0x74,0x7,0x26,0xc6,0x80,0x10,0x3f,0xe0,0xa0,0x7e,0x6f,0xc6,0x7e,0x48,0x7b},
-{0xd,0x55,0xa,0xa5,0x4a,0xf8,0xa4,0xc0,0x91,0xe3,0xe7,0x9f,0x97,0x8e,0xf1,0x9e,0x86,0x76,0x72,0x81,0x50,0x60,0x8d,0xd4,0x7e,0x9e,0x5a,0x41,0xf3,0xe5,0xb0,0x62},
-{0xfc,0x9f,0x1f,0xec,0x40,0x54,0x20,0x7a,0xe3,0xe4,0x1a,0x0,0xce,0xf4,0xc9,0x84,0x4f,0xd7,0x94,0xf5,0x9d,0xfa,0x95,0xd8,0x55,0x2e,0x7e,0x11,0x24,0xc3,0x54,0xa5},
-{0x5b,0xdf,0x72,0x28,0xbd,0xfe,0x6e,0x28,0x78,0xf5,0x7f,0xe2,0xf,0xa5,0xc4,0xb2,0x5,0x89,0x7c,0xef,0xee,0x49,0xd3,0x2e,0x44,0x7e,0x93,0x85,0xeb,0x28,0x59,0x7f},
-{0x70,0x5f,0x69,0x37,0xb3,0x24,0x31,0x4a,0x5e,0x86,0x28,0xf1,0x1d,0xd6,0xe4,0x65,0xc7,0x1b,0x77,0x4,0x51,0xb9,0x20,0xe7,0x74,0xfe,0x43,0xe8,0x23,0xd4,0x87,0x8a},
-{0x7d,0x29,0xe8,0xa3,0x92,0x76,0x94,0xf2,0xdd,0xcb,0x7a,0x9,0x9b,0x30,0xd9,0xc1,0x1d,0x1b,0x30,0xfb,0x5b,0xdc,0x1b,0xe0,0xda,0x24,0x49,0x4f,0xf2,0x9c,0x82,0xbf},
-{0xa4,0xe7,0xba,0x31,0xb4,0x70,0xbf,0xff,0xd,0x32,0x44,0x5,0xde,0xf8,0xbc,0x48,0x3b,0xae,0xfc,0x32,0x53,0xbb,0xd3,0x39,0x45,0x9f,0xc3,0xc1,0xe0,0x29,0x8b,0xa0},
-{0xe5,0xc9,0x5,0xfd,0xf7,0xae,0x9,0xf,0x94,0x70,0x34,0x12,0x42,0x90,0xf1,0x34,0xa2,0x71,0xb7,0x1,0xe3,0x44,0xed,0x95,0xe9,0x3b,0x8e,0x36,0x4f,0x2f,0x98,0x4a},
-{0x88,0x40,0x1d,0x63,0xa0,0x6c,0xf6,0x15,0x47,0xc1,0x44,0x4b,0x87,0x52,0xaf,0xff,0x7e,0xbb,0x4a,0xf1,0xe2,0xa,0xc6,0x30,0x46,0x70,0xb6,0xc5,0xcc,0x6e,0x8c,0xe6},
-{0xa4,0xd5,0xa4,0x56,0xbd,0x4f,0xca,0x0,0xda,0x9d,0x84,0x4b,0xc8,0x3e,0x18,0xae,0x73,0x57,0xce,0x45,0x30,0x64,0xd1,0xad,0xe8,0xa6,0xce,0x68,0x14,0x5c,0x25,0x67},
-{0xa3,0xda,0x8c,0xf2,0xcb,0xe,0xe1,0x16,0x33,0xe9,0x6,0x58,0x9a,0x94,0x99,0x9a,0x1f,0x60,0xb2,0x20,0xc2,0x6f,0x84,0x7b,0xd1,0xce,0xac,0x7f,0xa0,0xd1,0x85,0x18},
-{0x32,0x59,0x5b,0xa1,0x8d,0xdd,0x19,0xd3,0x50,0x9a,0x1c,0xc0,0xaa,0xa5,0xb4,0x46,0x9f,0x3d,0x63,0x67,0xe4,0x4,0x6b,0xba,0xf6,0xca,0x19,0xab,0xb,0x56,0xee,0x7e},
-{0x1f,0xb1,0x79,0xea,0xa9,0x28,0x21,0x74,0xe9,0xbd,0xf7,0x35,0x3b,0x36,0x51,0xee,0x1d,0x57,0xac,0x5a,0x75,0x50,0xd3,0x76,0x3a,0x46,0xc2,0xfe,0xa3,0x7d,0x70,0x1},
-{0xf7,0x35,0xc1,0xaf,0x98,0xa4,0xd8,0x42,0x78,0xed,0xec,0x20,0x9e,0x6b,0x67,0x79,0x41,0x83,0x63,0x15,0xea,0x3a,0xdb,0xa8,0xfa,0xc3,0x3b,0x4d,0x32,0x83,0x2c,0x83},
-{0xa7,0x40,0x3b,0x1f,0x1c,0x27,0x47,0xf3,0x59,0x40,0xf0,0x34,0xb7,0x2d,0x76,0x9a,0xe7,0x3e,0x4e,0x6c,0xd2,0x21,0x4f,0xfd,0xb8,0xfd,0x8d,0x39,0xdc,0x57,0x59,0xef},
-{0x8d,0x9b,0xc,0x49,0x2b,0x49,0xeb,0xda,0x5b,0xa2,0xd7,0x49,0x68,0xf3,0x70,0xd,0x7d,0x3b,0xae,0xd0,0x7a,0x8d,0x55,0x84,0xf5,0xa5,0xe9,0xf0,0xe4,0xf8,0x8e,0x65},
-{0xa0,0xb8,0xa2,0xf4,0x36,0x10,0x3b,0x53,0xc,0xa8,0x7,0x9e,0x75,0x3e,0xec,0x5a,0x91,0x68,0x94,0x92,0x56,0xe8,0x88,0x4f,0x5b,0xb0,0x5c,0x55,0xf8,0xba,0xbc,0x4c},
-{0xe3,0xbb,0x3b,0x99,0xf3,0x87,0x94,0x7b,0x75,0xda,0xf4,0xd6,0x72,0x6b,0x1c,0x5d,0x64,0xae,0xac,0x28,0xdc,0x34,0xb3,0x6d,0x6c,0x34,0xa5,0x50,0xb8,0x28,0xdb,0x71},
-{0xf8,0x61,0xe2,0xf2,0x10,0x8d,0x51,0x2a,0xe3,0xdb,0x64,0x33,0x59,0xdd,0x75,0xfc,0x1c,0xac,0xbc,0xf1,0x43,0xce,0x3f,0xa2,0x67,0xbb,0xd1,0x3c,0x2,0xe8,0x43,0xb0},
-{0x33,0xa,0x5b,0xca,0x88,0x29,0xa1,0x75,0x7f,0x34,0x19,0x4d,0xb4,0x16,0x53,0x5c,0x92,0x3b,0x94,0xc3,0xe,0x79,0x4d,0x1e,0x79,0x74,0x75,0xd7,0xb6,0xee,0xaf,0x3f},
-{0xea,0xa8,0xd4,0xf7,0xbe,0x1a,0x39,0x21,0x5c,0xf4,0x7e,0x9,0x4c,0x23,0x27,0x51,0x26,0xa3,0x24,0x53,0xba,0x32,0x3c,0xd2,0x44,0xa3,0x17,0x4a,0x6d,0xa6,0xd5,0xad},
-{0xb5,0x1d,0x3e,0xa6,0xaf,0xf2,0xc9,0x8,0x83,0x59,0x3d,0x98,0x91,0x6b,0x3c,0x56,0x4c,0xf8,0x7c,0xa1,0x72,0x86,0x60,0x4d,0x46,0xe2,0x3e,0xcc,0x8,0x6e,0xc7,0xf6},
-{0x2f,0x98,0x33,0xb3,0xb1,0xbc,0x76,0x5e,0x2b,0xd6,0x66,0xa5,0xef,0xc4,0xe6,0x2a,0x6,0xf4,0xb6,0xe8,0xbe,0xc1,0xd4,0x36,0x74,0xee,0x82,0x15,0xbc,0xef,0x21,0x63},
-{0xfd,0xc1,0x4e,0xd,0xf4,0x53,0xc9,0x69,0xa7,0x7d,0x5a,0xc4,0x6,0x58,0x58,0x26,0x7e,0xc1,0x14,0x16,0x6,0xe0,0xfa,0x16,0x7e,0x90,0xaf,0x3d,0x28,0x63,0x9d,0x3f},
-{0xd2,0xc9,0xf2,0xe3,0x0,0x9b,0xd2,0xc,0x5f,0xaa,0xce,0x30,0xb7,0xd4,0xc,0x30,0x74,0x2a,0x51,0x16,0xf2,0xe0,0x32,0x98,0xd,0xeb,0x30,0xd8,0xe3,0xce,0xf8,0x9a},
-{0x4b,0xc5,0x9e,0x7b,0xb5,0xf1,0x79,0x92,0xff,0x51,0xe6,0x6e,0x4,0x86,0x68,0xd3,0x9b,0x23,0x4d,0x57,0xe6,0x96,0x67,0x31,0xcc,0xe6,0xa6,0xf3,0x17,0xa,0x75,0x5},
-{0xb1,0x76,0x81,0xd9,0x13,0x32,0x6c,0xce,0x3c,0x17,0x52,0x84,0xf8,0x5,0xa2,0x62,0xf4,0x2b,0xcb,0xb3,0x78,0x47,0x15,0x47,0xff,0x46,0x54,0x82,0x23,0x93,0x6a,0x48},
-{0x38,0xdf,0x58,0x7,0x4e,0x5e,0x65,0x65,0xf2,0xfc,0x7c,0x89,0xfc,0x86,0x50,0x8e,0x31,0x70,0x2e,0x44,0xd0,0xb,0xca,0x86,0xf0,0x40,0x9,0xa2,0x30,0x78,0x47,0x4e},
-{0x65,0xa0,0xee,0x39,0xd1,0xf7,0x38,0x83,0xf7,0x5e,0xe9,0x37,0xe4,0x2c,0x3a,0xbd,0x21,0x97,0xb2,0x26,0x1,0x13,0xf8,0x6f,0xa3,0x44,0xed,0xd1,0xef,0x9f,0xde,0xe7},
-{0x8b,0xa0,0xdf,0x15,0x76,0x25,0x92,0xd9,0x3c,0x85,0xf7,0xf6,0x12,0xdc,0x42,0xbe,0xd8,0xa7,0xec,0x7c,0xab,0x27,0xb0,0x7e,0x53,0x8d,0x7d,0xda,0xaa,0x3e,0xa8,0xde},
-{0xaa,0x25,0xce,0x93,0xbd,0x2,0x69,0xd8,0x5a,0xf6,0x43,0xfd,0x1a,0x73,0x8,0xf9,0xc0,0x5f,0xef,0xda,0x17,0x4a,0x19,0xa5,0x97,0x4d,0x66,0x33,0x4c,0xfd,0x21,0x6a},
-{0x35,0xb4,0x98,0x31,0xdb,0x41,0x15,0x70,0xea,0x1e,0xf,0xbb,0xed,0xcd,0x54,0x9b,0x9a,0xd0,0x63,0xa1,0x51,0x97,0x40,0x72,0xf6,0x75,0x9d,0xbf,0x91,0x47,0x6f,0xe2}};
-
-
-//static void jhF8(jhState *state);    /* the compression function F8 */
-
-/*The API functions*/
-
-/*The following defines operations on 128-bit word(s)*/
-#define jhCONSTANT(b)   _mm_set1_epi8((b))          /*set each byte in a 128-bit register to be "b"*/
-
-#define jhXOR(x,y)      _mm_xor_si128((x),(y))      /*jhXOR(x,y) = x ^ y, where x and y are two 128-bit word*/
-#define jhAND(x,y)      _mm_and_si128((x),(y))      /*jhAND(x,y) = x & y, where x and y are two 128-bit word*/
-#define jhANDNOT(x,y)   _mm_andnot_si128((x),(y))   /*jhANDNOT(x,y) = (!x) & y, where x and y are two 128-bit word*/
-#define jhOR(x,y)       _mm_or_si128((x),(y))       /*jhOR(x,y)  = x | y, where x and y are two 128-bit word*/
-
-#define jhSHR1(x)       _mm_srli_epi16((x), 1)      /*jhSHR1(x)  = x >> 1, where x is a 128 bit word*/
-#define jhSHR2(x)       _mm_srli_epi16((x), 2)      /*jhSHR2(x)  = x >> 2, where x is a 128 bit word*/
-#define jhSHR4(x)       _mm_srli_epi16((x), 4)      /*jhSHR4(x)  = x >> 4, where x is a 128 bit word*/
-#define jhSHR8(x)       _mm_slli_epi16((x), 8)      /*jhSHR8(x)  = x >> 8, where x is a 128 bit word*/
-#define jhSHR16(x)      _mm_slli_epi32((x), 16)     /*jhSHR16(x) = x >> 16, where x is a 128 bit word*/
-#define jhSHR32(x)      _mm_slli_epi64((x), 32)     /*jhSHR32(x) = x >> 32, where x is a 128 bit word*/
-#define jhSHR64(x)      _mm_slli_si128((x), 8)      /*jhSHR64(x) = x >> 64, where x is a 128 bit word*/
-
-#define jhSHL1(x)       _mm_slli_epi16((x), 1)      /*jhSHL1(x)  = x << 1, where x is a 128 bit word*/
-#define jhSHL2(x)       _mm_slli_epi16((x), 2)	  /*jhSHL2(x)  = x << 2, where x is a 128 bit word*/
-#define jhSHL4(x)       _mm_slli_epi16((x), 4)	  /*jhSHL4(x)  = x << 4, where x is a 128 bit word*/
-#define jhSHL8(x)       _mm_srli_epi16((x), 8)	  /*jhSHL8(x)  = x << 8, where x is a 128 bit word*/
-#define jhSHL16(x)      _mm_srli_epi32((x), 16)	  /*jhSHL16(x) = x << 16, where x is a 128 bit word*/
-#define jhSHL32(x)      _mm_srli_epi64((x), 32)	  /*jhSHL32(x) = x << 32, where x is a 128 bit word*/
-#define jhSHL64(x)      _mm_srli_si128((x), 8)	  /*jhSHL64(x) = x << 64, where x is a 128 bit word*/
-
-#define jhSWAP1(x)      jhOR(jhSHR1(jhAND((x),jhCONSTANT(0xaa))),jhSHL1(jhAND((x),jhCONSTANT(0x55))))  /*swapping bit 2i with bit 2i+1 of the 128-bit x */
-#define jhSWAP2(x)      jhOR(jhSHR2(jhAND((x),jhCONSTANT(0xcc))),jhSHL2(jhAND((x),jhCONSTANT(0x33))))  /*swapping bit 4i||4i+1 with bit 4i+2||4i+3 of the 128-bit x */
-#define jhSWAP4(x)      jhOR(jhSHR4(jhAND((x),jhCONSTANT(0xf0))),jhSHL4(jhAND((x),jhCONSTANT(0xf))))   /*swapping bits 8i||8i+1||8i+2||8i+3 with bits 8i+4||8i+5||8i+6||8i+7 of the 128-bit x */
-#define jhSWAP8(x)      jhOR(jhSHR8(x),jhSHL8(x))                          /*swapping bits 16i||16i+1||...||16i+7 with bits 16i+8||16i+9||...||16i+15 of the 128-bit x */
-#define jhSWAP16(x)     jhOR(jhSHR16(x),jhSHL16(x))                        /*swapping bits 32i||32i+1||...||32i+15 with bits 32i+16||32i+17||...||32i+31 of the 128-bit x */
-#define jhSWAP32(x)     _mm_shuffle_epi32((x),_MM_SHUFFLE(2,3,0,1))  /*swapping bits 64i||64i+1||...||64i+31 with bits 64i+32||64i+33||...||64i+63 of the 128-bit x*/
-#define jhSWAP64(x)     _mm_shuffle_epi32((x),_MM_SHUFFLE(1,0,3,2))  /*swapping bits 128i||128i+1||...||128i+63 with bits 128i+64||128i+65||...||128i+127 of the 128-bit x*/
-#define jhSTORE(x,p)    _mm_store_si128((__m128i *)(p), (x))         /*store the 128-bit word x into memeory address p, where p is the multile of 16 bytes*/
-#define jhLOAD(p)       _mm_load_si128((__m128i *)(p))               /*load 16 bytes from the memory address p, return a 128-bit word, where p is the multile of 16 bytes*/
-
-/*The MDS code*/
-#define jhL(m0,m1,m2,m3,m4,m5,m6,m7)     \
-      (m4) = jhXOR((m4),(m1));           \
-      (m5) = jhXOR((m5),(m2));           \
-      (m6) = jhXOR(jhXOR((m6),(m3)),(m0)); \
-      (m7) = jhXOR((m7),(m0));           \
-      (m0) = jhXOR((m0),(m5));           \
-      (m1) = jhXOR((m1),(m6));           \
-      (m2) = jhXOR(jhXOR((m2),(m7)),(m4)); \
-      (m3) = jhXOR((m3),(m4));
-
-/*Two Sboxes computed in parallel, each Sbox implements S0 and S1, selected by a constant bit*/
-/*The reason to compute two Sboxes in parallel is to try to fully utilize the parallel processing power of SSE2 instructions*/
-#define jhSS(m0,m1,m2,m3,m4,m5,m6,m7,constant0,constant1)  \
-      m3 = jhXOR(m3,jhCONSTANT(0xff));       \
-      m7 = jhXOR(m7,jhCONSTANT(0xff));       \
-      m0 = jhXOR(m0,jhANDNOT(m2,constant0)); \
-      m4 = jhXOR(m4,jhANDNOT(m6,constant1)); \
-      a0 = jhXOR(constant0,jhAND(m0,m1));    \
-      a1 = jhXOR(constant1,jhAND(m4,m5));    \
-      m0 = jhXOR(m0,jhAND(m3,m2));           \
-      m4 = jhXOR(m4,jhAND(m7,m6));           \
-      m3 = jhXOR(m3,jhANDNOT(m1,m2));        \
-      m7 = jhXOR(m7,jhANDNOT(m5,m6));        \
-      m1 = jhXOR(m1,jhAND(m0,m2));           \
-      m5 = jhXOR(m5,jhAND(m4,m6));           \
-      m2 = jhXOR(m2,jhANDNOT(m3,m0));        \
-      m6 = jhXOR(m6,jhANDNOT(m7,m4));        \
-      m0 = jhXOR(m0,jhOR(m1,m3));            \
-      m4 = jhXOR(m4,jhOR(m5,m7));            \
-      m3 = jhXOR(m3,jhAND(m1,m2));           \
-      m7 = jhXOR(m7,jhAND(m5,m6));           \
-      m2 = jhXOR(m2,a0);                   \
-      m6 = jhXOR(m6,a1);                   \
-      m1 = jhXOR(m1,jhAND(a0,m0));           \
-      m5 = jhXOR(m5,jhAND(a1,m4));
-
-/* The linear transform of the (7*i+0)th round*/
-#define jhlineartransform_R00(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                                          \
-      jhL(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bit 2i with bit 2i+1 for m4,m5,m6 and m7 */ \
-      m4 = jhSWAP1(m4); m5 = jhSWAP1(m5); m6 = jhSWAP1(m6); m7 = jhSWAP1(m7);
-
-/* The linear transform of the (7*i+1)th round*/
-#define jhlineartransform_R01(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                                          \
-      jhL(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bit 4i||4i+1 with bit 4i+2||4i+3 for m4,m5,m6 and m7 */  \
-      m4 = jhSWAP2(m4); m5 = jhSWAP2(m5); m6 = jhSWAP2(m6); m7 = jhSWAP2(m7);
-
-/* The linear transform of the (7*i+2)th round*/
-#define jhlineartransform_R02(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                                          \
-      jhL(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bits 8i||8i+1||8i+2||8i+3 with bits 8i+4||8i+5||8i+6||8i+7 for m4,m5,m6 and m7*/      \
-      m4 = jhSWAP4(m4); m5 = jhSWAP4(m5); m6 = jhSWAP4(m6); m7 = jhSWAP4(m7);
-
-/* The linear transform of the (7*i+3)th round*/
-#define jhlineartransform_R03(m0,m1,m2,m3,m4,m5,m6,m7)         \
-      /*MDS layer*/                                          \
-      jhL(m0,m1,m2,m3,m4,m5,m6,m7);                            \
-      /*swapping bits 16i||16i+1||...||16i+7 with bits 16i+8||16i+9||...||16i+15 for m4,m5,m6 and m7*/  \
-      m4 = jhSWAP8(m4); m5 = jhSWAP8(m5); m6 = jhSWAP8(m6); m7 = jhSWAP8(m7);
-
-/* The linear transform of the (7*i+4)th round*/
-#define jhlineartransform_R04(m0,m1,m2,m3,m4,m5,m6,m7)  \
-      /*MDS layer*/                                   \
-      jhL(m0,m1,m2,m3,m4,m5,m6,m7);                     \
-      /*swapping bits 32i||32i+1||...||32i+15 with bits 32i+16||32i+17||...||32i+31 for m0,m1,m2 and m3*/  \
-      m4 = jhSWAP16(m4); m5 = jhSWAP16(m5); m6 = jhSWAP16(m6); m7 = jhSWAP16(m7);
-
-/* The linear transform of the (7*i+5)th round -- faster*/
-#define jhlineartransform_R05(m0,m1,m2,m3,m4,m5,m6,m7)  \
-      /*MDS layer*/                                   \
-      jhL(m0,m1,m2,m3,m4,m5,m6,m7);                     \
-      /*swapping bits 64i||64i+1||...||64i+31 with bits 64i+32||64i+33||...||64i+63 for m0,m1,m2 and m3*/  \
-      m4 = jhSWAP32(m4); m5 = jhSWAP32(m5); m6 = jhSWAP32(m6); m7 = jhSWAP32(m7);
-
-/* The linear transform of the (7*i+6)th round -- faster*/
-#define jhlineartransform_R06(m0,m1,m2,m3,m4,m5,m6,m7)  \
-      /*MDS layer*/                                   \
-      jhL(m0,m1,m2,m3,m4,m5,m6,m7);                     \
-      /*swapping bits 128i||128i+1||...||128i+63 with bits 128i+64||128i+65||...||128i+127 for m0,m1,m2 and m3*/  \
-      m4 = jhSWAP64(m4); m5 = jhSWAP64(m5); m6 = jhSWAP64(m6); m7 = jhSWAP64(m7);
-
-/*the round function of E8 */
-#define jhround_function(nn,r)                                                              \
-      jhSS(y0,y2,y4,y6,y1,y3,y5,y7, jhLOAD(jhE8_bitslice_roundconstant[r]), jhLOAD(jhE8_bitslice_roundconstant[r]+16) ); \
-      jhlineartransform_R##nn(y0,y2,y4,y6,y1,y3,y5,y7);
-
-/*the round function of E8 */
-#define jhround_functionI(nn,r)                                                              \
-      jhSS(jhSx0,jhSx2,jhSx4,jhSx6,jhSx1,jhSx3,jhSx5,jhSx7, jhLOAD(jhE8_bitslice_roundconstant[r]), jhLOAD(jhE8_bitslice_roundconstant[r]+16) ); \
-      jhlineartransform_R##nn(jhSx0,jhSx2,jhSx4,jhSx6,jhSx1,jhSx3,jhSx5,jhSx7);
-
-/*
-//the compression function F8
-static void jhF8(jhState *state)
-{
-    return;
-      uint64_t i;
-      word128  y0,y1,y2,y3,y4,y5,y6,y7;
-      word128  a0,a1;
-
-      y0 = state->x0,
-      y0 = jhXOR(y0, jhLOAD(state->buffer));
-      y1 = state->x1,
-      y1 = jhXOR(y1, jhLOAD(state->buffer+16));
-      y2 = state->x2,
-      y2 = jhXOR(y2, jhLOAD(state->buffer+32));
-      y3 = state->x3,
-      y3 = jhXOR(y3, jhLOAD(state->buffer+48));
-      y4 = state->x4;
-      y5 = state->x5;
-      y6 = state->x6;
-      y7 = state->x7;
-
-      //xor the 512-bit message with the fist half of the 1024-bit hash state
-
-      //perform 42 rounds
-      for (i = 0; i < 42; i = i+7) {
-            jhround_function(00,i);
-            jhround_function(01,i+1);
-            jhround_function(02,i+2);
-            jhround_function(03,i+3);
-            jhround_function(04,i+4);
-            jhround_function(05,i+5);
-            jhround_function(06,i+6);
-      }
-
-      //xor the 512-bit message with the second half of the 1024-bit hash state
-
-      state->x0 = y0;
-      state->x1 = y1;
-      state->x2 = y2;
-      state->x3 = y3;
-      y4 = jhXOR(y4, jhLOAD(state->buffer)),
-      state->x4 = y4;
-      y5 = jhXOR(y5, jhLOAD(state->buffer+16)),
-      state->x5 = y5;
-      y6 = jhXOR(y6, jhLOAD(state->buffer+32)),
-      state->x6 = y6;
-      y7 = jhXOR(y7, jhLOAD(state->buffer+48)),
-      state->x7 = y7;
-}
-*/
-
-#define jhF8I \
-do { \
-      uint64_t i; \
-      word128  a0,a1; \
-      jhSx0 = jhXOR(jhSx0, jhLOAD(jhSbuffer)); \
-      jhSx1 = jhXOR(jhSx1, jhLOAD(jhSbuffer+16)); \
-      jhSx2 = jhXOR(jhSx2, jhLOAD(jhSbuffer+32)); \
-      jhSx3 = jhXOR(jhSx3, jhLOAD(jhSbuffer+48)); \
-      for (i = 0; i < 42; i = i+7) { \
-            jhround_functionI(00,i); \
-            jhround_functionI(01,i+1); \
-            jhround_functionI(02,i+2); \
-            jhround_functionI(03,i+3); \
-            jhround_functionI(04,i+4); \
-            jhround_functionI(05,i+5); \
-            jhround_functionI(06,i+6); \
-      } \
-      jhSx4 = jhXOR(jhSx4, jhLOAD(jhSbuffer)); \
-      jhSx5 = jhXOR(jhSx5, jhLOAD(jhSbuffer+16)); \
-      jhSx6 = jhXOR(jhSx6, jhLOAD(jhSbuffer+32)); \
-      jhSx7 = jhXOR(jhSx7, jhLOAD(jhSbuffer+48)); \
-} while (0)
-
-/* the whole thing 
- * load from hash 
- * hash = JH512(loaded)
- */
-#define JH_H \
-do { \
-    jhSx0 = jhLOAD(JH512_H0); \
-    jhSx1 = jhLOAD(JH512_H0+16); \
-    jhSx2 = jhLOAD(JH512_H0+32); \
-    jhSx3 = jhLOAD(JH512_H0+48); \
-    jhSx4 = jhLOAD(JH512_H0+64); \
-    jhSx5 = jhLOAD(JH512_H0+80); \
-    jhSx6 = jhLOAD(JH512_H0+96); \
-    jhSx7 = jhLOAD(JH512_H0+112); \
-    /* for break loop */ \
-    /* one inlined copy of JHF8i */ \
-    int b = false; \
-    memcpy(jhSbuffer, hash, 64); \
-    for(;;) { \
-        jhF8I; \
-        if (b) break; \
-        memset(jhSbuffer,0,48); \
-        jhSbuffer[0] = 0x80; \
-        jhSbuffer[48] = 0x00, \
-        jhSbuffer[49] = 0x00, \
-        jhSbuffer[50] = 0x00, \
-        jhSbuffer[51] = 0x00, \
-        jhSbuffer[52] = 0x00, \
-        jhSbuffer[53] = 0x00, \
-        jhSbuffer[54] = 0x00, \
-        jhSbuffer[55] = 0x00; \
-        jhSbuffer[56] = ((char)((uint64_t)(64*8) >> 56)) & 0xff, \
-        jhSbuffer[57] = ((char)((uint64_t)(64*8) >> 48)) & 0xff, \
-        jhSbuffer[58] = ((char)((uint64_t)(64*8) >> 40)) & 0xff, \
-        jhSbuffer[59] = ((char)((uint64_t)(64*8) >> 32)) & 0xff, \
-        jhSbuffer[60] = ((char)((uint64_t)(64*8) >> 24)) & 0xff, \
-        jhSbuffer[61] = ((char)((uint64_t)(64*8) >> 16)) & 0xff, \
-        jhSbuffer[62] = ((char)((uint64_t)(64*8) >> 8)) & 0xff, \
-        jhSbuffer[63] = (64*8) & 0xff; \
-        b = true; \
-    } \
-jhSTORE(jhSx4,(char *)(hash)); \
-jhSTORE(jhSx5,(char *)(hash)+16); \
-jhSTORE(jhSx6,(char *)(hash)+32); \
-jhSTORE(jhSx7,(char *)(hash)+48); \
-} while (0) 
-

algo/jh/sse2/sph_jh.h

@@ -1,127 +0,0 @@
-/* $Id: sph_jh.h 216 2010-06-08 09:46:57Z tp $ */
-/**
- * JH interface. JH is a family of functions which differ by
- * their output size; this implementation defines JH for output
- * sizes 224, 256, 384 and 512 bits.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- * 
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @file     sph_jh.h
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#ifndef SPH_JH_H__
-#define SPH_JH_H__
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#include <stddef.h>
-#include "sph_types.h"
-
-#define QSTATIC static 
-
-/**
- * Output size (in bits) for JH-512.
- */
-#define SPH_SIZE_jh512   512
-
-/**
- * This structure is a context for JH computations: it contains the
- * intermediate values and some data from the last entered block. Once
- * a JH computation has been performed, the context can be reused for
- * another computation.
- *
- * The contents of this structure are private. A running JH computation
- * can be cloned by copying the context (e.g. with a simple
- * <code>memcpy()</code>).
- */
-typedef struct {
-#ifndef DOXYGEN_IGNORE
-	size_t ptr;
-	union {
-		sph_u64 wide[16];
-		sph_u32 narrow[32];
-	} H;
-	sph_u64 block_count;
-} sph_jh_context;
-
-/**
- * Type for a JH-512 context (identical to the common context).
- */
-typedef sph_jh_context sph_jh512_context;
-
-/**
- * Initialize a JH-512 context. This process performs no memory allocation.
- *
- * @param cc   the JH-512 context (pointer to a
- *             <code>sph_jh512_context</code>)
- */
-QSTATIC void sph_jh512_init(void *cc);
-
-/**
- * Process some data bytes. It is acceptable that <code>len</code> is zero
- * (in which case this function does nothing).
- *
- * @param cc     the JH-512 context
- * @param data   the input data
- * @param len    the input data length (in bytes)
- */
-QSTATIC void sph_jh512(void *cc, const void *data, size_t len);
-
-/**
- * Terminate the current JH-512 computation and output the result into
- * the provided buffer. The destination buffer must be wide enough to
- * accomodate the result (64 bytes). The context is automatically
- * reinitialized.
- *
- * @param cc    the JH-512 context
- * @param dst   the destination buffer
- */
-QSTATIC void sph_jh512_close(void *cc, void *dst);
-
-/**
- * Add a few additional bits (0 to 7) to the current computation, then
- * terminate it and output the result in the provided buffer, which must
- * be wide enough to accomodate the result (64 bytes). If bit number i
- * in <code>ub</code> has value 2^i, then the extra bits are those
- * numbered 7 downto 8-n (this is the big-endian convention at the byte
- * level). The context is automatically reinitialized.
- *
- * @param cc    the JH-512 context
- * @param ub    the extra bits
- * @param n     the number of extra bits (0 to 7)
- * @param dst   the destination buffer
- */
-QSTATIC void sph_jh512_addbits_and_close(
-	void *cc, unsigned ub, unsigned n, void *dst);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

algo/keccak/keccak-hash-4way.h

@@ -99,14 +99,12 @@ typedef keccak64_ctx_m256i keccak512_4way_context;
 void keccak256_4way_init(void *cc);
 void keccak256_4way_update(void *cc, const void *data, size_t len);
 void keccak256_4way_close(void *cc, void *dst);
-#define keccak256_4way keccak256_4way_update
 
 void keccak512_4way_init(void *cc);
 void keccak512_4way_update(void *cc, const void *data, size_t len);
 void keccak512_4way_close(void *cc, void *dst);
 void keccak512_4way_addbits_and_close(
         void *cc, unsigned ub, unsigned n, void *dst);
-#define keccak512_4way keccak512_4way_update
 
 #endif
 

algo/keccak/sse2/keccak.c

@@ -1,845 +0,0 @@
-/* $Id: keccak.c 259 2011-07-19 22:11:27Z tp $ */
-/*
- * Keccak implementation.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- * 
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#define QSTATIC static
-
-#include <stddef.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "sph_keccak.h"
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-/*
- * Parameters:
- *
- *  SPH_KECCAK_64          use a 64-bit type
- *  SPH_KECCAK_INTERLEAVE  use bit-interleaving (32-bit type only)
- *  SPH_KECCAK_NOCOPY      do not copy the state into local variables
- * 
- * If there is no usable 64-bit type, the code automatically switches
- * back to the 32-bit implementation.
- *
- * Some tests on an Intel Core2 Q6600 (both 64-bit and 32-bit, 32 kB L1
- * code cache), a PowerPC (G3, 32 kB L1 code cache), an ARM920T core
- * (16 kB L1 code cache), and a small MIPS-compatible CPU (Broadcom BCM3302,
- * 8 kB L1 code cache), seem to show that the following are optimal:
- *
- * -- x86, 64-bit: use the 64-bit implementation, unroll 8 rounds,
- * do not copy the state; unrolling 2, 6 or all rounds also provides
- * near-optimal performance.
- * -- x86, 32-bit: use the 32-bit implementation, unroll 6 rounds,
- * interleave, do not copy the state. Unrolling 1, 2, 4 or 8 rounds
- * also provides near-optimal performance.
- * -- PowerPC: use the 64-bit implementation, unroll 8 rounds,
- * copy the state. Unrolling 4 or 6 rounds is near-optimal.
- * -- ARM: use the 64-bit implementation, unroll 2 or 4 rounds,
- * copy the state.
- * -- MIPS: use the 64-bit implementation, unroll 2 rounds, copy
- * the state. Unrolling only 1 round is also near-optimal.
- *
- * Also, interleaving does not always yield actual improvements when
- * using a 32-bit implementation; in particular when the architecture
- * does not offer a native rotation opcode (interleaving replaces one
- * 64-bit rotation with two 32-bit rotations, which is a gain only if
- * there is a native 32-bit rotation opcode and not a native 64-bit
- * rotation opcode; also, interleaving implies a small overhead when
- * processing input words).
- *
- * To sum up:
- * -- when possible, use the 64-bit code
- * -- exception: on 32-bit x86, use 32-bit code
- * -- when using 32-bit code, use interleaving
- * -- copy the state, except on x86
- * -- unroll 8 rounds on "big" machine, 2 rounds on "small" machines
- */
-
-
-#ifdef _MSC_VER
-#pragma warning (disable: 4146)
-#endif
-
-/*
-static const sph_u64 RC[] = {
-	SPH_C64(0x0000000000000001), SPH_C64(0x0000000000008082),
-	SPH_C64(0x800000000000808A), SPH_C64(0x8000000080008000),
-	SPH_C64(0x000000000000808B), SPH_C64(0x0000000080000001),
-	SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008009),
-	SPH_C64(0x000000000000008A), SPH_C64(0x0000000000000088),
-	SPH_C64(0x0000000080008009), SPH_C64(0x000000008000000A),
-	SPH_C64(0x000000008000808B), SPH_C64(0x800000000000008B),
-	SPH_C64(0x8000000000008089), SPH_C64(0x8000000000008003),
-	SPH_C64(0x8000000000008002), SPH_C64(0x8000000000000080),
-	SPH_C64(0x000000000000800A), SPH_C64(0x800000008000000A),
-	SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008080),
-	SPH_C64(0x0000000080000001), SPH_C64(0x8000000080008008)
-};
-*/
-#define kekDECL_STATE \
-	sph_u64 keca00, keca01, keca02, keca03, keca04; \
-	sph_u64 keca10, keca11, keca12, keca13, keca14; \
-	sph_u64 keca20, keca21, keca22, keca23, keca24; \
-	sph_u64 keca30, keca31, keca32, keca33, keca34; \
-	sph_u64 keca40, keca41, keca42, keca43, keca44;
-
-#define kekREAD_STATE(state)   do { \
-		keca00 = (state)->kecu.wide[ 0]; \
-		keca10 = (state)->kecu.wide[ 1]; \
-		keca20 = (state)->kecu.wide[ 2]; \
-		keca30 = (state)->kecu.wide[ 3]; \
-		keca40 = (state)->kecu.wide[ 4]; \
-		keca01 = (state)->kecu.wide[ 5]; \
-		keca11 = (state)->kecu.wide[ 6]; \
-		keca21 = (state)->kecu.wide[ 7]; \
-		keca31 = (state)->kecu.wide[ 8]; \
-		keca41 = (state)->kecu.wide[ 9]; \
-		keca02 = (state)->kecu.wide[10]; \
-		keca12 = (state)->kecu.wide[11]; \
-		keca22 = (state)->kecu.wide[12]; \
-		keca32 = (state)->kecu.wide[13]; \
-		keca42 = (state)->kecu.wide[14]; \
-		keca03 = (state)->kecu.wide[15]; \
-		keca13 = (state)->kecu.wide[16]; \
-		keca23 = (state)->kecu.wide[17]; \
-		keca33 = (state)->kecu.wide[18]; \
-		keca43 = (state)->kecu.wide[19]; \
-		keca04 = (state)->kecu.wide[20]; \
-		keca14 = (state)->kecu.wide[21]; \
-		keca24 = (state)->kecu.wide[22]; \
-		keca34 = (state)->kecu.wide[23]; \
-		keca44 = (state)->kecu.wide[24]; \
-	} while (0)
-
-#define kecREAD_STATE(state)   do { \
-		keca00 = kecu.wide[ 0]; \
-		keca10 = kecu.wide[ 1]; \
-		keca20 = kecu.wide[ 2]; \
-		keca30 = kecu.wide[ 3]; \
-		keca40 = kecu.wide[ 4]; \
-		keca01 = kecu.wide[ 5]; \
-		keca11 = kecu.wide[ 6]; \
-		keca21 = kecu.wide[ 7]; \
-		keca31 = kecu.wide[ 8]; \
-		keca41 = kecu.wide[ 9]; \
-		keca02 = kecu.wide[10]; \
-		keca12 = kecu.wide[11]; \
-		keca22 = kecu.wide[12]; \
-		keca32 = kecu.wide[13]; \
-		keca42 = kecu.wide[14]; \
-		keca03 = kecu.wide[15]; \
-		keca13 = kecu.wide[16]; \
-		keca23 = kecu.wide[17]; \
-		keca33 = kecu.wide[18]; \
-		keca43 = kecu.wide[19]; \
-		keca04 = kecu.wide[20]; \
-		keca14 = kecu.wide[21]; \
-		keca24 = kecu.wide[22]; \
-		keca34 = kecu.wide[23]; \
-		keca44 = kecu.wide[24]; \
-	} while (0)
-
-#define kecINIT_STATE()   do { \
-		keca00 = 0x0000000000000000  \
-		    ^ sph_dec64le_aligned(buf +   0); \
-		keca10 = 0xFFFFFFFFFFFFFFFF  \
-		    ^ sph_dec64le_aligned(buf +   8); \
-		keca20 = 0xFFFFFFFFFFFFFFFF  \
-		    ^ sph_dec64le_aligned(buf +  16); \
-		keca30 = 0x0000000000000000  \
-		    ^ sph_dec64le_aligned(buf +  24); \
-		keca40 = 0x0000000000000000  \
-		    ^ sph_dec64le_aligned(buf +  32); \
-		keca01 = 0x0000000000000000  \
-		    ^ sph_dec64le_aligned(buf +  40); \
-		keca11 = 0x0000000000000000  \
-		    ^ sph_dec64le_aligned(buf +  48); \
-		keca21 = 0x0000000000000000  \
-		    ^ sph_dec64le_aligned(buf +  56); \
-		keca31 = 0xFFFFFFFFFFFFFFFF  \
-		    ^ sph_dec64le_aligned(buf +  64); \
-		keca41 = 0x0000000000000000, \
-		keca02 = 0x0000000000000000, \
-		keca12 = 0x0000000000000000, \
-		keca32 = 0x0000000000000000, \
-		keca42 = 0x0000000000000000, \
-		keca03 = 0x0000000000000000, \
-		keca13 = 0x0000000000000000, \
-		keca33 = 0x0000000000000000, \
-		keca43 = 0x0000000000000000, \
-		keca14 = 0x0000000000000000, \
-		keca24 = 0x0000000000000000, \
-		keca34 = 0x0000000000000000, \
-		keca44 = 0x0000000000000000; \
-		keca23 = 0xFFFFFFFFFFFFFFFF, \
-		keca04 = 0xFFFFFFFFFFFFFFFF, \
-		keca22 = 0xFFFFFFFFFFFFFFFF; \
-	} while (0)
-
-#define kekWRITE_STATE(state)   do { \
-		(state)->kecu.wide[ 0] = keca00; \
-		(state)->kecu.wide[ 1] = ~keca10; \
-		(state)->kecu.wide[ 2] = ~keca20; \
-		(state)->kecu.wide[ 3] = keca30; \
-		(state)->kecu.wide[ 4] = keca40; \
-		(state)->kecu.wide[ 5] = keca01; \
-		(state)->kecu.wide[ 6] = keca11; \
-		(state)->kecu.wide[ 7] = keca21; \
-		(state)->kecu.wide[ 8] = ~keca31; \
-		(state)->kecu.wide[ 9] = keca41; \
-		(state)->kecu.wide[10] = keca02; \
-		(state)->kecu.wide[11] = keca12; \
-		(state)->kecu.wide[12] = ~keca22; \
-		(state)->kecu.wide[13] = keca32; \
-		(state)->kecu.wide[14] = keca42; \
-		(state)->kecu.wide[15] = keca03; \
-		(state)->kecu.wide[16] = keca13; \
-		(state)->kecu.wide[17] = ~keca23; \
-		(state)->kecu.wide[18] = keca33; \
-		(state)->kecu.wide[19] = keca43; \
-		(state)->kecu.wide[20] = ~keca04; \
-		(state)->kecu.wide[21] = keca14; \
-		(state)->kecu.wide[22] = keca24; \
-		(state)->kecu.wide[23] = keca34; \
-		(state)->kecu.wide[24] = keca44; \
-	} while (0)
-
-/* only usefull for one round final */
-#define kecWRITE_STATE(state)   do { \
-		kecu.wide[ 0] = keca00; \
-		kecu.wide[ 1] = ~keca10; \
-		kecu.wide[ 2] = ~keca20; \
-		kecu.wide[ 3] = keca30; \
-		kecu.wide[ 4] = keca40; \
-		kecu.wide[ 5] = keca01; \
-		kecu.wide[ 6] = keca11; \
-		kecu.wide[ 7] = keca21; \
-		kecu.wide[ 8] = ~keca31; \
-		kecu.wide[ 9] = keca41; \
-		kecu.wide[10] = keca02; \
-		kecu.wide[11] = keca12; \
-		kecu.wide[12] = ~keca22; \
-		kecu.wide[13] = keca32; \
-		kecu.wide[14] = keca42; \
-		kecu.wide[15] = keca03; \
-		kecu.wide[16] = keca13; \
-		kecu.wide[17] = ~keca23; \
-		kecu.wide[18] = keca33; \
-		kecu.wide[19] = keca43; \
-		kecu.wide[20] = ~keca04; \
-		kecu.wide[21] = keca14; \
-		kecu.wide[22] = keca24; \
-		kecu.wide[23] = keca34; \
-		kecu.wide[24] = keca44; \
-	} while (0)
-
-#define kecPRINT_STATE(state)   do { \
-		printf("keca00=%lX\n", keca00); \
-		printf("keca10=%lX\n", keca10); \
-		printf("keca20=%lX\n", keca20); \
-		printf("keca30=%lX\n", keca30); \
-		printf("keca40=%lX\n", keca40); \
-		printf("keca01=%lX\n", keca01); \
-		printf("keca11=%lX\n", keca11); \
-		printf("keca21=%lX\n", keca21); \
-		printf("keca31=%lX\n", keca31); \
-		printf("keca41=%lX\n", keca41); \
-		printf("keca02=%lX\n", keca02); \
-		printf("keca12=%lX\n", keca12); \
-		printf("keca22=%lX\n", keca22); \
-		printf("keca32=%lX\n", keca32); \
-		printf("keca42=%lX\n", keca42); \
-		printf("keca03=%lX\n", keca03); \
-		printf("keca13=%lX\n", keca13); \
-		printf("keca23=%lX\n", keca23); \
-		printf("keca33=%lX\n", keca33); \
-		printf("keca43=%lX\n", keca43); \
-		printf("keca04=%lX\n", keca04); \
-		printf("keca14=%lX\n", keca14); \
-		printf("keca24=%lX\n", keca24); \
-		printf("keca34=%lX\n", keca34); \
-		printf("keca44=%lX\n", keca44); \
-                abort(); \
-	} while (0)
-
-#define kekINPUT_BUF()   do { \
-	} while (0)
-
-
-#define kekDECL64(x)        sph_u64 x
-#define MOV64(d, s)      (d = s)
-#define XOR64(d, a, b)   (d = a ^ b)
-#define AND64(d, a, b)   (d = a & b)
-#define OR64(d, a, b)    (d = a | b)
-#define NOT64(d, s)      (d = SPH_T64(~s))
-#define ROL64(d, v, n)   (d = SPH_ROTL64(v, n))
-#define XOR64_IOTA       XOR64
-
-#define TH_ELT(t, c0, c1, c2, c3, c4, d0, d1, d2, d3, d4)   do { \
-		kekDECL64(tt0); \
-		kekDECL64(tt1); \
-		kekDECL64(tt2); \
-		kekDECL64(tt3); \
-		XOR64(tt0, d0, d1); \
-		XOR64(tt1, d2, d3); \
-		XOR64(tt0, tt0, d4); \
-		XOR64(tt0, tt0, tt1); \
-		ROL64(tt0, tt0, 1); \
-		XOR64(tt2, c0, c1); \
-		XOR64(tt3, c2, c3); \
-		XOR64(tt0, tt0, c4); \
-		XOR64(tt2, tt2, tt3); \
-		XOR64(t, tt0, tt2); \
-	} while (0)
-
-#define THETA(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
-	b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
-	b40, b41, b42, b43, b44) \
-	do { \
-		kekDECL64(t0); \
-		kekDECL64(t1); \
-		kekDECL64(t2); \
-		kekDECL64(t3); \
-		kekDECL64(t4); \
-		TH_ELT(t0, b40, b41, b42, b43, b44, b10, b11, b12, b13, b14); \
-		TH_ELT(t1, b00, b01, b02, b03, b04, b20, b21, b22, b23, b24); \
-		TH_ELT(t2, b10, b11, b12, b13, b14, b30, b31, b32, b33, b34); \
-		TH_ELT(t3, b20, b21, b22, b23, b24, b40, b41, b42, b43, b44); \
-		TH_ELT(t4, b30, b31, b32, b33, b34, b00, b01, b02, b03, b04); \
-		XOR64(b00, b00, t0); \
-		XOR64(b01, b01, t0); \
-		XOR64(b02, b02, t0); \
-		XOR64(b03, b03, t0); \
-		XOR64(b04, b04, t0); \
-		XOR64(b10, b10, t1); \
-		XOR64(b11, b11, t1); \
-		XOR64(b12, b12, t1); \
-		XOR64(b13, b13, t1); \
-		XOR64(b14, b14, t1); \
-		XOR64(b20, b20, t2); \
-		XOR64(b21, b21, t2); \
-		XOR64(b22, b22, t2); \
-		XOR64(b23, b23, t2); \
-		XOR64(b24, b24, t2); \
-		XOR64(b30, b30, t3); \
-		XOR64(b31, b31, t3); \
-		XOR64(b32, b32, t3); \
-		XOR64(b33, b33, t3); \
-		XOR64(b34, b34, t3); \
-		XOR64(b40, b40, t4); \
-		XOR64(b41, b41, t4); \
-		XOR64(b42, b42, t4); \
-		XOR64(b43, b43, t4); \
-		XOR64(b44, b44, t4); \
-	} while (0)
-
-#define RHO(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
-	b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
-	b40, b41, b42, b43, b44) \
-	do { \
-		/* ROL64(b00, b00,  0); */ \
-		ROL64(b01, b01, 36); \
-		ROL64(b02, b02,  3); \
-		ROL64(b03, b03, 41); \
-		ROL64(b04, b04, 18); \
-		ROL64(b10, b10,  1); \
-		ROL64(b11, b11, 44); \
-		ROL64(b12, b12, 10); \
-		ROL64(b13, b13, 45); \
-		ROL64(b14, b14,  2); \
-		ROL64(b20, b20, 62); \
-		ROL64(b21, b21,  6); \
-		ROL64(b22, b22, 43); \
-		ROL64(b23, b23, 15); \
-		ROL64(b24, b24, 61); \
-		ROL64(b30, b30, 28); \
-		ROL64(b31, b31, 55); \
-		ROL64(b32, b32, 25); \
-		ROL64(b33, b33, 21); \
-		ROL64(b34, b34, 56); \
-		ROL64(b40, b40, 27); \
-		ROL64(b41, b41, 20); \
-		ROL64(b42, b42, 39); \
-		ROL64(b43, b43,  8); \
-		ROL64(b44, b44, 14); \
-	} while (0)
-
-/*
- * The KHI macro integrates the "lane complement" optimization. On input,
- * some words are complemented:
- *    keca00 keca01 keca02 keca04 keca13 keca20 keca21 keca22 keca30 keca33 keca34 keca43
- * On output, the following words are complemented:
- *    keca04 keca10 keca20 keca22 keca23 keca31
- *
- * The (implicit) permutation and the theta expansion will bring back
- * the input mask for the next round.
- */
-
-#define KHI_XO(d, a, b, c)   do { \
-		kekDECL64(kt); \
-		OR64(kt, b, c); \
-		XOR64(d, a, kt); \
-	} while (0)
-
-#define KHI_XA(d, a, b, c)   do { \
-		kekDECL64(kt); \
-		AND64(kt, b, c); \
-		XOR64(d, a, kt); \
-	} while (0)
-
-#define KHI(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
-	b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
-	b40, b41, b42, b43, b44) \
-	do { \
-		kekDECL64(c0); \
-		kekDECL64(c1); \
-		kekDECL64(c2); \
-		kekDECL64(c3); \
-		kekDECL64(c4); \
-		kekDECL64(bnn); \
-		NOT64(bnn, b20); \
-		KHI_XO(c0, b00, b10, b20); \
-		KHI_XO(c1, b10, bnn, b30); \
-		KHI_XA(c2, b20, b30, b40); \
-		KHI_XO(c3, b30, b40, b00); \
-		KHI_XA(c4, b40, b00, b10); \
-		MOV64(b00, c0); \
-		MOV64(b10, c1); \
-		MOV64(b20, c2); \
-		MOV64(b30, c3); \
-		MOV64(b40, c4); \
-		NOT64(bnn, b41); \
-		KHI_XO(c0, b01, b11, b21); \
-		KHI_XA(c1, b11, b21, b31); \
-		KHI_XO(c2, b21, b31, bnn); \
-		KHI_XO(c3, b31, b41, b01); \
-		KHI_XA(c4, b41, b01, b11); \
-		MOV64(b01, c0); \
-		MOV64(b11, c1); \
-		MOV64(b21, c2); \
-		MOV64(b31, c3); \
-		MOV64(b41, c4); \
-		NOT64(bnn, b32); \
-		KHI_XO(c0, b02, b12, b22); \
-		KHI_XA(c1, b12, b22, b32); \
-		KHI_XA(c2, b22, bnn, b42); \
-		KHI_XO(c3, bnn, b42, b02); \
-		KHI_XA(c4, b42, b02, b12); \
-		MOV64(b02, c0); \
-		MOV64(b12, c1); \
-		MOV64(b22, c2); \
-		MOV64(b32, c3); \
-		MOV64(b42, c4); \
-		NOT64(bnn, b33); \
-		KHI_XA(c0, b03, b13, b23); \
-		KHI_XO(c1, b13, b23, b33); \
-		KHI_XO(c2, b23, bnn, b43); \
-		KHI_XA(c3, bnn, b43, b03); \
-		KHI_XO(c4, b43, b03, b13); \
-		MOV64(b03, c0); \
-		MOV64(b13, c1); \
-		MOV64(b23, c2); \
-		MOV64(b33, c3); \
-		MOV64(b43, c4); \
-		NOT64(bnn, b14); \
-		KHI_XA(c0, b04, bnn, b24); \
-		KHI_XO(c1, bnn, b24, b34); \
-		KHI_XA(c2, b24, b34, b44); \
-		KHI_XO(c3, b34, b44, b04); \
-		KHI_XA(c4, b44, b04, b14); \
-		MOV64(b04, c0); \
-		MOV64(b14, c1); \
-		MOV64(b24, c2); \
-		MOV64(b34, c3); \
-		MOV64(b44, c4); \
-	} while (0)
-
-#define IOTA(r)   XOR64_IOTA(keca00, keca00, r)
-
-#define P0    keca00, keca01, keca02, keca03, keca04, keca10, keca11, keca12, keca13, keca14, keca20, keca21, \
-              keca22, keca23, keca24, keca30, keca31, keca32, keca33, keca34, keca40, keca41, keca42, keca43, keca44
-#define P1    keca00, keca30, keca10, keca40, keca20, keca11, keca41, keca21, keca01, keca31, keca22, keca02, \
-              keca32, keca12, keca42, keca33, keca13, keca43, keca23, keca03, keca44, keca24, keca04, keca34, keca14
-#define P2    keca00, keca33, keca11, keca44, keca22, keca41, keca24, keca02, keca30, keca13, keca32, keca10, \
-              keca43, keca21, keca04, keca23, keca01, keca34, keca12, keca40, keca14, keca42, keca20, keca03, keca31
-#define P3    keca00, keca23, keca41, keca14, keca32, keca24, keca42, keca10, keca33, keca01, keca43, keca11, \
-              keca34, keca02, keca20, keca12, keca30, keca03, keca21, keca44, keca31, keca04, keca22, keca40, keca13
-#define P4    keca00, keca12, keca24, keca31, keca43, keca42, keca04, keca11, keca23, keca30, keca34, keca41, \
-              keca03, keca10, keca22, keca21, keca33, keca40, keca02, keca14, keca13, keca20, keca32, keca44, keca01
-#define P5    keca00, keca21, keca42, keca13, keca34, keca04, keca20, keca41, keca12, keca33, keca03, keca24, \
-              keca40, keca11, keca32, keca02, keca23, keca44, keca10, keca31, keca01, keca22, keca43, keca14, keca30
-#define P6    keca00, keca02, keca04, keca01, keca03, keca20, keca22, keca24, keca21, keca23, keca40, keca42, \
-              keca44, keca41, keca43, keca10, keca12, keca14, keca11, keca13, keca30, keca32, keca34, keca31, keca33
-#define P7    keca00, keca10, keca20, keca30, keca40, keca22, keca32, keca42, keca02, keca12, keca44, keca04, \
-              keca14, keca24, keca34, keca11, keca21, keca31, keca41, keca01, keca33, keca43, keca03, keca13, keca23
-#define P8    keca00, keca11, keca22, keca33, keca44, keca32, keca43, keca04, keca10, keca21, keca14, keca20, \
-              keca31, keca42, keca03, keca41, keca02, keca13, keca24, keca30, keca23, keca34, keca40, keca01, keca12
-#define P9    keca00, keca41, keca32, keca23, keca14, keca43, keca34, keca20, keca11, keca02, keca31, keca22, \
-              keca13, keca04, keca40, keca24, keca10, keca01, keca42, keca33, keca12, keca03, keca44, keca30, keca21
-#define P10   keca00, keca24, keca43, keca12, keca31, keca34, keca03, keca22, keca41, keca10, keca13, keca32, \
-              keca01, keca20, keca44, keca42, keca11, keca30, keca04, keca23, keca21, keca40, keca14, keca33, keca02
-#define P11   keca00, keca42, keca34, keca21, keca13, keca03, keca40, keca32, keca24, keca11, keca01, keca43, \
-              keca30, keca22, keca14, keca04, keca41, keca33, keca20, keca12, keca02, keca44, keca31, keca23, keca10
-#define P12   keca00, keca04, keca03, keca02, keca01, keca40, keca44, keca43, keca42, keca41, keca30, keca34, \
-              keca33, keca32, keca31, keca20, keca24, keca23, keca22, keca21, keca10, keca14, keca13, keca12, keca11
-#define P13   keca00, keca20, keca40, keca10, keca30, keca44, keca14, keca34, keca04, keca24, keca33, keca03, \
-              keca23, keca43, keca13, keca22, keca42, keca12, keca32, keca02, keca11, keca31, keca01, keca21, keca41
-#define P14   keca00, keca22, keca44, keca11, keca33, keca14, keca31, keca03, keca20, keca42, keca23, keca40, \
-              keca12, keca34, keca01, keca32, keca04, keca21, keca43, keca10, keca41, keca13, keca30, keca02, keca24
-#define P15   keca00, keca32, keca14, keca41, keca23, keca31, keca13, keca40, keca22, keca04, keca12, keca44, \
-              keca21, keca03, keca30, keca43, keca20, keca02, keca34, keca11, keca24, keca01, keca33, keca10, keca42
-#define P16   keca00, keca43, keca31, keca24, keca12, keca13, keca01, keca44, keca32, keca20, keca21, keca14, \
-              keca02, keca40, keca33, keca34, keca22, keca10, keca03, keca41, keca42, keca30, keca23, keca11, keca04
-#define P17   keca00, keca34, keca13, keca42, keca21, keca01, keca30, keca14, keca43, keca22, keca02, keca31, \
-              keca10, keca44, keca23, keca03, keca32, keca11, keca40, keca24, keca04, keca33, keca12, keca41, keca20
-#define P18   keca00, keca03, keca01, keca04, keca02, keca30, keca33, keca31, keca34, keca32, keca10, keca13, \
-              keca11, keca14, keca12, keca40, keca43, keca41, keca44, keca42, keca20, keca23, keca21, keca24, keca22
-#define P19   keca00, keca40, keca30, keca20, keca10, keca33, keca23, keca13, keca03, keca43, keca11, keca01, \
-              keca41, keca31, keca21, keca44, keca34, keca24, keca14, keca04, keca22, keca12, keca02, keca42, keca32
-#define P20   keca00, keca44, keca33, keca22, keca11, keca23, keca12, keca01, keca40, keca34, keca41, keca30, \
-              keca24, keca13, keca02, keca14, keca03, keca42, keca31, keca20, keca32, keca21, keca10, keca04, keca43
-#define P21   keca00, keca14, keca23, keca32, keca41, keca12, keca21, keca30, keca44, keca03, keca24, keca33, \
-              keca42, keca01, keca10, keca31, keca40, keca04, keca13, keca22, keca43, keca02, keca11, keca20, keca34
-#define P22   keca00, keca31, keca12, keca43, keca24, keca21, keca02, keca33, keca14, keca40, keca42, keca23, \
-              keca04, keca30, keca11, keca13, keca44, keca20, keca01, keca32, keca34, keca10, keca41, keca22, keca03
-#define P23   keca00, keca13, keca21, keca34, keca42, keca02, keca10, keca23, keca31, keca44, keca04, keca12, \
-              keca20, keca33, keca41, keca01, keca14, keca22, keca30, keca43, keca03, keca11, keca24, keca32, keca40
-
-#define P1_TO_P0   do { \
-		kekDECL64(t); \
-		MOV64(t, keca01); \
-		MOV64(keca01, keca30); \
-		MOV64(keca30, keca33); \
-		MOV64(keca33, keca23); \
-		MOV64(keca23, keca12); \
-		MOV64(keca12, keca21); \
-		MOV64(keca21, keca02); \
-		MOV64(keca02, keca10); \
-		MOV64(keca10, keca11); \
-		MOV64(keca11, keca41); \
-		MOV64(keca41, keca24); \
-		MOV64(keca24, keca42); \
-		MOV64(keca42, keca04); \
-		MOV64(keca04, keca20); \
-		MOV64(keca20, keca22); \
-		MOV64(keca22, keca32); \
-		MOV64(keca32, keca43); \
-		MOV64(keca43, keca34); \
-		MOV64(keca34, keca03); \
-		MOV64(keca03, keca40); \
-		MOV64(keca40, keca44); \
-		MOV64(keca44, keca14); \
-		MOV64(keca14, keca31); \
-		MOV64(keca31, keca13); \
-		MOV64(keca13, t); \
-	} while (0)
-
-#define P2_TO_P0   do { \
-		kekDECL64(t); \
-		MOV64(t, keca01); \
-		MOV64(keca01, keca33); \
-		MOV64(keca33, keca12); \
-		MOV64(keca12, keca02); \
-		MOV64(keca02, keca11); \
-		MOV64(keca11, keca24); \
-		MOV64(keca24, keca04); \
-		MOV64(keca04, keca22); \
-		MOV64(keca22, keca43); \
-		MOV64(keca43, keca03); \
-		MOV64(keca03, keca44); \
-		MOV64(keca44, keca31); \
-		MOV64(keca31, t); \
-		MOV64(t, keca10); \
-		MOV64(keca10, keca41); \
-		MOV64(keca41, keca42); \
-		MOV64(keca42, keca20); \
-		MOV64(keca20, keca32); \
-		MOV64(keca32, keca34); \
-		MOV64(keca34, keca40); \
-		MOV64(keca40, keca14); \
-		MOV64(keca14, keca13); \
-		MOV64(keca13, keca30); \
-		MOV64(keca30, keca23); \
-		MOV64(keca23, keca21); \
-		MOV64(keca21, t); \
-	} while (0)
-
-#define P4_TO_P0   do { \
-		kekDECL64(t); \
-		MOV64(t, keca01); \
-		MOV64(keca01, keca12); \
-		MOV64(keca12, keca11); \
-		MOV64(keca11, keca04); \
-		MOV64(keca04, keca43); \
-		MOV64(keca43, keca44); \
-		MOV64(keca44, t); \
-		MOV64(t, keca02); \
-		MOV64(keca02, keca24); \
-		MOV64(keca24, keca22); \
-		MOV64(keca22, keca03); \
-		MOV64(keca03, keca31); \
-		MOV64(keca31, keca33); \
-		MOV64(keca33, t); \
-		MOV64(t, keca10); \
-		MOV64(keca10, keca42); \
-		MOV64(keca42, keca32); \
-		MOV64(keca32, keca40); \
-		MOV64(keca40, keca13); \
-		MOV64(keca13, keca23); \
-		MOV64(keca23, t); \
-		MOV64(t, keca14); \
-		MOV64(keca14, keca30); \
-		MOV64(keca30, keca21); \
-		MOV64(keca21, keca41); \
-		MOV64(keca41, keca20); \
-		MOV64(keca20, keca34); \
-		MOV64(keca34, t); \
-	} while (0)
-
-#define P6_TO_P0   do { \
-		kekDECL64(t); \
-		MOV64(t, keca01); \
-		MOV64(keca01, keca02); \
-		MOV64(keca02, keca04); \
-		MOV64(keca04, keca03); \
-		MOV64(keca03, t); \
-		MOV64(t, keca10); \
-		MOV64(keca10, keca20); \
-		MOV64(keca20, keca40); \
-		MOV64(keca40, keca30); \
-		MOV64(keca30, t); \
-		MOV64(t, keca11); \
-		MOV64(keca11, keca22); \
-		MOV64(keca22, keca44); \
-		MOV64(keca44, keca33); \
-		MOV64(keca33, t); \
-		MOV64(t, keca12); \
-		MOV64(keca12, keca24); \
-		MOV64(keca24, keca43); \
-		MOV64(keca43, keca31); \
-		MOV64(keca31, t); \
-		MOV64(t, keca13); \
-		MOV64(keca13, keca21); \
-		MOV64(keca21, keca42); \
-		MOV64(keca42, keca34); \
-		MOV64(keca34, t); \
-		MOV64(t, keca14); \
-		MOV64(keca14, keca23); \
-		MOV64(keca23, keca41); \
-		MOV64(keca41, keca32); \
-		MOV64(keca32, t); \
-	} while (0)
-
-#define P8_TO_P0   do { \
-		kekDECL64(t); \
-		MOV64(t, keca01); \
-		MOV64(keca01, keca11); \
-		MOV64(keca11, keca43); \
-		MOV64(keca43, t); \
-		MOV64(t, keca02); \
-		MOV64(keca02, keca22); \
-		MOV64(keca22, keca31); \
-		MOV64(keca31, t); \
-		MOV64(t, keca03); \
-		MOV64(keca03, keca33); \
-		MOV64(keca33, keca24); \
-		MOV64(keca24, t); \
-		MOV64(t, keca04); \
-		MOV64(keca04, keca44); \
-		MOV64(keca44, keca12); \
-		MOV64(keca12, t); \
-		MOV64(t, keca10); \
-		MOV64(keca10, keca32); \
-		MOV64(keca32, keca13); \
-		MOV64(keca13, t); \
-		MOV64(t, keca14); \
-		MOV64(keca14, keca21); \
-		MOV64(keca21, keca20); \
-		MOV64(keca20, t); \
-		MOV64(t, keca23); \
-		MOV64(keca23, keca42); \
-		MOV64(keca42, keca40); \
-		MOV64(keca40, t); \
-		MOV64(t, keca30); \
-		MOV64(keca30, keca41); \
-		MOV64(keca41, keca34); \
-		MOV64(keca34, t); \
-	} while (0)
-
-#define P12_TO_P0   do { \
-		kekDECL64(t); \
-		MOV64(t, keca01); \
-		MOV64(keca01, keca04); \
-		MOV64(keca04, t); \
-		MOV64(t, keca02); \
-		MOV64(keca02, keca03); \
-		MOV64(keca03, t); \
-		MOV64(t, keca10); \
-		MOV64(keca10, keca40); \
-		MOV64(keca40, t); \
-		MOV64(t, keca11); \
-		MOV64(keca11, keca44); \
-		MOV64(keca44, t); \
-		MOV64(t, keca12); \
-		MOV64(keca12, keca43); \
-		MOV64(keca43, t); \
-		MOV64(t, keca13); \
-		MOV64(keca13, keca42); \
-		MOV64(keca42, t); \
-		MOV64(t, keca14); \
-		MOV64(keca14, keca41); \
-		MOV64(keca41, t); \
-		MOV64(t, keca20); \
-		MOV64(keca20, keca30); \
-		MOV64(keca30, t); \
-		MOV64(t, keca21); \
-		MOV64(keca21, keca34); \
-		MOV64(keca34, t); \
-		MOV64(t, keca22); \
-		MOV64(keca22, keca33); \
-		MOV64(keca33, t); \
-		MOV64(t, keca23); \
-		MOV64(keca23, keca32); \
-		MOV64(keca32, t); \
-		MOV64(t, keca24); \
-		MOV64(keca24, keca31); \
-		MOV64(keca31, t); \
-	} while (0)
-
-#define LPAR   (
-#define RPAR   )
-
-#define KF_ELT(r, s, k)   do { \
-		THETA LPAR P ## r RPAR; \
-		RHO LPAR P ## r RPAR; \
-		KHI LPAR P ## s RPAR; \
-		IOTA(k); \
-	} while (0)
-
-#define DO(x)   x
-
-#define KECCAK_F_1600   DO(KECCAK_F_1600_)
-
-/*
- * removed loop unrolling 
- * tested faster saving space
-*/
-#define KECCAK_F_1600_   do { \
-static const sph_u64 RC[] = { \
-        SPH_C64(0x0000000000000001), SPH_C64(0x0000000000008082), \
-        SPH_C64(0x800000000000808A), SPH_C64(0x8000000080008000), \
-        SPH_C64(0x000000000000808B), SPH_C64(0x0000000080000001), \
-        SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008009), \
-        SPH_C64(0x000000000000008A), SPH_C64(0x0000000000000088), \
-        SPH_C64(0x0000000080008009), SPH_C64(0x000000008000000A), \
-        SPH_C64(0x000000008000808B), SPH_C64(0x800000000000008B), \
-        SPH_C64(0x8000000000008089), SPH_C64(0x8000000000008003), \
-        SPH_C64(0x8000000000008002), SPH_C64(0x8000000000000080), \
-        SPH_C64(0x000000000000800A), SPH_C64(0x800000008000000A), \
-        SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008080), \
-        SPH_C64(0x0000000080000001), SPH_C64(0x8000000080008008) \
-}; \
-		int j; \
-		for (j = 0; j < 24; j += 4) { \
-			KF_ELT( 0,  1, RC[j + 0]); \
-			KF_ELT( 1,  2, RC[j + 1]); \
-			KF_ELT( 2,  3, RC[j + 2]); \
-			KF_ELT( 3,  4, RC[j + 3]); \
-			P4_TO_P0; \
-		} \
-	} while (0)
-
-/*
-			KF_ELT( 0,  1, RC[j + 0]); \
-			KF_ELT( 1,  2, RC[j + 1]); \
-			KF_ELT( 2,  3, RC[j + 2]); \
-			KF_ELT( 3,  4, RC[j + 3]); \
-			KF_ELT( 4,  5, RC[j + 4]); \
-			KF_ELT( 5,  6, RC[j + 5]); \
-			KF_ELT( 6,  7, RC[j + 6]); \
-			KF_ELT( 7,  8, RC[j + 7]); \
-	kekDECL_STATE \
-*/        
-#define DECL_KEC  
-
-
-/* 
-	sph_u64 keca00, keca01, keca02, keca03, keca04; \
-	sph_u64 keca10, keca11, keca12, keca13, keca14; \
-	sph_u64 keca20, keca21, keca22, keca23, keca24; \
-	sph_u64 keca30, keca31, keca32, keca33, keca34; \
-	sph_u64 keca40, keca41, keca42, keca43, keca44;
-*/
-
-/* load initial constants */
-#define KEC_I 
-
-//static unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }; 
-/*
- unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }; \
-*/
-
-/* load hash for loop */
-#define KEC_U \
-do { \
-static unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }; \
-    /*memcpy(hashbuf, hash, 64); */ \
-    memcpy(hash + 64, keczword, 8); \
-} while (0); 
-
-/* keccak512 hash loaded */
-/* hash = keccak512(loaded */
-
-#define KEC_C \
-do { \
-    kekDECL_STATE \
-    unsigned char *buf = hash; \
-    /*BEGIN CORE */ \
-    kecINIT_STATE(); \
-    KECCAK_F_1600; \
-    /*END CORE */ \
-    /* Finalize the "lane complement" */ \
-    sph_enc64le_aligned((unsigned char*)(hash) +  0,  keca00); \
-    sph_enc64le_aligned((unsigned char*)(hash) +  8, ~keca10); \
-    sph_enc64le_aligned((unsigned char*)(hash) + 16, ~keca20); \
-    sph_enc64le_aligned((unsigned char*)(hash) + 24,  keca30); \
-    sph_enc64le_aligned((unsigned char*)(hash) + 32,  keca40); \
-    sph_enc64le_aligned((unsigned char*)(hash) + 40,  keca01); \
-    sph_enc64le_aligned((unsigned char*)(hash) + 48,  keca11); \
-    sph_enc64le_aligned((unsigned char*)(hash) + 56,  keca21); \
-} while (0);
-
-#ifdef __cplusplus
-}
-#endif

algo/keccak/sse2/sph_keccak.h

@@ -1,102 +0,0 @@
-/* $Id: sph_keccak.h 216 2010-06-08 09:46:57Z tp $ */
-/**
- * Keccak interface. This is the interface for Keccak with the
- * recommended parameters for SHA-3, with output lengths 224, 256,
- * 384 and 512 bits.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- * 
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @file     sph_keccak.h
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#ifndef SPH_KECCAK_H__
-#define SPH_KECCAK_H__
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#include <stddef.h>
-#include "algo/sha/sph_types.h"
-
-#define QSTATIC static 
-
-/**
- * Output size (in bits) for Keccak-512.
- */
-#define SPH_SIZE_keccak512   512
-
-/**
- * This structure is a context for Keccak computations: it contains the
- * intermediate values and some data from the last entered block. Once a
- * Keccak computation has been performed, the context can be reused for
- * another computation.
- *
- * The contents of this structure are private. A running Keccak computation
- * can be cloned by copying the context (e.g. with a simple
- * <code>memcpy()</code>).
- */
-/**
- * Type for a Keccak-512 context (identical to the common context).
- */
-
-/**
- * Initialize a Keccak-512 context. This process performs no memory allocation.
- *
- * @param cc   the Keccak-512 context (pointer to a
- *             <code>sph_keccak512_context</code>)
- */
-
-/**
- * Terminate the current Keccak-512 computation and output the result into
- * the provided buffer. The destination buffer must be wide enough to
- * accomodate the result (64 bytes). The context is automatically
- * reinitialized.
- *
- * @param cc    the Keccak-512 context
- * @param dst   the destination buffer
- */
-
-/**
- * Add a few additional bits (0 to 7) to the current computation, then
- * terminate it and output the result in the provided buffer, which must
- * be wide enough to accomodate the result (64 bytes). If bit number i
- * in <code>ub</code> has value 2^i, then the extra bits are those
- * numbered 7 downto 8-n (this is the big-endian convention at the byte
- * level). The context is automatically reinitialized.
- *
- * @param cc    the Keccak-512 context
- * @param ub    the extra bits
- * @param n     the number of extra bits (0 to 7)
- * @param dst   the destination buffer
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

algo/lyra2/allium-4way.c

@@ -1,15 +1,178 @@
 #include "lyra2-gate.h"
 #include <memory.h>
 #include <mm_malloc.h>
-
-#if defined (ALLIUM_4WAY)	
-
 #include "algo/blake/blake-hash-4way.h"
 #include "algo/keccak/keccak-hash-4way.h"
 #include "algo/skein/skein-hash-4way.h"
 #include "algo/cubehash/cubehash_sse2.h"
+#include "algo/cubehash/cube-hash-2way.h"
 #include "algo/groestl/aes_ni/hash-groestl256.h"
 
+#if defined (ALLIUM_8WAY)  
+
+typedef struct {
+   blake256_8way_context     blake;
+   keccak256_8way_context    keccak;
+   cube_4way_context          cube;
+   skein256_8way_context     skein;
+   hashState_groestl256      groestl;
+} allium_8way_ctx_holder;
+
+static __thread allium_8way_ctx_holder allium_8way_ctx;
+
+bool init_allium_8way_ctx()
+{
+   keccak256_8way_init( &allium_8way_ctx.keccak );
+   cube_4way_init( &allium_8way_ctx.cube, 256, 16, 32 );
+   skein256_8way_init( &allium_8way_ctx.skein );
+   init_groestl256( &allium_8way_ctx.groestl, 32 );
+   return true;
+}
+
+void allium_8way_hash( void *state, const void *input )
+{
+   uint32_t vhash[8*8] __attribute__ ((aligned (128)));
+   uint32_t vhashA[8*8] __attribute__ ((aligned (64)));
+   uint32_t vhashB[8*8] __attribute__ ((aligned (64)));
+   uint32_t hash0[8] __attribute__ ((aligned (64)));
+   uint32_t hash1[8] __attribute__ ((aligned (64)));
+   uint32_t hash2[8] __attribute__ ((aligned (64)));
+   uint32_t hash3[8] __attribute__ ((aligned (64)));
+   uint32_t hash4[8] __attribute__ ((aligned (64)));
+   uint32_t hash5[8] __attribute__ ((aligned (64)));
+   uint32_t hash6[8] __attribute__ ((aligned (64)));
+   uint32_t hash7[8] __attribute__ ((aligned (64)));
+   allium_8way_ctx_holder ctx __attribute__ ((aligned (64)));
+
+   memcpy( &ctx, &allium_8way_ctx, sizeof(allium_8way_ctx) );
+   blake256_8way_update( &ctx.blake, input + (64<<3), 16 );
+   blake256_8way_close( &ctx.blake, vhash );
+
+   rintrlv_8x32_8x64( vhashA, vhash, 256 );
+   keccak256_8way_update( &ctx.keccak, vhashA, 32 );
+   keccak256_8way_close( &ctx.keccak, vhash );
+
+   dintrlv_8x64( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
+                 vhash, 256 );
+
+   intrlv_2x256( vhash, hash0, hash1, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash0, hash1, vhash, 256 );
+   intrlv_2x256( vhash, hash2, hash3, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash2, hash3, vhash, 256 );
+   intrlv_2x256( vhash, hash4, hash5, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash4, hash5, vhash, 256 );
+   intrlv_2x256( vhash, hash6, hash7, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash6, hash7, vhash, 256 );
+  
+   intrlv_4x128( vhashA, hash0, hash1, hash2, hash3, 256 );
+   intrlv_4x128( vhashB, hash4, hash5, hash6, hash7, 256 );
+
+   cube_4way_update_close( &ctx.cube, vhashA, vhashA, 32 );
+   cube_4way_init( &ctx.cube, 256, 16, 32 );
+   cube_4way_update_close( &ctx.cube, vhashB, vhashB, 32 );
+
+   dintrlv_4x128( hash0, hash1, hash2, hash3, vhashA, 256 );
+   dintrlv_4x128( hash4, hash5, hash6, hash7, vhashB, 256 );
+
+   intrlv_2x256( vhash, hash0, hash1, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash0, hash1, vhash, 256 );
+   intrlv_2x256( vhash, hash2, hash3, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash2, hash3, vhash, 256 );
+   intrlv_2x256( vhash, hash4, hash5, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash4, hash5, vhash, 256 );
+   intrlv_2x256( vhash, hash6, hash7, 256 );
+   LYRA2RE_2WAY( vhash, 32, vhash, 32, 1, 8, 8 );
+   dintrlv_2x256( hash6, hash7, vhash, 256 );
+
+   intrlv_8x64( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
+                hash7, 256 );
+
+   skein256_8way_update( &ctx.skein, vhash, 32 );
+   skein256_8way_close( &ctx.skein, vhash );
+
+   dintrlv_8x64( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
+                 vhash, 256 );
+
+   update_and_final_groestl256( &ctx.groestl, state, hash0, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+32, hash1, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+64, hash2, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+96, hash3, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+128, hash4, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+160, hash5, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+192, hash6, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+224, hash7, 256 );
+   memcpy( &ctx.groestl, &allium_8way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+}
+
+int scanhash_allium_8way( struct work *work, uint32_t max_nonce,
+                             uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[8*8] __attribute__ ((aligned (128)));
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   uint32_t n = first_nonce;
+   const uint32_t last_nonce = max_nonce - 8;
+   const uint32_t Htarg = ptarget[7];
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+
+   if ( opt_benchmark )
+      ( (uint32_t*)ptarget )[7] = 0x0000ff;
+
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
+   blake256_8way_init( &allium_8way_ctx.blake );
+   blake256_8way_update( &allium_8way_ctx.blake, vdata, 64 );
+
+   do {
+     *noncev = mm256_bswap_32( _mm256_set_epi32( n+7, n+6, n+5, n+4,
+                                                 n+3, n+2, n+1, n ) );
+
+     allium_8way_hash( hash, vdata );
+     pdata[19] = n;
+
+     for ( int lane = 0; lane < 8; lane++ ) if ( (hash+(lane<<3))[7] <= Htarg )
+     {
+        if ( fulltest( hash+(lane<<3), ptarget ) && !opt_benchmark )
+        {
+           pdata[19] = n + lane;
+           submit_lane_solution( work, hash+(lane<<3), mythr, lane );
+         }
+     }
+     n += 8;
+   } while ( (n < last_nonce) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+
+#elif defined (ALLIUM_4WAY)  
+
+
 typedef struct {
    blake256_4way_context     blake;
    keccak256_4way_context    keccak;
@@ -41,11 +204,11 @@ void allium_4way_hash( void *state, const void *input )
    allium_4way_ctx_holder ctx __attribute__ ((aligned (64))); 
 
    memcpy( &ctx, &allium_4way_ctx, sizeof(allium_4way_ctx) );
-   blake256_4way( &ctx.blake, input + (64<<2), 16 );
+   blake256_4way_update( &ctx.blake, input + (64<<2), 16 );
    blake256_4way_close( &ctx.blake, vhash32 );
 
    rintrlv_4x32_4x64( vhash64, vhash32, 256 );
-   keccak256_4way( &ctx.keccak, vhash64, 32 );
+   keccak256_4way_update( &ctx.keccak, vhash64, 32 );
    keccak256_4way_close( &ctx.keccak, vhash64 );
 
    dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
@@ -70,7 +233,7 @@ void allium_4way_hash( void *state, const void *input )
 
    intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
 
-   skein256_4way( &ctx.skein, vhash64, 32 );
+   skein256_4way_update( &ctx.skein, vhash64, 32 );
    skein256_4way_close( &ctx.skein, vhash64 );
 
    dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );

algo/lyra2/lyra2-gate.c

@@ -129,7 +129,11 @@ bool register_lyra2rev2_algo( algo_gate_t* gate )
 
 bool register_lyra2z_algo( algo_gate_t* gate )
 {
-#if defined(LYRA2Z_8WAY)
+#if defined(LYRA2Z_16WAY)
+  gate->miner_thread_init = (void*)&lyra2z_16way_thread_init;
+  gate->scanhash   = (void*)&scanhash_lyra2z_16way;
+  gate->hash       = (void*)&lyra2z_16way_hash;
+#elif defined(LYRA2Z_8WAY)
   gate->miner_thread_init = (void*)&lyra2z_8way_thread_init;
   gate->scanhash   = (void*)&scanhash_lyra2z_8way;
   gate->hash       = (void*)&lyra2z_8way_hash;
@@ -142,7 +146,7 @@ bool register_lyra2z_algo( algo_gate_t* gate )
   gate->scanhash   = (void*)&scanhash_lyra2z;
   gate->hash       = (void*)&lyra2z_hash;
 #endif
-  gate->optimizations = SSE42_OPT | AVX2_OPT;
+  gate->optimizations = SSE42_OPT | AVX2_OPT | AVX512_OPT;
   opt_target_factor = 256.0;
   return true;
 };
@@ -170,7 +174,11 @@ bool register_lyra2h_algo( algo_gate_t* gate )
 
 bool register_allium_algo( algo_gate_t* gate )
 {
-#if defined (ALLIUM_4WAY)
+#if defined (ALLIUM_8WAY)
+  gate->miner_thread_init = (void*)&init_allium_8way_ctx;
+  gate->scanhash  = (void*)&scanhash_allium_8way;
+  gate->hash      = (void*)&allium_8way_hash;
+#elif defined (ALLIUM_4WAY)
   gate->miner_thread_init = (void*)&init_allium_4way_ctx;
   gate->scanhash  = (void*)&scanhash_allium_4way;
   gate->hash      = (void*)&allium_4way_hash;
@@ -179,7 +187,7 @@ bool register_allium_algo( algo_gate_t* gate )
   gate->scanhash  = (void*)&scanhash_allium;
   gate->hash      = (void*)&allium_hash;
 #endif
-  gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT;
+  gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT | AVX512_OPT;
   opt_target_factor = 256.0;
   return true;
 };
@@ -221,7 +229,7 @@ void phi2_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
 bool register_phi2_algo( algo_gate_t* gate )
 {
 //   init_phi2_ctx();
-   gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT;
+   gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT | AVX512_OPT;
    gate->get_work_data_size = (void*)&phi2_get_work_data_size;
    gate->decode_extra_data  = (void*)&phi2_decode_extra_data;
    gate->build_extraheader  = (void*)&phi2_build_extraheader;

algo/lyra2/lyra2-gate.h

@@ -85,17 +85,25 @@ bool init_lyra2rev2_ctx();
 
 /////////////////////////
 
-#if defined(__SSE2__)
-  #define LYRA2Z_4WAY
-#endif
-#if defined(__AVX2__)
-  #define LYRA2Z_8WAY
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define LYRA2Z_16WAY 1
+#elif defined(__AVX2__)
+  #define LYRA2Z_8WAY 1
+#elif defined(__SSE2__)
+  #define LYRA2Z_4WAY 1
 #endif
 
 
 #define LYRA2Z_MATRIX_SIZE  BLOCK_LEN_INT64 * 8 * 8 * 8
 
-#if defined(LYRA2Z_8WAY)
+#if defined(LYRA2Z_16WAY)
+
+void lyra2z_16way_hash( void *state, const void *input );
+int scanhash_lyra2z_16way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr );
+bool lyra2z_16way_thread_init();
+
+#elif defined(LYRA2Z_8WAY)
 
 void lyra2z_8way_hash( void *state, const void *input );
 int scanhash_lyra2z_8way( struct work *work, uint32_t max_nonce,
@@ -144,13 +152,22 @@ bool lyra2h_thread_init();
 
 //////////////////////////////////
 
-#if defined(__AVX2__) && defined(__AES__)
-  #define ALLIUM_4WAY
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define ALLIUM_8WAY 1
+#elif defined(__AVX2__) && defined(__AES__)
+  #define ALLIUM_4WAY 1
 #endif
 
 bool register_allium_algo( algo_gate_t* gate );
 
-#if defined(ALLIUM_4WAY)
+#if defined(ALLIUM_8WAY)
+
+void allium_8way_hash( void *state, const void *input );
+int scanhash_allium_8way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr );
+bool init_allium_8way_ctx();
+
+#elif defined(ALLIUM_4WAY)
 
 void allium_4way_hash( void *state, const void *input );
 int scanhash_allium_4way( struct work *work, uint32_t max_nonce,

algo/lyra2/lyra2-hash-2way.c

@@ -26,14 +26,17 @@
 #include "lyra2.h"
 #include "sponge.h"
 
-//  LYRA2RE 8 cols 8 rows used by lyea2re, allium, phi2, x22i, x25x.
+//  LYRA2RE 8 cols 8 rows used by lyra2re, allium, phi2, x22i, x25x, 
+//  dynamic matrix allocation.
 //
-//  LYRA2REV2 4 cols 4 rows used by lyra2rev2.
+//  LYRA2REV2 4 cols 4 rows used by lyra2rev2 and x21s, static matrix
+//  allocation.
 //
 //  LYRA2REV3 4 cols 4 rows with an extra twist in calculating
-//  rowa in the wandering phase. Used by lyra2rev3.
+//  rowa in the wandering phase. Used by lyra2rev3. Static matrix
+//  allocation.
 // 
-//  LYRA2Z various cols & rows and supports 80 input. Used by lyra2z,
+//  LYRA2Z various cols & rows and supports 80 byte input. Used by lyra2z,
 //  lyra2z330, lyra2h, 
 
 
@@ -60,7 +63,7 @@
  */
 
 // For lyra2rev3.
-// convert a simple offset to an index into interleaved data.
+// convert a simple offset to an index into 2x4 u64 interleaved data.
 // good for state and 4 row matrix. 
 // index = ( int( off / 4 ) * 2 ) + ( off mod 4 )
 
@@ -202,12 +205,8 @@ int LYRA2REV3_2WAY( uint64_t* wholeMatrix, void *K, uint64_t kLen,
 
 // hard coded for 32 byte input as well as matrix size.
 // Other required versions include 80 byte input and different block
-// sizez
+// sizes.
 
-//int LYRA2REV3_2WAY( uint64_t* wholeMatrix, void *K, uint64_t kLen,
-//      const void *pwd, const uint64_t pwdlen, const void *salt,
-//      const uint64_t saltlen, const uint64_t timeCost, const uint64_t nRows,
-//      const uint64_t nCols )
 {
    //====================== Basic variables ============================//
    uint64_t _ALIGN(256) state[32];
@@ -335,159 +334,111 @@ int LYRA2REV3_2WAY( uint64_t* wholeMatrix, void *K, uint64_t kLen,
    return 0;
 }
 
-#endif // AVX512
-
-#if 0
-
 //////////////////////////////////////////////////
-int LYRA2Z( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
-            const uint64_t pwdlen, const void *salt, const uint64_t saltlen,
-            const uint64_t timeCost, const uint64_t nRows,
-            const uint64_t nCols )
+
+int LYRA2Z_2WAY( uint64_t* wholeMatrix, void *K, uint64_t kLen,
+               const void *pwd, const uint64_t pwdlen, const uint64_t timeCost,
+               const uint64_t nRows, const uint64_t nCols )
 {
     //========================== Basic variables ============================//
-    uint64_t _ALIGN(256) state[16];
-    int64_t row = 2; //index of row to be processed
-    int64_t prev = 1; //index of prev (last row ever computed/modified)
-    int64_t rowa = 0; //index of row* (a previous row, deterministically picked during Setup and randomly picked while Wandering)
-    int64_t tau; //Time Loop iterator
-    int64_t step = 1; //Visitation step (used during Setup and Wandering phases)
-    int64_t window = 2; //Visitation window (used to define which rows can be revisited during Setup)
-    int64_t gap = 1; //Modifier to the step, assuming the values 1 or -1
-//    int64_t i; //auxiliary iteration counter
+    uint64_t _ALIGN(256) state[32];
+    int64_t row = 2;
+    int64_t prev = 1;
+    int64_t rowa0 = 0;
+    int64_t rowa1 = 0;
+    int64_t tau; 
+    int64_t step = 1;
+    int64_t window = 2;
+    int64_t gap = 1; 
     //=======================================================================/
 
-    //======= Initializing the Memory Matrix and pointers to it =============//
-    //Tries to allocate enough space for the whole memory matrix
-
     const int64_t ROW_LEN_INT64 = BLOCK_LEN_INT64 * nCols;
-//    const int64_t ROW_LEN_BYTES = ROW_LEN_INT64 * 8;
-
-//    memset( wholeMatrix, 0, ROW_LEN_BYTES * nRows );
-
-    //==== Getting the password + salt + basil padded with 10*1 ============//
-    //OBS.:The memory matrix will temporarily hold the password: not for saving memory,
-    //but this ensures that the password copied locally will be overwritten as soon as possible
 
     //First, we clean enough blocks for the password, salt, basil and padding
-    uint64_t nBlocksInput = ( ( saltlen + pwdlen + 6 *
+    uint64_t nBlocksInput = ( ( pwdlen + pwdlen + 6 *
                        sizeof (uint64_t) ) / BLOCK_LEN_BLAKE2_SAFE_BYTES ) + 1;
-    byte *ptrByte = (byte*) wholeMatrix;
-    memset( ptrByte, 0, nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES );
 
-    //Prepends the password
-    memcpy(ptrByte, pwd, pwdlen);
-    ptrByte += pwdlen;
+   uint64_t *ptr = wholeMatrix;
+   uint64_t *pw = (uint64_t*)pwd;
 
-    //Concatenates the salt
-    memcpy(ptrByte, salt, saltlen);
-    ptrByte += saltlen;
-    //Concatenates the basil: every integer passed as parameter, in the order they are provided by the interface
-    memcpy(ptrByte, &kLen, sizeof (uint64_t));
-    ptrByte += sizeof (uint64_t);
-    memcpy(ptrByte, &pwdlen, sizeof (uint64_t));
-    ptrByte += sizeof (uint64_t);
-    memcpy(ptrByte, &saltlen, sizeof (uint64_t));
-    ptrByte += sizeof (uint64_t);
-    memcpy(ptrByte, &timeCost, sizeof (uint64_t));
-    ptrByte += sizeof (uint64_t);
-    memcpy(ptrByte, &nRows, sizeof (uint64_t));
-    ptrByte += sizeof (uint64_t);
-    memcpy(ptrByte, &nCols, sizeof (uint64_t));
-    ptrByte += sizeof (uint64_t);
+   memcpy( ptr, pw, 2*pwdlen ); // password 
+   ptr += pwdlen>>2;
+   memcpy( ptr, pw, 2*pwdlen ); // password lane 1
+   ptr += pwdlen>>2;
 
-    //Now comes the padding
-    *ptrByte = 0x80; //first byte of padding: right after the password
-    ptrByte = (byte*) wholeMatrix; //resets the pointer to the start of the memory matrix
-    ptrByte += nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES - 1; //sets the pointer to the correct position: end of incomplete block
-    *ptrByte ^= 0x01; //last byte of padding: at the end of the last incomplete block
+   // now build the rest interleaving on the fly.
+   ptr[0] = ptr[ 4] = kLen;
+   ptr[1] = ptr[ 5] = pwdlen;
+   ptr[2] = ptr[ 6] = pwdlen;   // saltlen
+   ptr[3] = ptr[ 7] = timeCost;
+   ptr[8] = ptr[12] = nRows;
+   ptr[9] = ptr[13] = nCols;
+   ptr[10] = ptr[14] = 0x80;
+   ptr[11] = ptr[15] = 0x0100000000000000;
 
-    //=================== Initializing the Sponge State ====================//
-    //Sponge state: 16 uint64_t, BLOCK_LEN_INT64 words of them for the bitrate (b) and the remainder for the capacity (c)
-//        uint64_t *state = _mm_malloc(16 * sizeof(uint64_t), 32);
-//        if (state == NULL) {
-//                return -1;
-//        }
-//    initState( state );
+   uint64_t *ptrWord = wholeMatrix;
 
-    //============================== Setup Phase =============================//
-    //Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits
-    uint64_t *ptrWord = wholeMatrix;
+   absorbBlockBlake2Safe_2way( state, ptrWord, nBlocksInput,
+                               BLOCK_LEN_BLAKE2_SAFE_INT64 );
 
-    absorbBlockBlake2Safe( state, ptrWord, nBlocksInput,
-                           BLOCK_LEN_BLAKE2_SAFE_INT64 );
-/*
-    for ( i = 0; i < nBlocksInput; i++ )
-    {
-      absorbBlockBlake2Safe( state, ptrWord ); //absorbs each block of pad(pwd || salt || basil)
-      ptrWord += BLOCK_LEN_BLAKE2_SAFE_INT64; //goes to next block of pad(pwd || salt || basil)
-    }
-*/
-    //Initializes M[0] and M[1]
-        reducedSqueezeRow0(state, &wholeMatrix[0], nCols); //The locally copied password is most likely overwritten here
-        reducedDuplexRow1(state, &wholeMatrix[0], &wholeMatrix[ROW_LEN_INT64], nCols);
+   //Initializes M[0] and M[1]
+   reducedSqueezeRow0_2way( state, &wholeMatrix[0], nCols );
 
-        do {
-                //M[row] = rand; //M[row*] = M[row*] XOR rotW(rand)
-                reducedDuplexRowSetup(state, &wholeMatrix[prev*ROW_LEN_INT64], &wholeMatrix[rowa*ROW_LEN_INT64], &wholeMatrix[row*ROW_LEN_INT64], nCols);
+   reducedDuplexRow1_2way( state, &wholeMatrix[0],
+                           &wholeMatrix[ 2 * ROW_LEN_INT64 ],  nCols );
 
-                //updates the value of row* (deterministically picked during Setup))
-                rowa = (rowa + step) & (window - 1);
-                //update prev: it now points to the last row ever computed
-                prev = row;
-                //updates row: goes to the next row to be computed
-                row++;
+   do
+   {
+     //M[row] = rand; //M[row*] = M[row*] XOR rotW(rand)
 
-                //Checks if all rows in the window where visited.
-                if (rowa == 0) {
-                        step = window + gap; //changes the step: approximately doubles its value
-                        window *= 2; //doubles the size of the re-visitation window
-                        gap = -gap; //inverts the modifier to the step
-                }
+     reducedDuplexRowSetup_2way( state, &wholeMatrix[ 2* prev * ROW_LEN_INT64],
+                                        &wholeMatrix[ 2* rowa0 * ROW_LEN_INT64],
+                                        &wholeMatrix[ 2* row*ROW_LEN_INT64],
+                                        nCols );
 
-        } while (row < nRows);
+     rowa0 = (rowa0 + step) & (window - 1);
+     prev = row;
+     row++;
 
-    //======================== Wandering Phase =============================//
-    row = 0; //Resets the visitation to the first row of the memory matrix
-    for ( tau = 1; tau <= timeCost; tau++ )
-    {
-        //Step is approximately half the number of all rows of the memory matrix for an odd tau; otherwise, it is -1
+     if ( rowa0 == 0 )
+     {
+        step = window + gap;
+        window *= 2;
+        gap = -gap;
+     }
+   } while ( row < nRows );
+
+   row = 0;
+   for ( tau = 1; tau <= timeCost; tau++ )
+   {
         step = (tau % 2 == 0) ? -1 : nRows / 2 - 1;
-        do {
-        //Selects a pseudorandom index row*
-        //----------------------------------------------------------------------
-        //rowa = ((unsigned int)state[0]) & (nRows-1);  //(USE THIS IF nRows IS A POWER OF 2)
-        rowa = ((uint64_t) (state[0])) % nRows; //(USE THIS FOR THE "GENERIC" CASE)
-        //-----------------------------------------------------------------
+      do
+      {
+        rowa0 = state[ 0 ] % nRows;
+        rowa1 = state[ 4 ] % nRows;
 
-        //Performs a reduced-round duplexing operation over M[row*] XOR M[prev], updating both M[row*] and M[row]
-                reducedDuplexRow(state, &wholeMatrix[prev*ROW_LEN_INT64], &wholeMatrix[rowa*ROW_LEN_INT64], &wholeMatrix[row*ROW_LEN_INT64], nCols);
+        reducedDuplexRow_2way( state, &wholeMatrix[ 2* prev * ROW_LEN_INT64 ],
+                                      &wholeMatrix[ 2* rowa0 * ROW_LEN_INT64 ],
+                                      &wholeMatrix[ 2* rowa1 * ROW_LEN_INT64 ],
+                                      &wholeMatrix[ 2* row *ROW_LEN_INT64 ],
+                                      nCols );
 
-        //update prev: it now points to the last row ever computed
         prev = row;
-
-        //updates row: goes to the next row to be computed
-        //---------------------------------------------------------------
-        //row = (row + step) & (nRows-1);       //(USE THIS IF nRows IS A POWER OF 2)
-        row = (row + step) % nRows; //(USE THIS FOR THE "GENERIC" CASE)
-        //--------------------------------------------------------------------
+        row = (row + step) % nRows;
 
       } while (row != 0);
-    }
+   }
 
-    //========================= Wrap-up Phase ===============================//
-    //Absorbs the last block of the memory matrix
-    absorbBlock(state, &wholeMatrix[rowa*ROW_LEN_INT64]);
+   absorbBlock_2way( state, &wholeMatrix[ 2 * rowa0 *ROW_LEN_INT64 ],
+                            &wholeMatrix[ 2 * rowa1 *ROW_LEN_INT64 ] );
 
-    //Squeezes the key
-    squeeze( state, K, kLen );
+   //Squeezes the key
+   squeeze_2way( state, K, (unsigned int) kLen );
 
-    return 0;
+   return 0;
 }
 
-#endif
-
-#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+////////////////////////////////////////////////////
 
 // Lyra2RE doesn't like the new wholeMatrix implementation
 int LYRA2RE_2WAY( void *K, uint64_t kLen, const void *pwd,
@@ -495,7 +446,7 @@ int LYRA2RE_2WAY( void *K, uint64_t kLen, const void *pwd,
                   const uint64_t nRows, const uint64_t nCols )
 {
    //====================== Basic variables ============================//
-   uint64_t _ALIGN(256) state[16];
+   uint64_t _ALIGN(256) state[32];
    int64_t row = 2; //index of row to be processed
    int64_t prev = 1; //index of prev (last row ever computed/modified)
    int64_t rowa0 = 0;
@@ -517,25 +468,15 @@ int LYRA2RE_2WAY( void *K, uint64_t kLen, const void *pwd,
                                           : BLOCK_LEN_BLAKE2_SAFE_BYTES;
 
    i = (int64_t)ROW_LEN_BYTES * nRows;
-   uint64_t *wholeMatrix = _mm_malloc( i, 64 );
+   uint64_t *wholeMatrix = _mm_malloc( 2*i, 64 );
    if (wholeMatrix == NULL)
       return -1;
 
-#if defined(__AVX2__)
-   memset_zero_256( (__m256i*)wholeMatrix, i>>5 );
-#elif defined(__SSE2__)
-   memset_zero_128( (__m128i*)wholeMatrix, i>>4 );   
-#else
-   memset( wholeMatrix, 0, i );
-#endif
+   memset_zero_512( (__m512i*)wholeMatrix, i>>5 );
 
    uint64_t *ptrWord = wholeMatrix;
    uint64_t *pw = (uint64_t*)pwd;
 
-   //=== Getting the password + salt + basil padded with 10*1 ==========//
-   //OBS.:The memory matrix will temporarily hold the password: not for saving memory,
-   //but this ensures that the password copied locally will be overwritten as soon as possible
-
    //First, we clean enough blocks for the password, salt, basil and padding
    int64_t nBlocksInput = ( ( pwdlen + pwdlen + 6 * sizeof(uint64_t) )
                               / BLOCK_LEN_BLAKE2_SAFE_BYTES ) + 1;
@@ -558,66 +499,8 @@ int LYRA2RE_2WAY( void *K, uint64_t kLen, const void *pwd,
    ptr[10] = ptr[14] = 0x80;
    ptr[11] = ptr[15] = 0x0100000000000000;
 
-   
-/*   
-   byte *ptrByte = (byte*) wholeMatrix;
-
-   //Prepends the password
-   memcpy(ptrByte, pwd, pwdlen);
-   ptrByte += pwdlen;
-
-   //Concatenates the salt
-   memcpy(ptrByte, salt, saltlen);
-   ptrByte += saltlen;
-
-//   memset( ptrByte, 0, nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES
-//                       - (saltlen + pwdlen) );
-
-   //Concatenates the basil: every integer passed as parameter, in the order they are provided by the interface
-   memcpy(ptrByte, &kLen, sizeof(int64_t));
-   ptrByte += sizeof(uint64_t);
-   v64 = pwdlen;
-   memcpy(ptrByte, &v64, sizeof(int64_t));
-   ptrByte += sizeof(uint64_t);
-   v64 = saltlen;
-   memcpy(ptrByte, &v64, sizeof(int64_t));
-   ptrByte += sizeof(uint64_t);
-   v64 = timeCost;
-   memcpy(ptrByte, &v64, sizeof(int64_t));
-   ptrByte += sizeof(uint64_t);
-   v64 = nRows;
-   memcpy(ptrByte, &v64, sizeof(int64_t));
-   ptrByte += sizeof(uint64_t);
-   v64 = nCols;
-   memcpy(ptrByte, &v64, sizeof(int64_t));
-   ptrByte += sizeof(uint64_t);
-
-   //Now comes the padding
-   *ptrByte = 0x80; //first byte of padding: right after the password
-   ptrByte = (byte*) wholeMatrix; //resets the pointer to the start of the memory matrix
-   ptrByte += nBlocksInput * BLOCK_LEN_BLAKE2_SAFE_BYTES - 1; //sets the pointer to the correct position: end of incomplete block
-   *ptrByte ^= 0x01; //last byte of padding: at the end of the last incomplete block
-
-   //================= Initializing the Sponge State ====================//
-   //Sponge state: 16 uint64_t, BLOCK_LEN_INT64 words of them for the bitrate (b) and the remainder for the capacity (c)
-
-//   initState( state );
-
-   //========================= Setup Phase =============================//
-   //Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits
-
-   ptrWord = wholeMatrix;
-
-*/
-
    absorbBlockBlake2Safe_2way( state, ptrWord, nBlocksInput, BLOCK_LEN );
-/*
-   for (i = 0; i < nBlocksInput; i++)
-   {
-       absorbBlockBlake2Safe( state, ptrWord ); //absorbs each block of pad(pwd || salt || basil)
-       ptrWord += BLOCK_LEN; //goes to next block of pad(pwd || salt || basil)
-   }
-*/
+
    //Initializes M[0] and M[1]
    reducedSqueezeRow0_2way( state, &wholeMatrix[0], nCols ); //The locally copied password is most likely overwritten here
 

algo/lyra2/lyra2.h

@@ -62,6 +62,8 @@ int LYRA2(void *K, int64_t kLen, const void *pwd, int32_t pwdlen, const void *sa
 
 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
 
+int LYRA2RE_2WAY( void *K, uint64_t kLen, const void *pwd, uint64_t pwdlen,
+                  uint64_t timeCost, uint64_t nRows, uint64_t nCols );
 
 int LYRA2REV2_2WAY( uint64_t*, void *K, uint64_t kLen, const void *pwd,
         uint64_t pwdlen, uint64_t timeCost, uint64_t nRows, uint64_t nCols );
@@ -69,6 +71,9 @@ int LYRA2REV2_2WAY( uint64_t*, void *K, uint64_t kLen, const void *pwd,
 int LYRA2REV3_2WAY( uint64_t*, void *K, uint64_t kLen, const void *pwd,
         uint64_t pwdlen, uint64_t timeCost, uint64_t nRows, uint64_t nCols );
 
+int LYRA2Z_2WAY( uint64_t*, void *K, uint64_t kLen, const void *pwd,
+          uint64_t pwdlen, uint64_t timeCost, uint64_t nRows, uint64_t nCols );
+
 #endif
 
 #endif /* LYRA2_H_ */

algo/lyra2/lyra2h-4way.c

@@ -20,7 +20,7 @@ static __thread blake256_4way_context l2h_4way_blake_mid;
 void lyra2h_4way_midstate( const void* input )
 {
        blake256_4way_init( &l2h_4way_blake_mid );
-       blake256_4way( &l2h_4way_blake_mid, input, 64 );
+       blake256_4way_update( &l2h_4way_blake_mid, input, 64 );
 }
 
 void lyra2h_4way_hash( void *state, const void *input )

algo/lyra2/lyra2rev2-4way.c

@@ -44,7 +44,7 @@ void lyra2rev2_8way_hash( void *state, const void *input )
    lyra2v2_8way_ctx_holder ctx __attribute__ ((aligned (64)));
    memcpy( &ctx, &l2v2_8way_ctx, sizeof(l2v2_8way_ctx) );
 
-   blake256_8way( &ctx.blake, input + (64<<3), 16 );
+   blake256_8way_update( &ctx.blake, input + (64<<3), 16 );
    blake256_8way_close( &ctx.blake, vhash );
 
    rintrlv_8x32_8x64( vhashA, vhash, 256 );
@@ -176,12 +176,12 @@ void lyra2rev2_4way_hash( void *state, const void *input )
    lyra2v2_4way_ctx_holder ctx __attribute__ ((aligned (64))); 
    memcpy( &ctx, &l2v2_4way_ctx, sizeof(l2v2_4way_ctx) );
 
-   blake256_4way( &ctx.blake, input + (64<<2), 16 );
+   blake256_4way_update( &ctx.blake, input + (64<<2), 16 );
    blake256_4way_close( &ctx.blake, vhash );
 
    rintrlv_4x32_4x64( vhash64, vhash, 256 );
 
-   keccak256_4way( &ctx.keccak, vhash64, 32 );
+   keccak256_4way_update( &ctx.keccak, vhash64, 32 );
    keccak256_4way_close( &ctx.keccak, vhash64 );
 
    dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
@@ -201,7 +201,7 @@ void lyra2rev2_4way_hash( void *state, const void *input )
 
    intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
 
-   skein256_4way( &ctx.skein, vhash64, 32 );
+   skein256_4way_update( &ctx.skein, vhash64, 32 );
    skein256_4way_close( &ctx.skein, vhash64 );
 
    dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
@@ -217,7 +217,7 @@ void lyra2rev2_4way_hash( void *state, const void *input )
 
    intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 256 );
 
-   bmw256_4way( &ctx.bmw, vhash, 32 );
+   bmw256_4way_update( &ctx.bmw, vhash, 32 );
    bmw256_4way_close( &ctx.bmw, state );
 }
 
@@ -242,7 +242,7 @@ int scanhash_lyra2rev2_4way( struct work *work, uint32_t max_nonce,
    mm128_bswap32_intrlv80_4x32( vdata, pdata );
 
    blake256_4way_init( &l2v2_4way_ctx.blake );
-   blake256_4way( &l2v2_4way_ctx.blake, vdata, 64 );
+   blake256_4way_update( &l2v2_4way_ctx.blake, vdata, 64 );
 
    do
    {

algo/lyra2/lyra2rev3-4way.c

@@ -209,7 +209,7 @@ void lyra2rev3_8way_hash( void *state, const void *input )
    lyra2v3_8way_ctx_holder ctx __attribute__ ((aligned (64)));
    memcpy( &ctx, &l2v3_8way_ctx, sizeof(l2v3_8way_ctx) );
 
-   blake256_8way( &ctx.blake, input + (64*8), 16 );
+   blake256_8way_update( &ctx.blake, input + (64*8), 16 );
    blake256_8way_close( &ctx.blake, vhash );
 
    dintrlv_8x32( hash0, hash1, hash2, hash3,
@@ -252,7 +252,7 @@ void lyra2rev3_8way_hash( void *state, const void *input )
    intrlv_8x32( vhash, hash0, hash1, hash2, hash3,
                              hash4, hash5, hash6, hash7, 256 );
 
-   bmw256_8way( &ctx.bmw, vhash, 32 );
+   bmw256_8way_update( &ctx.bmw, vhash, 32 );
    bmw256_8way_close( &ctx.bmw, state );
 
    }
@@ -277,7 +277,7 @@ int scanhash_lyra2rev3_8way( struct work *work, const uint32_t max_nonce,
    mm256_bswap32_intrlv80_8x32( vdata, pdata );
 
    blake256_8way_init( &l2v3_8way_ctx.blake );
-   blake256_8way( &l2v3_8way_ctx.blake, vdata, 64 );
+   blake256_8way_update( &l2v3_8way_ctx.blake, vdata, 64 );
 
    do
    {
@@ -334,8 +334,7 @@ void lyra2rev3_4way_hash( void *state, const void *input )
    lyra2v3_4way_ctx_holder ctx __attribute__ ((aligned (64))); 
    memcpy( &ctx, &l2v3_4way_ctx, sizeof(l2v3_4way_ctx) );
 
-//   blake256_4way( &ctx.blake, input, 80 );
-   blake256_4way( &ctx.blake, input + (64*4), 16 );
+   blake256_4way_update( &ctx.blake, input + (64*4), 16 );
    blake256_4way_close( &ctx.blake, vhash );
    dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
 
@@ -358,7 +357,7 @@ void lyra2rev3_4way_hash( void *state, const void *input )
    LYRA2REV3( l2v3_wholeMatrix, hash3, 32, hash3, 32, hash3, 32, 1, 4, 4 );
 
    intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 256 );
-   bmw256_4way( &ctx.bmw, vhash, 32 );
+   bmw256_4way_update( &ctx.bmw, vhash, 32 );
    bmw256_4way_close( &ctx.bmw, state );
 }
 
@@ -383,7 +382,7 @@ int scanhash_lyra2rev3_4way( struct work *work, const uint32_t max_nonce,
    mm128_bswap32_intrlv80_4x32( vdata, pdata );
 
    blake256_4way_init( &l2v3_4way_ctx.blake );
-   blake256_4way( &l2v3_4way_ctx.blake, vdata, 64 );
+   blake256_4way_update( &l2v3_4way_ctx.blake, vdata, 64 );
 
    do
    {

algo/lyra2/lyra2z-4way.c

@@ -1,13 +1,240 @@
 #include "lyra2-gate.h"
-
-#ifdef LYRA2Z_4WAY
-
 #include <memory.h>
 #include <mm_malloc.h>
 #include "lyra2.h"
 #include "algo/blake/sph_blake.h"
 #include "algo/blake/blake-hash-4way.h"
 
+#if defined(LYRA2Z_16WAY)
+
+__thread uint64_t* lyra2z_16way_matrix;
+
+bool lyra2z_16way_thread_init()
+{
+ return ( lyra2z_16way_matrix = _mm_malloc( 2*LYRA2Z_MATRIX_SIZE, 64 ) );
+}
+
+static __thread blake256_16way_context l2z_16way_blake_mid;
+
+void lyra2z_16way_midstate( const void* input )
+{
+       blake256_16way_init( &l2z_16way_blake_mid );
+       blake256_16way_update( &l2z_16way_blake_mid, input, 64 );
+}
+
+void lyra2z_16way_hash( void *state, const void *input )
+{
+    uint32_t vhash[8*16] __attribute__ ((aligned (128)));
+    uint32_t hash0[8] __attribute__ ((aligned (64)));
+    uint32_t hash1[8] __attribute__ ((aligned (64)));
+    uint32_t hash2[8] __attribute__ ((aligned (64)));
+    uint32_t hash3[8] __attribute__ ((aligned (64)));
+    uint32_t hash4[8] __attribute__ ((aligned (64)));
+    uint32_t hash5[8] __attribute__ ((aligned (64)));
+    uint32_t hash6[8] __attribute__ ((aligned (64)));
+    uint32_t hash7[8] __attribute__ ((aligned (64)));
+    uint32_t hash8[8] __attribute__ ((aligned (64)));
+    uint32_t hash9[8] __attribute__ ((aligned (64)));
+    uint32_t hash10[8] __attribute__ ((aligned (64)));
+    uint32_t hash11[8] __attribute__ ((aligned (64)));
+    uint32_t hash12[8] __attribute__ ((aligned (64)));
+    uint32_t hash13[8] __attribute__ ((aligned (64)));
+    uint32_t hash14[8] __attribute__ ((aligned (64)));
+    uint32_t hash15[8] __attribute__ ((aligned (64)));
+    blake256_16way_context ctx_blake __attribute__ ((aligned (64)));
+
+    memcpy( &ctx_blake, &l2z_16way_blake_mid, sizeof l2z_16way_blake_mid );
+    blake256_16way_update( &ctx_blake, input + (64*16), 16 );
+    blake256_16way_close( &ctx_blake, vhash );
+
+    dintrlv_16x32( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
+              hash8, hash9, hash10, hash11 ,hash12, hash13, hash14, hash15,
+               vhash, 256 );
+
+    intrlv_2x256( vhash, hash0, hash1, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash0, hash1, vhash, 256 );
+    intrlv_2x256( vhash, hash2, hash3, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash2, hash3, vhash, 256 );
+    intrlv_2x256( vhash, hash4, hash5, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash4, hash5, vhash, 256 );
+    intrlv_2x256( vhash, hash6, hash7, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash6, hash7, vhash, 256 );
+    intrlv_2x256( vhash, hash8, hash9, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash8, hash9, vhash, 256 );
+    intrlv_2x256( vhash, hash10, hash11, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash10, hash11, vhash, 256 );
+    intrlv_2x256( vhash, hash12, hash13, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash12, hash13, vhash, 256 );
+    intrlv_2x256( vhash, hash14, hash15, 256 );
+    LYRA2Z_2WAY( lyra2z_16way_matrix, vhash, 32, vhash, 32, 8, 8, 8 );
+    dintrlv_2x256( hash14, hash15, vhash, 256 );
+   
+    memcpy( state,     hash0, 32 );
+    memcpy( state+ 32, hash1, 32 );
+    memcpy( state+ 64, hash2, 32 );
+    memcpy( state+ 96, hash3, 32 );
+    memcpy( state+128, hash4, 32 );
+    memcpy( state+160, hash5, 32 );
+    memcpy( state+192, hash6, 32 );
+    memcpy( state+224, hash7, 32 );
+    memcpy( state+256, hash8, 32 );
+    memcpy( state+288, hash9, 32 );
+    memcpy( state+320, hash10, 32 );
+    memcpy( state+352, hash11, 32 );
+    memcpy( state+384, hash12, 32 );
+    memcpy( state+416, hash13, 32 );
+    memcpy( state+448, hash14, 32 );
+    memcpy( state+480, hash15, 32 );
+}
+
+int scanhash_lyra2z_16way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[8*16] __attribute__ ((aligned (128)));
+   uint32_t vdata[20*16] __attribute__ ((aligned (64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   uint32_t n = first_nonce;
+   __m512i  *noncev = (__m512i*)vdata + 19;   // aligned
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+
+   if ( opt_benchmark )
+      ptarget[7] = 0x0000ff;
+
+   mm512_bswap32_intrlv80_16x32( vdata, pdata );
+   lyra2z_16way_midstate( vdata );
+
+   do {
+      *noncev = mm512_bswap_32( _mm512_set_epi32( n+15, n+14, n+13, n+12,
+                                                  n+11, n+10, n+ 9, n+ 8,
+                                                  n+ 7, n+ 6, n+ 5, n+ 4,
+                                                  n+ 3, n+ 2, n+ 1, n ) );
+      lyra2z_16way_hash( hash, vdata );
+      pdata[19] = n;
+
+      for ( int i = 0; i < 16; i++ )
+      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget )
+           && !opt_benchmark )
+      {
+          pdata[19] = n+i;
+          submit_lane_solution( work, hash+(i<<3), mythr, i );
+      }
+      n += 16;
+   } while ( (n < max_nonce-16) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#elif defined(LYRA2Z_8WAY)
+
+__thread uint64_t* lyra2z_8way_matrix;
+
+bool lyra2z_8way_thread_init()
+{
+ return ( lyra2z_8way_matrix = _mm_malloc( LYRA2Z_MATRIX_SIZE, 64 ) );
+}
+
+static __thread blake256_8way_context l2z_8way_blake_mid;
+
+void lyra2z_8way_midstate( const void* input )
+{
+       blake256_8way_init( &l2z_8way_blake_mid );
+       blake256_8way_update( &l2z_8way_blake_mid, input, 64 );
+}
+
+void lyra2z_8way_hash( void *state, const void *input )
+{
+     uint32_t hash0[8] __attribute__ ((aligned (64)));
+     uint32_t hash1[8] __attribute__ ((aligned (64)));
+     uint32_t hash2[8] __attribute__ ((aligned (64)));
+     uint32_t hash3[8] __attribute__ ((aligned (64)));
+     uint32_t hash4[8] __attribute__ ((aligned (64)));
+     uint32_t hash5[8] __attribute__ ((aligned (64)));
+     uint32_t hash6[8] __attribute__ ((aligned (64)));
+     uint32_t hash7[8] __attribute__ ((aligned (64)));
+     uint32_t vhash[8*8] __attribute__ ((aligned (64)));
+     blake256_8way_context ctx_blake __attribute__ ((aligned (64)));
+
+     memcpy( &ctx_blake, &l2z_8way_blake_mid, sizeof l2z_8way_blake_mid );
+     blake256_8way_update( &ctx_blake, input + (64*8), 16 );
+     blake256_8way_close( &ctx_blake, vhash );
+
+     dintrlv_8x32( hash0, hash1, hash2, hash3,
+                   hash4, hash5, hash6, hash7, vhash, 256 );
+
+     LYRA2Z( lyra2z_8way_matrix, hash0, 32, hash0, 32, hash0, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_8way_matrix, hash1, 32, hash1, 32, hash1, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_8way_matrix, hash2, 32, hash2, 32, hash2, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_8way_matrix, hash3, 32, hash3, 32, hash3, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_8way_matrix, hash4, 32, hash4, 32, hash4, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_8way_matrix, hash5, 32, hash5, 32, hash5, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_8way_matrix, hash6, 32, hash6, 32, hash6, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_8way_matrix, hash7, 32, hash7, 32, hash7, 32, 8, 8, 8 );
+
+
+     memcpy( state,     hash0, 32 );
+     memcpy( state+ 32, hash1, 32 );
+     memcpy( state+ 64, hash2, 32 );
+     memcpy( state+ 96, hash3, 32 );
+     memcpy( state+128, hash4, 32 );
+     memcpy( state+160, hash5, 32 );
+     memcpy( state+192, hash6, 32 );
+     memcpy( state+224, hash7, 32 );
+}
+
+int scanhash_lyra2z_8way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[8*8] __attribute__ ((aligned (64)));
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   uint32_t n = first_nonce;
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+
+   if ( opt_benchmark )
+      ptarget[7] = 0x0000ff;
+
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
+   lyra2z_8way_midstate( vdata );
+
+   do {
+      *noncev = mm256_bswap_32(
+                 _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n ) );
+      lyra2z_8way_hash( hash, vdata );
+      pdata[19] = n;
+
+      for ( int i = 0; i < 8; i++ )
+      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget )
+           && !opt_benchmark )
+      {
+          pdata[19] = n+i;
+          submit_lane_solution( work, hash+(i<<3), mythr, i );
+      }
+      n += 8;
+   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+
+#elif defined(LYRA2Z_4WAY)
+
+
 __thread uint64_t* lyra2z_4way_matrix;
 
 bool lyra2z_4way_thread_init()
@@ -20,7 +247,7 @@ static __thread blake256_4way_context l2z_4way_blake_mid;
 void lyra2z_4way_midstate( const void* input )
 {
        blake256_4way_init( &l2z_4way_blake_mid );
-       blake256_4way( &l2z_4way_blake_mid, input, 64 );
+       blake256_4way_update( &l2z_4way_blake_mid, input, 64 );
 }
 
 void lyra2z_4way_hash( void *state, const void *input )
@@ -33,7 +260,7 @@ void lyra2z_4way_hash( void *state, const void *input )
      blake256_4way_context ctx_blake __attribute__ ((aligned (64)));
 
      memcpy( &ctx_blake, &l2z_4way_blake_mid, sizeof l2z_4way_blake_mid );
-     blake256_4way( &ctx_blake, input + (64*4), 16 );
+     blake256_4way_update( &ctx_blake, input + (64*4), 16 );
      blake256_4way_close( &ctx_blake, vhash );
 
      dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
@@ -85,100 +312,3 @@ int scanhash_lyra2z_4way( struct work *work, uint32_t max_nonce,
 
 #endif
 
-#if defined(LYRA2Z_8WAY)
-
-__thread uint64_t* lyra2z_8way_matrix;
-
-bool lyra2z_8way_thread_init()
-{
- return ( lyra2z_8way_matrix = _mm_malloc( LYRA2Z_MATRIX_SIZE, 64 ) );
-}
-
-static __thread blake256_8way_context l2z_8way_blake_mid;
-
-void lyra2z_8way_midstate( const void* input )
-{
-       blake256_8way_init( &l2z_8way_blake_mid );
-       blake256_8way( &l2z_8way_blake_mid, input, 64 );
-}
-
-void lyra2z_8way_hash( void *state, const void *input )
-{
-     uint32_t hash0[8] __attribute__ ((aligned (64)));
-     uint32_t hash1[8] __attribute__ ((aligned (64)));
-     uint32_t hash2[8] __attribute__ ((aligned (64)));
-     uint32_t hash3[8] __attribute__ ((aligned (64)));
-     uint32_t hash4[8] __attribute__ ((aligned (64)));
-     uint32_t hash5[8] __attribute__ ((aligned (64)));
-     uint32_t hash6[8] __attribute__ ((aligned (64)));
-     uint32_t hash7[8] __attribute__ ((aligned (64)));
-     uint32_t vhash[8*8] __attribute__ ((aligned (64)));
-     blake256_8way_context ctx_blake __attribute__ ((aligned (64)));
-
-     memcpy( &ctx_blake, &l2z_8way_blake_mid, sizeof l2z_8way_blake_mid );
-     blake256_8way( &ctx_blake, input + (64*8), 16 );
-     blake256_8way_close( &ctx_blake, vhash );
-
-     dintrlv_8x32( hash0, hash1, hash2, hash3,
-                   hash4, hash5, hash6, hash7, vhash, 256 );
-
-     LYRA2Z( lyra2z_8way_matrix, hash0, 32, hash0, 32, hash0, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_8way_matrix, hash1, 32, hash1, 32, hash1, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_8way_matrix, hash2, 32, hash2, 32, hash2, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_8way_matrix, hash3, 32, hash3, 32, hash3, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_8way_matrix, hash4, 32, hash4, 32, hash4, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_8way_matrix, hash5, 32, hash5, 32, hash5, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_8way_matrix, hash6, 32, hash6, 32, hash6, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_8way_matrix, hash7, 32, hash7, 32, hash7, 32, 8, 8, 8 );
-
-     memcpy( state,     hash0, 32 );
-     memcpy( state+ 32, hash1, 32 );
-     memcpy( state+ 64, hash2, 32 );
-     memcpy( state+ 96, hash3, 32 );
-     memcpy( state+128, hash4, 32 );
-     memcpy( state+160, hash5, 32 );
-     memcpy( state+192, hash6, 32 );
-     memcpy( state+224, hash7, 32 );
-}
-
-int scanhash_lyra2z_8way( struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done, struct thr_info *mythr )
-{
-   uint32_t hash[8*8] __attribute__ ((aligned (64)));
-   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t *pdata = work->data;
-   uint32_t *ptarget = work->target;
-   const uint32_t Htarg = ptarget[7];
-   const uint32_t first_nonce = pdata[19];
-   uint32_t n = first_nonce;
-   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
-   int thr_id = mythr->id;  // thr_id arg is deprecated
-
-   if ( opt_benchmark )
-      ptarget[7] = 0x0000ff;
-
-   mm256_bswap32_intrlv80_8x32( vdata, pdata );
-   lyra2z_8way_midstate( vdata );
-
-   do {
-      *noncev = mm256_bswap_32(
-                 _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n ) );
-      lyra2z_8way_hash( hash, vdata );
-      pdata[19] = n;
-
-      for ( int i = 0; i < 8; i++ )
-      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget )
-           && !opt_benchmark )
-      {
-          pdata[19] = n+i;         
-          submit_lane_solution( work, hash+(i<<3), mythr, i );
-      }
-      n += 8;
-   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
-
-   *hashes_done = n - first_nonce + 1;
-   return 0;
-}
-
-
-#endif

algo/nist5/nist5-4way.c

@@ -133,7 +133,7 @@ void nist5hash_4way( void *out, const void *input )
      keccak512_4way_context ctx_keccak;
 
      blake512_4way_init( &ctx_blake );
-     blake512_4way( &ctx_blake, input, 80 );
+     blake512_4way_update( &ctx_blake, input, 80 );
      blake512_4way_close( &ctx_blake, vhash );
 
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
@@ -154,15 +154,15 @@ void nist5hash_4way( void *out, const void *input )
      intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
 
      jh512_4way_init( &ctx_jh );
-     jh512_4way( &ctx_jh, vhash, 64 );
+     jh512_4way_update( &ctx_jh, vhash, 64 );
      jh512_4way_close( &ctx_jh, vhash );
 
      keccak512_4way_init( &ctx_keccak );
-     keccak512_4way( &ctx_keccak, vhash, 64 );
+     keccak512_4way_update( &ctx_keccak, vhash, 64 );
      keccak512_4way_close( &ctx_keccak, vhash );
 
      skein512_4way_init( &ctx_skein );
-     skein512_4way( &ctx_skein, vhash, 64 );
+     skein512_4way_update( &ctx_skein, vhash, 64 );
      skein512_4way_close( &ctx_skein, out );
 }
 

algo/nist5/nist5-gate.c

@@ -10,7 +10,6 @@ bool register_nist5_algo( algo_gate_t* gate )
     gate->scanhash = (void*)&scanhash_nist5_4way;
     gate->hash     = (void*)&nist5hash_4way;
 #else
-    init_nist5_ctx();
     gate->scanhash = (void*)&scanhash_nist5;
     gate->hash     = (void*)&nist5hash;
 #endif

algo/nist5/nist5-gate.h

@@ -1,5 +1,5 @@
-#ifndef __NIST5_GATE_H__
-#define __NIST5_GATE_H__ 1
+#ifndef NIST5_GATE_H__
+#define NIST5_GATE_H__ 1
 
 #include "algo-gate-api.h"
 #include <stdint.h>
@@ -30,7 +30,7 @@ void nist5hash( void *state, const void *input );
 
 int scanhash_nist5( struct work *work, uint32_t max_nonce,
                     uint64_t *hashes_done, struct thr_info *mythr );
-void init_nist5_ctx();
+
 #endif
 
 #endif

algo/nist5/nist5.c

@@ -1,84 +1,59 @@
 #include "nist5-gate.h"
-
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-
 #include "algo/blake/sph_blake.h"
-#include "algo/groestl/sph_groestl.h"
-#include "algo/skein/sph_skein.h"
 #include "algo/jh/sph_jh.h"
 #include "algo/keccak/sph_keccak.h"
-
-#include "algo/blake/sse2/blake.c"
-#include "algo/keccak/sse2/keccak.c"
-#include "algo/skein/sse2/skein.c"
-#include "algo/jh/sse2/jh_sse2_opt64.h"
-
-#ifndef NO_AES_NI
+#include "algo/skein/sph_skein.h"
+#if defined(__AES__)
   #include "algo/groestl/aes_ni/hash-groestl.h"
-#endif
-
-typedef struct {
-#ifdef NO_AES_NI
-    sph_groestl512_context groestl;
 #else
-    hashState_groestl      groestl;
+  #include "algo/groestl/sph_groestl.h"
 #endif
-} nist5_ctx_holder;
-
-nist5_ctx_holder nist5_ctx;
-
-void init_nist5_ctx()
-{
-#ifdef NO_AES_NI
-     sph_groestl512_init( &nist5_ctx.groestl );
-#else
-     init_groestl( &nist5_ctx.groestl, 64 );
-#endif
-}
 
 void nist5hash(void *output, const void *input)
 {
-     size_t hashptr;
-     unsigned char hashbuf[128];
-     sph_u64 hashctA;
-     sph_u64 hashctB;
-     unsigned char hash[128] __attribute__ ((aligned (64))) ;
-     #define hashA hash
-     #define hashB hash+64
+   uint32_t hash[16] __attribute__((aligned(64)));
+   sph_blake512_context    ctx_blake;
+#if defined(__AES__)
+   hashState_groestl       ctx_groestl;
+#else
+   sph_groestl512_context  ctx_groestl;
+#endif
+   sph_skein512_context    ctx_skein;
+   sph_jh512_context       ctx_jh;
+   sph_keccak512_context   ctx_keccak;
+   uint32_t mask = 8;
 
-     nist5_ctx_holder ctx __attribute__ ((aligned (64)));
-     memcpy( &ctx, &nist5_ctx, sizeof(nist5_ctx) );
+   sph_blake512_init( &ctx_blake );
+   sph_blake512( &ctx_blake, input, 80 );
+   sph_blake512_close( &ctx_blake, hash );
 
-     DECL_BLK;
-     BLK_I;
-     BLK_W;
-     BLK_C;
+#if defined(__AES__)
+   init_groestl( &ctx_groestl, 64 );
+   update_and_final_groestl( &ctx_groestl, (char*)hash,
+                                     (const char*)hash, 512 );
+#else
+   sph_groestl512_init( &ctx_groestl );
+   sph_groestl512( &ctx_groestl, hash, 64 );
+   sph_groestl512_close( &ctx_groestl, hash );
+#endif
 
-     #ifdef NO_AES_NI
-       sph_groestl512 (&ctx.groestl, hash, 64);
-       sph_groestl512_close(&ctx.groestl, hash);
-     #else
-       update_and_final_groestl( &ctx.groestl, (char*)hash,
-                                 (const char*)hash, 512 );
-     #endif
+   sph_jh512_init( &ctx_jh );
+   sph_jh512( &ctx_jh, hash, 64 );
+   sph_jh512_close( &ctx_jh, hash );
 
-     DECL_JH;
-     JH_H;
+   sph_keccak512_init( &ctx_keccak );
+   sph_keccak512( &ctx_keccak, hash, 64 );
+   sph_keccak512_close( &ctx_keccak, hash );
 
-     DECL_KEC;
-     KEC_I;
-     KEC_U;
-     KEC_C;
+   sph_skein512_init( &ctx_skein );
+   sph_skein512( &ctx_skein, hash, 64 );
+   sph_skein512_close( &ctx_skein, hash );
 
-     DECL_SKN;
-     SKN_I;
-     SKN_U;
-     SKN_C;
-
-     memcpy(output, hash, 32);
+   memcpy( output, hash, 32 );
 }
 
 int scanhash_nist5( struct work *work, uint32_t max_nonce,

algo/nist5/zr5.c

@@ -30,23 +30,14 @@
 #include "algo-gate-api.h"
 #include <string.h>
 #include <stdint.h>
-
-#include "algo/groestl/sph_groestl.h"
+#include "algo/blake/sph_blake.h"
+#include "algo/jh/sph_jh.h"
 #include "algo/keccak/sph_keccak.h"
-
-#ifndef NO_AES_NI
+#include "algo/skein/sph_skein.h"
+#if defined(__AES__)
   #include "algo/groestl/aes_ni/hash-groestl.h"
-#endif
-
-#include "algo/jh/sse2/jh_sse2_opt64.h"
-#include "algo/skein/sse2/skein.c"
-#include "algo/blake/sse2/blake.c"
-
-/*define data alignment for different C compilers*/
-#if defined(__GNUC__)
-      #define DATA_ALIGN16(x) x __attribute__ ((aligned(16)))
 #else
-      #define DATA_ALIGN16(x) __declspec(align(16)) x
+  #include "algo/groestl/sph_groestl.h"
 #endif
 
 #define ZR_BLAKE 0
@@ -56,38 +47,19 @@
 #define POK_BOOL_MASK 0x00008000
 #define POK_DATA_MASK 0xFFFF0000
 
-typedef struct {
-  #ifdef NO_AES_NI
-    sph_groestl512_context  groestl;
-  #else
-    hashState_groestl       groestl;
-  #endif
-    sph_keccak512_context    keccak;
-} zr5_ctx_holder;
-
-zr5_ctx_holder zr5_ctx;
-
-void init_zr5_ctx()
-{
-  #ifdef NO_AES_NI
-     sph_groestl512_init( &zr5_ctx.groestl );
-  #else
-     init_groestl( &zr5_ctx.groestl, 64 );
-  #endif
-     sph_keccak512_init(&zr5_ctx.keccak);
-}  
-
 static void zr5hash(void *state, const void *input)
 {
+   char hash[128] __attribute__((aligned(64)));
+   sph_blake512_context    ctx_blake;
+#if defined(__AES__)
+   hashState_groestl       ctx_groestl;
+#else
+   sph_groestl512_context  ctx_groestl;
+#endif
+   sph_skein512_context    ctx_skein;
+   sph_jh512_context       ctx_jh;
+   sph_keccak512_context   ctx_keccak;
     
-DATA_ALIGN16(unsigned char hashbuf[128]);
-DATA_ALIGN16(unsigned char hash[128]);
-DATA_ALIGN16(size_t hashptr);
-DATA_ALIGN16(sph_u64 hashctA);
-DATA_ALIGN16(sph_u64 hashctB);
-
-//memset(hash, 0, 128);
-
 static const int arrOrder[][4] =
 {
    { 0, 1, 2, 3 }, { 0, 1, 3, 2 }, { 0, 2, 1, 3 }, { 0, 2, 3, 1 },
@@ -98,50 +70,48 @@ static const int arrOrder[][4] =
    { 3, 1, 0, 2 }, { 3, 1, 2, 0 }, { 3, 2, 0, 1 }, { 3, 2, 1, 0 }
 };
 
-    zr5_ctx_holder ctx;
-    memcpy( &ctx, &zr5_ctx, sizeof(zr5_ctx) );
-
-    sph_keccak512 (&ctx.keccak, input, 80);
-    sph_keccak512_close(&ctx.keccak, hash);
+    sph_keccak512_init( &ctx_keccak );
+    sph_keccak512( &ctx_keccak, input, 80 );
+    sph_keccak512_close( &ctx_keccak, hash );
   
     unsigned int nOrder = *(unsigned int *)(&hash) % 24;
     unsigned int i = 0;
 
-    for (i = 0; i < 4; i++)
+    for ( i = 0; i < 4; i++ )
     {
-       switch (arrOrder[nOrder][i])
+       switch ( arrOrder[nOrder][i] )
        {
          case 0:
-		{DECL_BLK;
-		BLK_I;
-		BLK_U;
-		BLK_C;}
-		break;
+            sph_blake512_init( &ctx_blake );
+            sph_blake512( &ctx_blake, hash, 64 );
+            sph_blake512_close( &ctx_blake, hash );
+		      break;
          case 1:
-            #ifdef NO_AES_NI
-                sph_groestl512 (&ctx.groestl, hash, 64);
-                sph_groestl512_close(&ctx.groestl, hash);
-            #else
-                update_groestl( &ctx.groestl, (char*)hash,512);
-                final_groestl( &ctx.groestl, (char*)hash);
-            #endif
-	    break;
+#if defined(__AES__)
+            init_groestl( &ctx_groestl, 64 );
+            update_and_final_groestl( &ctx_groestl, (char*)hash,
+                                               (const char*)hash, 512 );
+#else
+            sph_groestl512_init( &ctx_groestl );
+            sph_groestl512( &ctx_groestl, hash, 64 );
+            sph_groestl512_close( &ctx_groestl, hash );
+#endif
+	         break;
          case 2:
-		{DECL_JH;
-		JH_H;} 
-		break;
+            sph_jh512_init( &ctx_jh );
+            sph_jh512( &ctx_jh, hash, 64 );
+            sph_jh512_close( &ctx_jh, hash );
+	         break;
          case 3:
-		{DECL_SKN;
-                SKN_I;
-                SKN_U;
-                SKN_C; }
-		break;
+            sph_skein512_init( &ctx_skein );
+            sph_skein512( &ctx_skein, hash, 64 );
+            sph_skein512_close( &ctx_skein, hash );
+            break;
          default:
            break;
        }
     }
-	asm volatile ("emms");
-	memcpy(state, hash, 32);
+	memcpy( state, hash, 32 );
 }
 
 int scanhash_zr5( struct work *work, uint32_t max_nonce,
@@ -219,7 +189,6 @@ int zr5_get_work_data_size() { return 80; }
 bool register_zr5_algo( algo_gate_t* gate )
 {
     gate->optimizations = SSE2_OPT | AES_OPT;
-    init_zr5_ctx();
     gate->get_new_work          = (void*)&zr5_get_new_work;
     gate->scanhash              = (void*)&scanhash_zr5;
     gate->hash                  = (void*)&zr5hash;

algo/panama/panama-hash-4way.c

@@ -0,0 +1,547 @@
+#include <stddef.h>
+#include <string.h>
+#include "panama-hash-4way.h"
+
+//  Common macros
+
+#define M17( macro ) \
+do { \
+      macro( 0,  1,  2,  4); \
+      macro( 1,  2,  3,  5); \
+      macro( 2,  3,  4,  6); \
+      macro( 3,  4,  5,  7); \
+      macro( 4,  5,  6,  8); \
+      macro( 5,  6,  7,  9); \
+      macro( 6,  7,  8, 10); \
+      macro( 7,  8,  9, 11); \
+      macro( 8,  9, 10, 12); \
+      macro( 9, 10, 11, 13); \
+      macro(10, 11, 12, 14); \
+      macro(11, 12, 13, 15); \
+      macro(12, 13, 14, 16); \
+      macro(13, 14, 15,  0); \
+      macro(14, 15, 16,  1); \
+      macro(15, 16,  0,  2); \
+      macro(16,  0,  1,  3); \
+} while (0)
+
+
+#define RSTATE(n0, n1, n2, n4)    (a ## n0 = sc->state[n0])
+
+#define WSTATE(n0, n1, n2, n4)    (sc->state[n0] = a ## n0)
+
+#define INC0     1
+#define INC1     2
+#define INC2     3
+#define INC3     4
+#define INC4     5
+#define INC5     6
+#define INC6     7
+#define INC7     8
+
+//////////////////////////////////
+//
+//    Panama-256 4 way SSE2
+
+#define LVAR17_4W(b)  __m128i \
+	b ## 0, b ## 1, b ## 2, b ## 3, b ## 4, b ## 5, \
+	b ## 6, b ## 7, b ## 8, b ## 9, b ## 10, b ## 11, \
+	b ## 12, b ## 13, b ## 14, b ## 15, b ## 16;
+
+#define LVARS_4W   \
+	LVAR17_4W(a) \
+	LVAR17_4W(g) \
+	LVAR17_4W(p) \
+	LVAR17_4W(t)
+
+#define BUPDATE1_4W( n0, n2 ) \
+do { \
+   sc->buffer[ptr24][n0] = _mm_xor_si128( sc->buffer[ptr24][n0], \
+                                          sc->buffer[ptr31][n2] ); \
+   sc->buffer[ptr31][n2] = _mm_xor_si128( sc->buffer[ptr31][n2], INW1(n2) ); \
+} while (0)
+
+#define BUPDATE_4W \
+do { \
+		BUPDATE1_4W(0, 2); \
+		BUPDATE1_4W(1, 3); \
+		BUPDATE1_4W(2, 4); \
+		BUPDATE1_4W(3, 5); \
+		BUPDATE1_4W(4, 6); \
+		BUPDATE1_4W(5, 7); \
+		BUPDATE1_4W(6, 0); \
+		BUPDATE1_4W(7, 1); \
+} while (0)
+
+#define GAMMA_4W(n0, n1, n2, n4)   \
+   (g ## n0 = _mm_xor_si128( a ## n0, \
+                             _mm_or_si128( a ## n1, mm128_not( a ## n2 ) ) ) )
+
+#define PI_ALL_4W   do { \
+      p0  = g0; \
+      p1  = mm128_rol_32(  g7,  1 ); \
+      p2  = mm128_rol_32( g14,  3 ); \
+      p3  = mm128_rol_32(  g4,  6 ); \
+      p4  = mm128_rol_32( g11, 10 ); \
+      p5  = mm128_rol_32(  g1, 15 ); \
+      p6  = mm128_rol_32(  g8, 21 ); \
+      p7  = mm128_rol_32( g15, 28 ); \
+      p8  = mm128_rol_32(  g5,  4 ); \
+      p9  = mm128_rol_32( g12, 13 ); \
+      p10 = mm128_rol_32(  g2, 23 ); \
+      p11 = mm128_rol_32(  g9,  2 ); \
+      p12 = mm128_rol_32( g16, 14 ); \
+      p13 = mm128_rol_32(  g6, 27 ); \
+      p14 = mm128_rol_32( g13,  9 ); \
+      p15 = mm128_rol_32(  g3, 24 ); \
+      p16 = mm128_rol_32( g10,  8 ); \
+   } while (0)
+
+#define THETA_4W(n0, n1, n2, n4)   \
+   ( t ## n0 = _mm_xor_si128( p ## n0, _mm_xor_si128( p ## n1, p ## n4 ) ) )
+
+#define SIGMA_ALL_4W   do { \
+		a0 = _mm_xor_si128( t0, _mm_set1_epi32( 1 ) ); \
+		a1 = _mm_xor_si128( t1, INW2( 0 ) ); \
+		a2 = _mm_xor_si128( t2, INW2( 1 ) ); \
+		a3 = _mm_xor_si128( t3, INW2( 2 ) ); \
+		a4 = _mm_xor_si128( t4, INW2( 3 ) ); \
+		a5 = _mm_xor_si128( t5, INW2( 4 ) ); \
+		a6 = _mm_xor_si128( t6, INW2( 5 ) ); \
+		a7 = _mm_xor_si128( t7, INW2( 6 ) ); \
+		a8 = _mm_xor_si128( t8, INW2( 7 ) ); \
+		a9  = _mm_xor_si128(  t9, sc->buffer[ ptr16 ] [0 ] ); \
+		a10 = _mm_xor_si128( t10, sc->buffer[ ptr16 ] [1 ] ); \
+		a11 = _mm_xor_si128( t11, sc->buffer[ ptr16 ] [2 ] ); \
+		a12 = _mm_xor_si128( t12, sc->buffer[ ptr16 ] [3 ] ); \
+		a13 = _mm_xor_si128( t13, sc->buffer[ ptr16 ] [4 ] ); \
+		a14 = _mm_xor_si128( t14, sc->buffer[ ptr16 ] [5 ] ); \
+		a15 = _mm_xor_si128( t15, sc->buffer[ ptr16 ] [6 ] ); \
+		a16 = _mm_xor_si128( t16, sc->buffer[ ptr16 ] [7 ] ); \
+	} while (0)
+
+#define PANAMA_STEP_4W   do { \
+		unsigned ptr16, ptr24, ptr31; \
+ \
+		ptr24 = (ptr0 - 8) & 31; \
+		ptr31 = (ptr0 - 1) & 31; \
+		BUPDATE_4W; \
+		M17( GAMMA_4W ); \
+		PI_ALL_4W; \
+		M17( THETA_4W ); \
+		ptr16 = ptr0 ^ 16; \
+		SIGMA_ALL_4W; \
+		ptr0 = ptr31; \
+	} while (0)
+
+static void
+panama_4way_push( panama_4way_context *sc, const unsigned char *pbuf,
+                  size_t num )
+{
+	LVARS_4W
+	unsigned ptr0;
+
+#define INW1(i)   casti_m128i( pbuf, i )
+#define INW2(i)   INW1(i)
+
+	M17( RSTATE );
+
+   ptr0 = sc->buffer_ptr;
+	while (num -- > 0) {
+		PANAMA_STEP_4W;
+		pbuf = (const unsigned char *)pbuf + 32*4;
+	}
+	M17( WSTATE );
+	sc->buffer_ptr = ptr0;
+
+#undef INW1
+#undef INW2
+}
+
+/*
+ * Perform the "pull" operation repeatedly ("num" times). The hash output
+ * will be extracted from the state afterwards.
+ */
+static void
+panama_4way_pull( panama_4way_context *sc, unsigned num )
+{
+	LVARS_4W
+	unsigned ptr0;
+#define INW1(i)     INW_H1(INC ## i)
+#define INW_H1(i)   INW_H2(i)
+#define INW_H2(i)   a ## i
+#define INW2(i)     casti_m128i( sc->buffer[ptr4], i )
+
+	M17( RSTATE );
+
+   ptr0 = sc->buffer_ptr;
+
+   while (num -- > 0) {
+		unsigned ptr4;
+
+		ptr4 = ( (ptr0 + 4) & 31 );
+
+      PANAMA_STEP_4W;
+	}
+	M17( WSTATE );
+
+#undef INW1
+#undef INW_H1
+#undef INW_H2
+#undef INW2
+}
+
+void
+panama_4way_init(void *cc)
+{
+	panama_4way_context *sc;
+
+	sc = cc;
+	/*
+	 * This is not completely conformant, but "it will work
+	 * everywhere". Initial state consists of zeroes everywhere.
+	 * Conceptually, the sph_u32 type may have padding bits which
+	 * must not be set to 0; but such an architecture remains to
+	 * be seen.
+	 */
+	sc->data_ptr = 0;
+	memset( sc->buffer, 0, sizeof sc->buffer );
+	sc->buffer_ptr = 0;
+	memset( sc->state, 0, sizeof sc->state );
+}
+
+static void
+panama_4way_short( void *cc, const void *data, size_t len )
+{
+	panama_4way_context *sc;
+	unsigned current;
+	sc = cc;
+	current = sc->data_ptr;
+	while (len > 0) {
+		unsigned clen;
+
+		clen = ( (sizeof sc->data ) >> 2 ) - current;
+		if (clen > len)
+			clen = len;
+
+      memcpy( sc->data + (current << 2), data, clen << 2 );
+		data = (const unsigned char *)data + ( clen << 2 );
+		len -= clen;
+		current += clen;
+		if (current == ( (sizeof sc->data) >> 2 ) )
+      {
+			current = 0;
+			panama_4way_push( sc, sc->data, 1 );
+		}
+	}
+
+   sc->data_ptr = current;
+}
+
+void
+panama_4way_update( void *cc, const void *data, size_t len )
+{
+	panama_4way_context *sc;
+	unsigned current;
+	size_t rlen;
+
+	if ( len < ( 2 * ( (sizeof sc->data ) >> 2 ) ) )
+   {
+		panama_4way_short( cc, data, len );
+		return;
+	}
+	sc = cc;
+	current = sc->data_ptr;
+	if ( current > 0 )
+   {
+		unsigned t;
+
+		t = ( (sizeof sc->data) >> 2 ) -  current;
+		panama_4way_short(sc, data, t);
+		data = (const unsigned char *)data + ( t << 2 );
+		len -= t;
+	}
+
+   panama_4way_push( sc, data, len >> 5 );
+
+   rlen = len & 31;
+	if ( rlen > 0 )
+      memcpy_128( (__m128i*)sc->data, (__m128i*)data  + len - rlen, rlen );
+
+	sc->data_ptr = rlen;
+}
+
+void
+panama_4way_close( void *cc, void *dst )
+{
+	panama_4way_context *sc;
+	unsigned current;
+	int i;
+
+	sc = cc;
+	current = sc->data_ptr;
+	*(__m128i*)( sc->data + current ) = m128_one_32;
+   current++;
+   memset_zero_128( (__m128i*)sc->data + current, 32 - current );
+
+   panama_4way_push( sc, sc->data, 1 );
+
+   panama_4way_pull( sc, 32 );
+
+   for ( i = 0; i < 8; i ++ )
+      casti_m128i( dst, i ) = sc->state[i + 9];
+}
+
+
+#if defined(__AVX2__)
+
+///////////////////////
+//
+//    Panama-256 8 way AVX2
+
+#define LVAR17_8W(b)  __m256i \
+   b ## 0, b ## 1, b ## 2, b ## 3, b ## 4, b ## 5, \
+   b ## 6, b ## 7, b ## 8, b ## 9, b ## 10, b ## 11, \
+   b ## 12, b ## 13, b ## 14, b ## 15, b ## 16;
+
+#define LVARS_8W   \
+   LVAR17_8W(a) \
+   LVAR17_8W(g) \
+   LVAR17_8W(p) \
+   LVAR17_8W(t)
+
+#define BUPDATE1_8W( n0, n2 ) \
+do { \
+   sc->buffer[ptr24][n0] = _mm256_xor_si256( sc->buffer[ptr24][n0], \
+                                             sc->buffer[ptr31][n2] ); \
+   sc->buffer[ptr31][n2] = _mm256_xor_si256( sc->buffer[ptr31][n2], INW1(n2) ); \
+} while (0)
+
+#define BUPDATE_8W \
+do { \
+      BUPDATE1_8W(0, 2); \
+      BUPDATE1_8W(1, 3); \
+      BUPDATE1_8W(2, 4); \
+      BUPDATE1_8W(3, 5); \
+      BUPDATE1_8W(4, 6); \
+      BUPDATE1_8W(5, 7); \
+      BUPDATE1_8W(6, 0); \
+      BUPDATE1_8W(7, 1); \
+} while (0)
+
+#define GAMMA_8W(n0, n1, n2, n4)   \
+   (g ## n0 = _mm256_xor_si256( a ## n0, \
+                         _mm256_or_si256( a ## n1, mm256_not( a ## n2 ) ) ) )
+
+#define PI_ALL_8W   do { \
+      p0  = g0; \
+      p1  = mm256_rol_32(  g7,  1 ); \
+      p2  = mm256_rol_32( g14,  3 ); \
+      p3  = mm256_rol_32(  g4,  6 ); \
+      p4  = mm256_rol_32( g11, 10 ); \
+      p5  = mm256_rol_32(  g1, 15 ); \
+      p6  = mm256_rol_32(  g8, 21 ); \
+      p7  = mm256_rol_32( g15, 28 ); \
+      p8  = mm256_rol_32(  g5,  4 ); \
+      p9  = mm256_rol_32( g12, 13 ); \
+      p10 = mm256_rol_32(  g2, 23 ); \
+      p11 = mm256_rol_32(  g9,  2 ); \
+      p12 = mm256_rol_32( g16, 14 ); \
+      p13 = mm256_rol_32(  g6, 27 ); \
+      p14 = mm256_rol_32( g13,  9 ); \
+      p15 = mm256_rol_32(  g3, 24 ); \
+      p16 = mm256_rol_32( g10,  8 ); \
+   } while (0)
+
+#define THETA_8W(n0, n1, n2, n4)   \
+   ( t ## n0 = _mm256_xor_si256( p ## n0, _mm256_xor_si256( p ## n1, p ## n4 ) ) )
+
+#define SIGMA_ALL_8W   do { \
+      a0  = _mm256_xor_si256( t0, m256_one_32 ); \
+      a1  = _mm256_xor_si256( t1, INW2( 0 ) ); \
+      a2  = _mm256_xor_si256( t2, INW2( 1 ) ); \
+      a3  = _mm256_xor_si256( t3, INW2( 2 ) ); \
+      a4  = _mm256_xor_si256( t4, INW2( 3 ) ); \
+      a5  = _mm256_xor_si256( t5, INW2( 4 ) ); \
+      a6  = _mm256_xor_si256( t6, INW2( 5 ) ); \
+      a7  = _mm256_xor_si256( t7, INW2( 6 ) ); \
+      a8  = _mm256_xor_si256( t8, INW2( 7 ) ); \
+      a9  = _mm256_xor_si256(  t9, sc->buffer[ ptr16 ] [0 ] ); \
+      a10 = _mm256_xor_si256( t10, sc->buffer[ ptr16 ] [1 ] ); \
+      a11 = _mm256_xor_si256( t11, sc->buffer[ ptr16 ] [2 ] ); \
+      a12 = _mm256_xor_si256( t12, sc->buffer[ ptr16 ] [3 ] ); \
+      a13 = _mm256_xor_si256( t13, sc->buffer[ ptr16 ] [4 ] ); \
+      a14 = _mm256_xor_si256( t14, sc->buffer[ ptr16 ] [5 ] ); \
+      a15 = _mm256_xor_si256( t15, sc->buffer[ ptr16 ] [6 ] ); \
+      a16 = _mm256_xor_si256( t16, sc->buffer[ ptr16 ] [7 ] ); \
+   } while (0)
+
+#define PANAMA_STEP_8W   do { \
+      unsigned ptr16, ptr24, ptr31; \
+ \
+      ptr24 = (ptr0 - 8) & 31; \
+      ptr31 = (ptr0 - 1) & 31; \
+      BUPDATE_8W; \
+      M17( GAMMA_8W ); \
+      PI_ALL_8W; \
+      M17( THETA_8W ); \
+      ptr16 = ptr0 ^ 16; \
+      SIGMA_ALL_8W; \
+      ptr0 = ptr31; \
+   } while (0)
+
+static void
+panama_8way_push( panama_8way_context *sc, const unsigned char *pbuf,
+                  size_t num )
+{
+   LVARS_8W
+   unsigned ptr0;
+
+#define INW1(i)   casti_m256i( pbuf, i )
+#define INW2(i)   INW1(i)
+
+   M17( RSTATE );
+
+   ptr0 = sc->buffer_ptr;
+   while ( num-- > 0 )
+   {
+      PANAMA_STEP_8W;
+      pbuf = (const unsigned char *)pbuf + 32*8;
+   }
+   M17( WSTATE );
+   sc->buffer_ptr = ptr0;
+
+#undef INW1
+#undef INW2
+}
+
+static void
+panama_8way_pull( panama_8way_context *sc, unsigned num )
+{
+   LVARS_8W
+   unsigned ptr0;
+#define INW1(i)     INW_H1(INC ## i)
+#define INW_H1(i)   INW_H2(i)
+#define INW_H2(i)   a ## i
+#define INW2(i)     casti_m256i( sc->buffer[ptr4], i )
+
+   M17( RSTATE );
+
+   ptr0 = sc->buffer_ptr;
+
+   while (num -- > 0) {
+      unsigned ptr4;
+
+      ptr4 = ( (ptr0 + 4) & 31 );
+      PANAMA_STEP_8W;
+   }
+   M17( WSTATE );
+
+#undef INW1
+#undef INW_H1
+#undef INW_H2
+#undef INW2
+}
+
+void
+panama_8way_init( void *cc )
+{
+   panama_8way_context *sc;
+
+   sc = cc;
+   /*
+    * This is not completely conformant, but "it will work
+    * everywhere". Initial state consists of zeroes everywhere.
+    * Conceptually, the sph_u32 type may have padding bits which
+    * must not be set to 0; but such an architecture remains to
+    * be seen.
+    */
+   sc->data_ptr = 0;
+   memset( sc->buffer, 0, sizeof sc->buffer );
+   sc->buffer_ptr = 0;
+   memset( sc->state, 0, sizeof sc->state );
+}
+
+static void
+panama_8way_short( void *cc, const void *data, size_t len )
+{
+   panama_8way_context *sc;
+   unsigned current;
+   sc = cc;
+   current = sc->data_ptr;
+   while (len > 0) {
+      unsigned clen;
+
+      clen = ( (sizeof sc->data ) >> 3 ) - current;
+      if (clen > len)
+         clen = len;
+
+      memcpy( sc->data + (current << 3), data, clen << 3 );
+      data = (const unsigned char *)data + ( clen << 3 );
+      len -= clen;
+      current += clen;
+      if (current == ( (sizeof sc->data) >> 3 ) )
+      {
+         current = 0;
+         panama_8way_push( sc, sc->data, 1 );
+      }
+   }
+
+   sc->data_ptr = current;
+}
+
+void
+panama_8way_update( void *cc, const void *data, size_t len )
+{
+   panama_8way_context *sc;
+   unsigned current;
+   size_t rlen;
+
+   if ( len < ( 2 * ( (sizeof sc->data ) >> 3 ) ) )
+   {
+      panama_8way_short( cc, data, len );
+      return;
+   }
+   sc = cc;
+   current = sc->data_ptr;
+   if ( current > 0 )
+   {
+      unsigned t;
+
+      t = ( (sizeof sc->data) >> 3 ) -  current;
+      panama_8way_short(sc, data, t);
+      data = (const unsigned char *)data + ( t << 3 );
+      len -= t;
+   }
+
+   panama_8way_push( sc, data, len >> 5 );
+
+   rlen = len & 31;
+   if ( rlen > 0 )
+      memcpy_256( (__m256i*)sc->data, (__m256i*)data  + len - rlen, rlen );
+
+   sc->data_ptr = rlen;
+}
+
+void
+panama_8way_close( void *cc, void *dst )
+{
+   panama_8way_context *sc;
+   unsigned current;
+   int i;
+
+   sc = cc;
+   current = sc->data_ptr;
+   *(__m256i*)( sc->data + current ) = m256_one_32;
+   current++;
+   memset_zero_256( (__m256i*)sc->data + current, 32 - current );
+
+   panama_8way_push( sc, sc->data, 1 );
+
+   panama_8way_pull( sc, 32 );
+
+   for ( i = 0; i < 8; i ++ )
+      casti_m256i( dst, i ) = sc->state[i + 9];
+}
+
+#endif

algo/panama/panama-hash-4way.h

@@ -0,0 +1,43 @@
+#ifndef PANAMA_HASH_4WAY_H__
+#define PANAMA_HASH_4WAY_H__ 1
+
+#include <stddef.h>
+#include "simd-utils.h"
+
+/**
+ * Output size (in bits) for PANAMA.
+ */
+#define SPH_SIZE_panama   256
+
+typedef struct {
+   unsigned char data[32<<2];
+   __m128i buffer[32][8];
+   __m128i state[17];
+   unsigned data_ptr;
+   unsigned buffer_ptr;
+} panama_4way_context __attribute__ ((aligned (64)));
+
+void panama_4way_init( void *cc );
+
+void panama_4way_update( void *cc, const void *data, size_t len );
+
+void panama_4way_close( void *cc, void *dst );
+
+#if defined(__AVX2__)
+
+typedef struct {
+   unsigned char data[32<<3];
+   __m256i buffer[32][8];
+   __m256i state[17];
+   unsigned data_ptr;
+   unsigned buffer_ptr;
+} panama_8way_context __attribute__ ((aligned (128)));
+
+void panama_8way_init( void *cc );
+
+void panama_8way_update( void *cc, const void *data, size_t len );
+
+void panama_8way_close( void *cc, void *dst );
+
+#endif
+#endif

algo/quark/anime-4way.c

@@ -54,10 +54,10 @@ void anime_4way_hash( void *state, const void *input )
     anime_4way_ctx_holder ctx;
     memcpy( &ctx, &anime_4way_ctx, sizeof(anime_4way_ctx) );
 
-    bmw512_4way( &ctx.bmw, input, 80 );
+    bmw512_4way_update( &ctx.bmw, input, 80 );
     bmw512_4way_close( &ctx.bmw, vhash );
 
-    blake512_4way( &ctx.blake, vhash, 64 );
+    blake512_4way_update( &ctx.blake, vhash, 64 );
     blake512_4way_close( &ctx.blake, vhash );
 
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ), zero );
@@ -92,7 +92,7 @@ void anime_4way_hash( void *state, const void *input )
 
     if ( mm256_anybits0( vh_mask ) )
     {
-       skein512_4way( &ctx.skein, vhash, 64 );
+       skein512_4way_update( &ctx.skein, vhash, 64 );
        skein512_4way_close( &ctx.skein, vhashB );
     }
 
@@ -111,7 +111,7 @@ void anime_4way_hash( void *state, const void *input )
 
     intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
 
-    jh512_4way( &ctx.jh, vhash, 64 );
+    jh512_4way_update( &ctx.jh, vhash, 64 );
     jh512_4way_close( &ctx.jh, vhash );
 
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ), zero );
@@ -119,23 +119,23 @@ void anime_4way_hash( void *state, const void *input )
     if ( mm256_anybits1( vh_mask ) )
     {
        blake512_4way_init( &ctx.blake );
-       blake512_4way( &ctx.blake, vhash, 64 );
+       blake512_4way_update( &ctx.blake, vhash, 64 );
        blake512_4way_close( &ctx.blake, vhashA );
     }
     if ( mm256_anybits0( vh_mask ) )
     {
        bmw512_4way_init( &ctx.bmw );
-       bmw512_4way( &ctx.bmw, vhash, 64 );
+       bmw512_4way_update( &ctx.bmw, vhash, 64 );
        bmw512_4way_close( &ctx.bmw, vhashB );
     }
 
     mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
 
-    keccak512_4way( &ctx.keccak, vhash, 64 );
+    keccak512_4way_update( &ctx.keccak, vhash, 64 );
     keccak512_4way_close( &ctx.keccak, vhash );
 
     skein512_4way_init( &ctx.skein );
-    skein512_4way( &ctx.skein, vhash, 64 );
+    skein512_4way_update( &ctx.skein, vhash, 64 );
     skein512_4way_close( &ctx.skein, vhash );
 
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ), zero );
@@ -143,13 +143,13 @@ void anime_4way_hash( void *state, const void *input )
     if ( mm256_anybits1( vh_mask ) )
     {
        keccak512_4way_init( &ctx.keccak );
-       keccak512_4way( &ctx.keccak, vhash, 64 );
+       keccak512_4way_update( &ctx.keccak, vhash, 64 );
        keccak512_4way_close( &ctx.keccak, vhashA );
     }
     if ( mm256_anybits0( vh_mask ) )
     {
        jh512_4way_init( &ctx.jh );
-       jh512_4way( &ctx.jh, vhash, 64 );
+       jh512_4way_update( &ctx.jh, vhash, 64 );
        jh512_4way_close( &ctx.jh, vhashB );
     }
 

algo/quark/hmq1725-4way.c

@@ -21,6 +21,11 @@
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/haval-hash-4way.h"
 #include "algo/sha/sha-hash-4way.h"
+#if defined(__VAES__)
+  #include "algo/groestl/groestl512-hash-4way.h"
+  #include "algo/shavite/shavite-hash-4way.h"
+  #include "algo/echo/echo-hash-4way.h"
+#endif
 
 #if defined(HMQ1725_8WAY)
 
@@ -28,21 +33,27 @@ union _hmq1725_8way_context_overlay
 {
     blake512_8way_context   blake;
     bmw512_8way_context     bmw;
-    hashState_groestl       groestl;
     skein512_8way_context   skein;
     jh512_8way_context      jh;
     keccak512_8way_context  keccak;
     luffa_4way_context      luffa;
     cube_4way_context       cube;
-    sph_shavite512_context  shavite;
     simd_4way_context       simd;
-    hashState_echo          echo;
     hamsi512_8way_context   hamsi;
     sph_fugue512_context    fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
     haval256_5_8way_context haval;
+#if defined(__VAES__)
+    groestl512_4way_context groestl;
+    shavite512_4way_context shavite;
+    echo_4way_context       echo;
+#else
+    hashState_groestl       groestl;
+    sph_shavite512_context  shavite;
+    hashState_echo          echo;
+#endif
 } __attribute__ ((aligned (64)));
 
 typedef union _hmq1725_8way_context_overlay hmq1725_8way_context_overlay;
@@ -52,6 +63,7 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    uint32_t vhash [16<<3] __attribute__ ((aligned (128)));
    uint32_t vhashA[16<<3] __attribute__ ((aligned (64)));
    uint32_t vhashB[16<<3] __attribute__ ((aligned (64)));
+   uint32_t vhashC[16<<3] __attribute__ ((aligned (64)));
    uint32_t hash0 [16]    __attribute__ ((aligned (64)));
    uint32_t hash1 [16]    __attribute__ ((aligned (64)));
    uint32_t hash2 [16]    __attribute__ ((aligned (64)));
@@ -67,6 +79,7 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    __m512i* vh  = (__m512i*)vhash;
    __m512i* vhA = (__m512i*)vhashA;
    __m512i* vhB = (__m512i*)vhashB;
+   __m512i* vhC = (__m512i*)vhashC;
 
    bmw512_8way_init( &ctx.bmw );
    bmw512_8way_update( &ctx.bmw, input, 80 );
@@ -106,6 +119,28 @@ extern void hmq1725_8way_hash(void *state, const void *input)
                                        m512_zero );
 
    // A
+
+#if defined(__VAES__)
+
+   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+   if ( likely( ( vh_mask & 0x0f ) != 0x0f ) )
+   {
+     groestl512_4way_init( &ctx.groestl, 64 );
+     groestl512_4way_update_close( &ctx.groestl, vhashA, vhashA, 512 );
+   }
+   if ( likely( ( vh_mask & 0xf0 ) != 0xf0 ) )
+   {
+     groestl512_4way_init( &ctx.groestl, 64 );
+     groestl512_4way_update_close( &ctx.groestl, vhashB, vhashB, 512 );
+   }
+   rintrlv_4x128_8x64( vhashC, vhashA, vhashB, 512 );
+
+#else
+
+   dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
+                   vhash );
+
    if ( hash0[0] & mask )
    {
      init_groestl( &ctx.groestl, 64 );
@@ -140,13 +175,13 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    {
      init_groestl( &ctx.groestl, 64 );
      update_and_final_groestl( &ctx.groestl, (char*)hash5,
-                                               (char*)hash5, 512 );
+                                             (char*)hash5, 512 );
    }
    if ( hash6[0] & mask )
    {
      init_groestl( &ctx.groestl, 64 );
      update_and_final_groestl( &ctx.groestl, (char*)hash6,
-                                               (char*)hash6, 512 );
+                                             (char*)hash6, 512 );
    }
    if ( hash7[0] & mask )
    {
@@ -155,9 +190,11 @@ extern void hmq1725_8way_hash(void *state, const void *input)
                                              (char*)hash7, 512 );
    }
 
-   intrlv_8x64_512( vhashA, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
+   intrlv_8x64_512( vhashC, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                          hash7 );
 
+#endif
+
    // B
    if ( likely( vh_mask & 0xff ) )
    {
@@ -166,7 +203,7 @@ extern void hmq1725_8way_hash(void *state, const void *input)
       skein512_8way_close( &ctx.skein, vhashB );
    }
 
-   mm512_blend_hash_8x64( vh, vhA, vhB, vh_mask );
+   mm512_blend_hash_8x64( vh, vhC, vhB, vh_mask );
 
    jh512_8way_init( &ctx.jh );
    jh512_8way_update( &ctx.jh, vhash, 64 );
@@ -225,6 +262,20 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    }
 
    mm512_blend_hash_8x64( vh, vhA, vhB, vh_mask );
+
+#if defined(__VAES__)
+
+   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+   shavite512_4way_init( &ctx.shavite );
+   shavite512_4way_update_close( &ctx.shavite, vhashA, vhashA, 64 );
+   shavite512_4way_init( &ctx.shavite );
+   shavite512_4way_update_close( &ctx.shavite, vhashB, vhashB, 64 );
+
+   rintrlv_4x128_8x64( vhash, vhashA, vhashB, 512 );
+     
+#else
+
    dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                   vhash );
 
@@ -256,6 +307,8 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    intrlv_4x128_512( vhashA, hash0, hash1, hash2, hash3 );
    intrlv_4x128_512( vhashB, hash4, hash5, hash6, hash7 );
 
+#endif
+
    simd_4way_init( &ctx.simd, 512 );
    simd_4way_update_close( &ctx.simd, vhashA, vhashA, 512 );
    simd_4way_init( &ctx.simd, 512 );
@@ -334,6 +387,20 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    }
 
    mm512_blend_hash_8x64( vh, vhA, vhB, vh_mask );
+
+#if defined(__VAES__)
+
+   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+   echo_4way_init( &ctx.echo, 512 );
+   echo_4way_update_close( &ctx.echo, vhashA, vhashA, 512 );
+   echo_4way_init( &ctx.echo, 512 );
+   echo_4way_update_close( &ctx.echo, vhashB, vhashB, 512 );
+
+   rintrlv_4x128_8x64( vhash, vhashA, vhashB, 512 );
+
+#else
+
    dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                      vhash );
 
@@ -365,17 +432,38 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    intrlv_8x64_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                     hash7 );
 
+#endif
+
    blake512_8way_init( &ctx.blake );
    blake512_8way_update( &ctx.blake, vhash, 64 );
    blake512_8way_close( &ctx.blake, vhash );
 
    vh_mask = _mm512_cmpeq_epi64_mask( _mm512_and_si512( vh[0], vmask ),
                                        m512_zero );
-   dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
-                  vhash );
-   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
 
    // A
+#if defined(__VAES__)
+
+   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+   if ( likely( ( vh_mask & 0x0f ) != 0x0f ) )
+   {
+     shavite512_4way_init( &ctx.shavite );
+     shavite512_4way_update_close( &ctx.shavite, vhashA, vhashA, 64 );
+   }
+   if ( likely( ( vh_mask & 0xf0 ) != 0xf0 ) )
+   {
+     shavite512_4way_init( &ctx.shavite );
+     shavite512_4way_update_close( &ctx.shavite, vhashB, vhashB, 64 );
+   }
+
+   rintrlv_4x128_8x64( vhashC, vhashA, vhashB, 512 );
+
+#else
+
+   dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
+                  vhash );
+
    if ( hash0[0] & mask )
    {
       sph_shavite512_init( &ctx.shavite );
@@ -425,19 +513,28 @@ extern void hmq1725_8way_hash(void *state, const void *input)
       sph_shavite512_close( &ctx.shavite, hash7 ); //8
    }
 
+   intrlv_8x64_512( vhashC, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
+                         hash7 );
+
+#endif
+
    // B
-   if ( likely( vh_mask & 0xff ) )
+   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+   if ( likely( vh_mask & 0x0f ) )
    {
       luffa_4way_init( &ctx.luffa, 512 );
       luffa_4way_update_close( &ctx.luffa, vhashA, vhashA, 64 );
+   }
+   if ( likely( vh_mask & 0xf0 ) )
+   {
       luffa_4way_init( &ctx.luffa, 512 );
       luffa_4way_update_close( &ctx.luffa, vhash, vhashB, 64 );
-      rintrlv_4x128_8x64( vhashB, vhashA, vhash, 512 );
    }
 
-   intrlv_8x64_512( vhashA, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
-                         hash7 );
-   mm512_blend_hash_8x64( vh, vhA, vhB, vh_mask );
+   rintrlv_4x128_8x64( vhashB, vhashA, vhash, 512 );
+
+   mm512_blend_hash_8x64( vh, vhC, vhB, vh_mask );
 
    hamsi512_8way_init( &ctx.hamsi );
    hamsi512_8way_update( &ctx.hamsi, vhash, 64 );
@@ -475,8 +572,27 @@ extern void hmq1725_8way_hash(void *state, const void *input)
                          hash7 );
    vh_mask = _mm512_cmpeq_epi64_mask( _mm512_and_si512( vh[0], vmask ),
                                        m512_zero );
-   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
 
+     // A   
+#if defined(__VAES__)
+
+     rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+   if ( likely( ( vh_mask & 0x0f ) != 0x0f ) )
+   {
+     echo_4way_init( &ctx.echo, 512 );
+     echo_4way_update_close( &ctx.echo, vhashA, vhashA, 512 );
+   }
+   if ( likely( ( vh_mask & 0xf0 ) != 0xf0 ) )
+   {
+     echo_4way_init( &ctx.echo, 512 );
+     echo_4way_update_close( &ctx.echo, vhashB, vhashB, 512 );
+   }
+
+   rintrlv_4x128_8x64( vhashC, vhashA, vhashB, 512 );
+
+#else
+   
    if ( hash0[0] & mask ) //4
    {
        init_echo( &ctx.echo, 512 );
@@ -526,19 +642,29 @@ extern void hmq1725_8way_hash(void *state, const void *input)
                                (const BitSequence *)hash7, 512 );
    }
 
+   intrlv_8x64_512( vhashC, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
+                         hash7 );
+   
+#endif
+
    // B
-   if ( likely( vh_mask & 0xff ) )
+   rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+   if ( likely( vh_mask & 0x0f ) )
    {
       simd_4way_init( &ctx.simd, 512 );
       simd_4way_update_close( &ctx.simd, vhashA, vhashA, 512 );
+   }
+   if ( likely( vh_mask & 0xf0 ) )
+   {
       simd_4way_init( &ctx.simd, 512 );
       simd_4way_update_close( &ctx.simd, vhash, vhashB, 512 );
-      rintrlv_4x128_8x64( vhashB, vhashA, vhash, 512 );
    }
 
-   intrlv_8x64_512( vhashA, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
-                         hash7 );
-   mm512_blend_hash_8x64( vh, vhA, vhB, vh_mask );
+   rintrlv_4x128_8x64( vhashB, vhashA, vhash, 512 );
+
+   mm512_blend_hash_8x64( vh, vhC, vhB, vh_mask );
+
    rintrlv_8x64_8x32( vhashA, vhash, 512 );
 
    shabal512_8way_init( &ctx.shabal );
@@ -641,6 +767,20 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    }
 
    mm512_blend_hash_8x64( vh, vhA, vhB, vh_mask );
+
+#if defined(__VAES__)
+
+     rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+     groestl512_4way_init( &ctx.groestl, 64 );
+     groestl512_4way_update_close( &ctx.groestl, vhashA, vhashA, 512 );
+     groestl512_4way_init( &ctx.groestl, 64 );
+     groestl512_4way_update_close( &ctx.groestl, vhashB, vhashB, 512 );
+
+     rintrlv_4x128_8x64( vhash, vhashA, vhashB, 512 );
+
+#else
+
    dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                   vhash );
 
@@ -664,6 +804,8 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    intrlv_8x64_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                          hash7 );
    
+#endif
+
    sha512_8way_init( &ctx.sha512 );
    sha512_8way_update( &ctx.sha512, vhash, 64 );
    sha512_8way_close( &ctx.sha512, vhash );
@@ -830,7 +972,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
      __m256i* vhB = (__m256i*)vhashB;
 
      bmw512_4way_init( &ctx.bmw );
-     bmw512_4way( &ctx.bmw, input, 80 );
+     bmw512_4way_update( &ctx.bmw, input, 80 );
      bmw512_4way_close( &ctx.bmw, vhash );
 
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
@@ -889,18 +1031,18 @@ extern void hmq1725_4way_hash(void *state, const void *input)
      if ( mm256_anybits1( vh_mask ) )
      {
        skein512_4way_init( &ctx.skein );
-       skein512_4way( &ctx.skein, vhash, 64 );
+       skein512_4way_update( &ctx.skein, vhash, 64 );
        skein512_4way_close( &ctx.skein, vhashB );
      }
 
      mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
 
      jh512_4way_init( &ctx.jh );
-     jh512_4way( &ctx.jh, vhash, 64 );
+     jh512_4way_update( &ctx.jh, vhash, 64 );
      jh512_4way_close( &ctx.jh, vhash );
 
      keccak512_4way_init( &ctx.keccak );
-     keccak512_4way( &ctx.keccak, vhash, 64 );
+     keccak512_4way_update( &ctx.keccak, vhash, 64 );
      keccak512_4way_close( &ctx.keccak, vhash );
 
 // second fork, A = blake parallel, B= bmw parallel.
@@ -911,14 +1053,14 @@ extern void hmq1725_4way_hash(void *state, const void *input)
      if ( mm256_anybits0( vh_mask ) )
      {
        blake512_4way_init( &ctx.blake );
-       blake512_4way( &ctx.blake, vhash, 64 );
+       blake512_4way_update( &ctx.blake, vhash, 64 );
        blake512_4way_close( &ctx.blake, vhashA );
      }
 
      if ( mm256_anybits1( vh_mask ) )
      {
        bmw512_4way_init( &ctx.bmw );
-       bmw512_4way( &ctx.bmw, vhash, 64 );
+       bmw512_4way_update( &ctx.bmw, vhash, 64 );
        bmw512_4way_close( &ctx.bmw, vhashB );
      }
 
@@ -962,14 +1104,14 @@ extern void hmq1725_4way_hash(void *state, const void *input)
      if ( mm256_anybits0( vh_mask ) )
      {
         keccak512_4way_init( &ctx.keccak );
-        keccak512_4way( &ctx.keccak, vhash, 64 );
+        keccak512_4way_update( &ctx.keccak, vhash, 64 );
         keccak512_4way_close( &ctx.keccak, vhashA );
      }
 
      if ( mm256_anybits1( vh_mask ) )
      {
         jh512_4way_init( &ctx.jh );
-        jh512_4way( &ctx.jh, vhash, 64 );
+        jh512_4way_update( &ctx.jh, vhash, 64 );
         jh512_4way_close( &ctx.jh, vhashB );
      }
 
@@ -990,7 +1132,6 @@ extern void hmq1725_4way_hash(void *state, const void *input)
      sph_shavite512 ( &ctx.shavite, hash3, 64 );
      sph_shavite512_close( &ctx.shavite, hash3 );
 
-
      intrlv_2x128_512( vhashA, hash0, hash1 );
      intrlv_2x128_512( vhashB, hash2, hash3 );
 
@@ -1042,7 +1183,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
      if ( mm256_anybits1( vh_mask ) )
      {
         haval256_5_4way_init( &ctx.haval );
-        haval256_5_4way( &ctx.haval, vhash, 64 );
+        haval256_5_4way_update( &ctx.haval, vhash, 64 );
         haval256_5_4way_close( &ctx.haval, vhash );
         memset( &vhash[8<<2], 0, 32<<2 );
         rintrlv_4x32_4x64( vhashB, vhash, 512 );
@@ -1068,7 +1209,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
      intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
      
      blake512_4way_init( &ctx.blake );
-     blake512_4way( &ctx.blake, vhash, 64 );
+     blake512_4way_update( &ctx.blake, vhash, 64 );
      blake512_4way_close( &ctx.blake, vhash );
 
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
@@ -1130,7 +1271,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
    intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
 
    hamsi512_4way_init( &ctx.hamsi );
-   hamsi512_4way( &ctx.hamsi, vhash, 64 );
+   hamsi512_4way_update( &ctx.hamsi, vhash, 64 );
    hamsi512_4way_close( &ctx.hamsi, vhash );
 
    dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
@@ -1214,7 +1355,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
    intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
 
    shabal512_4way_init( &ctx.shabal );
-   shabal512_4way( &ctx.shabal, vhash, 64 );
+   shabal512_4way_update( &ctx.shabal, vhash, 64 );
    shabal512_4way_close( &ctx.shabal, vhash );
 
    dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
@@ -1269,7 +1410,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
    if ( mm256_anybits1( vh_mask ) )
    {
       sha512_4way_init( &ctx.sha512 );
-      sha512_4way( &ctx.sha512, vhash, 64 );
+      sha512_4way_update( &ctx.sha512, vhash, 64 );
       sha512_4way_close( &ctx.sha512, vhashB );
    }
 
@@ -1289,7 +1430,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
    intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
 
    sha512_4way_init( &ctx.sha512 ); 
-   sha512_4way( &ctx.sha512, vhash, 64 );
+   sha512_4way_update( &ctx.sha512, vhash, 64 );
    sha512_4way_close( &ctx.sha512, vhash ); 
 
 // A = haval parallel, B = Whirlpool serial
@@ -1305,7 +1446,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
    if ( mm256_anybits0( vh_mask ) )
    {
       haval256_5_4way_init( &ctx.haval );
-      haval256_5_4way( &ctx.haval, vhash, 64 );
+      haval256_5_4way_update( &ctx.haval, vhash, 64 );
       haval256_5_4way_close( &ctx.haval, vhash );
       memset( &vhash[8<<2], 0, 32<<2 );
       rintrlv_4x32_4x64( vhashA, vhash, 512 );
@@ -1341,7 +1482,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
    mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
 
    bmw512_4way_init( &ctx.bmw );
-   bmw512_4way( &ctx.bmw, vhash, 64 );
+   bmw512_4way_update( &ctx.bmw, vhash, 64 );
    bmw512_4way_close( &ctx.bmw, vhash );
 
  	memcpy(state, vhash, 32<<2 );

algo/quark/hmq1725-gate.c

@@ -13,7 +13,7 @@ bool register_hmq1725_algo( algo_gate_t* gate )
   gate->scanhash  = (void*)&scanhash_hmq1725;
   gate->hash      = (void*)&hmq1725hash;
 #endif
-  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT;
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT | VAES_OPT;
   opt_target_factor = 65536.0;
   return true;
 };

algo/quark/hmq1725.c

@@ -25,7 +25,6 @@
 #include "algo/luffa/luffa_for_sse2.h"
 #include "algo/cubehash/cubehash_sse2.h"
 #include "algo/simd/nist.h"
-#include "algo/jh/sse2/jh_sse2_opt64.h"
 
 typedef struct {
   sph_blake512_context    blake1, blake2;

algo/quark/quark-4way.c

@@ -9,16 +9,23 @@
 #include "algo/jh/jh-hash-4way.h"
 #include "algo/keccak/keccak-hash-4way.h"
 #include "algo/groestl/aes_ni/hash-groestl.h"
+#if defined(__VAES__)
+  #include "algo/groestl/groestl512-hash-4way.h"
+#endif
 
 #if defined (QUARK_8WAY)
 
 typedef struct {
     blake512_8way_context  blake;
     bmw512_8way_context    bmw;
-    hashState_groestl      groestl;
     jh512_8way_context     jh;
     skein512_8way_context  skein;
     keccak512_8way_context keccak;
+#if defined(__VAES__)
+    groestl512_4way_context groestl;
+#else
+    hashState_groestl       groestl;
+#endif
 } quark_8way_ctx_holder;
 
 quark_8way_ctx_holder quark_8way_ctx __attribute__ ((aligned (128)));
@@ -27,10 +34,14 @@ void init_quark_8way_ctx()
 {
      blake512_8way_init( &quark_8way_ctx.blake );
      bmw512_8way_init( &quark_8way_ctx.bmw );
-     init_groestl( &quark_8way_ctx.groestl, 64 );
      skein512_8way_init( &quark_8way_ctx.skein );
      jh512_8way_init( &quark_8way_ctx.jh );
      keccak512_8way_init( &quark_8way_ctx.keccak );
+#if defined(__VAES__)
+     groestl512_4way_init( &quark_8way_ctx.groestl, 64 );
+#else
+     init_groestl( &quark_8way_ctx.groestl, 64 );
+#endif
 }
 
 void quark_8way_hash( void *state, const void *input )
@@ -38,6 +49,8 @@ void quark_8way_hash( void *state, const void *input )
     uint64_t vhash[8*8] __attribute__ ((aligned (128)));
     uint64_t vhashA[8*8] __attribute__ ((aligned (64)));
     uint64_t vhashB[8*8] __attribute__ ((aligned (64)));
+    uint64_t vhashC[8*8] __attribute__ ((aligned (64)));
+#if !defined(__VAES__)
     uint64_t hash0[8] __attribute__ ((aligned (64)));
     uint64_t hash1[8] __attribute__ ((aligned (64)));
     uint64_t hash2[8] __attribute__ ((aligned (64)));
@@ -46,9 +59,11 @@ void quark_8way_hash( void *state, const void *input )
     uint64_t hash5[8] __attribute__ ((aligned (64)));
     uint64_t hash6[8] __attribute__ ((aligned (64)));
     uint64_t hash7[8] __attribute__ ((aligned (64)));
+#endif
     __m512i* vh  = (__m512i*)vhash;
     __m512i* vhA = (__m512i*)vhashA;
     __m512i* vhB = (__m512i*)vhashB;
+    __m512i* vhC = (__m512i*)vhashC;
     __mmask8 vh_mask;
     quark_8way_ctx_holder ctx;
     const uint32_t mask = 8;
@@ -66,6 +81,25 @@ void quark_8way_hash( void *state, const void *input )
     vh_mask = _mm512_cmpeq_epi64_mask( _mm512_and_si512( vh[0], bit3_mask ),
                                        zero );
 
+    
+#if defined(__VAES__)
+
+     rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+     if ( ( vh_mask & 0x0f ) != 0x0f )
+     {
+        groestl512_4way_init( &ctx.groestl, 64 );
+        groestl512_4way_update_close( &ctx.groestl, vhashA, vhashA, 512 );
+     }
+     if ( ( vh_mask & 0xf0 ) != 0xf0 )
+     {     
+        groestl512_4way_init( &ctx.groestl, 64 );
+        groestl512_4way_update_close( &ctx.groestl, vhashB, vhashB, 512 );
+     }
+     rintrlv_4x128_8x64( vhashC, vhashA, vhashB, 512 );
+
+#else
+
     dintrlv_8x64( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                   vhash, 512 );
 
@@ -117,16 +151,31 @@ void quark_8way_hash( void *state, const void *input )
                                                (char*)hash7, 512 );
     }
 
-    intrlv_8x64( vhashA, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
+    intrlv_8x64( vhashC, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                          hash7, 512 );
 
+#endif
+
     if ( vh_mask & 0xff )
     {
        skein512_8way_update( &ctx.skein, vhash, 64 );
        skein512_8way_close( &ctx.skein, vhashB );
     }
 
-    mm512_blend_hash_8x64( vh, vhA, vhB, vh_mask );
+    mm512_blend_hash_8x64( vh, vhC, vhB, vh_mask );
+
+#if defined(__VAES__)
+
+     rintrlv_8x64_4x128( vhashA, vhashB, vhash, 512 );
+
+     groestl512_4way_init( &ctx.groestl, 64 );
+     groestl512_4way_update_close( &ctx.groestl, vhashA, vhashA, 512 );
+     groestl512_4way_init( &ctx.groestl, 64 );
+     groestl512_4way_update_close( &ctx.groestl, vhashB, vhashB, 512 );
+
+     rintrlv_4x128_8x64( vhash, vhashA, vhashB, 512 );
+
+#else
 
     dintrlv_8x64( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                   vhash, 512 );
@@ -151,6 +200,8 @@ void quark_8way_hash( void *state, const void *input )
     intrlv_8x64( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                  512 );
 
+#endif
+
     jh512_8way_update( &ctx.jh, vhash, 64 );
     jh512_8way_close( &ctx.jh, vhash );
 
@@ -289,10 +340,10 @@ void quark_4way_hash( void *state, const void *input )
 
     memcpy( &ctx, &quark_4way_ctx, sizeof(quark_4way_ctx) );
 
-    blake512_4way( &ctx.blake, input, 80 );
+    blake512_4way_update( &ctx.blake, input, 80 );
     blake512_4way_close( &ctx.blake, vhash );
 
-    bmw512_4way( &ctx.bmw, vhash, 64 );
+    bmw512_4way_update( &ctx.bmw, vhash, 64 );
     bmw512_4way_close( &ctx.bmw, vhash );
 
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ), zero );
@@ -327,7 +378,7 @@ void quark_4way_hash( void *state, const void *input )
 
     if ( mm256_anybits1( vh_mask ) )   
     {
-       skein512_4way( &ctx.skein, vhash, 64 );
+       skein512_4way_update( &ctx.skein, vhash, 64 );
        skein512_4way_close( &ctx.skein, vhashB );
     }
 
@@ -346,7 +397,7 @@ void quark_4way_hash( void *state, const void *input )
 
     intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
 
-    jh512_4way( &ctx.jh, vhash, 64 );
+    jh512_4way_update( &ctx.jh, vhash, 64 );
     jh512_4way_close( &ctx.jh, vhash );
 
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ), zero );
@@ -354,24 +405,24 @@ void quark_4way_hash( void *state, const void *input )
     if ( mm256_anybits0( vh_mask ) )   
     {
        blake512_4way_init( &ctx.blake );
-       blake512_4way( &ctx.blake, vhash, 64 );
+       blake512_4way_update( &ctx.blake, vhash, 64 );
        blake512_4way_close( &ctx.blake, vhashA );
     }
 
     if ( mm256_anybits1( vh_mask ) )
     {
        bmw512_4way_init( &ctx.bmw );
-       bmw512_4way( &ctx.bmw, vhash, 64 );
+       bmw512_4way_update( &ctx.bmw, vhash, 64 );
        bmw512_4way_close( &ctx.bmw, vhashB );
     }
 
     mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
 
-    keccak512_4way( &ctx.keccak, vhash, 64 );
+    keccak512_4way_update( &ctx.keccak, vhash, 64 );
     keccak512_4way_close( &ctx.keccak, vhash );
 
     skein512_4way_init( &ctx.skein );
-    skein512_4way( &ctx.skein, vhash, 64 );
+    skein512_4way_update( &ctx.skein, vhash, 64 );
     skein512_4way_close( &ctx.skein, vhash );
 
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ), zero );
@@ -379,14 +430,14 @@ void quark_4way_hash( void *state, const void *input )
     if ( mm256_anybits0( vh_mask ) )    
     {
        keccak512_4way_init( &ctx.keccak );
-       keccak512_4way( &ctx.keccak, vhash, 64 );
+       keccak512_4way_update( &ctx.keccak, vhash, 64 );
        keccak512_4way_close( &ctx.keccak, vhashA );
     }
 
     if ( mm256_anybits1( vh_mask ) )
     {
        jh512_4way_init( &ctx.jh );
-       jh512_4way( &ctx.jh, vhash, 64 );
+       jh512_4way_update( &ctx.jh, vhash, 64 );
        jh512_4way_close( &ctx.jh, vhashB );
     }
 

algo/quark/quark-gate.c

@@ -11,11 +11,10 @@ bool register_quark_algo( algo_gate_t* gate )
   gate->scanhash  = (void*)&scanhash_quark_4way;
   gate->hash      = (void*)&quark_4way_hash;
 #else
-  init_quark_ctx();
   gate->scanhash  = (void*)&scanhash_quark;
   gate->hash      = (void*)&quark_hash;
 #endif
-  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT;
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT | VAES_OPT;
   return true;
 };
 

algo/quark/quark-gate.h

@@ -26,12 +26,11 @@ int scanhash_quark_4way( struct work *work, uint32_t max_nonce,
                          uint64_t *hashes_done, struct thr_info *mythr );
 void init_quark_4way_ctx();
 
-#endif
+#else
 
 void quark_hash( void *state, const void *input );
 int scanhash_quark( struct work *work, uint32_t max_nonce,
                     uint64_t *hashes_done, struct thr_info *mythr );
-void init_quark_ctx();
 
 #endif
-
+#endif

algo/quark/quark.c

@@ -1,177 +1,114 @@
 #include "cpuminer-config.h"
 #include "quark-gate.h"
-
-#include <stdio.h>
-#include <string.h>
+#include <stdlib.h>
 #include <stdint.h>
-
+#include <string.h>
+#include <stdio.h>
 #include "algo/blake/sph_blake.h"
 #include "algo/bmw/sph_bmw.h"
-#include "algo/groestl/sph_groestl.h"
 #include "algo/jh/sph_jh.h"
 #include "algo/keccak/sph_keccak.h"
 #include "algo/skein/sph_skein.h"
-
-#include "algo/blake/sse2/blake.c"
-#include "algo/bmw/sse2/bmw.c"
-#include "algo/keccak/sse2/keccak.c"
-#include "algo/skein/sse2/skein.c"
-#include "algo/jh/sse2/jh_sse2_opt64.h"
-
-#ifndef NO_AES_NI
- #include "algo/groestl/aes_ni/hash-groestl.h"
-#endif
-
-/*define data alignment for different C compilers*/
-#if defined(__GNUC__)
-      #define DATA_ALIGN16(x) x __attribute__ ((aligned(16)))
-      #define DATA_ALIGNXY(x,y) x __attribute__ ((aligned(y)))
-
+#if defined(__AES__)
+  #include "algo/groestl/aes_ni/hash-groestl.h"
 #else
-      #define DATA_ALIGN16(x) __declspec(align(16)) x
-      #define DATA_ALIGNXY(x,y) __declspec(align(y)) x
+  #include "algo/groestl/sph_groestl.h"
 #endif
 
-#ifdef NO_AES_NI
-    sph_groestl512_context quark_ctx;
-#else
-    hashState_groestl      quark_ctx;
-#endif
-
-void init_quark_ctx()
-{
-#ifdef NO_AES_NI
-   sph_groestl512_init( &quark_ctx );
-#else
-   init_groestl( &quark_ctx, 64 );
-#endif
-}
-
 void quark_hash(void *state, const void *input)
 {
-    unsigned char hashbuf[128];
-    size_t hashptr;
-    sph_u64 hashctA;
-    sph_u64 hashctB;
-    int i;
-    unsigned char hash[128] __attribute__ ((aligned (32)));
-#ifdef NO_AES_NI
-    sph_groestl512_context ctx;
+   uint32_t hash[16] __attribute__((aligned(64)));
+   sph_blake512_context    ctx_blake;
+   sph_bmw512_context      ctx_bmw;
+#if defined(__AES__)
+   hashState_groestl       ctx_groestl;
 #else
-    hashState_groestl ctx;
+   sph_groestl512_context  ctx_groestl;
+#endif
+   sph_skein512_context    ctx_skein;
+   sph_jh512_context       ctx_jh;
+   sph_keccak512_context   ctx_keccak;
+   uint32_t mask = 8;
+
+   sph_blake512_init( &ctx_blake );
+   sph_blake512( &ctx_blake, input, 80 );
+   sph_blake512_close( &ctx_blake, hash );
+
+   sph_bmw512_init( &ctx_bmw );
+   sph_bmw512( &ctx_bmw, hash, 64 );
+   sph_bmw512_close( &ctx_bmw, hash ); 
+
+   if ( hash[0] & mask )
+   {
+#if defined(__AES__)
+      init_groestl( &ctx_groestl, 64 );
+      update_and_final_groestl( &ctx_groestl, (char*)hash,
+                                        (const char*)hash, 512 );
+#else
+      sph_groestl512_init( &ctx_groestl );
+      sph_groestl512( &ctx_groestl, hash, 64 );
+      sph_groestl512_close( &ctx_groestl, hash );
+#endif
+   }
+   else
+   {
+      sph_skein512_init( &ctx_skein );
+      sph_skein512( &ctx_skein, hash, 64 );
+      sph_skein512_close( &ctx_skein, hash );
+   }
+
+#if defined(__AES__)
+   init_groestl( &ctx_groestl, 64 );
+   update_and_final_groestl( &ctx_groestl, (char*)hash,
+                                     (const char*)hash, 512 );
+#else
+   sph_groestl512_init( &ctx_groestl );
+   sph_groestl512( &ctx_groestl, hash, 64 );
+   sph_groestl512_close( &ctx_groestl, hash );
 #endif
 
-    memcpy( &ctx, &quark_ctx, sizeof(ctx) );
+   sph_jh512_init( &ctx_jh );
+   sph_jh512( &ctx_jh, hash, 64 );
+   sph_jh512_close( &ctx_jh, hash );
 
-    // Blake
-    DECL_BLK;
-    BLK_I;
-    BLK_W;
-    for(i=0; i<9; i++)
-    {
-    /* blake is split between 64byte hashes and the 80byte initial block */
-    //DECL_BLK;
-      switch (i+(16*((hash[0] & (uint32_t)(8)) == (uint32_t)(0))))
-      {
-        // Blake
-        case 5 :
-            BLK_I;
-            BLK_U;
-        case 0:
-        case 16: 
-            BLK_C;
-            break;
-        case 1:
-        case 17:
-        case 21:
+   if ( hash[0] & mask )
+   {
+      sph_blake512_init( &ctx_blake );
+      sph_blake512( &ctx_blake, hash, 64 );
+      sph_blake512_close( &ctx_blake, hash );
+   }
+   else
+   {
+      sph_bmw512_init( &ctx_bmw );
+      sph_bmw512( &ctx_bmw, hash, 64 );
+      sph_bmw512_close( &ctx_bmw, hash );
+   }
 
-            // BMW
-            do
-            { 
-              DECL_BMW;
-              BMW_I;
-              BMW_U;
-              /* bmw compress uses some defines */
-              /* i havent gotten around to rewriting these */
-              #define M(x)    sph_dec64le_aligned(data + 8 * (x))
-              #define H(x)    (h[x])
-              #define dH(x)   (dh[x])
-              BMW_C;
-              #undef M
-              #undef H
-              #undef dH
-            } while(0); continue;;
+   sph_keccak512_init( &ctx_keccak );
+   sph_keccak512( &ctx_keccak, hash, 64 );
+   sph_keccak512_close( &ctx_keccak, hash );
 
-        case 2:
-            // dos this entry point represent a second groestl round?
+   sph_skein512_init( &ctx_skein );
+   sph_skein512( &ctx_skein, hash, 64 );
+   sph_skein512_close( &ctx_skein, hash );
 
-        case 3:
-        case 19:
-          // Groestl 
-          do
-          {
+   if ( hash[0] & mask )
+   {
+      sph_keccak512_init( &ctx_keccak );
+      sph_keccak512( &ctx_keccak, hash, 64 );
+      sph_keccak512_close( &ctx_keccak, hash );
+   }
+   else
+   {
+      sph_jh512_init( &ctx_jh );
+      sph_jh512( &ctx_jh, hash, 64 );
+      sph_jh512_close( &ctx_jh, hash );
+   }
 
-#ifdef NO_AES_NI
-             sph_groestl512_init( &ctx );
-             sph_groestl512 ( &ctx, hash, 64 );
-             sph_groestl512_close( &ctx, hash );
-#else
-             reinit_groestl( &ctx );
-             update_and_final_groestl( &ctx, (char*)hash, (char*)hash, 512 );
-//             update_groestl( &ctx, (char*)hash, 512 );
-//             final_groestl( &ctx, (char*)hash );
-#endif
-
-          } while(0); continue;
-
-        case 4:
-        case 20:
-        case 24:
-            // JH
-            do
-            {
-              DECL_JH;
-              JH_H;
-            } while(0); continue;
-
-        case 6:
-        case 22:
-        case 8:
-            // Keccak
-            do
-            {
-              DECL_KEC;
-              KEC_I;
-              KEC_U;
-              KEC_C;
-            } while(0); continue;
-
-        case 18:
-        case 7:
-        case 23:
-            // Skein
-            do
-            {
-              DECL_SKN;
-              SKN_I;
-              SKN_U;
-              SKN_C; /* is a magintue faster than others, done */
-            } while(0); continue;
- 
-       default:
-            /* bad things happend, i counted to potato */
-            abort();
-    }
-    /* only blake shouuld get here without continue */
-    /* blake finishs from top split */
-    //BLK_C;
- }
- 
-
-//    asm volatile ("emms");
-  memcpy(state, hash, 32);
+   memcpy(state, hash, 32);
 }
 
+
 int scanhash_quark( struct work *work, uint32_t max_nonce,
                     uint64_t *hashes_done, struct thr_info *mythr )
 {

algo/qubit/qubit-2way.c

@@ -9,6 +9,10 @@
 #include "algo/simd/simd-hash-2way.h"
 #include "algo/shavite/sph_shavite.h"
 #include "algo/echo/aes_ni/hash_api.h"
+#if defined(__VAES__)
+  #include "algo/shavite/shavite-hash-4way.h"
+  #include "algo/echo/echo-hash-4way.h"
+#endif
 
 #if defined(QUBIT_4WAY)
 
@@ -16,10 +20,14 @@ typedef struct
 {
     luffa_4way_context      luffa;
     cube_4way_context       cube;
-    sph_shavite512_context  shavite;
     simd_4way_context       simd;
-    simd_2way_context       simd2;
+#if defined(__VAES__)
+    shavite512_4way_context shavite;
+    echo_4way_context       echo;
+#else
+    sph_shavite512_context  shavite;
     hashState_echo          echo;
+#endif
 } qubit_4way_ctx_holder;
 
 qubit_4way_ctx_holder qubit_4way_ctx;
@@ -27,19 +35,25 @@ qubit_4way_ctx_holder qubit_4way_ctx;
 void init_qubit_4way_ctx()
 {
     cube_4way_init( &qubit_4way_ctx.cube, 512, 16, 32 );
-    sph_shavite512_init(&qubit_4way_ctx.shavite);
     simd_4way_init( &qubit_4way_ctx.simd, 512 );
-    simd_2way_init( &qubit_4way_ctx.simd2, 512 );
-    init_echo(&qubit_4way_ctx.echo, 512);
+#if defined(__VAES__)
+    shavite512_4way_init( &qubit_4way_ctx.shavite );
+    echo_4way_init( &qubit_4way_ctx.echo, 512 );
+#else
+    sph_shavite512_init( &qubit_4way_ctx.shavite );
+    init_echo( &qubit_4way_ctx.echo, 512 );
+#endif
 };
 
 void qubit_4way_hash( void *output, const void *input )
 {
      uint32_t vhash[16*4] __attribute__ ((aligned (128)));
+#if !defined(__VAES__)
      uint32_t hash0[16] __attribute__ ((aligned (64)));
      uint32_t hash1[16] __attribute__ ((aligned (64)));
      uint32_t hash2[16] __attribute__ ((aligned (64)));
      uint32_t hash3[16] __attribute__ ((aligned (64)));
+#endif
      qubit_4way_ctx_holder ctx;
 
      memcpy( &ctx, &qubit_4way_ctx, sizeof(qubit_4way_ctx) );
@@ -48,6 +62,13 @@ void qubit_4way_hash( void *output, const void *input )
      luffa_4way_close( &ctx.luffa, vhash );
      
      cube_4way_update_close( &ctx.cube, vhash, vhash, 64 );
+
+#if defined(__VAES__)
+
+     shavite512_4way_update_close( &ctx.shavite, vhash, vhash, 64 );
+
+#else
+
      dintrlv_4x128_512( hash0, hash1, hash2, hash3, vhash );
      
      sph_shavite512( &ctx.shavite, hash0, 64 );
@@ -66,31 +87,44 @@ void qubit_4way_hash( void *output, const void *input )
      sph_shavite512_close( &ctx.shavite, hash3 );
 
      intrlv_4x128_512( vhash, hash0, hash1, hash2, hash3 );
+
+#endif
+
      simd_4way_update_close( &ctx.simd, vhash, vhash, 512 );
+
+#if defined(__VAES__)
+
+     echo_4way_update_close( &ctx.echo, vhash, vhash, 512 );
+
+     dintrlv_4x128( output, output+32, output+64, output+96, vhash, 256 );
+    
+#else
+
      dintrlv_4x128_512( hash0, hash1, hash2, hash3, vhash );
 
-     update_final_echo( &ctx.echo, (BitSequence *)hash0,
-                       (const BitSequence *) hash0, 512 );
+     update_final_echo( &ctx.echo, (BitSequence*)hash0,
+                            (const BitSequence*)hash0, 512 );
      memcpy( &ctx.echo, &qubit_4way_ctx.echo, sizeof(hashState_echo) );
-     update_final_echo( &ctx.echo, (BitSequence *)hash1,
-                       (const BitSequence *) hash1, 512 );
+     update_final_echo( &ctx.echo, (BitSequence*)hash1,
+                             (const BitSequence*)hash1, 512 );
      memcpy( &ctx.echo, &qubit_4way_ctx.echo, sizeof(hashState_echo) );
-     update_final_echo( &ctx.echo, (BitSequence *)hash2,
-                       (const BitSequence *) hash2, 512 );
+     update_final_echo( &ctx.echo, (BitSequence*)hash2,
+                             (const BitSequence*)hash2, 512 );
      memcpy( &ctx.echo, &qubit_4way_ctx.echo, sizeof(hashState_echo) );
-     update_final_echo( &ctx.echo, (BitSequence *)hash3,
-                       (const BitSequence *) hash3, 512 );
+     update_final_echo( &ctx.echo, (BitSequence*)hash3,
+                             (const BitSequence*)hash3, 512 );
 
      memcpy( output,    hash0, 32 );
      memcpy( output+32, hash1, 32 );
      memcpy( output+64, hash2, 32 );
      memcpy( output+96, hash3, 32 );
+#endif
 }
 
 int scanhash_qubit_4way( struct work *work,uint32_t max_nonce,
                          uint64_t *hashes_done, struct thr_info *mythr )
 {
-     uint32_t hash[4*8] __attribute__ ((aligned (128)));
+     uint32_t hash[8*4] __attribute__ ((aligned (128)));
      uint32_t vdata[24*4] __attribute__ ((aligned (64)));
      uint32_t *pdata = work->data;
      uint32_t *ptarget = work->target;

algo/qubit/qubit-gate.c

@@ -16,7 +16,7 @@ bool register_qubit_algo( algo_gate_t* gate )
   gate->scanhash  = (void*)&scanhash_qubit;
   gate->hash      = (void*)&qubit_hash;
 #endif
-  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT;
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT | VAES_OPT;
   return true;
 };
 

algo/ripemd/lbry-4way.c

@@ -7,16 +7,147 @@
 #include "ripemd-hash-4way.h"
 
 #define LBRY_INPUT_SIZE 112
-#define LBRY_MIDSTATE    64
+#define LBRY_MIDSTATE    96
 #define LBRY_TAIL (LBRY_INPUT_SIZE) - (LBRY_MIDSTATE)
 
-#if defined(LBRY_8WAY)
+#if defined(LBRY_16WAY)
+
+static __thread sha256_16way_context sha256_16w_mid;
+
+void lbry_16way_hash( void* output, const void* input )
+{
+   uint32_t _ALIGN(128) vhashA[16<<4];
+   uint32_t _ALIGN(64) vhashB[16<<4];
+   uint32_t _ALIGN(64) vhashC[16<<4];
+   uint32_t _ALIGN(64) h0[32];
+   uint32_t _ALIGN(64) h1[32];
+   uint32_t _ALIGN(64) h2[32];
+   uint32_t _ALIGN(64) h3[32];
+   uint32_t _ALIGN(64) h4[32];
+   uint32_t _ALIGN(64) h5[32];
+   uint32_t _ALIGN(64) h6[32];
+   uint32_t _ALIGN(64) h7[32];
+   uint32_t _ALIGN(64) h8[32];
+   uint32_t _ALIGN(64) h9[32];
+   uint32_t _ALIGN(64) h10[32];
+   uint32_t _ALIGN(64) h11[32];
+   uint32_t _ALIGN(64) h12[32];
+   uint32_t _ALIGN(64) h13[32];
+   uint32_t _ALIGN(64) h14[32];
+   uint32_t _ALIGN(64) h15[32];
+   sha256_16way_context    ctx_sha256 __attribute__ ((aligned (64)));
+   sha512_8way_context     ctx_sha512;
+   ripemd160_16way_context ctx_ripemd;
+
+   memcpy( &ctx_sha256, &sha256_16w_mid, sizeof(ctx_sha256) );
+   sha256_16way_update( &ctx_sha256, input + (LBRY_MIDSTATE<<4), LBRY_TAIL );
+   sha256_16way_close( &ctx_sha256, vhashA );
+
+   sha256_16way_init( &ctx_sha256 );
+   sha256_16way_update( &ctx_sha256, vhashA, 32 );
+   sha256_16way_close( &ctx_sha256, vhashA );
+
+   // reinterleave to do sha512 4-way 64 bit twice.
+   dintrlv_16x32( h0, h1, h2, h3, h4, h5, h6, h7,
+                  h8, h9, h10, h11, h12, h13, h14, h15, vhashA, 256 );
+   intrlv_8x64( vhashA, h0, h1, h2, h3, h4, h5, h6, h7, 256 );
+   intrlv_8x64( vhashB, h8, h9, h10, h11, h12, h13, h14, h15, 256 );
+
+   sha512_8way_init( &ctx_sha512 );
+   sha512_8way_update( &ctx_sha512, vhashA, 32 );
+   sha512_8way_close( &ctx_sha512, vhashA );
+
+   sha512_8way_init( &ctx_sha512 );
+   sha512_8way_update( &ctx_sha512, vhashB, 32 );
+   sha512_8way_close( &ctx_sha512, vhashB );
+
+   // back to 8-way 32 bit
+   dintrlv_8x64( h0, h1, h2, h3, h4, h5, h6, h7, vhashA, 512 );
+   dintrlv_8x64( h8, h9, h10, h11, h12, h13, h14, h15, vhashB, 512 );
+   intrlv_16x32( vhashA, h0, h1, h2, h3, h4, h5, h6, h7,
+                         h8, h9, h10, h11, h12, h13, h14, h15, 512 );
+
+   ripemd160_16way_init( &ctx_ripemd );
+   ripemd160_16way_update( &ctx_ripemd, vhashA, 32 );
+   ripemd160_16way_close( &ctx_ripemd, vhashB );
+
+   ripemd160_16way_init( &ctx_ripemd );
+   ripemd160_16way_update( &ctx_ripemd, vhashA+(8<<4), 32 );
+   ripemd160_16way_close( &ctx_ripemd, vhashC );
+
+   sha256_16way_init( &ctx_sha256 );
+   sha256_16way_update( &ctx_sha256, vhashB, 20 );
+   sha256_16way_update( &ctx_sha256, vhashC, 20 );
+   sha256_16way_close( &ctx_sha256, vhashA );
+
+   sha256_16way_init( &ctx_sha256 );
+   sha256_16way_update( &ctx_sha256, vhashA, 32 );
+   sha256_16way_close( &ctx_sha256, output );
+}
+
+int scanhash_lbry_16way( struct work *work, uint32_t max_nonce,
+                        uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[8*16] __attribute__ ((aligned (128)));
+   uint32_t vdata[32*16] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t edata[32] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[7<<4]);
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   uint32_t n = pdata[27];
+   const uint32_t first_nonce = pdata[27];
+   const uint32_t last_nonce = max_nonce - 16;
+   const uint32_t Htarg = ptarget[7];
+   __m512i  *noncev = (__m512i*)vdata + 27;   // aligned
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+
+   // we need bigendian data...
+   casti_m128i( edata, 0 ) = mm128_bswap_32( casti_m128i( pdata, 0 ) );
+   casti_m128i( edata, 1 ) = mm128_bswap_32( casti_m128i( pdata, 1 ) );
+   casti_m128i( edata, 2 ) = mm128_bswap_32( casti_m128i( pdata, 2 ) );
+   casti_m128i( edata, 3 ) = mm128_bswap_32( casti_m128i( pdata, 3 ) );
+   casti_m128i( edata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
+   casti_m128i( edata, 5 ) = mm128_bswap_32( casti_m128i( pdata, 5 ) );
+   casti_m128i( edata, 6 ) = mm128_bswap_32( casti_m128i( pdata, 6 ) );
+   casti_m128i( edata, 7 ) = mm128_bswap_32( casti_m128i( pdata, 7 ) );
+   intrlv_16x32( vdata, edata, edata, edata, edata, edata, edata, edata,
+        edata, edata, edata, edata, edata, edata, edata, edata, edata, 1024 );
+
+   sha256_16way_init( &sha256_16w_mid );
+   sha256_16way_update( &sha256_16w_mid, vdata, LBRY_MIDSTATE );
+
+   do
+   {
+      *noncev = mm512_bswap_32( _mm512_set_epi32(
+                         n+15, n+14, n+13, n+12, n+11, n+10, n+ 9, n+ 8,
+                         n+ 7, n+ 6, n+ 5, n+ 4, n+ 3, n+ 2, n+ 1, n ) );
+      lbry_16way_hash( hash, vdata );
+
+      for ( int i = 0; i < 16; i++ )
+      if ( unlikely( hash7[ i ] <= Htarg ) )
+      {
+         // deinterleave hash for lane
+         extr_lane_16x32( lane_hash, hash, i, 256 );
+         if ( likely( fulltest( lane_hash, ptarget ) && !opt_benchmark ) )
+         {
+            pdata[27] = n + i;
+            submit_lane_solution( work, lane_hash, mythr, i );
+         }
+      }
+      n += 16;
+   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+#elif defined(LBRY_8WAY)
 
 static __thread sha256_8way_context sha256_8w_mid;
 
 void lbry_8way_hash( void* output, const void* input )
 {
-   uint32_t _ALIGN(64) vhashA[16<<3];
+   uint32_t _ALIGN(128) vhashA[16<<3];
    uint32_t _ALIGN(64) vhashB[16<<3];
    uint32_t _ALIGN(64) vhashC[16<<3];
    uint32_t _ALIGN(32) h0[32];
@@ -32,11 +163,11 @@ void lbry_8way_hash( void* output, const void* input )
    ripemd160_8way_context  ctx_ripemd;
 
    memcpy( &ctx_sha256, &sha256_8w_mid, sizeof(ctx_sha256) );
-   sha256_8way( &ctx_sha256, input + (LBRY_MIDSTATE<<3), LBRY_TAIL );
+   sha256_8way_update( &ctx_sha256, input + (LBRY_MIDSTATE<<3), LBRY_TAIL );
    sha256_8way_close( &ctx_sha256, vhashA );
 
    sha256_8way_init( &ctx_sha256 );
-   sha256_8way( &ctx_sha256, vhashA, 32 );
+   sha256_8way_update( &ctx_sha256, vhashA, 32 );
    sha256_8way_close( &ctx_sha256, vhashA );
 
    // reinterleave to do sha512 4-way 64 bit twice.
@@ -45,11 +176,11 @@ void lbry_8way_hash( void* output, const void* input )
    intrlv_4x64( vhashB, h4, h5, h6, h7, 256 );
 
    sha512_4way_init( &ctx_sha512 );
-   sha512_4way( &ctx_sha512, vhashA, 32 );
+   sha512_4way_update( &ctx_sha512, vhashA, 32 );
    sha512_4way_close( &ctx_sha512, vhashA );
 
    sha512_4way_init( &ctx_sha512 );
-   sha512_4way( &ctx_sha512, vhashB, 32 );
+   sha512_4way_update( &ctx_sha512, vhashB, 32 );
    sha512_4way_close( &ctx_sha512, vhashB );
 
    // back to 8-way 32 bit
@@ -58,20 +189,20 @@ void lbry_8way_hash( void* output, const void* input )
    intrlv_8x32( vhashA, h0, h1, h2, h3, h4, h5, h6, h7, 512 );
 
    ripemd160_8way_init( &ctx_ripemd );
-   ripemd160_8way( &ctx_ripemd, vhashA, 32 );
+   ripemd160_8way_update( &ctx_ripemd, vhashA, 32 );
    ripemd160_8way_close( &ctx_ripemd, vhashB );
 
    ripemd160_8way_init( &ctx_ripemd );
-   ripemd160_8way( &ctx_ripemd, vhashA+(8<<3), 32 );
+   ripemd160_8way_update( &ctx_ripemd, vhashA+(8<<3), 32 );
    ripemd160_8way_close( &ctx_ripemd, vhashC );
 
    sha256_8way_init( &ctx_sha256 );
-   sha256_8way( &ctx_sha256, vhashB, 20 );
-   sha256_8way( &ctx_sha256, vhashC, 20 );
+   sha256_8way_update( &ctx_sha256, vhashB, 20 );
+   sha256_8way_update( &ctx_sha256, vhashC, 20 );
    sha256_8way_close( &ctx_sha256, vhashA );
 
    sha256_8way_init( &ctx_sha256 );
-   sha256_8way( &ctx_sha256, vhashA, 32 );
+   sha256_8way_update( &ctx_sha256, vhashA, 32 );
    sha256_8way_close( &ctx_sha256, output );
 }
 
@@ -81,21 +212,16 @@ int scanhash_lbry_8way( struct work *work, uint32_t max_nonce,
    uint32_t hash[8*8] __attribute__ ((aligned (64)));
    uint32_t vdata[32*8] __attribute__ ((aligned (64)));
    uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t edata[32] __attribute__ ((aligned (64)));
    uint32_t *hash7 = &(hash[7<<3]);
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    uint32_t n = pdata[27];
    const uint32_t first_nonce = pdata[27];
    const uint32_t Htarg = ptarget[7];
-   uint32_t edata[32] __attribute__ ((aligned (64)));
    __m256i  *noncev = (__m256i*)vdata + 27;   // aligned
    int thr_id = mythr->id;  // thr_id arg is deprecated
 
-   uint64_t htmax[] = {          0,        0xF,       0xFF,
-                             0xFFF,     0xFFFF, 0x10000000 };
-   uint32_t masks[] = { 0xFFFFFFFF, 0xFFFFFFF0, 0xFFFFFF00,
-                        0xFFFFF000, 0xFFFF0000,          0 };
-
    // we need bigendian data...
    casti_m128i( edata, 0 ) = mm128_bswap_32( casti_m128i( pdata, 0 ) );
    casti_m128i( edata, 1 ) = mm128_bswap_32( casti_m128i( pdata, 1 ) );
@@ -106,33 +232,30 @@ int scanhash_lbry_8way( struct work *work, uint32_t max_nonce,
    casti_m128i( edata, 6 ) = mm128_bswap_32( casti_m128i( pdata, 6 ) );
    casti_m128i( edata, 7 ) = mm128_bswap_32( casti_m128i( pdata, 7 ) );
    intrlv_8x32( vdata, edata, edata, edata, edata,
-                             edata, edata, edata, edata, 1024 );
+                       edata, edata, edata, edata, 1024 );
+
    sha256_8way_init( &sha256_8w_mid );
-   sha256_8way( &sha256_8w_mid, vdata, LBRY_MIDSTATE );
+   sha256_8way_update( &sha256_8w_mid, vdata, LBRY_MIDSTATE );
 
-   for ( int m = 0; m < sizeof(masks); m++ ) if ( Htarg <= htmax[m] )
+   do
    {
-      uint32_t mask = masks[m];
-      do
-      {
-        *noncev = mm256_bswap_32( _mm256_set_epi32(
-                                          n+7,n+6,n+5,n+4,n+3,n+2,n+1,n ) );
-         lbry_8way_hash( hash, vdata );
+      *noncev = mm256_bswap_32( _mm256_set_epi32(
+                                       n+7,n+6,n+5,n+4,n+3,n+2,n+1,n ) );
+      lbry_8way_hash( hash, vdata );
 
-         for ( int i = 0; i < 8; i++ )  if ( !( hash7[ i ] & mask ) )
+      for ( int i = 0; i < 8; i++ )
+      if ( unlikely( hash7[ i ] <= Htarg ) )
+      {
+         // deinterleave hash for lane
+         extr_lane_8x32( lane_hash, hash, i, 256 );
+         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
          {
-            // deinterleave hash for lane
-            extr_lane_8x32( lane_hash, hash, i, 256 );
-            if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
-            {
-              pdata[27] = n + i;
-              submit_lane_solution( work, lane_hash, mythr, i );
-            }
+            pdata[27] = n + i;
+            submit_lane_solution( work, lane_hash, mythr, i );
          }
-         n += 8;
-      } while ( (n < max_nonce-10) && !work_restart[thr_id].restart );
-      break;
-   }
+      }
+      n += 8;
+   } while ( (n < max_nonce-10) && !work_restart[thr_id].restart );
    *hashes_done = n - first_nonce + 1;
    return 0;
 }

algo/ripemd/lbry-gate.c

@@ -98,16 +98,23 @@ int lbry_get_work_data_size() { return LBRY_WORK_DATA_SIZE; }
 
 bool register_lbry_algo( algo_gate_t* gate )
 {
-  gate->optimizations = AVX2_OPT | SHA_OPT;
-#if defined (LBRY_8WAY)
+//  gate->optimizations = AVX2_OPT | AVX512_OPT | SHA_OPT;
+#if defined (LBRY_16WAY)
+  gate->scanhash              = (void*)&scanhash_lbry_16way;
+  gate->hash                  = (void*)&lbry_16way_hash;
+  gate->optimizations = AVX2_OPT | AVX512_OPT;
+#elif defined (LBRY_8WAY)
   gate->scanhash              = (void*)&scanhash_lbry_8way;
   gate->hash                  = (void*)&lbry_8way_hash;
+  gate->optimizations = AVX2_OPT | AVX512_OPT;
 #elif defined (LBRY_4WAY)
   gate->scanhash              = (void*)&scanhash_lbry_4way;
   gate->hash                  = (void*)&lbry_4way_hash;
+  gate->optimizations = AVX2_OPT | AVX512_OPT;
 #else 
   gate->scanhash              = (void*)&scanhash_lbry;
   gate->hash                  = (void*)&lbry_hash;
+  gate->optimizations = AVX2_OPT | AVX512_OPT | SHA_OPT;
 #endif
   gate->calc_network_diff     = (void*)&lbry_calc_network_diff;
   gate->build_stratum_request = (void*)&lbry_le_build_stratum_request;

algo/ripemd/lbry-gate.h

@@ -4,11 +4,19 @@
 #include "algo-gate-api.h"
 #include <stdint.h>
 
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define LBRY_16WAY 1
+#elif defined(__AVX2__)
+  #define LBRY_8WAY 1
+#endif
+/*
 #if !defined(__SHA__)
  #if defined(__AVX2__)
   #define LBRY_8WAY
  #endif
 #endif
+*/
 
 #define LBRY_NTIME_INDEX 25
 #define LBRY_NBITS_INDEX 26
@@ -18,18 +26,23 @@
 
 bool register_lbry_algo( algo_gate_t* gate );
 
-#if defined(LBRY_8WAY)
+#if defined(LBRY_16WAY)
+
+void lbry_16way_hash( void *state, const void *input );
+int scanhash_lbry_16way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+#elif defined(LBRY_8WAY)
 
 void lbry_8way_hash( void *state, const void *input );
 int scanhash_lbry_8way( struct work *work, uint32_t max_nonce,
                          uint64_t *hashes_done, struct thr_info *mythr );
-/*
+
 #elif defined(LBRY_4WAY)
 
 void lbry_4way_hash( void *state, const void *input );
 int scanhash_lbry_4way( struct work *work, uint32_t max_nonce,
                          uint64_t *hashes_done );
-*/
+
 #else
 
 void lbry_hash( void *state, const void *input );

algo/ripemd/lbry.c

@@ -80,9 +80,6 @@ int scanhash_lbry( struct work *work, uint32_t max_nonce,
 	// we need bigendian data...
         swab32_array( endiandata, pdata, 32 );
 
-#ifdef DEBUG_ALGO
-	printf("[%d] Htarg=%X\n", thr_id, Htarg);
-#endif
 	for (int m=0; m < sizeof(masks); m++) {
 		if (Htarg <= htmax[m]) {
 			uint32_t mask = masks[m];
@@ -90,23 +87,11 @@ int scanhash_lbry( struct work *work, uint32_t max_nonce,
 				pdata[27] = ++n;
 				be32enc(&endiandata[27], n);
 				lbry_hash(hash64, &endiandata);
-#ifndef DEBUG_ALGO
 				if ((!(hash64[7] & mask)) && fulltest(hash64, ptarget)) {
-					*hashes_done = n - first_nonce + 1;
-					return true;
+               pdata[27] = n;
+               submit_solution( work, hash64, mythr );
 				}
-#else
-				if (!(n % 0x1000) && !thr_id) printf(".");
-				if (!(hash64[7] & mask)) {
-					printf("[%d]",thr_id);
-					if (fulltest(hash64, ptarget)) {
-						*hashes_done = n - first_nonce + 1;
-						return true;
-					}
-				}
-#endif
-			} while (n < max_nonce && !work_restart[thr_id].restart);
-			// see blake.c if else to understand the loop on htmax => mask
+			} while ( (n < max_nonce -8) && !work_restart[thr_id].restart);
 			break;
 		}
 	}

algo/ripemd/ripemd-hash-4way.c

@@ -259,7 +259,8 @@ void ripemd160_4way_init( ripemd160_4way_context *sc )
    sc->count_high = sc->count_low = 0;
 }
 
-void ripemd160_4way( ripemd160_4way_context *sc, const void *data, size_t len )
+void ripemd160_4way_update( ripemd160_4way_context *sc, const void *data,
+                            size_t len )
 {
    __m128i *vdata = (__m128i*)data;
    size_t ptr;
@@ -559,7 +560,8 @@ void ripemd160_8way_init( ripemd160_8way_context *sc )
    sc->count_high = sc->count_low = 0;
 }
 
-void ripemd160_8way( ripemd160_8way_context *sc, const void *data, size_t len )
+void ripemd160_8way_update( ripemd160_8way_context *sc, const void *data,
+                            size_t len )
 {
    __m256i *vdata = (__m256i*)data;
    size_t ptr;
@@ -623,3 +625,303 @@ void ripemd160_8way_close( ripemd160_8way_context  *sc, void *dst )
 
 #endif // __AVX2__
 
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//  RIPEMD-160 16 way
+
+
+#define F16W_1(x, y, z) \
+   _mm512_xor_si512( _mm512_xor_si512( x, y ), z )
+
+#define F16W_2(x, y, z) \
+   _mm512_xor_si512( _mm512_and_si512( _mm512_xor_si512( y, z ), x ), z )
+
+#define F16W_3(x, y, z) \
+   _mm512_xor_si512( _mm512_or_si512( x, mm512_not( y ) ), z )
+
+#define F16W_4(x, y, z) \
+   _mm512_xor_si512( _mm512_and_si512( _mm512_xor_si512( x, y ), z ), y )
+
+#define F16W_5(x, y, z) \
+   _mm512_xor_si512( x, _mm512_or_si512( y, mm512_not( z ) ) )
+
+#define RR_16W(a, b, c, d, e, f, s, r, k) \
+do{ \
+   a = _mm512_add_epi32( mm512_rol_32( _mm512_add_epi32( _mm512_add_epi32( \
+                _mm512_add_epi32( a, f( b ,c, d ) ), r ), \
+                                 m512_const1_64( k ) ), s ), e ); \
+   c = mm512_rol_32( c, 10 );\
+} while (0)
+
+#define ROUND1_16W(a, b, c, d, e, f, s, r, k)  \
+        RR_16W(a ## 1, b ## 1, c ## 1, d ## 1, e ## 1, f, s, r, K1 ## k)
+
+#define ROUND2_16W(a, b, c, d, e, f, s, r, k)  \
+        RR_16W(a ## 2, b ## 2, c ## 2, d ## 2, e ## 2, f, s, r, K2 ## k)
+
+static void ripemd160_16way_round( ripemd160_16way_context *sc )
+{
+   const __m512i *in = (__m512i*)sc->buf;
+   __m512i *h  = (__m512i*)sc->val;
+   register __m512i A1, B1, C1, D1, E1;
+   register __m512i A2, B2, C2, D2, E2;
+   __m512i tmp;
+
+   A1 = A2 = h[0];
+   B1 = B2 = h[1];
+   C1 = C2 = h[2];
+   D1 = D2 = h[3];
+   E1 = E2 = h[4];
+
+   ROUND1_16W( A, B, C, D, E, F16W_1, 11, in[ 0], 1 );
+   ROUND1_16W( E, A, B, C, D, F16W_1, 14, in[ 1], 1 );
+   ROUND1_16W( D, E, A, B, C, F16W_1, 15, in[ 2], 1 );
+   ROUND1_16W( C, D, E, A, B, F16W_1, 12, in[ 3], 1 );
+   ROUND1_16W( B, C, D, E, A, F16W_1,  5, in[ 4], 1 );
+   ROUND1_16W( A, B, C, D, E, F16W_1,  8, in[ 5], 1 );
+   ROUND1_16W( E, A, B, C, D, F16W_1,  7, in[ 6], 1 );
+   ROUND1_16W( D, E, A, B, C, F16W_1,  9, in[ 7], 1 );
+   ROUND1_16W( C, D, E, A, B, F16W_1, 11, in[ 8], 1 );
+   ROUND1_16W( B, C, D, E, A, F16W_1, 13, in[ 9], 1 );
+   ROUND1_16W( A, B, C, D, E, F16W_1, 14, in[10], 1 );
+   ROUND1_16W( E, A, B, C, D, F16W_1, 15, in[11], 1 );
+   ROUND1_16W( D, E, A, B, C, F16W_1,  6, in[12], 1 );
+   ROUND1_16W( C, D, E, A, B, F16W_1,  7, in[13], 1 );
+   ROUND1_16W( B, C, D, E, A, F16W_1,  9, in[14], 1 );
+   ROUND1_16W( A, B, C, D, E, F16W_1,  8, in[15], 1 );
+
+   ROUND1_16W( E, A, B, C, D, F16W_2,  7, in[ 7], 2 );
+   ROUND1_16W( D, E, A, B, C, F16W_2,  6, in[ 4], 2 );
+   ROUND1_16W( C, D, E, A, B, F16W_2,  8, in[13], 2 );
+   ROUND1_16W( B, C, D, E, A, F16W_2, 13, in[ 1], 2 );
+   ROUND1_16W( A, B, C, D, E, F16W_2, 11, in[10], 2 );
+   ROUND1_16W( E, A, B, C, D, F16W_2,  9, in[ 6], 2 );
+   ROUND1_16W( D, E, A, B, C, F16W_2,  7, in[15], 2 );
+   ROUND1_16W( C, D, E, A, B, F16W_2, 15, in[ 3], 2 );
+   ROUND1_16W( B, C, D, E, A, F16W_2,  7, in[12], 2 );
+   ROUND1_16W( A, B, C, D, E, F16W_2, 12, in[ 0], 2 );
+   ROUND1_16W( E, A, B, C, D, F16W_2, 15, in[ 9], 2 );
+   ROUND1_16W( D, E, A, B, C, F16W_2,  9, in[ 5], 2 );
+   ROUND1_16W( C, D, E, A, B, F16W_2, 11, in[ 2], 2 );
+   ROUND1_16W( B, C, D, E, A, F16W_2,  7, in[14], 2 );
+   ROUND1_16W( A, B, C, D, E, F16W_2, 13, in[11], 2 );
+   ROUND1_16W( E, A, B, C, D, F16W_2, 12, in[ 8], 2 );
+
+   ROUND1_16W( D, E, A, B, C, F16W_3, 11, in[ 3], 3 );
+   ROUND1_16W( C, D, E, A, B, F16W_3, 13, in[10], 3 );
+   ROUND1_16W( B, C, D, E, A, F16W_3,  6, in[14], 3 );
+   ROUND1_16W( A, B, C, D, E, F16W_3,  7, in[ 4], 3 );
+   ROUND1_16W( E, A, B, C, D, F16W_3, 14, in[ 9], 3 );
+   ROUND1_16W( D, E, A, B, C, F16W_3,  9, in[15], 3 );
+   ROUND1_16W( C, D, E, A, B, F16W_3, 13, in[ 8], 3 );
+   ROUND1_16W( B, C, D, E, A, F16W_3, 15, in[ 1], 3 );
+   ROUND1_16W( A, B, C, D, E, F16W_3, 14, in[ 2], 3 );
+   ROUND1_16W( E, A, B, C, D, F16W_3,  8, in[ 7], 3 );
+   ROUND1_16W( D, E, A, B, C, F16W_3, 13, in[ 0], 3 );
+   ROUND1_16W( C, D, E, A, B, F16W_3,  6, in[ 6], 3 );
+   ROUND1_16W( B, C, D, E, A, F16W_3,  5, in[13], 3 );
+   ROUND1_16W( A, B, C, D, E, F16W_3, 12, in[11], 3 );
+   ROUND1_16W( E, A, B, C, D, F16W_3,  7, in[ 5], 3 );
+   ROUND1_16W( D, E, A, B, C, F16W_3,  5, in[12], 3 );
+
+   ROUND1_16W( C, D, E, A, B, F16W_4, 11, in[ 1], 4 );
+   ROUND1_16W( B, C, D, E, A, F16W_4, 12, in[ 9], 4 );
+   ROUND1_16W( A, B, C, D, E, F16W_4, 14, in[11], 4 );
+   ROUND1_16W( E, A, B, C, D, F16W_4, 15, in[10], 4 );
+   ROUND1_16W( D, E, A, B, C, F16W_4, 14, in[ 0], 4 );
+   ROUND1_16W( C, D, E, A, B, F16W_4, 15, in[ 8], 4 );
+   ROUND1_16W( B, C, D, E, A, F16W_4,  9, in[12], 4 );
+   ROUND1_16W( A, B, C, D, E, F16W_4,  8, in[ 4], 4 );
+   ROUND1_16W( E, A, B, C, D, F16W_4,  9, in[13], 4 );
+   ROUND1_16W( D, E, A, B, C, F16W_4, 14, in[ 3], 4 );
+   ROUND1_16W( C, D, E, A, B, F16W_4,  5, in[ 7], 4 );
+   ROUND1_16W( B, C, D, E, A, F16W_4,  6, in[15], 4 );
+   ROUND1_16W( A, B, C, D, E, F16W_4,  8, in[14], 4 );
+   ROUND1_16W( E, A, B, C, D, F16W_4,  6, in[ 5], 4 );
+   ROUND1_16W( D, E, A, B, C, F16W_4,  5, in[ 6], 4 );
+   ROUND1_16W( C, D, E, A, B, F16W_4, 12, in[ 2], 4 );
+
+   ROUND1_16W( B, C, D, E, A, F16W_5,  9, in[ 4], 5 );
+   ROUND1_16W( A, B, C, D, E, F16W_5, 15, in[ 0], 5 );
+   ROUND1_16W( E, A, B, C, D, F16W_5,  5, in[ 5], 5 );
+   ROUND1_16W( D, E, A, B, C, F16W_5, 11, in[ 9], 5 );
+   ROUND1_16W( C, D, E, A, B, F16W_5,  6, in[ 7], 5 );
+   ROUND1_16W( B, C, D, E, A, F16W_5,  8, in[12], 5 );
+   ROUND1_16W( A, B, C, D, E, F16W_5, 13, in[ 2], 5 );
+   ROUND1_16W( E, A, B, C, D, F16W_5, 12, in[10], 5 );
+   ROUND1_16W( D, E, A, B, C, F16W_5,  5, in[14], 5 );
+   ROUND1_16W( C, D, E, A, B, F16W_5, 12, in[ 1], 5 );
+   ROUND1_16W( B, C, D, E, A, F16W_5, 13, in[ 3], 5 );
+   ROUND1_16W( A, B, C, D, E, F16W_5, 14, in[ 8], 5 );
+   ROUND1_16W( E, A, B, C, D, F16W_5, 11, in[11], 5 );
+   ROUND1_16W( D, E, A, B, C, F16W_5,  8, in[ 6], 5 );
+   ROUND1_16W( C, D, E, A, B, F16W_5,  5, in[15], 5 );
+   ROUND1_16W( B, C, D, E, A, F16W_5,  6, in[13], 5 );
+
+   ROUND2_16W( A, B, C, D, E, F16W_5,  8, in[ 5], 1 );
+   ROUND2_16W( E, A, B, C, D, F16W_5,  9, in[14], 1 );
+   ROUND2_16W( D, E, A, B, C, F16W_5,  9, in[ 7], 1 );
+   ROUND2_16W( C, D, E, A, B, F16W_5, 11, in[ 0], 1 );
+   ROUND2_16W( B, C, D, E, A, F16W_5, 13, in[ 9], 1 );
+   ROUND2_16W( A, B, C, D, E, F16W_5, 15, in[ 2], 1 );
+   ROUND2_16W( E, A, B, C, D, F16W_5, 15, in[11], 1 );
+   ROUND2_16W( D, E, A, B, C, F16W_5,  5, in[ 4], 1 );
+   ROUND2_16W( C, D, E, A, B, F16W_5,  7, in[13], 1 );
+   ROUND2_16W( B, C, D, E, A, F16W_5,  7, in[ 6], 1 );
+   ROUND2_16W( A, B, C, D, E, F16W_5,  8, in[15], 1 );
+   ROUND2_16W( E, A, B, C, D, F16W_5, 11, in[ 8], 1 );
+   ROUND2_16W( D, E, A, B, C, F16W_5, 14, in[ 1], 1 );
+   ROUND2_16W( C, D, E, A, B, F16W_5, 14, in[10], 1 );
+   ROUND2_16W( B, C, D, E, A, F16W_5, 12, in[ 3], 1 );
+   ROUND2_16W( A, B, C, D, E, F16W_5,  6, in[12], 1 );
+
+   ROUND2_16W( E, A, B, C, D, F16W_4,  9, in[ 6], 2 );
+   ROUND2_16W( D, E, A, B, C, F16W_4, 13, in[11], 2 );
+   ROUND2_16W( C, D, E, A, B, F16W_4, 15, in[ 3], 2 );
+   ROUND2_16W( B, C, D, E, A, F16W_4,  7, in[ 7], 2 );
+   ROUND2_16W( A, B, C, D, E, F16W_4, 12, in[ 0], 2 );
+   ROUND2_16W( E, A, B, C, D, F16W_4,  8, in[13], 2 );
+   ROUND2_16W( D, E, A, B, C, F16W_4,  9, in[ 5], 2 );
+   ROUND2_16W( C, D, E, A, B, F16W_4, 11, in[10], 2 );
+   ROUND2_16W( B, C, D, E, A, F16W_4,  7, in[14], 2 );
+   ROUND2_16W( A, B, C, D, E, F16W_4,  7, in[15], 2 );
+   ROUND2_16W( E, A, B, C, D, F16W_4, 12, in[ 8], 2 );
+   ROUND2_16W( D, E, A, B, C, F16W_4,  7, in[12], 2 );
+   ROUND2_16W( C, D, E, A, B, F16W_4,  6, in[ 4], 2 );
+   ROUND2_16W( B, C, D, E, A, F16W_4, 15, in[ 9], 2 );
+   ROUND2_16W( A, B, C, D, E, F16W_4, 13, in[ 1], 2 );
+   ROUND2_16W( E, A, B, C, D, F16W_4, 11, in[ 2], 2 );
+
+   ROUND2_16W( D, E, A, B, C, F16W_3,  9, in[15], 3 );
+   ROUND2_16W( C, D, E, A, B, F16W_3,  7, in[ 5], 3 );
+   ROUND2_16W( B, C, D, E, A, F16W_3, 15, in[ 1], 3 );
+   ROUND2_16W( A, B, C, D, E, F16W_3, 11, in[ 3], 3 );
+   ROUND2_16W( E, A, B, C, D, F16W_3,  8, in[ 7], 3 );
+   ROUND2_16W( D, E, A, B, C, F16W_3,  6, in[14], 3 );
+   ROUND2_16W( C, D, E, A, B, F16W_3,  6, in[ 6], 3 );
+   ROUND2_16W( B, C, D, E, A, F16W_3, 14, in[ 9], 3 );
+   ROUND2_16W( A, B, C, D, E, F16W_3, 12, in[11], 3 );
+   ROUND2_16W( E, A, B, C, D, F16W_3, 13, in[ 8], 3 );
+   ROUND2_16W( D, E, A, B, C, F16W_3,  5, in[12], 3 );
+   ROUND2_16W( C, D, E, A, B, F16W_3, 14, in[ 2], 3 );
+   ROUND2_16W( B, C, D, E, A, F16W_3, 13, in[10], 3 );
+   ROUND2_16W( A, B, C, D, E, F16W_3, 13, in[ 0], 3 );
+   ROUND2_16W( E, A, B, C, D, F16W_3,  7, in[ 4], 3 );
+   ROUND2_16W( D, E, A, B, C, F16W_3,  5, in[13], 3 );
+
+   ROUND2_16W( C, D, E, A, B, F16W_2, 15, in[ 8], 4 );
+   ROUND2_16W( B, C, D, E, A, F16W_2,  5, in[ 6], 4 );
+   ROUND2_16W( A, B, C, D, E, F16W_2,  8, in[ 4], 4 );
+   ROUND2_16W( E, A, B, C, D, F16W_2, 11, in[ 1], 4 );
+   ROUND2_16W( D, E, A, B, C, F16W_2, 14, in[ 3], 4 );
+   ROUND2_16W( C, D, E, A, B, F16W_2, 14, in[11], 4 );
+   ROUND2_16W( B, C, D, E, A, F16W_2,  6, in[15], 4 );
+   ROUND2_16W( A, B, C, D, E, F16W_2, 14, in[ 0], 4 );
+   ROUND2_16W( E, A, B, C, D, F16W_2,  6, in[ 5], 4 );
+   ROUND2_16W( D, E, A, B, C, F16W_2,  9, in[12], 4 );
+   ROUND2_16W( C, D, E, A, B, F16W_2, 12, in[ 2], 4 );
+   ROUND2_16W( B, C, D, E, A, F16W_2,  9, in[13], 4 );
+   ROUND2_16W( A, B, C, D, E, F16W_2, 12, in[ 9], 4 );
+   ROUND2_16W( E, A, B, C, D, F16W_2,  5, in[ 7], 4 );
+   ROUND2_16W( D, E, A, B, C, F16W_2, 15, in[10], 4 );
+   ROUND2_16W( C, D, E, A, B, F16W_2,  8, in[14], 4 );
+
+   ROUND2_16W( B, C, D, E, A, F16W_1,  8, in[12], 5 );
+   ROUND2_16W( A, B, C, D, E, F16W_1,  5, in[15], 5 );
+   ROUND2_16W( E, A, B, C, D, F16W_1, 12, in[10], 5 );
+   ROUND2_16W( D, E, A, B, C, F16W_1,  9, in[ 4], 5 );
+   ROUND2_16W( C, D, E, A, B, F16W_1, 12, in[ 1], 5 );
+   ROUND2_16W( B, C, D, E, A, F16W_1,  5, in[ 5], 5 );
+   ROUND2_16W( A, B, C, D, E, F16W_1, 14, in[ 8], 5 );
+   ROUND2_16W( E, A, B, C, D, F16W_1,  6, in[ 7], 5 );
+   ROUND2_16W( D, E, A, B, C, F16W_1,  8, in[ 6], 5 );
+   ROUND2_16W( C, D, E, A, B, F16W_1, 13, in[ 2], 5 );
+   ROUND2_16W( B, C, D, E, A, F16W_1,  6, in[13], 5 );
+   ROUND2_16W( A, B, C, D, E, F16W_1,  5, in[14], 5 );
+   ROUND2_16W( E, A, B, C, D, F16W_1, 15, in[ 0], 5 );
+   ROUND2_16W( D, E, A, B, C, F16W_1, 13, in[ 3], 5 );
+   ROUND2_16W( C, D, E, A, B, F16W_1, 11, in[ 9], 5 );
+   ROUND2_16W( B, C, D, E, A, F16W_1, 11, in[11], 5 );
+
+   tmp =  _mm512_add_epi32( _mm512_add_epi32( h[1], C1 ), D2 );
+   h[1] = _mm512_add_epi32( _mm512_add_epi32( h[2], D1 ), E2 );
+   h[2] = _mm512_add_epi32( _mm512_add_epi32( h[3], E1 ), A2 );
+   h[3] = _mm512_add_epi32( _mm512_add_epi32( h[4], A1 ), B2 );
+   h[4] = _mm512_add_epi32( _mm512_add_epi32( h[0], B1 ), C2 );
+   h[0] = tmp;
+}
+
+void ripemd160_16way_init( ripemd160_16way_context *sc )
+{
+   sc->val[0] = m512_const1_64( 0x6745230167452301 );
+   sc->val[1] = m512_const1_64( 0xEFCDAB89EFCDAB89 );
+   sc->val[2] = m512_const1_64( 0x98BADCFE98BADCFE );
+   sc->val[3] = m512_const1_64( 0x1032547610325476 );
+   sc->val[4] = m512_const1_64( 0xC3D2E1F0C3D2E1F0 );
+   sc->count_high = sc->count_low = 0;
+}
+
+void ripemd160_16way_update( ripemd160_16way_context *sc, const void *data,
+                      size_t len )
+{
+   __m512i *vdata = (__m512i*)data;
+   size_t ptr;
+   const int block_size = 64;
+
+   ptr = (unsigned)sc->count_low & (block_size - 1U);
+   while ( len > 0 )
+   {
+      size_t clen;
+      uint32_t clow, clow2;
+
+      clen = block_size - ptr;
+      if ( clen > len )
+         clen = len;
+      memcpy_512( sc->buf + (ptr>>2), vdata, clen>>2 );
+      vdata = vdata + (clen>>2);
+      ptr += clen;
+      len -= clen;
+      if ( ptr == block_size )
+      {
+         ripemd160_16way_round( sc );
+         ptr = 0;
+      }
+      clow = sc->count_low;
+      clow2 = clow + clen;
+      sc->count_low = clow2;
+      if ( clow2 < clow )
+         sc->count_high++;
+   }
+}
+
+void ripemd160_16way_close( ripemd160_16way_context  *sc, void *dst )
+{
+   unsigned ptr, u;
+   uint32_t low, high;
+   const int block_size = 64;
+   const int pad = block_size - 8;
+
+   ptr = (unsigned)sc->count_low & ( block_size - 1U);
+   sc->buf[ ptr>>2 ] = m512_const1_32( 0x80 );
+   ptr += 4;
+
+   if ( ptr > pad )
+   {
+       memset_zero_512( sc->buf + (ptr>>2), (block_size - ptr) >> 2 );
+       ripemd160_16way_round( sc );
+       memset_zero_512( sc->buf, pad>>2 );
+   }
+   else
+       memset_zero_512( sc->buf + (ptr>>2), (pad - ptr) >> 2 );
+
+    low = sc->count_low;
+    high = (sc->count_high << 3) | (low >> 29);
+    low = low << 3;
+    sc->buf[  pad>>2      ] = _mm512_set1_epi32( low  );
+    sc->buf[ (pad>>2) + 1 ] = _mm512_set1_epi32( high );
+    ripemd160_16way_round( sc );
+    for (u = 0; u < 5; u ++)
+        casti_m512i( dst, u ) = sc->val[u];
+}
+
+#endif  // AVX512

algo/ripemd/ripemd-hash-4way.h

@@ -16,7 +16,8 @@ typedef struct
 } __attribute__ ((aligned (64))) ripemd160_4way_context;
 
 void ripemd160_4way_init( ripemd160_4way_context *sc );
-void ripemd160_4way( ripemd160_4way_context *sc, const void *data, size_t len );
+void ripemd160_4way_update( ripemd160_4way_context *sc, const void *data,
+                            size_t len );
 void ripemd160_4way_close( ripemd160_4way_context *sc, void *dst );
 
 #if defined (__AVX2__)
@@ -26,13 +27,28 @@ typedef struct
    __m256i buf[64>>2];
    __m256i val[5];
    uint32_t count_high, count_low;
-} __attribute__ ((aligned (64))) ripemd160_8way_context;
+} __attribute__ ((aligned (128))) ripemd160_8way_context;
 
 void ripemd160_8way_init( ripemd160_8way_context *sc );
-void ripemd160_8way( ripemd160_8way_context *sc, const void *data, size_t len );
+void ripemd160_8way_update( ripemd160_8way_context *sc, const void *data,
+                            size_t len );
 void ripemd160_8way_close( ripemd160_8way_context *sc, void *dst );
 
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
 
+typedef struct
+{
+   __m512i buf[64>>2];
+   __m512i val[5];
+   uint32_t count_high, count_low;
+} __attribute__ ((aligned (128))) ripemd160_16way_context;
+
+void ripemd160_16way_init( ripemd160_16way_context *sc );
+void ripemd160_16way_update( ripemd160_16way_context *sc, const void *data,
+                      size_t len );
+void ripemd160_16way_close( ripemd160_16way_context *sc, void *dst );
+
+#endif // AVX512
 #endif // __AVX2__
 #endif // __SSE4_2__
 #endif // RIPEMD_HASH_4WAY_H__

algo/scryptjane/scrypt-conf.h

@@ -1,28 +0,0 @@
-/*
-	pick the best algo at runtime or compile time?
-	----------------------------------------------
-	SCRYPT_CHOOSE_COMPILETIME (gcc only!)
-	SCRYPT_CHOOSE_RUNTIME
-*/
-#define SCRYPT_CHOOSE_RUNTIME
-
-
-/*
-	hash function to use
-	-------------------------------
-	SCRYPT_BLAKE256
-	SCRYPT_BLAKE512
-	SCRYPT_SHA256
-	SCRYPT_SHA512
-	SCRYPT_SKEIN512
-*/
-//#define SCRYPT_SHA256
-
-
-/*
-	block mixer to use
-	-----------------------------
-	SCRYPT_CHACHA
-	SCRYPT_SALSA
-*/
-//#define SCRYPT_SALSA

algo/scryptjane/scrypt-jane-chacha.h

@@ -1,149 +0,0 @@
-#define SCRYPT_MIX_BASE "ChaCha20/8"
-
-typedef uint32_t scrypt_mix_word_t;
-
-#define SCRYPT_WORDTO8_LE U32TO8_LE
-#define SCRYPT_WORD_ENDIAN_SWAP U32_SWAP
-
-#define SCRYPT_BLOCK_BYTES 64
-#define SCRYPT_BLOCK_WORDS (SCRYPT_BLOCK_BYTES / sizeof(scrypt_mix_word_t))
-
-/* must have these here in case block bytes is ever != 64 */
-#include "scrypt-jane-romix-basic.h"
-
-#include "scrypt-jane-mix_chacha-avx.h"
-#include "scrypt-jane-mix_chacha-ssse3.h"
-#include "scrypt-jane-mix_chacha-sse2.h"
-#include "scrypt-jane-mix_chacha.h"
-
-#if defined(SCRYPT_CHACHA_AVX)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_avx
-	#if defined(X86_INTRINSIC_AVX)
-		#define SCRYPT_CHUNKMIX_1_FN scrypt_ChunkMix_avx_1
-		#define SCRYPT_CHUNKMIX_1_XOR_FN scrypt_ChunkMix_avx_1_xor
-	#endif
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_avx
-	#define SCRYPT_MIX_FN chacha_core_avx
-	#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_nop
-	#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_nop
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-#if defined(SCRYPT_CHACHA_SSSE3)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_ssse3
-	#if defined(X86_INTRINSIC_SSSE3)
-		#define SCRYPT_CHUNKMIX_1_FN scrypt_ChunkMix_ssse3_1
-		#define SCRYPT_CHUNKMIX_1_XOR_FN scrypt_ChunkMix_ssse3_1_xor
-	#endif
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_ssse3
-	#define SCRYPT_MIX_FN chacha_core_ssse3
-	#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_nop
-	#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_nop
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-#if defined(SCRYPT_CHACHA_SSE2)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_sse2
-	#if defined(X86_INTRINSIC_SSE2)
-		#define SCRYPT_CHUNKMIX_1_FN scrypt_ChunkMix_sse2_1
-		#define SCRYPT_CHUNKMIX_1_XOR_FN scrypt_ChunkMix_sse2_1_xor
-	#endif
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_sse2
-	#define SCRYPT_MIX_FN chacha_core_sse2
-	#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_nop
-	#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_nop
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-
-/* cpu agnostic */
-#define SCRYPT_ROMIX_FN scrypt_ROMix_basic
-#define SCRYPT_MIX_FN chacha_core_basic
-#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_convert_endian
-#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_convert_endian
-#include "scrypt-jane-romix-template.h"
-
-#if !defined(SCRYPT_CHOOSE_COMPILETIME)
-static scrypt_ROMixfn
-scrypt_getROMix() {
-	size_t cpuflags = detect_cpu();
-
-#if defined(SCRYPT_CHACHA_AVX)
-	if (cpuflags & cpu_avx)
-		return scrypt_ROMix_avx;
-	else
-#endif
-
-#if defined(SCRYPT_CHACHA_SSSE3)
-	if (cpuflags & cpu_ssse3)
-		return scrypt_ROMix_ssse3;
-	else
-#endif
-
-#if defined(SCRYPT_CHACHA_SSE2)
-	if (cpuflags & cpu_sse2)
-		return scrypt_ROMix_sse2;
-	else
-#endif
-
-	return scrypt_ROMix_basic;
-}
-#endif
-
-
-#if defined(SCRYPT_TEST_SPEED)
-static size_t
-available_implementations() {
-	size_t cpuflags = detect_cpu();
-	size_t flags = 0;
-
-#if defined(SCRYPT_CHACHA_AVX)
-	if (cpuflags & cpu_avx)
-		flags |= cpu_avx;
-#endif
-
-#if defined(SCRYPT_CHACHA_SSSE3)
-	if (cpuflags & cpu_ssse3)
-		flags |= cpu_ssse3;
-#endif
-
-#if defined(SCRYPT_CHACHA_SSE2)
-	if (cpuflags & cpu_sse2)
-		flags |= cpu_sse2;
-#endif
-
-	return flags;
-}
-#endif
-/*
-static int
-scrypt_test_mix() {
-	static const uint8_t expected[16] = {
-		0x48,0x2b,0x2d,0xb8,0xa1,0x33,0x22,0x73,0xcd,0x16,0xc4,0xb4,0xb0,0x7f,0xb1,0x8a,
-	};
-
-	int ret = 1;
-	size_t cpuflags = detect_cpu();
-
-#if defined(SCRYPT_CHACHA_AVX)
-	if (cpuflags & cpu_avx)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_avx, scrypt_romix_nop, scrypt_romix_nop, expected);
-#endif
-
-#if defined(SCRYPT_CHACHA_SSSE3)
-	if (cpuflags & cpu_ssse3)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_ssse3, scrypt_romix_nop, scrypt_romix_nop, expected);
-#endif
-
-#if defined(SCRYPT_CHACHA_SSE2)
-	if (cpuflags & cpu_sse2)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_sse2, scrypt_romix_nop, scrypt_romix_nop, expected);
-#endif
-
-#if defined(SCRYPT_CHACHA_BASIC)
-	ret &= scrypt_test_mix_instance(scrypt_ChunkMix_basic, scrypt_romix_convert_endian, scrypt_romix_convert_endian, expected);
-#endif
-
-	return ret;
-}
-*/

algo/scryptjane/scrypt-jane-hash.h

@@ -1,48 +0,0 @@
-#if defined(SCRYPT_BLAKE512)
-#include "scrypt-jane-hash_blake512.h"
-#elif defined(SCRYPT_BLAKE256)
-#include "scrypt-jane-hash_blake256.h"
-#elif defined(SCRYPT_SHA512)
-#include "scrypt-jane-hash_sha512.h"
-#elif defined(SCRYPT_SHA256)
-#include "scrypt-jane-hash_sha256.h"
-#elif defined(SCRYPT_SKEIN512)
-#include "scrypt-jane-hash_skein512.h"
-#elif defined(SCRYPT_KECCAK512) || defined(SCRYPT_KECCAK256)
-#include "scrypt-jane-hash_keccak.h"
-#else
-	#define SCRYPT_HASH "ERROR"
-	#define SCRYPT_HASH_BLOCK_SIZE 64
-	#define SCRYPT_HASH_DIGEST_SIZE 64
-	typedef struct scrypt_hash_state_t { size_t dummy; } scrypt_hash_state;
-	typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-	static void scrypt_hash_init(scrypt_hash_state *S) {}
-	static void scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {}
-	static void scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {}
-	static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {0};
-	#error must define a hash function!
-#endif
-
-#include "scrypt-jane-pbkdf2.h"
-
-#define SCRYPT_TEST_HASH_LEN 257 /* (2 * largest block size) + 1 */
-/*
-static int
-scrypt_test_hash() {
-	scrypt_hash_state st;
-	scrypt_hash_digest hash, final;
-	uint8_t msg[SCRYPT_TEST_HASH_LEN];
-	size_t i;
-
-	for (i = 0; i < SCRYPT_TEST_HASH_LEN; i++)
-		msg[i] = (uint8_t)i;
-
-	scrypt_hash_init(&st);
-	for (i = 0; i < SCRYPT_TEST_HASH_LEN + 1; i++) {
-		scrypt_hash(hash, msg, i);
-		scrypt_hash_update(&st, hash, sizeof(hash));
-	}
-	scrypt_hash_finish(&st, final);
-	return scrypt_verify(final, scrypt_test_hash_expected, SCRYPT_HASH_DIGEST_SIZE);
-}
-*/

algo/scryptjane/scrypt-jane-hash_blake256.h

@@ -1,177 +0,0 @@
-#define SCRYPT_HASH "BLAKE-256"
-#define SCRYPT_HASH_BLOCK_SIZE 64
-#define SCRYPT_HASH_DIGEST_SIZE 32
-
-typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-
-const uint8_t blake256_sigma[] = {
-	 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
-	14,10, 4, 8, 9,15,13, 6, 1,12, 0, 2,11, 7, 5, 3,
-	11, 8,12, 0, 5, 2,15,13,10,14, 3, 6, 7, 1, 9, 4,
-	 7, 9, 3, 1,13,12,11,14, 2, 6, 5,10, 4, 0,15, 8,
-	 9, 0, 5, 7, 2, 4,10,15,14, 1,11,12, 6, 8, 3,13,
-	 2,12, 6,10, 0,11, 8, 3, 4,13, 7, 5,15,14, 1, 9,
-	12, 5, 1,15,14,13, 4,10, 0, 7, 6, 3, 9, 2, 8,11,
-	13,11, 7,14,12, 1, 3, 9, 5, 0,15, 4, 8, 6, 2,10,
-	 6,15,14, 9,11, 3, 0, 8,12, 2,13, 7, 1, 4,10, 5,
-	10, 2, 8, 4, 7, 6, 1, 5,15,11, 9,14, 3,12,13 ,0,
-};
-
-const uint32_t blake256_constants[16] = {
-	0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
-	0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917
-};
-
-typedef struct scrypt_hash_state_t {
-	uint32_t H[8], T[2];
-	uint32_t leftover;
-	uint8_t buffer[SCRYPT_HASH_BLOCK_SIZE];
-} scrypt_hash_state;
-
-static void
-blake256_blocks(scrypt_hash_state *S, const uint8_t *in, size_t blocks) {
-	const uint8_t *sigma, *sigma_end = blake256_sigma + (10 * 16);
-	uint32_t m[16], v[16], h[8], t[2];
-	uint32_t i;
-
-	for (i = 0; i < 8; i++) h[i] = S->H[i];
-	for (i = 0; i < 2; i++) t[i] = S->T[i];
-
-	while (blocks--) {
-		t[0] += 512;
-		t[1] += (t[0] < 512) ? 1 : 0;
-
-		for (i = 0; i <  8; i++) v[i     ] = h[i];
-		for (i = 0; i <  4; i++) v[i +  8] = blake256_constants[i];
-		for (i = 0; i <  2; i++) v[i + 12] = blake256_constants[i+4] ^ t[0];
-		for (i = 0; i <  2; i++) v[i + 14] = blake256_constants[i+6] ^ t[1];
-
-		for (i = 0; i < 16; i++) m[i] = U8TO32_BE(&in[i * 4]);
-		in += 64;
-
-		#define G(a,b,c,d,e)                                                 \
-			v[a] += (m[sigma[e+0]] ^ blake256_constants[sigma[e+1]]) + v[b]; \
-			v[d] = ROTR32(v[d] ^ v[a],16);                                   \
-			v[c] += v[d];                                                    \
-			v[b] = ROTR32(v[b] ^ v[c],12);                                   \
-			v[a] += (m[sigma[e+1]] ^ blake256_constants[sigma[e+0]]) + v[b]; \
-			v[d] = ROTR32(v[d] ^ v[a], 8);                                   \
-			v[c] += v[d];                                                    \
-			v[b] = ROTR32(v[b] ^ v[c], 7);
-
-		for (i = 0, sigma = blake256_sigma; i < 14; i++) {
-			G(0, 4, 8,12, 0);
-			G(1, 5, 9,13, 2);
-			G(2, 6,10,14, 4);
-			G(3, 7,11,15, 6);
-
-			G(0, 5,10,15, 8);
-			G(1, 6,11,12,10);
-			G(2, 7, 8,13,12);
-			G(3, 4, 9,14,14);
-
-			sigma += 16;
-			if (sigma == sigma_end)
-				sigma = blake256_sigma;
-		}
-
-		#undef G
-
-		for (i = 0; i < 8; i++) h[i] ^= (v[i] ^ v[i + 8]);
-	}
-
-	for (i = 0; i < 8; i++) S->H[i] = h[i];
-	for (i = 0; i < 2; i++) S->T[i] = t[i];
-}
-
-static void
-scrypt_hash_init(scrypt_hash_state *S) {
-	S->H[0] = 0x6a09e667ULL;
-	S->H[1] = 0xbb67ae85ULL;
-	S->H[2] = 0x3c6ef372ULL;
-	S->H[3] = 0xa54ff53aULL;
-	S->H[4] = 0x510e527fULL;
-	S->H[5] = 0x9b05688cULL;
-	S->H[6] = 0x1f83d9abULL;
-	S->H[7] = 0x5be0cd19ULL;
-	S->T[0] = 0;
-	S->T[1] = 0;
-	S->leftover = 0;
-}
-
-static void
-scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {
-	size_t blocks, want;
-
-	/* handle the previous data */
-	if (S->leftover) {
-		want = (SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-		want = (want < inlen) ? want : inlen;
-		memcpy(S->buffer + S->leftover, in, want);
-		S->leftover += (uint32_t)want;
-		if (S->leftover < SCRYPT_HASH_BLOCK_SIZE)
-			return;
-		in += want;
-		inlen -= want;
-		blake256_blocks(S, S->buffer, 1);
-	}
-
-	/* handle the current data */
-	blocks = (inlen & ~(SCRYPT_HASH_BLOCK_SIZE - 1));
-	S->leftover = (uint32_t)(inlen - blocks);
-	if (blocks) {
-		blake256_blocks(S, in, blocks / SCRYPT_HASH_BLOCK_SIZE);
-		in += blocks;
-	}
-
-	/* handle leftover data */
-	if (S->leftover)
-		memcpy(S->buffer, in, S->leftover);
-}
-
-static void
-scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {
-	uint32_t th, tl, bits;
-
-	bits = (S->leftover << 3);
-	tl = S->T[0] + bits;
-	th = S->T[1];
-	if (S->leftover == 0) {
-		S->T[0] = (uint32_t)0 - (uint32_t)512;
-		S->T[1] = (uint32_t)0 - (uint32_t)1;
-	} else if (S->T[0] == 0) {
-		S->T[0] = ((uint32_t)0 - (uint32_t)512) + bits;
-		S->T[1] = S->T[1] - 1;
-	} else {
-		S->T[0] -= (512 - bits);
-	}
-
-	S->buffer[S->leftover] = 0x80;
-	if (S->leftover <= 55) {
-		memset(S->buffer + S->leftover + 1, 0, 55 - S->leftover);
-	} else {
-		memset(S->buffer + S->leftover + 1, 0, 63 - S->leftover);
-		blake256_blocks(S, S->buffer, 1);
-		S->T[0] = (uint32_t)0 - (uint32_t)512;
-		S->T[1] = (uint32_t)0 - (uint32_t)1;
-		memset(S->buffer, 0, 56);
-	}
-	S->buffer[55] |= 1;
-	U32TO8_BE(S->buffer + 56, th);
-	U32TO8_BE(S->buffer + 60, tl);
-	blake256_blocks(S, S->buffer, 1);
-
-	U32TO8_BE(&hash[ 0], S->H[0]);
-	U32TO8_BE(&hash[ 4], S->H[1]);
-	U32TO8_BE(&hash[ 8], S->H[2]);
-	U32TO8_BE(&hash[12], S->H[3]);
-	U32TO8_BE(&hash[16], S->H[4]);
-	U32TO8_BE(&hash[20], S->H[5]);
-	U32TO8_BE(&hash[24], S->H[6]);
-	U32TO8_BE(&hash[28], S->H[7]);
-}
-
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0xcc,0xa9,0x1e,0xa9,0x20,0x97,0x37,0x40,0x17,0xc0,0xa0,0x52,0x87,0xfc,0x08,0x20,
-	0x40,0xf5,0x81,0x86,0x62,0x75,0x78,0xb2,0x79,0xce,0xde,0x27,0x3c,0x7f,0x85,0xd8,
-};

algo/scryptjane/scrypt-jane-hash_blake512.h

@@ -1,181 +0,0 @@
-#define SCRYPT_HASH "BLAKE-512"
-#define SCRYPT_HASH_BLOCK_SIZE 128
-#define SCRYPT_HASH_DIGEST_SIZE 64
-
-typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-
-const uint8_t blake512_sigma[] = {
-	 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
-	14,10, 4, 8, 9,15,13, 6, 1,12, 0, 2,11, 7, 5, 3,
-	11, 8,12, 0, 5, 2,15,13,10,14, 3, 6, 7, 1, 9, 4,
-	 7, 9, 3, 1,13,12,11,14, 2, 6, 5,10, 4, 0,15, 8,
-	 9, 0, 5, 7, 2, 4,10,15,14, 1,11,12, 6, 8, 3,13,
-	 2,12, 6,10, 0,11, 8, 3, 4,13, 7, 5,15,14, 1, 9,
-	12, 5, 1,15,14,13, 4,10, 0, 7, 6, 3, 9, 2, 8,11,
-	13,11, 7,14,12, 1, 3, 9, 5, 0,15, 4, 8, 6, 2,10,
-	 6,15,14, 9,11, 3, 0, 8,12, 2,13, 7, 1, 4,10, 5,
-	10, 2, 8, 4, 7, 6, 1, 5,15,11, 9,14, 3,12,13 ,0,
-};
-
-const uint64_t blake512_constants[16] = {
-	0x243f6a8885a308d3ULL, 0x13198a2e03707344ULL, 0xa4093822299f31d0ULL, 0x082efa98ec4e6c89ULL,
-	0x452821e638d01377ULL, 0xbe5466cf34e90c6cULL, 0xc0ac29b7c97c50ddULL, 0x3f84d5b5b5470917ULL,
-	0x9216d5d98979fb1bULL, 0xd1310ba698dfb5acULL, 0x2ffd72dbd01adfb7ULL, 0xb8e1afed6a267e96ULL,
-	0xba7c9045f12c7f99ULL, 0x24a19947b3916cf7ULL, 0x0801f2e2858efc16ULL, 0x636920d871574e69ULL
-};
-
-typedef struct scrypt_hash_state_t {
-	uint64_t H[8], T[2];
-	uint32_t leftover;
-	uint8_t buffer[SCRYPT_HASH_BLOCK_SIZE];
-} scrypt_hash_state;
-
-static void
-blake512_blocks(scrypt_hash_state *S, const uint8_t *in, size_t blocks) {
-	const uint8_t *sigma, *sigma_end = blake512_sigma + (10 * 16);
-	uint64_t m[16], v[16], h[8], t[2];
-	uint32_t i;
-
-	for (i = 0; i < 8; i++) h[i] = S->H[i];
-	for (i = 0; i < 2; i++) t[i] = S->T[i];
-
-	while (blocks--) {
-		t[0] += 1024;
-		t[1] += (t[0] < 1024) ? 1 : 0;
-
-		for (i = 0; i <  8; i++) v[i     ] = h[i];
-		for (i = 0; i <  4; i++) v[i +  8] = blake512_constants[i];
-		for (i = 0; i <  2; i++) v[i + 12] = blake512_constants[i+4] ^ t[0];
-		for (i = 0; i <  2; i++) v[i + 14] = blake512_constants[i+6] ^ t[1];
-
-		for (i = 0; i < 16; i++) m[i] = U8TO64_BE(&in[i * 8]);
-		in += 128;
-
-		#define G(a,b,c,d,e)                                                 \
-			v[a] += (m[sigma[e+0]] ^ blake512_constants[sigma[e+1]]) + v[b]; \
-			v[d] = ROTR64(v[d] ^ v[a],32);                                   \
-			v[c] += v[d];                                                    \
-			v[b] = ROTR64(v[b] ^ v[c],25);                                   \
-			v[a] += (m[sigma[e+1]] ^ blake512_constants[sigma[e+0]]) + v[b]; \
-			v[d] = ROTR64(v[d] ^ v[a],16);                                   \
-			v[c] += v[d];                                                    \
-			v[b] = ROTR64(v[b] ^ v[c],11);
-
-		for (i = 0, sigma = blake512_sigma; i < 16; i++) {
-			G(0, 4, 8,12, 0);
-			G(1, 5, 9,13, 2);
-			G(2, 6,10,14, 4);
-			G(3, 7,11,15, 6);
-			G(0, 5,10,15, 8);
-			G(1, 6,11,12,10);
-			G(2, 7, 8,13,12);
-			G(3, 4, 9,14,14);
-
-			sigma += 16;
-			if (sigma == sigma_end)
-				sigma = blake512_sigma;
-		}
-
-		#undef G
-
-		for (i = 0; i < 8; i++) h[i] ^= (v[i] ^ v[i + 8]);
-	}
-
-	for (i = 0; i < 8; i++) S->H[i] = h[i];
-	for (i = 0; i < 2; i++) S->T[i] = t[i];
-}
-
-static void
-scrypt_hash_init(scrypt_hash_state *S) {
-	S->H[0] = 0x6a09e667f3bcc908ULL;
-	S->H[1] = 0xbb67ae8584caa73bULL;
-	S->H[2] = 0x3c6ef372fe94f82bULL;
-	S->H[3] = 0xa54ff53a5f1d36f1ULL;
-	S->H[4] = 0x510e527fade682d1ULL;
-	S->H[5] = 0x9b05688c2b3e6c1fULL;
-	S->H[6] = 0x1f83d9abfb41bd6bULL;
-	S->H[7] = 0x5be0cd19137e2179ULL;
-	S->T[0] = 0;
-	S->T[1] = 0;
-	S->leftover = 0;
-}
-
-static void
-scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {
-	size_t blocks, want;
-
-	/* handle the previous data */
-	if (S->leftover) {
-		want = (SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-		want = (want < inlen) ? want : inlen;
-		memcpy(S->buffer + S->leftover, in, want);
-		S->leftover += (uint32_t)want;
-		if (S->leftover < SCRYPT_HASH_BLOCK_SIZE)
-			return;
-		in += want;
-		inlen -= want;
-		blake512_blocks(S, S->buffer, 1);
-	}
-
-	/* handle the current data */
-	blocks = (inlen & ~(SCRYPT_HASH_BLOCK_SIZE - 1));
-	S->leftover = (uint32_t)(inlen - blocks);
-	if (blocks) {
-		blake512_blocks(S, in, blocks / SCRYPT_HASH_BLOCK_SIZE);
-		in += blocks;
-	}
-
-	/* handle leftover data */
-	if (S->leftover)
-		memcpy(S->buffer, in, S->leftover);
-}
-
-static void
-scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {
-	uint64_t th, tl;
-	size_t bits;
-
-	bits = (S->leftover << 3);
-	tl = S->T[0] + bits;
-	th = S->T[1];
-	if (S->leftover == 0) {
-		S->T[0] = (uint64_t)0 - (uint64_t)1024;
-		S->T[1] = (uint64_t)0 - (uint64_t)1;
-	} else if (S->T[0] == 0) {
-		S->T[0] = ((uint64_t)0 - (uint64_t)1024) + bits;
-		S->T[1] = S->T[1] - 1;
-	} else {
-		S->T[0] -= (1024 - bits);
-	}
-
-	S->buffer[S->leftover] = 0x80;
-	if (S->leftover <= 111) {
-		memset(S->buffer + S->leftover + 1, 0, 111 - S->leftover);
-	} else {
-		memset(S->buffer + S->leftover + 1, 0, 127 - S->leftover);
-		blake512_blocks(S, S->buffer, 1);
-		S->T[0] = (uint64_t)0 - (uint64_t)1024;
-		S->T[1] = (uint64_t)0 - (uint64_t)1;
-		memset(S->buffer, 0, 112);
-	}
-	S->buffer[111] |= 1;
-	U64TO8_BE(S->buffer + 112, th);
-	U64TO8_BE(S->buffer + 120, tl);
-	blake512_blocks(S, S->buffer, 1);
-
-	U64TO8_BE(&hash[ 0], S->H[0]);
-	U64TO8_BE(&hash[ 8], S->H[1]);
-	U64TO8_BE(&hash[16], S->H[2]);
-	U64TO8_BE(&hash[24], S->H[3]);
-	U64TO8_BE(&hash[32], S->H[4]);
-	U64TO8_BE(&hash[40], S->H[5]);
-	U64TO8_BE(&hash[48], S->H[6]);
-	U64TO8_BE(&hash[56], S->H[7]);
-}
-
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0x2f,0x9d,0x5b,0xbe,0x24,0x0d,0x63,0xd3,0xa0,0xac,0x4f,0xd3,0x01,0xc0,0x23,0x6f,
-	0x6d,0xdf,0x6e,0xfb,0x60,0x6f,0xa0,0x74,0xdf,0x9f,0x25,0x65,0xb6,0x11,0x0a,0x83,
-	0x23,0x96,0xba,0x91,0x68,0x4b,0x85,0x15,0x13,0x54,0xba,0x19,0xf3,0x2c,0x5a,0x4a,
-	0x1f,0x78,0x31,0x02,0xc9,0x1e,0x56,0xc4,0x54,0xca,0xf9,0x8f,0x2c,0x7f,0x85,0xac
-};

algo/scryptjane/scrypt-jane-hash_keccak.h

@@ -1,168 +0,0 @@
-#if defined(SCRYPT_KECCAK256)
-	#define SCRYPT_HASH "Keccak-256"
-	#define SCRYPT_HASH_DIGEST_SIZE 32
-#else
-	#define SCRYPT_HASH "Keccak-512"
-	#define SCRYPT_HASH_DIGEST_SIZE 64
-#endif
-#define SCRYPT_KECCAK_F 1600
-#define SCRYPT_KECCAK_C (SCRYPT_HASH_DIGEST_SIZE * 8 * 2) /* 256=512, 512=1024 */
-#define SCRYPT_KECCAK_R (SCRYPT_KECCAK_F - SCRYPT_KECCAK_C) /* 256=1088, 512=576 */
-#define SCRYPT_HASH_BLOCK_SIZE (SCRYPT_KECCAK_R / 8)
-
-typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-
-typedef struct scrypt_hash_state_t {
-	uint64_t state[SCRYPT_KECCAK_F / 64];
-	uint32_t leftover;
-	uint8_t buffer[SCRYPT_HASH_BLOCK_SIZE];
-} scrypt_hash_state;
-
-static const uint64_t keccak_round_constants[24] = {
-	0x0000000000000001ull, 0x0000000000008082ull,
-	0x800000000000808aull, 0x8000000080008000ull,
-	0x000000000000808bull, 0x0000000080000001ull,
-	0x8000000080008081ull, 0x8000000000008009ull,
-	0x000000000000008aull, 0x0000000000000088ull,
-	0x0000000080008009ull, 0x000000008000000aull,
-	0x000000008000808bull, 0x800000000000008bull,
-	0x8000000000008089ull, 0x8000000000008003ull,
-	0x8000000000008002ull, 0x8000000000000080ull,
-	0x000000000000800aull, 0x800000008000000aull,
-	0x8000000080008081ull, 0x8000000000008080ull,
-	0x0000000080000001ull, 0x8000000080008008ull
-};
-
-static void
-keccak_block(scrypt_hash_state *S, const uint8_t *in) {
-	size_t i;
-	uint64_t *s = S->state, t[5], u[5], v, w;
-
-	/* absorb input */
-	for (i = 0; i < SCRYPT_HASH_BLOCK_SIZE / 8; i++, in += 8)
-		s[i] ^= U8TO64_LE(in);
-	
-	for (i = 0; i < 24; i++) {
-		/* theta: c = a[0,i] ^ a[1,i] ^ .. a[4,i] */
-		t[0] = s[0] ^ s[5] ^ s[10] ^ s[15] ^ s[20];
-		t[1] = s[1] ^ s[6] ^ s[11] ^ s[16] ^ s[21];
-		t[2] = s[2] ^ s[7] ^ s[12] ^ s[17] ^ s[22];
-		t[3] = s[3] ^ s[8] ^ s[13] ^ s[18] ^ s[23];
-		t[4] = s[4] ^ s[9] ^ s[14] ^ s[19] ^ s[24];
-
-		/* theta: d[i] = c[i+4] ^ rotl(c[i+1],1) */
-		u[0] = t[4] ^ ROTL64(t[1], 1);
-		u[1] = t[0] ^ ROTL64(t[2], 1);
-		u[2] = t[1] ^ ROTL64(t[3], 1);
-		u[3] = t[2] ^ ROTL64(t[4], 1);
-		u[4] = t[3] ^ ROTL64(t[0], 1);
-
-		/* theta: a[0,i], a[1,i], .. a[4,i] ^= d[i] */
-		s[0] ^= u[0]; s[5] ^= u[0]; s[10] ^= u[0]; s[15] ^= u[0]; s[20] ^= u[0];
-		s[1] ^= u[1]; s[6] ^= u[1]; s[11] ^= u[1]; s[16] ^= u[1]; s[21] ^= u[1];
-		s[2] ^= u[2]; s[7] ^= u[2]; s[12] ^= u[2]; s[17] ^= u[2]; s[22] ^= u[2];
-		s[3] ^= u[3]; s[8] ^= u[3]; s[13] ^= u[3]; s[18] ^= u[3]; s[23] ^= u[3];
-		s[4] ^= u[4]; s[9] ^= u[4]; s[14] ^= u[4]; s[19] ^= u[4]; s[24] ^= u[4];
-
-		/* rho pi: b[..] = rotl(a[..], ..) */
-		v = s[ 1];
-		s[ 1] = ROTL64(s[ 6], 44);
-		s[ 6] = ROTL64(s[ 9], 20);
-		s[ 9] = ROTL64(s[22], 61);
-		s[22] = ROTL64(s[14], 39);
-		s[14] = ROTL64(s[20], 18);
-		s[20] = ROTL64(s[ 2], 62);
-		s[ 2] = ROTL64(s[12], 43);
-		s[12] = ROTL64(s[13], 25);
-		s[13] = ROTL64(s[19],  8);
-		s[19] = ROTL64(s[23], 56);
-		s[23] = ROTL64(s[15], 41);
-		s[15] = ROTL64(s[ 4], 27);
-		s[ 4] = ROTL64(s[24], 14);
-		s[24] = ROTL64(s[21],  2);
-		s[21] = ROTL64(s[ 8], 55);
-		s[ 8] = ROTL64(s[16], 45);
-		s[16] = ROTL64(s[ 5], 36);
-		s[ 5] = ROTL64(s[ 3], 28);
-		s[ 3] = ROTL64(s[18], 21);
-		s[18] = ROTL64(s[17], 15);
-		s[17] = ROTL64(s[11], 10);
-		s[11] = ROTL64(s[ 7],  6);
-		s[ 7] = ROTL64(s[10],  3);
-		s[10] = ROTL64(    v,  1);
-
-		/* chi: a[i,j] ^= ~b[i,j+1] & b[i,j+2] */
-		v = s[ 0]; w = s[ 1]; s[ 0] ^= (~w) & s[ 2]; s[ 1] ^= (~s[ 2]) & s[ 3]; s[ 2] ^= (~s[ 3]) & s[ 4]; s[ 3] ^= (~s[ 4]) & v; s[ 4] ^= (~v) & w;
-		v = s[ 5]; w = s[ 6]; s[ 5] ^= (~w) & s[ 7]; s[ 6] ^= (~s[ 7]) & s[ 8]; s[ 7] ^= (~s[ 8]) & s[ 9]; s[ 8] ^= (~s[ 9]) & v; s[ 9] ^= (~v) & w;
-		v = s[10]; w = s[11]; s[10] ^= (~w) & s[12]; s[11] ^= (~s[12]) & s[13]; s[12] ^= (~s[13]) & s[14]; s[13] ^= (~s[14]) & v; s[14] ^= (~v) & w;
-		v = s[15]; w = s[16]; s[15] ^= (~w) & s[17]; s[16] ^= (~s[17]) & s[18]; s[17] ^= (~s[18]) & s[19]; s[18] ^= (~s[19]) & v; s[19] ^= (~v) & w;
-		v = s[20]; w = s[21]; s[20] ^= (~w) & s[22]; s[21] ^= (~s[22]) & s[23]; s[22] ^= (~s[23]) & s[24]; s[23] ^= (~s[24]) & v; s[24] ^= (~v) & w;
-
-		/* iota: a[0,0] ^= round constant */
-		s[0] ^= keccak_round_constants[i];
-	}
-}
-
-static void
-scrypt_hash_init(scrypt_hash_state *S) {
-	memset(S, 0, sizeof(*S));
-}
-
-static void
-scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {
-	size_t want;
-
-	/* handle the previous data */
-	if (S->leftover) {
-		want = (SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-		want = (want < inlen) ? want : inlen;
-		memcpy(S->buffer + S->leftover, in, want);
-		S->leftover += (uint32_t)want;
-		if (S->leftover < SCRYPT_HASH_BLOCK_SIZE)
-			return;
-		in += want;
-		inlen -= want;
-		keccak_block(S, S->buffer);
-	}
-
-	/* handle the current data */
-	while (inlen >= SCRYPT_HASH_BLOCK_SIZE) {
-		keccak_block(S, in);
-		in += SCRYPT_HASH_BLOCK_SIZE;
-		inlen -= SCRYPT_HASH_BLOCK_SIZE;
-	}
-
-	/* handle leftover data */
-	S->leftover = (uint32_t)inlen;
-	if (S->leftover)
-		memcpy(S->buffer, in, S->leftover);
-}
-
-static void
-scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {
-	size_t i;
-
-	S->buffer[S->leftover] = 0x01;
-	memset(S->buffer + (S->leftover + 1), 0, SCRYPT_HASH_BLOCK_SIZE - (S->leftover + 1));
-	S->buffer[SCRYPT_HASH_BLOCK_SIZE - 1] |= 0x80;
-	keccak_block(S, S->buffer);
-
-	for (i = 0; i < SCRYPT_HASH_DIGEST_SIZE; i += 8) {
-		U64TO8_LE(&hash[i], S->state[i / 8]);
-	}
-}
-
-#if defined(SCRYPT_KECCAK256)
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0x26,0xb7,0x10,0xb3,0x66,0xb1,0xd1,0xb1,0x25,0xfc,0x3e,0xe3,0x1e,0x33,0x1d,0x19,
-	0x94,0xaa,0x63,0x7a,0xd5,0x77,0x29,0xb4,0x27,0xe9,0xe0,0xf4,0x19,0xba,0x68,0xea,
-};
-#else
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0x17,0xc7,0x8c,0xa0,0xd9,0x08,0x1d,0xba,0x8a,0xc8,0x3e,0x07,0x90,0xda,0x91,0x88,
-	0x25,0xbd,0xd3,0xf8,0x78,0x4a,0x8d,0x5e,0xe4,0x96,0x9c,0x01,0xf3,0xeb,0xdc,0x12,
-	0xea,0x35,0x57,0xba,0x94,0xb8,0xe9,0xb9,0x27,0x45,0x0a,0x48,0x5c,0x3d,0x69,0xf0,
-	0xdb,0x22,0x38,0xb5,0x52,0x22,0x29,0xea,0x7a,0xb2,0xe6,0x07,0xaa,0x37,0x4d,0xe6,
-};
-#endif
-

algo/scryptjane/scrypt-jane-hash_sha256.h

@@ -1,135 +0,0 @@
-#define SCRYPT_HASH "SHA-2-256"
-#define SCRYPT_HASH_BLOCK_SIZE 64
-#define SCRYPT_HASH_DIGEST_SIZE 32
-
-typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-
-typedef struct scrypt_hash_state_t {
-	uint32_t H[8];
-	uint64_t T;
-	uint32_t leftover;
-	uint8_t buffer[SCRYPT_HASH_BLOCK_SIZE];
-} scrypt_hash_state;
-
-static const uint32_t sha256_constants[64] = {
-	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-};
-
-#define Ch(x,y,z)  (z ^ (x & (y ^ z)))
-#define Maj(x,y,z) (((x | y) & z) | (x & y))
-#define S0(x)      (ROTR32(x,  2) ^ ROTR32(x, 13) ^ ROTR32(x, 22))
-#define S1(x)      (ROTR32(x,  6) ^ ROTR32(x, 11) ^ ROTR32(x, 25))
-#define G0(x)      (ROTR32(x,  7) ^ ROTR32(x, 18) ^ (x >>  3))
-#define G1(x)      (ROTR32(x, 17) ^ ROTR32(x, 19) ^ (x >> 10))
-#define W0(in,i)   (U8TO32_BE(&in[i * 4]))
-#define W1(i)      (G1(w[i - 2]) + w[i - 7] + G0(w[i - 15]) + w[i - 16])
-#define STEP(i) \
-	t1 = S0(r[0]) + Maj(r[0], r[1], r[2]); \
-	t0 = r[7] + S1(r[4]) + Ch(r[4], r[5], r[6]) + sha256_constants[i] + w[i]; \
-	r[7] = r[6]; \
-	r[6] = r[5]; \
-	r[5] = r[4]; \
-	r[4] = r[3] + t0; \
-	r[3] = r[2]; \
-	r[2] = r[1]; \
-	r[1] = r[0]; \
-	r[0] = t0 + t1;
-
-static void
-sha256_blocks(scrypt_hash_state *S, const uint8_t *in, size_t blocks) {
-	uint32_t r[8], w[64], t0, t1;
-	size_t i;
-
-	for (i = 0; i < 8; i++) r[i] = S->H[i];
-
-	while (blocks--) {
-		for (i =  0; i < 16; i++) { w[i] = W0(in, i); }
-		for (i = 16; i < 64; i++) { w[i] = W1(i); }
-		for (i =  0; i < 64; i++) { STEP(i); }
-		for (i =  0; i <  8; i++) { r[i] += S->H[i]; S->H[i] = r[i]; }
-		S->T += SCRYPT_HASH_BLOCK_SIZE * 8;
-		in += SCRYPT_HASH_BLOCK_SIZE;
-	}
-}
-
-static void
-scrypt_hash_init(scrypt_hash_state *S) {
-	S->H[0] = 0x6a09e667;
-	S->H[1] = 0xbb67ae85;
-	S->H[2] = 0x3c6ef372;
-	S->H[3] = 0xa54ff53a;
-	S->H[4] = 0x510e527f;
-	S->H[5] = 0x9b05688c;
-	S->H[6] = 0x1f83d9ab;
-	S->H[7] = 0x5be0cd19;
-	S->T = 0;
-	S->leftover = 0;
-}
-
-static void
-scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {
-	size_t blocks, want;
-
-	/* handle the previous data */
-	if (S->leftover) {
-		want = (SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-		want = (want < inlen) ? want : inlen;
-		memcpy(S->buffer + S->leftover, in, want);
-		S->leftover += (uint32_t)want;
-		if (S->leftover < SCRYPT_HASH_BLOCK_SIZE)
-			return;
-		in += want;
-		inlen -= want;
-		sha256_blocks(S, S->buffer, 1);
-	}
-
-	/* handle the current data */
-	blocks = (inlen & ~(SCRYPT_HASH_BLOCK_SIZE - 1));
-	S->leftover = (uint32_t)(inlen - blocks);
-	if (blocks) {
-		sha256_blocks(S, in, blocks / SCRYPT_HASH_BLOCK_SIZE);
-		in += blocks;
-	}
-
-	/* handle leftover data */
-	if (S->leftover)
-		memcpy(S->buffer, in, S->leftover);
-}
-
-static void
-scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {
-	uint64_t t = S->T + (S->leftover * 8);
-
-	S->buffer[S->leftover] = 0x80;
-	if (S->leftover <= 55) {
-		memset(S->buffer + S->leftover + 1, 0, 55 - S->leftover);
-	} else {
-		memset(S->buffer + S->leftover + 1, 0, 63 - S->leftover);
-		sha256_blocks(S, S->buffer, 1);
-		memset(S->buffer, 0, 56);
-	}
-
-	U64TO8_BE(S->buffer + 56, t);
-	sha256_blocks(S, S->buffer, 1);
-
-	U32TO8_BE(&hash[ 0], S->H[0]);
-	U32TO8_BE(&hash[ 4], S->H[1]);
-	U32TO8_BE(&hash[ 8], S->H[2]);
-	U32TO8_BE(&hash[12], S->H[3]);
-	U32TO8_BE(&hash[16], S->H[4]);
-	U32TO8_BE(&hash[20], S->H[5]);
-	U32TO8_BE(&hash[24], S->H[6]);
-	U32TO8_BE(&hash[28], S->H[7]);
-}
-
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0xee,0x36,0xae,0xa6,0x65,0xf0,0x28,0x7d,0xc9,0xde,0xd8,0xad,0x48,0x33,0x7d,0xbf,
-	0xcb,0xc0,0x48,0xfa,0x5f,0x92,0xfd,0x0a,0x95,0x6f,0x34,0x8e,0x8c,0x1e,0x73,0xad,
-};

algo/scryptjane/scrypt-jane-hash_sha512.h

@@ -1,152 +0,0 @@
-#define SCRYPT_HASH "SHA-2-512"
-#define SCRYPT_HASH_BLOCK_SIZE 128
-#define SCRYPT_HASH_DIGEST_SIZE 64
-
-typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-
-typedef struct scrypt_hash_state_t {
-	uint64_t H[8];
-	uint64_t T[2];
-	uint32_t leftover;
-	uint8_t buffer[SCRYPT_HASH_BLOCK_SIZE];
-} scrypt_hash_state;
-
-static const uint64_t sha512_constants[80] = {
-	0x428a2f98d728ae22ull, 0x7137449123ef65cdull, 0xb5c0fbcfec4d3b2full, 0xe9b5dba58189dbbcull,
-	0x3956c25bf348b538ull, 0x59f111f1b605d019ull, 0x923f82a4af194f9bull, 0xab1c5ed5da6d8118ull,
-	0xd807aa98a3030242ull, 0x12835b0145706fbeull, 0x243185be4ee4b28cull, 0x550c7dc3d5ffb4e2ull,
-	0x72be5d74f27b896full, 0x80deb1fe3b1696b1ull, 0x9bdc06a725c71235ull, 0xc19bf174cf692694ull,
-	0xe49b69c19ef14ad2ull, 0xefbe4786384f25e3ull, 0x0fc19dc68b8cd5b5ull, 0x240ca1cc77ac9c65ull,
-	0x2de92c6f592b0275ull, 0x4a7484aa6ea6e483ull, 0x5cb0a9dcbd41fbd4ull, 0x76f988da831153b5ull,
-	0x983e5152ee66dfabull, 0xa831c66d2db43210ull, 0xb00327c898fb213full, 0xbf597fc7beef0ee4ull,
-	0xc6e00bf33da88fc2ull, 0xd5a79147930aa725ull, 0x06ca6351e003826full, 0x142929670a0e6e70ull,
-	0x27b70a8546d22ffcull, 0x2e1b21385c26c926ull, 0x4d2c6dfc5ac42aedull, 0x53380d139d95b3dfull,
-	0x650a73548baf63deull, 0x766a0abb3c77b2a8ull, 0x81c2c92e47edaee6ull, 0x92722c851482353bull,
-	0xa2bfe8a14cf10364ull, 0xa81a664bbc423001ull, 0xc24b8b70d0f89791ull, 0xc76c51a30654be30ull,
-	0xd192e819d6ef5218ull, 0xd69906245565a910ull, 0xf40e35855771202aull, 0x106aa07032bbd1b8ull,
-	0x19a4c116b8d2d0c8ull, 0x1e376c085141ab53ull, 0x2748774cdf8eeb99ull, 0x34b0bcb5e19b48a8ull,
-	0x391c0cb3c5c95a63ull, 0x4ed8aa4ae3418acbull, 0x5b9cca4f7763e373ull, 0x682e6ff3d6b2b8a3ull,
-	0x748f82ee5defb2fcull, 0x78a5636f43172f60ull, 0x84c87814a1f0ab72ull, 0x8cc702081a6439ecull,
-	0x90befffa23631e28ull, 0xa4506cebde82bde9ull, 0xbef9a3f7b2c67915ull, 0xc67178f2e372532bull,
-	0xca273eceea26619cull, 0xd186b8c721c0c207ull, 0xeada7dd6cde0eb1eull, 0xf57d4f7fee6ed178ull,
-	0x06f067aa72176fbaull, 0x0a637dc5a2c898a6ull, 0x113f9804bef90daeull, 0x1b710b35131c471bull,
-	0x28db77f523047d84ull, 0x32caab7b40c72493ull, 0x3c9ebe0a15c9bebcull, 0x431d67c49c100d4cull,
-	0x4cc5d4becb3e42b6ull, 0x597f299cfc657e2aull, 0x5fcb6fab3ad6faecull, 0x6c44198c4a475817ull
-};
-
-#define Ch(x,y,z)  (z ^ (x & (y ^ z)))
-#define Maj(x,y,z) (((x | y) & z) | (x & y))
-#define S0(x)      (ROTR64(x, 28) ^ ROTR64(x, 34) ^ ROTR64(x, 39))
-#define S1(x)      (ROTR64(x, 14) ^ ROTR64(x, 18) ^ ROTR64(x, 41))
-#define G0(x)      (ROTR64(x,  1) ^ ROTR64(x,  8) ^ (x >>  7))
-#define G1(x)      (ROTR64(x, 19) ^ ROTR64(x, 61) ^ (x >>  6))
-#define W0(in,i)   (U8TO64_BE(&in[i * 8]))
-#define W1(i)      (G1(w[i - 2]) + w[i - 7] + G0(w[i - 15]) + w[i - 16])
-#define STEP(i) \
-	t1 = S0(r[0]) + Maj(r[0], r[1], r[2]); \
-	t0 = r[7] + S1(r[4]) + Ch(r[4], r[5], r[6]) + sha512_constants[i] + w[i]; \
-	r[7] = r[6]; \
-	r[6] = r[5]; \
-	r[5] = r[4]; \
-	r[4] = r[3] + t0; \
-	r[3] = r[2]; \
-	r[2] = r[1]; \
-	r[1] = r[0]; \
-	r[0] = t0 + t1;
-
-static void
-sha512_blocks(scrypt_hash_state *S, const uint8_t *in, size_t blocks) {
-	uint64_t r[8], w[80], t0, t1;
-	size_t i;
-
-	for (i = 0; i < 8; i++) r[i] = S->H[i];
-
-	while (blocks--) {
-		for (i =  0; i < 16; i++) { w[i] = W0(in, i); }
-		for (i = 16; i < 80; i++) { w[i] = W1(i); }
-		for (i =  0; i < 80; i++) { STEP(i); }
-		for (i =  0; i <  8; i++) { r[i] += S->H[i]; S->H[i] = r[i]; }
-		S->T[0] += SCRYPT_HASH_BLOCK_SIZE * 8;
-		S->T[1] += (!S->T[0]) ? 1 : 0;
-		in += SCRYPT_HASH_BLOCK_SIZE;
-	}
-}
-
-static void
-scrypt_hash_init(scrypt_hash_state *S) {
-	S->H[0] = 0x6a09e667f3bcc908ull;
-	S->H[1] = 0xbb67ae8584caa73bull;
-	S->H[2] = 0x3c6ef372fe94f82bull;
-	S->H[3] = 0xa54ff53a5f1d36f1ull;
-	S->H[4] = 0x510e527fade682d1ull;
-	S->H[5] = 0x9b05688c2b3e6c1full;
-	S->H[6] = 0x1f83d9abfb41bd6bull;
-	S->H[7] = 0x5be0cd19137e2179ull;
-	S->T[0] = 0;
-	S->T[1] = 0;
-	S->leftover = 0;
-}
-
-static void
-scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {
-	size_t blocks, want;
-
-	/* handle the previous data */
-	if (S->leftover) {
-		want = (SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-		want = (want < inlen) ? want : inlen;
-		memcpy(S->buffer + S->leftover, in, want);
-		S->leftover += (uint32_t)want;
-		if (S->leftover < SCRYPT_HASH_BLOCK_SIZE)
-			return;
-		in += want;
-		inlen -= want;
-		sha512_blocks(S, S->buffer, 1);
-	}
-
-	/* handle the current data */
-	blocks = (inlen & ~(SCRYPT_HASH_BLOCK_SIZE - 1));
-	S->leftover = (uint32_t)(inlen - blocks);
-	if (blocks) {
-		sha512_blocks(S, in, blocks / SCRYPT_HASH_BLOCK_SIZE);
-		in += blocks;
-	}
-
-	/* handle leftover data */
-	if (S->leftover)
-		memcpy(S->buffer, in, S->leftover);
-}
-
-static void
-scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {
-	uint64_t t0 = S->T[0] + (S->leftover * 8), t1 = S->T[1];
-
-	S->buffer[S->leftover] = 0x80;
-	if (S->leftover <= 111) {
-		memset(S->buffer + S->leftover + 1, 0, 111 - S->leftover);
-	} else {
-		memset(S->buffer + S->leftover + 1, 0, 127 - S->leftover);
-		sha512_blocks(S, S->buffer, 1);
-		memset(S->buffer, 0, 112);
-	}
-
-	U64TO8_BE(S->buffer + 112, t1);
-	U64TO8_BE(S->buffer + 120, t0);
-	sha512_blocks(S, S->buffer, 1);
-
-	U64TO8_BE(&hash[ 0], S->H[0]);
-	U64TO8_BE(&hash[ 8], S->H[1]);
-	U64TO8_BE(&hash[16], S->H[2]);
-	U64TO8_BE(&hash[24], S->H[3]);
-	U64TO8_BE(&hash[32], S->H[4]);
-	U64TO8_BE(&hash[40], S->H[5]);
-	U64TO8_BE(&hash[48], S->H[6]);
-	U64TO8_BE(&hash[56], S->H[7]);
-}
-
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0xba,0xc3,0x80,0x2b,0x24,0x56,0x95,0x1f,0x19,0x7c,0xa2,0xd3,0x72,0x7c,0x9a,0x4d,
-	0x1d,0x50,0x3a,0xa9,0x12,0x27,0xd8,0xe1,0xbe,0x76,0x53,0x87,0x5a,0x1e,0x82,0xec,
-	0xc8,0xe1,0x6b,0x87,0xd0,0xb5,0x25,0x7e,0xe8,0x1e,0xd7,0x58,0xc6,0x2d,0xc2,0x9c,
-	0x06,0x31,0x8f,0x5b,0x57,0x8e,0x76,0xba,0xd5,0xf6,0xec,0xfe,0x85,0x1f,0x34,0x0c,
-};

algo/scryptjane/scrypt-jane-hash_skein512.h

@@ -1,188 +0,0 @@
-#define SCRYPT_HASH "Skein-512"
-#define SCRYPT_HASH_BLOCK_SIZE 64
-#define SCRYPT_HASH_DIGEST_SIZE 64
-
-typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-
-typedef struct scrypt_hash_state_t {
-	uint64_t X[8], T[2];
-	uint32_t leftover;
-	uint8_t buffer[SCRYPT_HASH_BLOCK_SIZE];
-} scrypt_hash_state;
-
-#include <stdio.h>
-
-static void
-skein512_blocks(scrypt_hash_state *S, const uint8_t *in, size_t blocks, size_t add) {
-	uint64_t X[8], key[8], Xt[9+18], T[3+1];
-	size_t r;
-
-	while (blocks--) {
-		T[0] = S->T[0] + add;
-		T[1] = S->T[1];
-		T[2] = T[0] ^ T[1];
-		key[0] = U8TO64_LE(in +  0); Xt[0] = S->X[0]; X[0] = key[0] + Xt[0];
-		key[1] = U8TO64_LE(in +  8); Xt[1] = S->X[1]; X[1] = key[1] + Xt[1];
-		key[2] = U8TO64_LE(in + 16); Xt[2] = S->X[2]; X[2] = key[2] + Xt[2];
-		key[3] = U8TO64_LE(in + 24); Xt[3] = S->X[3]; X[3] = key[3] + Xt[3];
-		key[4] = U8TO64_LE(in + 32); Xt[4] = S->X[4]; X[4] = key[4] + Xt[4];
-		key[5] = U8TO64_LE(in + 40); Xt[5] = S->X[5]; X[5] = key[5] + Xt[5] + T[0];
-		key[6] = U8TO64_LE(in + 48); Xt[6] = S->X[6]; X[6] = key[6] + Xt[6] + T[1];
-		key[7] = U8TO64_LE(in + 56); Xt[7] = S->X[7]; X[7] = key[7] + Xt[7];
-		Xt[8] = 0x1BD11BDAA9FC1A22ull ^ Xt[0] ^ Xt[1] ^ Xt[2] ^ Xt[3] ^ Xt[4] ^ Xt[5] ^ Xt[6] ^ Xt[7];
-		in += SCRYPT_HASH_BLOCK_SIZE;
-
-		for (r = 0; r < 18; r++)
-			Xt[r + 9] = Xt[r + 0];
-
-		for (r = 0; r < 18; r += 2) {
-			X[0] += X[1]; X[1] = ROTL64(X[1], 46) ^ X[0];
-			X[2] += X[3]; X[3] = ROTL64(X[3], 36) ^ X[2];
-			X[4] += X[5]; X[5] = ROTL64(X[5], 19) ^ X[4];
-			X[6] += X[7]; X[7] = ROTL64(X[7], 37) ^ X[6];
-			X[2] += X[1]; X[1] = ROTL64(X[1], 33) ^ X[2];
-			X[0] += X[3]; X[3] = ROTL64(X[3], 42) ^ X[0];
-			X[6] += X[5]; X[5] = ROTL64(X[5], 14) ^ X[6];
-			X[4] += X[7]; X[7] = ROTL64(X[7], 27) ^ X[4];
-			X[4] += X[1]; X[1] = ROTL64(X[1], 17) ^ X[4];
-			X[6] += X[3]; X[3] = ROTL64(X[3], 49) ^ X[6];
-			X[0] += X[5]; X[5] = ROTL64(X[5], 36) ^ X[0];
-			X[2] += X[7]; X[7] = ROTL64(X[7], 39) ^ X[2];
-			X[6] += X[1]; X[1] = ROTL64(X[1], 44) ^ X[6];
-			X[4] += X[3]; X[3] = ROTL64(X[3], 56) ^ X[4];
-			X[2] += X[5]; X[5] = ROTL64(X[5], 54) ^ X[2];
-			X[0] += X[7]; X[7] = ROTL64(X[7],  9) ^ X[0];
-
-			X[0] += Xt[r + 1];
-			X[1] += Xt[r + 2];
-			X[2] += Xt[r + 3];
-			X[3] += Xt[r + 4];
-			X[4] += Xt[r + 5];
-			X[5] += Xt[r + 6] + T[1];
-			X[6] += Xt[r + 7] + T[2];
-			X[7] += Xt[r + 8] + r + 1;
-
-			T[3] = T[0];
-			T[0] = T[1];
-			T[1] = T[2];
-			T[2] = T[3];
-
-			X[0] += X[1]; X[1] = ROTL64(X[1], 39) ^ X[0];
-			X[2] += X[3]; X[3] = ROTL64(X[3], 30) ^ X[2];
-			X[4] += X[5]; X[5] = ROTL64(X[5], 34) ^ X[4];
-			X[6] += X[7]; X[7] = ROTL64(X[7], 24) ^ X[6];
-			X[2] += X[1]; X[1] = ROTL64(X[1], 13) ^ X[2];
-			X[0] += X[3]; X[3] = ROTL64(X[3], 17) ^ X[0];
-			X[6] += X[5]; X[5] = ROTL64(X[5], 10) ^ X[6];
-			X[4] += X[7]; X[7] = ROTL64(X[7], 50) ^ X[4];
-			X[4] += X[1]; X[1] = ROTL64(X[1], 25) ^ X[4];
-			X[6] += X[3]; X[3] = ROTL64(X[3], 29) ^ X[6];
-			X[0] += X[5]; X[5] = ROTL64(X[5], 39) ^ X[0];
-			X[2] += X[7]; X[7] = ROTL64(X[7], 43) ^ X[2];
-			X[6] += X[1]; X[1] = ROTL64(X[1],  8) ^ X[6];
-			X[4] += X[3]; X[3] = ROTL64(X[3], 22) ^ X[4];
-			X[2] += X[5]; X[5] = ROTL64(X[5], 56) ^ X[2];
-			X[0] += X[7]; X[7] = ROTL64(X[7], 35) ^ X[0];
-
-			X[0] += Xt[r + 2];
-			X[1] += Xt[r + 3];
-			X[2] += Xt[r + 4];
-			X[3] += Xt[r + 5];
-			X[4] += Xt[r + 6];
-			X[5] += Xt[r + 7] + T[1];
-			X[6] += Xt[r + 8] + T[2];
-			X[7] += Xt[r + 9] + r + 2;
-
-			T[3] = T[0];
-			T[0] = T[1];
-			T[1] = T[2];
-			T[2] = T[3];
-		}
-
-		S->X[0] = key[0] ^ X[0];
-		S->X[1] = key[1] ^ X[1];
-		S->X[2] = key[2] ^ X[2];
-		S->X[3] = key[3] ^ X[3];
-		S->X[4] = key[4] ^ X[4];
-		S->X[5] = key[5] ^ X[5];
-		S->X[6] = key[6] ^ X[6];
-		S->X[7] = key[7] ^ X[7];
-
-		S->T[0] = T[0];
-		S->T[1] = T[1] & ~0x4000000000000000ull;
-	}
-}
-
-static void
-scrypt_hash_init(scrypt_hash_state *S) {
-	S->X[0] = 0x4903ADFF749C51CEull;
-	S->X[1] = 0x0D95DE399746DF03ull;
-	S->X[2] = 0x8FD1934127C79BCEull;
-	S->X[3] = 0x9A255629FF352CB1ull;
-	S->X[4] = 0x5DB62599DF6CA7B0ull;
-	S->X[5] = 0xEABE394CA9D5C3F4ull;
-	S->X[6] = 0x991112C71A75B523ull;
-	S->X[7] = 0xAE18A40B660FCC33ull;
-	S->T[0] = 0x0000000000000000ull;
-	S->T[1] = 0x7000000000000000ull;
-	S->leftover = 0;
-}
-
-static void
-scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {
-	size_t blocks, want;
-
-	/* skein processes the final <=64 bytes raw, so we can only update if there are at least 64+1 bytes available */
-	if ((S->leftover + inlen) > SCRYPT_HASH_BLOCK_SIZE) {
-		/* handle the previous data, we know there is enough for at least one block */
-		if (S->leftover) {
-			want = (SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-			memcpy(S->buffer + S->leftover, in, want);
-			in += want;
-			inlen -= want;
-			S->leftover = 0;
-			skein512_blocks(S, S->buffer, 1, SCRYPT_HASH_BLOCK_SIZE);
-		}
-
-		/* handle the current data if there's more than one block */
-		if (inlen > SCRYPT_HASH_BLOCK_SIZE) {
-			blocks = ((inlen - 1) & ~(SCRYPT_HASH_BLOCK_SIZE - 1));
-			skein512_blocks(S, in, blocks / SCRYPT_HASH_BLOCK_SIZE, SCRYPT_HASH_BLOCK_SIZE);
-			inlen -= blocks;
-			in += blocks;
-		}
-	}
-
-	/* handle leftover data */
-	memcpy(S->buffer + S->leftover, in, inlen);
-	S->leftover += inlen;
-}
-
-static void
-scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {
-	memset(S->buffer + S->leftover, 0, SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-	S->T[1] |= 0x8000000000000000ull;
-	skein512_blocks(S, S->buffer, 1, S->leftover);
-
-	memset(S->buffer, 0, SCRYPT_HASH_BLOCK_SIZE);
-	S->T[0] = 0;
-	S->T[1] = 0xff00000000000000ull;
-	skein512_blocks(S, S->buffer, 1, 8);
-
-	U64TO8_LE(&hash[ 0], S->X[0]);
-	U64TO8_LE(&hash[ 8], S->X[1]);
-	U64TO8_LE(&hash[16], S->X[2]);
-	U64TO8_LE(&hash[24], S->X[3]);
-	U64TO8_LE(&hash[32], S->X[4]);
-	U64TO8_LE(&hash[40], S->X[5]);
-	U64TO8_LE(&hash[48], S->X[6]);
-	U64TO8_LE(&hash[56], S->X[7]);
-}
-
-
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0x4d,0x52,0x29,0xff,0x10,0xbc,0xd2,0x62,0xd1,0x61,0x83,0xc8,0xe6,0xf0,0x83,0xc4,
-	0x9f,0xf5,0x6a,0x42,0x75,0x2a,0x26,0x4e,0xf0,0x28,0x72,0x28,0x47,0xe8,0x23,0xdf,
-	0x1e,0x64,0xf1,0x51,0x38,0x35,0x9d,0xc2,0x83,0xfc,0x35,0x4e,0xc0,0x52,0x5f,0x41,
-	0x6a,0x0b,0x7d,0xf5,0xce,0x98,0xde,0x6f,0x36,0xd8,0x51,0x15,0x78,0x78,0x93,0x67,
-};

algo/scryptjane/scrypt-jane-mix_chacha-avx.h

@@ -1,564 +0,0 @@
-/* x86 */
-#if defined(X86ASM_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_AVX
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_avx)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_avx)
-	a1(push ebx)
-	a1(push edi)
-	a1(push esi)
-	a1(push ebp)
-	a2(mov ebp,esp)
-	a2(mov edi,[ebp+20])
-	a2(mov esi,[ebp+24])
-	a2(mov eax,[ebp+28])
-	a2(mov ebx,[ebp+32])
-	a2(sub esp,64)
-	a2(and esp,~63)
-	a2(lea edx,[ebx*2])
-	a2(shl edx,6)
-	a2(lea ecx,[edx-64])
-	a2(and eax, eax)
-	a2(mov ebx, 0x01000302)
-	a2(vmovd xmm4, ebx)
-	a2(mov ebx, 0x05040706)
-	a2(vmovd xmm0, ebx)
-	a2(mov ebx, 0x09080b0a)
-	a2(vmovd xmm1, ebx)
-	a2(mov ebx, 0x0d0c0f0e)
-	a2(vmovd xmm2, ebx)
-	a2(mov ebx, 0x02010003)
-	a2(vmovd xmm5, ebx)
-	a2(mov ebx, 0x06050407)
-	a2(vmovd xmm3, ebx)
-	a2(mov ebx, 0x0a09080b)
-	a2(vmovd xmm6, ebx)
-	a2(mov ebx, 0x0e0d0c0f)
-	a2(vmovd xmm7, ebx)
-	a3(vpunpckldq xmm4, xmm4, xmm0)
-	a3(vpunpckldq xmm5, xmm5, xmm3)
-	a3(vpunpckldq xmm1, xmm1, xmm2)
-	a3(vpunpckldq xmm6, xmm6, xmm7)
-	a3(vpunpcklqdq xmm4, xmm4, xmm1)
-	a3(vpunpcklqdq xmm5, xmm5, xmm6)
-	a2(vmovdqa xmm0,[ecx+esi+0])
-	a2(vmovdqa xmm1,[ecx+esi+16])
-	a2(vmovdqa xmm2,[ecx+esi+32])
-	a2(vmovdqa xmm3,[ecx+esi+48])
-	a1(jz scrypt_ChunkMix_avx_no_xor1)
-	a3(vpxor xmm0,xmm0,[ecx+eax+0])
-	a3(vpxor xmm1,xmm1,[ecx+eax+16])
-	a3(vpxor xmm2,xmm2,[ecx+eax+32])
-	a3(vpxor xmm3,xmm3,[ecx+eax+48])
-	a1(scrypt_ChunkMix_avx_no_xor1:)
-	a2(xor ecx,ecx)
-	a2(xor ebx,ebx)
-	a1(scrypt_ChunkMix_avx_loop:)
-		a2(and eax, eax)
-		a3(vpxor xmm0,xmm0,[esi+ecx+0])
-		a3(vpxor xmm1,xmm1,[esi+ecx+16])
-		a3(vpxor xmm2,xmm2,[esi+ecx+32])
-		a3(vpxor xmm3,xmm3,[esi+ecx+48])
-		a1(jz scrypt_ChunkMix_avx_no_xor2)
-		a3(vpxor xmm0,xmm0,[eax+ecx+0])
-		a3(vpxor xmm1,xmm1,[eax+ecx+16])
-		a3(vpxor xmm2,xmm2,[eax+ecx+32])
-		a3(vpxor xmm3,xmm3,[eax+ecx+48])
-		a1(scrypt_ChunkMix_avx_no_xor2:)
-		a2(vmovdqa [esp+0],xmm0)
-		a2(vmovdqa [esp+16],xmm1)
-		a2(vmovdqa [esp+32],xmm2)
-		a2(vmovdqa [esp+48],xmm3)
-		a2(mov eax,8)
-		a1(scrypt_chacha_avx_loop: )
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm4)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(vpxor  xmm1,xmm1,xmm2)
-			a3(vpsrld xmm6,xmm1,20)
-			a3(vpslld xmm1,xmm1,12)
-			a3(vpxor  xmm1,xmm1,xmm6)
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm5)
-			a3(vpshufd xmm0,xmm0,0x93)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(vpshufd xmm3,xmm3,0x4e)
-			a3(vpxor xmm1,xmm1,xmm2)
-			a3(vpshufd xmm2,xmm2,0x39)
-			a3(vpsrld xmm6,xmm1,25)
-			a3(vpslld xmm1,xmm1,7)
-			a3(vpxor xmm1,xmm1,xmm6)
-			a2(sub eax,2)
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm4)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(vpxor  xmm1,xmm1,xmm2)
-			a3(vpsrld xmm6,xmm1,20)
-			a3(vpslld xmm1,xmm1,12)
-			a3(vpxor xmm1,xmm1,xmm6)
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm5)
-			a3(vpshufd xmm0,xmm0,0x39)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a3(vpxor  xmm1,xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x93)
-			a3(vpsrld xmm6,xmm1,25)
-			a3(vpslld xmm1,xmm1,7)
-			a3(vpxor  xmm1,xmm1,xmm6)
-			a1(ja scrypt_chacha_avx_loop)
-		a3(vpaddd xmm0,xmm0,[esp+0])
-		a3(vpaddd xmm1,xmm1,[esp+16])
-		a3(vpaddd xmm2,xmm2,[esp+32])
-		a3(vpaddd xmm3,xmm3,[esp+48])
-		a2(lea eax,[ebx+ecx])
-		a2(xor ebx,edx)
-		a2(and eax,~0x7f)
-		a2(add ecx,64)
-		a2(shr eax,1)
-		a2(add eax, edi)
-		a2(cmp ecx,edx)
-		a2(vmovdqa [eax+0],xmm0)
-		a2(vmovdqa [eax+16],xmm1)
-		a2(vmovdqa [eax+32],xmm2)
-		a2(vmovdqa [eax+48],xmm3)
-		a2(mov eax,[ebp+28])
-		a1(jne scrypt_ChunkMix_avx_loop)
-	a2(mov esp,ebp)
-	a1(pop ebp)
-	a1(pop esi)
-	a1(pop edi)
-	a1(pop ebx)
-	aret(16)
-asm_naked_fn_end(scrypt_ChunkMix_avx)
-
-#endif
-
-
-
-/* x64 */
-#if defined(X86_64ASM_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_AVX
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_avx)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_avx)
-	a2(lea rcx,[rcx*2])
-	a2(shl rcx,6)
-	a2(lea r9,[rcx-64])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(vmovdqa xmm0,[rax+0])
-	a2(vmovdqa xmm1,[rax+16])
-	a2(vmovdqa xmm2,[rax+32])
-	a2(vmovdqa xmm3,[rax+48])
-	a2(mov r8, 0x0504070601000302)
-	a2(mov rax, 0x0d0c0f0e09080b0a)
-	a2(movq xmm4, r8)
-	a2(movq xmm6, rax)
-	a2(mov r8, 0x0605040702010003)
-	a2(mov rax, 0x0e0d0c0f0a09080b)
-	a2(movq xmm5, r8)
-	a2(movq xmm7, rax)
-	a3(vpunpcklqdq xmm4, xmm4, xmm6)
-	a3(vpunpcklqdq xmm5, xmm5, xmm7)
-	a1(jz scrypt_ChunkMix_avx_no_xor1)
-	a3(vpxor xmm0,xmm0,[r9+0])
-	a3(vpxor xmm1,xmm1,[r9+16])
-	a3(vpxor xmm2,xmm2,[r9+32])
-	a3(vpxor xmm3,xmm3,[r9+48])
-	a1(scrypt_ChunkMix_avx_no_xor1:)
-	a2(xor r8,r8)
-	a2(xor r9,r9)
-	a1(scrypt_ChunkMix_avx_loop:)
-		a2(and rdx, rdx)
-		a3(vpxor xmm0,xmm0,[rsi+r9+0])
-		a3(vpxor xmm1,xmm1,[rsi+r9+16])
-		a3(vpxor xmm2,xmm2,[rsi+r9+32])
-		a3(vpxor xmm3,xmm3,[rsi+r9+48])
-		a1(jz scrypt_ChunkMix_avx_no_xor2)
-		a3(vpxor xmm0,xmm0,[rdx+r9+0])
-		a3(vpxor xmm1,xmm1,[rdx+r9+16])
-		a3(vpxor xmm2,xmm2,[rdx+r9+32])
-		a3(vpxor xmm3,xmm3,[rdx+r9+48])
-		a1(scrypt_ChunkMix_avx_no_xor2:)
-		a2(vmovdqa xmm8,xmm0)
-		a2(vmovdqa xmm9,xmm1)
-		a2(vmovdqa xmm10,xmm2)
-		a2(vmovdqa xmm11,xmm3)
-		a2(mov rax,8)
-		a1(scrypt_chacha_avx_loop: )
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm4)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(vpxor  xmm1,xmm1,xmm2)
-			a3(vpsrld xmm12,xmm1,20)
-			a3(vpslld xmm1,xmm1,12)
-			a3(vpxor  xmm1,xmm1,xmm12)
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm5)
-			a3(vpshufd xmm0,xmm0,0x93)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(vpshufd xmm3,xmm3,0x4e)
-			a3(vpxor xmm1,xmm1,xmm2)
-			a3(vpshufd xmm2,xmm2,0x39)
-			a3(vpsrld xmm12,xmm1,25)
-			a3(vpslld xmm1,xmm1,7)
-			a3(vpxor xmm1,xmm1,xmm12)
-			a2(sub rax,2)
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm4)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(vpxor  xmm1,xmm1,xmm2)
-			a3(vpsrld xmm12,xmm1,20)
-			a3(vpslld xmm1,xmm1,12)
-			a3(vpxor xmm1,xmm1,xmm12)
-			a3(vpaddd xmm0,xmm0,xmm1)
-			a3(vpxor  xmm3,xmm3,xmm0)
-			a3(vpshufb xmm3,xmm3,xmm5)
-			a3(vpshufd xmm0,xmm0,0x39)
-			a3(vpaddd xmm2,xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a3(vpxor  xmm1,xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x93)
-			a3(vpsrld xmm12,xmm1,25)
-			a3(vpslld xmm1,xmm1,7)
-			a3(vpxor  xmm1,xmm1,xmm12)
-			a1(ja scrypt_chacha_avx_loop)
-		a3(vpaddd xmm0,xmm0,xmm8)
-		a3(vpaddd xmm1,xmm1,xmm9)
-		a3(vpaddd xmm2,xmm2,xmm10)
-		a3(vpaddd xmm3,xmm3,xmm11)
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0x7f)
-		a2(add r9,64)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(vmovdqa [rax+0],xmm0)
-		a2(vmovdqa [rax+16],xmm1)
-		a2(vmovdqa [rax+32],xmm2)
-		a2(vmovdqa [rax+48],xmm3)
-		a1(jne scrypt_ChunkMix_avx_loop)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_avx)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_AVX
-
-static void NOINLINE
-scrypt_ChunkMix_avx(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x6,t0,t1,t2,t3;
-	const xmmi x4 = *(xmmi *)&ssse3_rotl16_32bit, x5 = *(xmmi *)&ssse3_rotl8_32bit;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = _mm_srli_epi32(x1, 20);
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x6 = _mm_srli_epi32(x1, 25);
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = _mm_srli_epi32(x1, 20);
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x6 = _mm_srli_epi32(x1, 25);
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, x6);
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-/*
- * Special version with r = 1 and no XORing
- *  - mikaelh
- */
-static void NOINLINE
-scrypt_ChunkMix_avx_1(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/) {
-	const uint32_t r = 1;
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x6,t0,t1,t2,t3;
-	const xmmi x4 = *(xmmi *)&ssse3_rotl16_32bit, x5 = *(xmmi *)&ssse3_rotl8_32bit;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = _mm_srli_epi32(x1, 20);
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x6 = _mm_srli_epi32(x1, 25);
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = _mm_srli_epi32(x1, 20);
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x6 = _mm_srli_epi32(x1, 25);
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, x6);
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-/*
- * Special version with r = 1 and unconditional XORing
- *  - mikaelh
- */
-static void NOINLINE
-scrypt_ChunkMix_avx_1_xor(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/) {
-	const uint32_t r = 1;
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x6,t0,t1,t2,t3;
-	const xmmi x4 = *(xmmi *)&ssse3_rotl16_32bit, x5 = *(xmmi *)&ssse3_rotl8_32bit;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-	x0 = _mm_xor_si128(x0, xmmp[0]);
-	x1 = _mm_xor_si128(x1, xmmp[1]);
-	x2 = _mm_xor_si128(x2, xmmp[2]);
-	x3 = _mm_xor_si128(x3, xmmp[3]);
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		xmmp = (xmmi *)scrypt_block(Bxor, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = _mm_srli_epi32(x1, 20);
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x6 = _mm_srli_epi32(x1, 25);
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = _mm_srli_epi32(x1, 20);
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, x6);
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x6 = _mm_srli_epi32(x1, 25);
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, x6);
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_CHACHA_AVX)
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "ChaCha/8-AVX"
-	#undef SCRYPT_CHACHA_INCLUDED
-	#define SCRYPT_CHACHA_INCLUDED
-#endif

algo/scryptjane/scrypt-jane-mix_chacha-sse2.h

@@ -1,585 +0,0 @@
-/* x86 */
-#if defined(X86ASM_SSE2) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_SSE2
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_sse2)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_sse2)
-	a1(push ebx)
-	a1(push edi)
-	a1(push esi)
-	a1(push ebp)
-	a2(mov ebp,esp)
-	a2(mov edi,[ebp+20])
-	a2(mov esi,[ebp+24])
-	a2(mov eax,[ebp+28])
-	a2(mov ebx,[ebp+32])
-	a2(sub esp,16)
-	a2(and esp,~15)
-	a2(lea edx,[ebx*2])
-	a2(shl edx,6)
-	a2(lea ecx,[edx-64])
-	a2(and eax, eax)
-	a2(movdqa xmm0,[ecx+esi+0])
-	a2(movdqa xmm1,[ecx+esi+16])
-	a2(movdqa xmm2,[ecx+esi+32])
-	a2(movdqa xmm3,[ecx+esi+48])
-	a1(jz scrypt_ChunkMix_sse2_no_xor1)
-	a2(pxor xmm0,[ecx+eax+0])
-	a2(pxor xmm1,[ecx+eax+16])
-	a2(pxor xmm2,[ecx+eax+32])
-	a2(pxor xmm3,[ecx+eax+48])
-	a1(scrypt_ChunkMix_sse2_no_xor1:)
-	a2(xor ecx,ecx)
-	a2(xor ebx,ebx)
-	a1(scrypt_ChunkMix_sse2_loop:)
-		a2(and eax, eax)
-		a2(pxor xmm0,[esi+ecx+0])
-		a2(pxor xmm1,[esi+ecx+16])
-		a2(pxor xmm2,[esi+ecx+32])
-		a2(pxor xmm3,[esi+ecx+48])
-		a1(jz scrypt_ChunkMix_sse2_no_xor2)
-		a2(pxor xmm0,[eax+ecx+0])
-		a2(pxor xmm1,[eax+ecx+16])
-		a2(pxor xmm2,[eax+ecx+32])
-		a2(pxor xmm3,[eax+ecx+48])
-		a1(scrypt_ChunkMix_sse2_no_xor2:)
-		a2(movdqa [esp+0],xmm0)
-		a2(movdqa xmm4,xmm1)
-		a2(movdqa xmm5,xmm2)
-		a2(movdqa xmm7,xmm3)
-		a2(mov eax,8)
-		a1(scrypt_chacha_sse2_loop: )
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,16)
-			a2(psrld xmm6,16)
-			a2(pxor  xmm3,xmm6)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm6,20)
-			a2(pxor  xmm1,xmm6)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,8)
-			a2(psrld xmm6,24)
-			a2(pxor  xmm3,xmm6)
-			a3(pshufd xmm0,xmm0,0x93)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x39)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm6,25)
-			a2(pxor  xmm1,xmm6)
-			a2(sub eax,2)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,16)
-			a2(psrld xmm6,16)
-			a2(pxor  xmm3,xmm6)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm6,20)
-			a2(pxor  xmm1,xmm6)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,8)
-			a2(psrld xmm6,24)
-			a2(pxor  xmm3,xmm6)
-			a3(pshufd xmm0,xmm0,0x39)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x93)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm6,25)
-			a2(pxor  xmm1,xmm6)
-			a1(ja scrypt_chacha_sse2_loop)
-		a2(paddd xmm0,[esp+0])
-		a2(paddd xmm1,xmm4)
-		a2(paddd xmm2,xmm5)
-		a2(paddd xmm3,xmm7)
-		a2(lea eax,[ebx+ecx])
-		a2(xor ebx,edx)
-		a2(and eax,~0x7f)
-		a2(add ecx,64)
-		a2(shr eax,1)
-		a2(add eax, edi)
-		a2(cmp ecx,edx)
-		a2(movdqa [eax+0],xmm0)
-		a2(movdqa [eax+16],xmm1)
-		a2(movdqa [eax+32],xmm2)
-		a2(movdqa [eax+48],xmm3)
-		a2(mov eax,[ebp+28])
-		a1(jne scrypt_ChunkMix_sse2_loop)
-	a2(mov esp,ebp)
-	a1(pop ebp)
-	a1(pop esi)
-	a1(pop edi)
-	a1(pop ebx)
-	aret(16)
-asm_naked_fn_end(scrypt_ChunkMix_sse2)
-
-#endif
-
-
-
-/* x64 */
-#if defined(X86_64ASM_SSE2) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_SSE2
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_sse2)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_sse2)
-	a2(lea rcx,[rcx*2])
-	a2(shl rcx,6)
-	a2(lea r9,[rcx-64])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(movdqa xmm0,[rax+0])
-	a2(movdqa xmm1,[rax+16])
-	a2(movdqa xmm2,[rax+32])
-	a2(movdqa xmm3,[rax+48])
-	a1(jz scrypt_ChunkMix_sse2_no_xor1)
-	a2(pxor xmm0,[r9+0])
-	a2(pxor xmm1,[r9+16])
-	a2(pxor xmm2,[r9+32])
-	a2(pxor xmm3,[r9+48])
-	a1(scrypt_ChunkMix_sse2_no_xor1:)
-	a2(xor r9,r9)
-	a2(xor r8,r8)
-	a1(scrypt_ChunkMix_sse2_loop:)
-		a2(and rdx, rdx)
-		a2(pxor xmm0,[rsi+r9+0])
-		a2(pxor xmm1,[rsi+r9+16])
-		a2(pxor xmm2,[rsi+r9+32])
-		a2(pxor xmm3,[rsi+r9+48])
-		a1(jz scrypt_ChunkMix_sse2_no_xor2)
-		a2(pxor xmm0,[rdx+r9+0])
-		a2(pxor xmm1,[rdx+r9+16])
-		a2(pxor xmm2,[rdx+r9+32])
-		a2(pxor xmm3,[rdx+r9+48])
-		a1(scrypt_ChunkMix_sse2_no_xor2:)
-		a2(movdqa xmm8,xmm0)
-		a2(movdqa xmm9,xmm1)
-		a2(movdqa xmm10,xmm2)
-		a2(movdqa xmm11,xmm3)
-		a2(mov rax,8)
-		a1(scrypt_chacha_sse2_loop: )
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,16)
-			a2(psrld xmm6,16)
-			a2(pxor  xmm3,xmm6)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm6,20)
-			a2(pxor  xmm1,xmm6)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,8)
-			a2(psrld xmm6,24)
-			a2(pxor  xmm3,xmm6)
-			a3(pshufd xmm0,xmm0,0x93)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x39)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm6,25)
-			a2(pxor  xmm1,xmm6)
-			a2(sub rax,2)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,16)
-			a2(psrld xmm6,16)
-			a2(pxor  xmm3,xmm6)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm6,20)
-			a2(pxor  xmm1,xmm6)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(movdqa xmm6,xmm3)
-			a2(pslld xmm3,8)
-			a2(psrld xmm6,24)
-			a2(pxor  xmm3,xmm6)
-			a3(pshufd xmm0,xmm0,0x39)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x93)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm6,25)
-			a2(pxor  xmm1,xmm6)
-			a1(ja scrypt_chacha_sse2_loop)
-		a2(paddd xmm0,xmm8)
-		a2(paddd xmm1,xmm9)
-		a2(paddd xmm2,xmm10)
-		a2(paddd xmm3,xmm11)
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0x7f)
-		a2(add r9,64)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(movdqa [rax+0],xmm0)
-		a2(movdqa [rax+16],xmm1)
-		a2(movdqa [rax+32],xmm2)
-		a2(movdqa [rax+48],xmm3)
-		a1(jne scrypt_ChunkMix_sse2_loop)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_sse2)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_SSE2) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_SSE2
-
-static void NOINLINE
-scrypt_ChunkMix_sse2(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,t0,t1,t2,t3;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 16);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 16));
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 8);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 24));
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 25));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 16);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 16));
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 8);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 24));
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 25));
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-/*
- * Special version with r = 1 and no XORing
- *  - mikaelh
- */
-static void NOINLINE
-scrypt_ChunkMix_sse2_1(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/) {
-	const uint32_t r = 1;
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,t0,t1,t2,t3;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 16);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 16));
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 8);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 24));
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 25));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 16);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 16));
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 8);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 24));
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 25));
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-/*
- * Special version with r = 1 and unconditional XORing
- *  - mikaelh
- */
-static void NOINLINE
-scrypt_ChunkMix_sse2_1_xor(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/) {
-	const uint32_t r = 1;
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,t0,t1,t2,t3;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-	x0 = _mm_xor_si128(x0, xmmp[0]);
-	x1 = _mm_xor_si128(x1, xmmp[1]);
-	x2 = _mm_xor_si128(x2, xmmp[2]);
-	x3 = _mm_xor_si128(x3, xmmp[3]);
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		xmmp = (xmmi *)scrypt_block(Bxor, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 16);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 16));
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 8);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 24));
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 25));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 16);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 16));
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x4 = x3;
-			x3 = _mm_slli_epi32(x3, 8);
-			x3 = _mm_or_si128(x3, _mm_srli_epi32(x4, 24));
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x4 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x4, 25));
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_CHACHA_SSE2)
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "ChaCha/8-SSE2"
-	#undef SCRYPT_CHACHA_INCLUDED
-	#define SCRYPT_CHACHA_INCLUDED
-#endif

algo/scryptjane/scrypt-jane-mix_chacha-ssse3.h

@@ -1,572 +0,0 @@
-/* x86 */
-#if defined(X86ASM_SSSE3) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_SSSE3
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_ssse3)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_ssse3)
-	a1(push ebx)
-	a1(push edi)
-	a1(push esi)
-	a1(push ebp)
-	a2(mov ebp,esp)
-	a2(mov edi,[ebp+20])
-	a2(mov esi,[ebp+24])
-	a2(mov eax,[ebp+28])
-	a2(mov ebx,[ebp+32])
-	a2(sub esp,64)
-	a2(and esp,~63)
-	a2(lea edx,[ebx*2])
-	a2(shl edx,6)
-	a2(lea ecx,[edx-64])
-	a2(and eax, eax)
-	a2(mov ebx, 0x01000302)
-	a2(movd xmm4, ebx)
-	a2(mov ebx, 0x05040706)
-	a2(movd xmm0, ebx)
-	a2(mov ebx, 0x09080b0a)
-	a2(movd xmm1, ebx)
-	a2(mov ebx, 0x0d0c0f0e)
-	a2(movd xmm2, ebx)
-	a2(mov ebx, 0x02010003)
-	a2(movd xmm5, ebx)
-	a2(mov ebx, 0x06050407)
-	a2(movd xmm3, ebx)
-	a2(mov ebx, 0x0a09080b)
-	a2(movd xmm6, ebx)
-	a2(mov ebx, 0x0e0d0c0f)
-	a2(movd xmm7, ebx)
-	a2(punpckldq xmm4, xmm0)
-	a2(punpckldq xmm5, xmm3)
-	a2(punpckldq xmm1, xmm2)
-	a2(punpckldq xmm6, xmm7)
-	a2(punpcklqdq xmm4, xmm1)
-	a2(punpcklqdq xmm5, xmm6)
-	a2(movdqa xmm0,[ecx+esi+0])
-	a2(movdqa xmm1,[ecx+esi+16])
-	a2(movdqa xmm2,[ecx+esi+32])
-	a2(movdqa xmm3,[ecx+esi+48])
-	a1(jz scrypt_ChunkMix_ssse3_no_xor1)
-	a2(pxor xmm0,[ecx+eax+0])
-	a2(pxor xmm1,[ecx+eax+16])
-	a2(pxor xmm2,[ecx+eax+32])
-	a2(pxor xmm3,[ecx+eax+48])
-	a1(scrypt_ChunkMix_ssse3_no_xor1:)
-	a2(xor ecx,ecx)
-	a2(xor ebx,ebx)
-	a1(scrypt_ChunkMix_ssse3_loop:)
-		a2(and eax, eax)
-		a2(pxor xmm0,[esi+ecx+0])
-		a2(pxor xmm1,[esi+ecx+16])
-		a2(pxor xmm2,[esi+ecx+32])
-		a2(pxor xmm3,[esi+ecx+48])
-		a1(jz scrypt_ChunkMix_ssse3_no_xor2)
-		a2(pxor xmm0,[eax+ecx+0])
-		a2(pxor xmm1,[eax+ecx+16])
-		a2(pxor xmm2,[eax+ecx+32])
-		a2(pxor xmm3,[eax+ecx+48])
-		a1(scrypt_ChunkMix_ssse3_no_xor2:)
-		a2(movdqa [esp+0],xmm0)
-		a2(movdqa [esp+16],xmm1)
-		a2(movdqa [esp+32],xmm2)
-		a2(movdqa xmm7,xmm3)
-		a2(mov eax,8)
-		a1(scrypt_chacha_ssse3_loop: )
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm4)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm6,20)
-			a2(pxor  xmm1,xmm6)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm5)
-			a3(pshufd xmm0,xmm0,0x93)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x39)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm6,25)
-			a2(pxor  xmm1,xmm6)
-			a2(sub eax,2)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm4)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm6,20)
-			a2(pxor  xmm1,xmm6)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm5)
-			a3(pshufd xmm0,xmm0,0x39)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x93)
-			a2(movdqa xmm6,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm6,25)
-			a2(pxor  xmm1,xmm6)
-			a1(ja scrypt_chacha_ssse3_loop)
-		a2(paddd xmm0,[esp+0])
-		a2(paddd xmm1,[esp+16])
-		a2(paddd xmm2,[esp+32])
-		a2(paddd xmm3,xmm7)
-		a2(lea eax,[ebx+ecx])
-		a2(xor ebx,edx)
-		a2(and eax,~0x7f)
-		a2(add ecx,64)
-		a2(shr eax,1)
-		a2(add eax, edi)
-		a2(cmp ecx,edx)
-		a2(movdqa [eax+0],xmm0)
-		a2(movdqa [eax+16],xmm1)
-		a2(movdqa [eax+32],xmm2)
-		a2(movdqa [eax+48],xmm3)
-		a2(mov eax,[ebp+28])
-		a1(jne scrypt_ChunkMix_ssse3_loop)
-	a2(mov esp,ebp)
-	a1(pop ebp)
-	a1(pop esi)
-	a1(pop edi)
-	a1(pop ebx)
-	aret(16)
-asm_naked_fn_end(scrypt_ChunkMix_ssse3)
-
-#endif
-
-
-
-/* x64 */
-#if defined(X86_64ASM_SSSE3) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_SSSE3
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_ssse3)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_ssse3)
-	a2(lea rcx,[rcx*2])
-	a2(shl rcx,6)
-	a2(lea r9,[rcx-64])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(movdqa xmm0,[rax+0])
-	a2(movdqa xmm1,[rax+16])
-	a2(movdqa xmm2,[rax+32])
-	a2(movdqa xmm3,[rax+48])
-	a2(mov r8, 0x0504070601000302)
-	a2(mov rax, 0x0d0c0f0e09080b0a)
-	a2(movq xmm4, r8)
-	a2(movq xmm6, rax)
-	a2(mov r8, 0x0605040702010003)
-	a2(mov rax, 0x0e0d0c0f0a09080b)
-	a2(movq xmm5, r8)
-	a2(movq xmm7, rax)
-	a2(punpcklqdq xmm4, xmm6)
-	a2(punpcklqdq xmm5, xmm7)
-	a1(jz scrypt_ChunkMix_ssse3_no_xor1)
-	a2(pxor xmm0,[r9+0])
-	a2(pxor xmm1,[r9+16])
-	a2(pxor xmm2,[r9+32])
-	a2(pxor xmm3,[r9+48])
-	a1(scrypt_ChunkMix_ssse3_no_xor1:)
-	a2(xor r8,r8)
-	a2(xor r9,r9)
-	a1(scrypt_ChunkMix_ssse3_loop:)
-		a2(and rdx, rdx)
-		a2(pxor xmm0,[rsi+r9+0])
-		a2(pxor xmm1,[rsi+r9+16])
-		a2(pxor xmm2,[rsi+r9+32])
-		a2(pxor xmm3,[rsi+r9+48])
-		a1(jz scrypt_ChunkMix_ssse3_no_xor2)
-		a2(pxor xmm0,[rdx+r9+0])
-		a2(pxor xmm1,[rdx+r9+16])
-		a2(pxor xmm2,[rdx+r9+32])
-		a2(pxor xmm3,[rdx+r9+48])
-		a1(scrypt_ChunkMix_ssse3_no_xor2:)
-		a2(movdqa xmm8,xmm0)
-		a2(movdqa xmm9,xmm1)
-		a2(movdqa xmm10,xmm2)
-		a2(movdqa xmm11,xmm3)
-		a2(mov rax,8)
-		a1(scrypt_chacha_ssse3_loop: )
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm4)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm12,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm12,20)
-			a2(pxor  xmm1,xmm12)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm5)
-			a3(pshufd xmm0,xmm0,0x93)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x39)
-			a2(movdqa xmm12,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm12,25)
-			a2(pxor  xmm1,xmm12)
-			a2(sub rax,2)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm4)
-			a2(paddd xmm2,xmm3)
-			a2(pxor  xmm1,xmm2)
-			a2(movdqa xmm12,xmm1)
-			a2(pslld xmm1,12)
-			a2(psrld xmm12,20)
-			a2(pxor  xmm1,xmm12)
-			a2(paddd xmm0,xmm1)
-			a2(pxor  xmm3,xmm0)
-			a2(pshufb xmm3,xmm5)
-			a3(pshufd xmm0,xmm0,0x39)
-			a2(paddd xmm2,xmm3)
-			a3(pshufd xmm3,xmm3,0x4e)
-			a2(pxor  xmm1,xmm2)
-			a3(pshufd xmm2,xmm2,0x93)
-			a2(movdqa xmm12,xmm1)
-			a2(pslld xmm1,7)
-			a2(psrld xmm12,25)
-			a2(pxor  xmm1,xmm12)
-			a1(ja scrypt_chacha_ssse3_loop)
-		a2(paddd xmm0,xmm8)
-		a2(paddd xmm1,xmm9)
-		a2(paddd xmm2,xmm10)
-		a2(paddd xmm3,xmm11)
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0x7f)
-		a2(add r9,64)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(movdqa [rax+0],xmm0)
-		a2(movdqa [rax+16],xmm1)
-		a2(movdqa [rax+32],xmm2)
-		a2(movdqa [rax+48],xmm3)
-		a1(jne scrypt_ChunkMix_ssse3_loop)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_ssse3)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_SSSE3) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED))
-
-#define SCRYPT_CHACHA_SSSE3
-
-static void NOINLINE
-scrypt_ChunkMix_ssse3(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x6,t0,t1,t2,t3;
-	const xmmi x4 = *(xmmi *)&ssse3_rotl16_32bit, x5 = *(xmmi *)&ssse3_rotl8_32bit;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 25));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 25));
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-/*
- * Special version with r = 1 and no XORing
- *  - mikaelh
- */
-static void NOINLINE
-scrypt_ChunkMix_ssse3_1(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/) {
-	const uint32_t r = 1;
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x6,t0,t1,t2,t3;
-	const xmmi x4 = *(xmmi *)&ssse3_rotl16_32bit, x5 = *(xmmi *)&ssse3_rotl8_32bit;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 25));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 25));
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-/*
- * Special version with r = 1 and unconditional XORing
- *  - mikaelh
- */
-static void NOINLINE
-scrypt_ChunkMix_ssse3_1_xor(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/) {
-	const uint32_t r = 1;
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x6,t0,t1,t2,t3;
-	const xmmi x4 = *(xmmi *)&ssse3_rotl16_32bit, x5 = *(xmmi *)&ssse3_rotl8_32bit;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-	x0 = _mm_xor_si128(x0, xmmp[0]);
-	x1 = _mm_xor_si128(x1, xmmp[1]);
-	x2 = _mm_xor_si128(x2, xmmp[2]);
-	x3 = _mm_xor_si128(x3, xmmp[3]);
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		xmmp = (xmmi *)scrypt_block(Bxor, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x93);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x39);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 25));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x4);
-			x2 = _mm_add_epi32(x2, x3);
-			x1 = _mm_xor_si128(x1, x2);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 12);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 20));
-			x0 = _mm_add_epi32(x0, x1);
-			x3 = _mm_xor_si128(x3, x0);
-			x3 = _mm_shuffle_epi8(x3, x5);
-			x0 = _mm_shuffle_epi32(x0, 0x39);
-			x2 = _mm_add_epi32(x2, x3);
-			x3 = _mm_shuffle_epi32(x3, 0x4e);
-			x1 = _mm_xor_si128(x1, x2);
-			x2 = _mm_shuffle_epi32(x2, 0x93);
-			x6 = x1;
-			x1 = _mm_slli_epi32(x1, 7);
-			x1 = _mm_or_si128(x1, _mm_srli_epi32(x6, 25));
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_CHACHA_SSSE3)
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "ChaCha/8-SSSE3"
-	#undef SCRYPT_CHACHA_INCLUDED
-	#define SCRYPT_CHACHA_INCLUDED
-#endif

algo/scryptjane/scrypt-jane-mix_chacha.h

@@ -1,69 +0,0 @@
-#if !defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_CHACHA_INCLUDED)
-
-#undef SCRYPT_MIX
-#define SCRYPT_MIX "ChaCha20/8 Ref"
-
-#undef SCRYPT_CHACHA_INCLUDED
-#define SCRYPT_CHACHA_INCLUDED
-#define SCRYPT_CHACHA_BASIC
-
-static void
-chacha_core_basic(uint32_t state[16]) {
-	size_t rounds = 8;
-	uint32_t x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,t;
-
-	x0 = state[0];
-	x1 = state[1];
-	x2 = state[2];
-	x3 = state[3];
-	x4 = state[4];
-	x5 = state[5];
-	x6 = state[6];
-	x7 = state[7];
-	x8 = state[8];
-	x9 = state[9];
-	x10 = state[10];
-	x11 = state[11];
-	x12 = state[12];
-	x13 = state[13];
-	x14 = state[14];
-	x15 = state[15];
-
-	#define quarter(a,b,c,d) \
-		a += b; t = d^a; d = ROTL32(t,16); \
-		c += d; t = b^c; b = ROTL32(t,12); \
-		a += b; t = d^a; d = ROTL32(t, 8); \
-		c += d; t = b^c; b = ROTL32(t, 7);
-
-	for (; rounds; rounds -= 2) {
-		quarter( x0, x4, x8,x12)
-		quarter( x1, x5, x9,x13)
-		quarter( x2, x6,x10,x14)
-		quarter( x3, x7,x11,x15)
-		quarter( x0, x5,x10,x15)
-		quarter( x1, x6,x11,x12)
-		quarter( x2, x7, x8,x13)
-		quarter( x3, x4, x9,x14)
-	}
-
-	state[0] += x0;
-	state[1] += x1;
-	state[2] += x2;
-	state[3] += x3;
-	state[4] += x4;
-	state[5] += x5;
-	state[6] += x6;
-	state[7] += x7;
-	state[8] += x8;
-	state[9] += x9;
-	state[10] += x10;
-	state[11] += x11;
-	state[12] += x12;
-	state[13] += x13;
-	state[14] += x14;
-	state[15] += x15;
-
-	#undef quarter
-}
-
-#endif

algo/scryptjane/scrypt-jane-mix_salsa-avx.h

@@ -1,381 +0,0 @@
-/* x86 */
-#if defined(X86ASM_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA_INCLUDED))
-
-#define SCRYPT_SALSA_AVX
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_avx)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_avx)
-	a1(push ebx)
-	a1(push edi)
-	a1(push esi)
-	a1(push ebp)
-	a2(mov ebp,esp)
-	a2(mov edi,[ebp+20])
-	a2(mov esi,[ebp+24])
-	a2(mov eax,[ebp+28])
-	a2(mov ebx,[ebp+32])
-	a2(sub esp,32)
-	a2(and esp,~63)
-	a2(lea edx,[ebx*2])
-	a2(shl edx,6)
-	a2(lea ecx,[edx-64])
-	a2(and eax, eax)
-	a2(movdqa xmm0,[ecx+esi+0])
-	a2(movdqa xmm1,[ecx+esi+16])
-	a2(movdqa xmm2,[ecx+esi+32])
-	a2(movdqa xmm3,[ecx+esi+48])
-	a1(jz scrypt_ChunkMix_avx_no_xor1)
-	a3(vpxor xmm0,xmm0,[ecx+eax+0])
-	a3(vpxor xmm1,xmm1,[ecx+eax+16])
-	a3(vpxor xmm2,xmm2,[ecx+eax+32])
-	a3(vpxor xmm3,xmm3,[ecx+eax+48])
-	a1(scrypt_ChunkMix_avx_no_xor1:)
-	a2(xor ecx,ecx)
-	a2(xor ebx,ebx)
-	a1(scrypt_ChunkMix_avx_loop:)
-		a2(and eax, eax)
-		a3(vpxor xmm0,xmm0,[esi+ecx+0])
-		a3(vpxor xmm1,xmm1,[esi+ecx+16])
-		a3(vpxor xmm2,xmm2,[esi+ecx+32])
-		a3(vpxor xmm3,xmm3,[esi+ecx+48])
-		a1(jz scrypt_ChunkMix_avx_no_xor2)
-		a3(vpxor xmm0,xmm0,[eax+ecx+0])
-		a3(vpxor xmm1,xmm1,[eax+ecx+16])
-		a3(vpxor xmm2,xmm2,[eax+ecx+32])
-		a3(vpxor xmm3,xmm3,[eax+ecx+48])
-		a1(scrypt_ChunkMix_avx_no_xor2:)
-		a2(vmovdqa [esp+0],xmm0)
-		a2(vmovdqa [esp+16],xmm1)
-		a2(vmovdqa xmm6,xmm2)
-		a2(vmovdqa xmm7,xmm3)
-		a2(mov eax,8)
-		a1(scrypt_salsa_avx_loop: )
-			a3(vpaddd xmm4, xmm1, xmm0)
-			a3(vpsrld xmm5, xmm4, 25)
-			a3(vpslld xmm4, xmm4, 7)
-			a3(vpxor xmm3, xmm3, xmm5)
-			a3(vpxor xmm3, xmm3, xmm4)
-			a3(vpaddd xmm4, xmm0, xmm3)
-			a3(vpsrld xmm5, xmm4, 23)
-			a3(vpslld xmm4, xmm4, 9)
-			a3(vpxor xmm2, xmm2, xmm5)
-			a3(vpxor xmm2, xmm2, xmm4)
-			a3(vpaddd xmm4, xmm3, xmm2)
-			a3(vpsrld xmm5, xmm4, 19)
-			a3(vpslld xmm4, xmm4, 13)
-			a3(vpxor xmm1, xmm1, xmm5)
-			a3(pshufd xmm3, xmm3, 0x93)
-			a3(vpxor xmm1, xmm1, xmm4)
-			a3(vpaddd xmm4, xmm2, xmm1)
-			a3(vpsrld xmm5, xmm4, 14)
-			a3(vpslld xmm4, xmm4, 18)
-			a3(vpxor xmm0, xmm0, xmm5)
-			a3(pshufd xmm2, xmm2, 0x4e)
-			a3(vpxor xmm0, xmm0, xmm4)
-			a2(sub eax, 2)
-			a3(vpaddd xmm4, xmm3, xmm0)
-			a3(pshufd xmm1, xmm1, 0x39)
-			a3(vpsrld xmm5, xmm4, 25)
-			a3(vpslld xmm4, xmm4, 7)
-			a3(vpxor xmm1, xmm1, xmm5)
-			a3(vpxor xmm1, xmm1, xmm4)
-			a3(vpaddd xmm4, xmm0, xmm1)
-			a3(vpsrld xmm5, xmm4, 23)
-			a3(vpslld xmm4, xmm4, 9)
-			a3(vpxor xmm2, xmm2, xmm5)
-			a3(vpxor xmm2, xmm2, xmm4)
-			a3(vpaddd xmm4, xmm1, xmm2)
-			a3(vpsrld xmm5, xmm4, 19)
-			a3(vpslld xmm4, xmm4, 13)
-			a3(vpxor xmm3, xmm3, xmm5)
-			a3(pshufd xmm1, xmm1, 0x93)
-			a3(vpxor xmm3, xmm3, xmm4)
-			a3(vpaddd xmm4, xmm2, xmm3)
-			a3(vpsrld xmm5, xmm4, 14)
-			a3(vpslld xmm4, xmm4, 18)
-			a3(vpxor xmm0, xmm0, xmm5)
-			a3(pshufd xmm2, xmm2, 0x4e)
-			a3(vpxor xmm0, xmm0, xmm4)
-			a3(pshufd xmm3, xmm3, 0x39)
-			a1(ja scrypt_salsa_avx_loop)
-		a3(vpaddd xmm0,xmm0,[esp+0])
-		a3(vpaddd xmm1,xmm1,[esp+16])
-		a3(vpaddd xmm2,xmm2,xmm6)
-		a3(vpaddd xmm3,xmm3,xmm7)
-		a2(lea eax,[ebx+ecx])
-		a2(xor ebx,edx)
-		a2(and eax,~0x7f)
-		a2(add ecx,64)
-		a2(shr eax,1)
-		a2(add eax, edi)
-		a2(cmp ecx,edx)
-		a2(vmovdqa [eax+0],xmm0)
-		a2(vmovdqa [eax+16],xmm1)
-		a2(vmovdqa [eax+32],xmm2)
-		a2(vmovdqa [eax+48],xmm3)
-		a2(mov eax,[ebp+28])
-		a1(jne scrypt_ChunkMix_avx_loop)
-	a2(mov esp,ebp)
-	a1(pop ebp)
-	a1(pop esi)
-	a1(pop edi)
-	a1(pop ebx)
-	aret(16)
-asm_naked_fn_end(scrypt_ChunkMix_avx)
-
-#endif
-
-
-
-/* x64 */
-#if defined(X86_64ASM_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA_INCLUDED))
-
-#define SCRYPT_SALSA_AVX
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_avx)(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_avx)
-	a2(lea rcx,[rcx*2])
-	a2(shl rcx,6)
-	a2(lea r9,[rcx-64])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(vmovdqa xmm0,[rax+0])
-	a2(vmovdqa xmm1,[rax+16])
-	a2(vmovdqa xmm2,[rax+32])
-	a2(vmovdqa xmm3,[rax+48])
-	a1(jz scrypt_ChunkMix_avx_no_xor1)
-	a3(vpxor xmm0,xmm0,[r9+0])
-	a3(vpxor xmm1,xmm1,[r9+16])
-	a3(vpxor xmm2,xmm2,[r9+32])
-	a3(vpxor xmm3,xmm3,[r9+48])
-	a1(scrypt_ChunkMix_avx_no_xor1:)
-	a2(xor r9,r9)
-	a2(xor r8,r8)
-	a1(scrypt_ChunkMix_avx_loop:)
-		a2(and rdx, rdx)
-		a3(vpxor xmm0,xmm0,[rsi+r9+0])
-		a3(vpxor xmm1,xmm1,[rsi+r9+16])
-		a3(vpxor xmm2,xmm2,[rsi+r9+32])
-		a3(vpxor xmm3,xmm3,[rsi+r9+48])
-		a1(jz scrypt_ChunkMix_avx_no_xor2)
-		a3(vpxor xmm0,xmm0,[rdx+r9+0])
-		a3(vpxor xmm1,xmm1,[rdx+r9+16])
-		a3(vpxor xmm2,xmm2,[rdx+r9+32])
-		a3(vpxor xmm3,xmm3,[rdx+r9+48])
-		a1(scrypt_ChunkMix_avx_no_xor2:)
-		a2(vmovdqa xmm8,xmm0)
-		a2(vmovdqa xmm9,xmm1)
-		a2(vmovdqa xmm10,xmm2)
-		a2(vmovdqa xmm11,xmm3)
-		a2(mov rax,8)
-		a1(scrypt_salsa_avx_loop: )
-			a3(vpaddd xmm4, xmm1, xmm0)
-			a3(vpsrld xmm5, xmm4, 25)
-			a3(vpslld xmm4, xmm4, 7)
-			a3(vpxor xmm3, xmm3, xmm5)
-			a3(vpxor xmm3, xmm3, xmm4)
-			a3(vpaddd xmm4, xmm0, xmm3)
-			a3(vpsrld xmm5, xmm4, 23)
-			a3(vpslld xmm4, xmm4, 9)
-			a3(vpxor xmm2, xmm2, xmm5)
-			a3(vpxor xmm2, xmm2, xmm4)
-			a3(vpaddd xmm4, xmm3, xmm2)
-			a3(vpsrld xmm5, xmm4, 19)
-			a3(vpslld xmm4, xmm4, 13)
-			a3(vpxor xmm1, xmm1, xmm5)
-			a3(pshufd xmm3, xmm3, 0x93)
-			a3(vpxor xmm1, xmm1, xmm4)
-			a3(vpaddd xmm4, xmm2, xmm1)
-			a3(vpsrld xmm5, xmm4, 14)
-			a3(vpslld xmm4, xmm4, 18)
-			a3(vpxor xmm0, xmm0, xmm5)
-			a3(pshufd xmm2, xmm2, 0x4e)
-			a3(vpxor xmm0, xmm0, xmm4)
-			a2(sub rax, 2)
-			a3(vpaddd xmm4, xmm3, xmm0)
-			a3(pshufd xmm1, xmm1, 0x39)
-			a3(vpsrld xmm5, xmm4, 25)
-			a3(vpslld xmm4, xmm4, 7)
-			a3(vpxor xmm1, xmm1, xmm5)
-			a3(vpxor xmm1, xmm1, xmm4)
-			a3(vpaddd xmm4, xmm0, xmm1)
-			a3(vpsrld xmm5, xmm4, 23)
-			a3(vpslld xmm4, xmm4, 9)
-			a3(vpxor xmm2, xmm2, xmm5)
-			a3(vpxor xmm2, xmm2, xmm4)
-			a3(vpaddd xmm4, xmm1, xmm2)
-			a3(vpsrld xmm5, xmm4, 19)
-			a3(vpslld xmm4, xmm4, 13)
-			a3(vpxor xmm3, xmm3, xmm5)
-			a3(pshufd xmm1, xmm1, 0x93)
-			a3(vpxor xmm3, xmm3, xmm4)
-			a3(vpaddd xmm4, xmm2, xmm3)
-			a3(vpsrld xmm5, xmm4, 14)
-			a3(vpslld xmm4, xmm4, 18)
-			a3(vpxor xmm0, xmm0, xmm5)
-			a3(pshufd xmm2, xmm2, 0x4e)
-			a3(vpxor xmm0, xmm0, xmm4)
-			a3(pshufd xmm3, xmm3, 0x39)
-			a1(ja scrypt_salsa_avx_loop)
-		a3(vpaddd xmm0,xmm0,xmm8)
-		a3(vpaddd xmm1,xmm1,xmm9)
-		a3(vpaddd xmm2,xmm2,xmm10)
-		a3(vpaddd xmm3,xmm3,xmm11)
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0x7f)
-		a2(add r9,64)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(vmovdqa [rax+0],xmm0)
-		a2(vmovdqa [rax+16],xmm1)
-		a2(vmovdqa [rax+32],xmm2)
-		a2(vmovdqa [rax+48],xmm3)
-		a1(jne scrypt_ChunkMix_avx_loop)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_avx)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA_INCLUDED))
-
-#define SCRYPT_SALSA_AVX
-
-static void NOINLINE
-scrypt_ChunkMix_avx(uint32_t *Bout/*[chunkBytes]*/, uint32_t *Bin/*[chunkBytes]*/, uint32_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,x5,t0,t1,t2,t3;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			x4 = x1;
-			x4 = _mm_add_epi32(x4, x0);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 7);
-			x5 = _mm_srli_epi32(x5, 25);
-			x3 = _mm_xor_si128(x3, x4);
-			x4 = x0;
-			x3 = _mm_xor_si128(x3, x5);
-			x4 = _mm_add_epi32(x4, x3);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 9);
-			x5 = _mm_srli_epi32(x5, 23);
-			x2 = _mm_xor_si128(x2, x4);
-			x4 = x3;
-			x2 = _mm_xor_si128(x2, x5);
-			x3 = _mm_shuffle_epi32(x3, 0x93);
-			x4 = _mm_add_epi32(x4, x2);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 13);
-			x5 = _mm_srli_epi32(x5, 19);
-			x1 = _mm_xor_si128(x1, x4);
-			x4 = x2;
-			x1 = _mm_xor_si128(x1, x5);
-			x2 = _mm_shuffle_epi32(x2, 0x4e);
-			x4 = _mm_add_epi32(x4, x1);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 18);
-			x5 = _mm_srli_epi32(x5, 14);
-			x0 = _mm_xor_si128(x0, x4);
-			x4 = x3;
-			x0 = _mm_xor_si128(x0, x5);
-			x1 = _mm_shuffle_epi32(x1, 0x39);
-			x4 = _mm_add_epi32(x4, x0);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 7);
-			x5 = _mm_srli_epi32(x5, 25);
-			x1 = _mm_xor_si128(x1, x4);
-			x4 = x0;
-			x1 = _mm_xor_si128(x1, x5);
-			x4 = _mm_add_epi32(x4, x1);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 9);
-			x5 = _mm_srli_epi32(x5, 23);
-			x2 = _mm_xor_si128(x2, x4);
-			x4 = x1;
-			x2 = _mm_xor_si128(x2, x5);
-			x1 = _mm_shuffle_epi32(x1, 0x93);
-			x4 = _mm_add_epi32(x4, x2);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 13);
-			x5 = _mm_srli_epi32(x5, 19);
-			x3 = _mm_xor_si128(x3, x4);
-			x4 = x2;
-			x3 = _mm_xor_si128(x3, x5);
-			x2 = _mm_shuffle_epi32(x2, 0x4e);
-			x4 = _mm_add_epi32(x4, x3);
-			x5 = x4;
-			x4 = _mm_slli_epi32(x4, 18);
-			x5 = _mm_srli_epi32(x5, 14);
-			x0 = _mm_xor_si128(x0, x4);
-			x3 = _mm_shuffle_epi32(x3, 0x39);
-			x0 = _mm_xor_si128(x0, x5);
-		}
-
-		x0 = _mm_add_epi32(x0, t0);
-		x1 = _mm_add_epi32(x1, t1);
-		x2 = _mm_add_epi32(x2, t2);
-		x3 = _mm_add_epi32(x3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_SALSA_AVX)
-	/* uses salsa_core_tangle_sse2 */
-
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "Salsa/8-AVX"
-	#undef SCRYPT_SALSA_INCLUDED
-	#define SCRYPT_SALSA_INCLUDED
-#endif