v3.23.2

v3.23.1
v3.23.0
2025-09-17 23:44:27 +00:00 · 2023-09-21 12:34:06 -04:00 · 2023-09-13 11:48:52 -04:00 · 2023-08-30 20:15:48 -04:00
162 changed files with 14541 additions and 5811 deletions
--- a/Makefile.am
+++ b/Makefile.am
@@ -163,8 +163,6 @@ cpuminer_SOURCES = \
  algo/sha/sph_sha2big.c \
  algo/sha/sha256-hash-4way.c \
  algo/sha/sha512-hash-4way.c \
-  algo/sha/sha256-hash-opt.c \
-  algo/sha/sha256-hash-2way-ni.c \
  algo/sha/hmac-sha256-hash.c \
  algo/sha/hmac-sha256-hash-4way.c \
  algo/sha/sha256d.c \
@@ -172,7 +170,6 @@ cpuminer_SOURCES = \
  algo/sha/sha256d-4way.c \
  algo/sha/sha256t-gate.c \
  algo/sha/sha256t-4way.c \
-  algo/sha/sha256t.c \
  algo/sha/sha256q-4way.c \
  algo/sha/sha256q.c \
  algo/sha/sha512256d-4way.c \
@@ -294,10 +291,10 @@ disable_flags =
 if USE_ASM
   cpuminer_SOURCES += asm/neoscrypt_asm.S
 if ARCH_x86
-   cpuminer_SOURCES += asm/sha2-x86.S asm/scrypt-x86.S asm/aesb-x86.S
+   cpuminer_SOURCES += asm/sha2-x86.S asm/scrypt-x86.S
 endif
 if ARCH_x86_64
-   cpuminer_SOURCES += asm/sha2-x64.S asm/scrypt-x64.S asm/aesb-x64.S
+   cpuminer_SOURCES += asm/sha2-x64.S asm/scrypt-x64.S
 endif
 if ARCH_ARM
   cpuminer_SOURCES += asm/sha2-arm.S asm/scrypt-arm.S
--- a/51
+++ b/51
@@ -65,9 +65,31 @@ If not what makes it happen or not happen?
 Change Log
 ----------

+v3.23.2
+
+sha256dt, sha256t & sha256d +10% with SHA, small improvement with AVX2.
+Other small improvements and code cleanup.
+
+v3.23.1
+
+#349: Fix sha256t low difficulty shares and low effective hash rate.
+Faster sha256dt:  AVX512 +7%, SHA +200%, AVX2 +5%.
+Faster blakecoin & vanilla: AVX2 +30%, AVX512 +110%.
+Other small improvements and code cleanup.
+
+v3.23.0
+
+#398: Prevent GBT fallback to Getwork on network error.
+#398: Prevent excessive logs when conditional mining is paused when mining solo.
+Fix a false start if stratum doesn't immediately send a new job after connecting.
+Tweak diagonal shuffle in Blake2b & Blake256 1-way SIMD to reduce latency.
+CPUID support for AVX10.
+Initial changes to AVX2 targeted code in preparation for AVX10.
+Code cleanup and miscellaneous small improvements.
+
 v3.22.3

-Data interleaving and byte swap optimizations iwith AVX2, AVX512 & AVX512VBMI.
+Data interleaving and byte swap optimizations with AVX2, AVX512 & AVX512VBMI.
 Faster Luffa with AVX2 & AVX512.
 Other small optimizations.
 Some code cleanup.
@@ -204,40 +226,29 @@ v3.19.5

 Enhanced stratum-keepalive preemptively resets the stratum connection
 before the server to avoid lost shares.
-
 Added build-msys2.sh shell script for easier compiling on Windows, see Wiki for details.
-
 X16RT: eliminate unnecessary recalculations of the hash order.
-
 Fix a few compiler warnings.
-
 Fixed log colour error when a block is solved.

 v3.19.4

 #359: Fix verthash memory allocation for non-hugepages, broken in v3.19.3.
-
 New option stratum-keepalive prevents stratum timeouts when no shares are
 submitted for several minutes due to high difficulty.
-
 Fixed a bug displaying optimizations for some algos.

 v3.19.3

 Linux: Faster verthash (+25%), scryptn2 (+2%) when huge pages are available.
-
 Small speed up for Hamsi AVX2 & AVX512, Keccak AVX512.

 v3.19.2

 Fixed log displaying incorrect memory usage for scrypt, broken in v3.19.1.
-
 Reduce log noise when replies to submitted shares are lost due to stratum errors.
-
 Fugue prehash optimization for X16r family AVX2 & AVX512.
-
 Small speed improvement for Hamsi AVX2 & AVX512.
-
 Win: With CPU groups enabled the number of CPUs displayed in the ASCII art
 affinity map is the number of CPUs in a CPU group, was number of CPUs up to 64.

@@ -249,7 +260,6 @@ Changes to Windows binaries package:
 - zen build renamed to avx2-sha, supports Zen1 & Zen2,
 - avx512-sha build removed, Rocketlake CPUs can use avx512-sha-vaes,
 - see README.txt for compatibility details.
-
 Fixed a few compiler warnings that are new in GCC 11.
 Other minor fixes.

@@ -263,22 +273,17 @@ Changes to cpu-affinity:
  - streamlined code for more efficient initialization of miner threads,
  - precise affining of each miner thread to a specific CPU,
  - added an option to disable CPU affinity with "--cpu-affinity 0"
-
 Faster sha256t with AVX512 & AVX2.
-
 Added stratum error count to stats log, reported only when non-zero.

 v3.18.2

 Issue #342, fixed Groestl AES on Windows, broken in v3.18.0.
-
 AVX512 for sha256d.
-
 SSE42 and AVX may now be displayed as mining features at startup.
 This is hard coded for each algo, and is only implemented for scrypt
 at this time as it is the only algo with significant performance differences
 with those features.
-
 Fixed an issue where a high hashrate algo could cause excessive invalid hash
 rate log reports when starting up in benchmark mode.

@@ -289,9 +294,7 @@ More speed for scrypt:
 - AVX2 is now used by default on CPUS with SHA but not AVX512,
 - scrypt:1024 performance lost in v3.18.0 is restored,
 - AVX512 & AVX2 improvements to scrypt:1024.
-
 Big speedup for SwiFFTx AVX2 & SSE4.1: x22i +55%, x25x +22%.
-
 Issue #337: fixed a problem that could display negative stats values in the
 first summary report if the report was forced prematurely due to a stratum
 diff change. The stats will still be invalid but should display zeros.
@@ -304,26 +307,19 @@ Complete rewrite of Scrypt code, optimized for large N factor (scryptn2):
  - memory requirements reduced 30-60% depending on CPU architecture,
  - memory usage displayed at startup,
  - scrypt, default N=1024 (LTC), will likely perform slower.
-
 Improved stale share detection and handling for Scrypt with large N factor:
  - abort and discard partially computed hash when new work is detected,
  - quicker response to new job, less time wasted mining stale job.
-
 Improved stale share handling for all algorithms:
  - report possible stale share when new work received with a previously
    submitted share still pending,
  - when new work is detected report the submission of an already completed,
    otherwise valid, but likely stale, share,
  - fixed incorrect block height in stale share log.
-
 Small performance improvements to sha, bmw, cube & hamsi for AVX512 & AVX2.
-
 When stratum disconnects miner threads go to idle until reconnected.
-
 Colour changes to some logs.
-
 Some low level function name changes for clarity and consistency.
-
 The reference hashrate in the summary log and the benchmark total hashrate
 are now the mean hashrate for the session. 

@@ -436,7 +432,6 @@ Fixed neoscrypt BUG log.
 v3.14.3

 #265: more mutex changes to reduce blocking with high thread count.
-
 #267: fixed hodl algo potential memory alignment issue,
      add warning when thread count is not valid for mining hodl algo.

--- a/algo-gate-api.c
+++ b/algo-gate-api.c
@@ -171,7 +171,7 @@ int scanhash_4way_64in_32out( struct work *work, uint32_t max_nonce,
         }
      }
      *noncev = _mm256_add_epi32( *noncev,
-                                  m256_const1_64( 0x0000000400000000 ) );
+                                  _mm256_set1_epi64x( 0x0000000400000000 ) );
      n += 4;
   } while ( likely( ( n <= last_nonce ) && !work_restart[thr_id].restart ) );
   pdata[19] = n;
@@ -227,7 +227,7 @@ int scanhash_8way_64in_32out( struct work *work, uint32_t max_nonce,
         }
      }
      *noncev = _mm512_add_epi32( *noncev,
-                                  m512_const1_64( 0x0000000800000000 ) );
+                                  _mm512_set1_epi64( 0x0000000800000000 ) );
      n += 8;
   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
   pdata[19] = n;
@@ -248,7 +248,7 @@ int null_hash()
   return 0;
 };

-void init_algo_gate( algo_gate_t* gate )
+static void init_algo_gate( algo_gate_t* gate )
 {
   gate->miner_thread_init       = (void*)&return_true;
   gate->scanhash                = (void*)&scanhash_generic;
--- a/algo-gate-api.h
+++ b/algo-gate-api.h
@@ -94,10 +94,13 @@ typedef  uint32_t set_t;
 #define SSE42_OPT        4
 #define AVX_OPT          8   // Sandybridge
 #define AVX2_OPT      0x10   // Haswell, Zen1
-#define SHA_OPT       0x20   // Zen1, Icelake (sha256)
-#define AVX512_OPT    0x40   // Skylake-X (AVX512[F,VL,DQ,BW])
-#define VAES_OPT      0x80   // Icelake (VAES & AVX512)
+#define SHA_OPT       0x20   // Zen1, Icelake (deprecated)
+#define AVX512_OPT    0x40   // Skylake-X, Zen4 (AVX512[F,VL,DQ,BW])
+#define VAES_OPT      0x80   // Icelake, Zen3

+// AVX10 does not have explicit algo features:
+//  AVX10_512 is compatible with AVX512 + VAES
+//  AVX10_256 is compatible with AVX2 + VAES

 // return set containing all elements from sets a & b
 inline set_t set_union ( set_t a, set_t b ) { return a | b; }
@@ -264,7 +267,9 @@ void std_get_new_work( struct work *work, struct work *g_work, int thr_id,
                       uint32_t* end_nonce_ptr );

 void sha256d_gen_merkle_root( char *merkle_root, struct stratum_ctx *sctx );
-void SHA256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );
+void sha256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );
+// OpenSSL sha256 deprecated
+//void SHA256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );

 bool std_le_work_decode( struct work *work );
 bool std_be_work_decode( struct work *work );
--- a/algo/argon2/argon2a/argon2a.c
+++ b/algo/argon2/argon2a/argon2a.c
@@ -77,7 +77,7 @@ bool register_argon2_algo( algo_gate_t* gate )
  gate->optimizations = SSE2_OPT | AVX_OPT | AVX2_OPT;
  gate->scanhash        = (void*)&scanhash_argon2;
  gate->hash            = (void*)&argon2hash;
-  gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
+  gate->gen_merkle_root = (void*)&sha256_gen_merkle_root;
  opt_target_factor = 65536.0;

  return true;
--- a/algo/blake/blake-hash-4way.h
+++ b/algo/blake/blake-hash-4way.h
@@ -1,60 +1,15 @@
-/* $Id: sph_blake.h 252 2011-06-07 17:55:14Z tp $ */
-/**
- * BLAKE interface. BLAKE is a family of functions which differ by their
- * output size; this implementation defines BLAKE for output sizes 224,
- * 256, 384 and 512 bits. This implementation conforms to the "third
- * round" specification.
- *
- * ==========================(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_blake.h
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#ifndef __BLAKE_HASH_4WAY__
-#define __BLAKE_HASH_4WAY__ 1
-
-#ifdef __cplusplus
-extern "C"{
-#endif
+#ifndef BLAKE_HASH_4WAY__
+#define BLAKE_HASH_4WAY__ 1

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
 #include "simd-utils.h"

-#define SPH_SIZE_blake256   256
-
-#define SPH_SIZE_blake512   512
-
 /////////////////////////
 //
 //  Blake-256 1 way SSE2

 void  blake256_transform_le( uint32_t *H, const uint32_t *buf,
-                             const uint32_t T0, const uint32_t T1 );
+                             const uint32_t T0, const uint32_t T1, int rounds );

 /////////////////////////
 //
@@ -75,13 +30,13 @@ typedef struct {
   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
 } blake_4way_small_context __attribute__ ((aligned (64)));

-// Default, 14 rounds, blake, decred
+// Default, 14 rounds
 typedef blake_4way_small_context blake256_4way_context;
 void blake256_4way_init(void *ctx);
 void blake256_4way_update(void *ctx, const void *data, size_t len);
 void blake256_4way_close(void *ctx, void *dst);

-// 14 rounds, blake, decred
+// 14 rounds
 typedef blake_4way_small_context blake256r14_4way_context;
 void blake256r14_4way_init(void *cc);
 void blake256r14_4way_update(void *cc, const void *data, size_t len);
@@ -103,7 +58,7 @@ typedef struct {
   __m256i buf[16] __attribute__ ((aligned (64)));
   __m256i H[8];
   size_t ptr;
-   sph_u32 T0, T1;
+   uint32_t T0, T1;
   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
 } blake_8way_small_context;

@@ -117,7 +72,7 @@ void blake256_8way_close_le(void *cc, void *dst);
 void blake256_8way_round0_prehash_le( void *midstate, const void *midhash,
                                      void *data );
 void blake256_8way_final_rounds_le( void *final_hash, const void *midstate,
-                                     const void *midhash, const void *data );
+                    const void *midhash, const void *data, const int rounds );

 // 14 rounds, blake, decred
 typedef blake_8way_small_context blake256r14_8way_context;
@@ -138,7 +93,7 @@ typedef struct {
   __m256i H[8];
   __m256i S[4];   
   size_t ptr;
-   sph_u64 T0, T1;
+   uint64_t T0, T1;
 } blake_4way_big_context __attribute__ ((aligned (128)));

 typedef blake_4way_big_context blake512_4way_context;
@@ -180,7 +135,7 @@ void blake256_16way_close_le(void *cc, void *dst);
 void blake256_16way_round0_prehash_le( void *midstate, const void *midhash,
                                       void *data );
 void blake256_16way_final_rounds_le( void *final_hash, const void *midstate,
-                                     const void *midhash, const void *data );
+                     const void *midhash, const void *data, const int rounds );


 // 14 rounds, blake, decred
@@ -204,7 +159,7 @@ typedef struct {
   __m512i H[8];
   __m512i S[4];
   size_t ptr;
-   sph_u64 T0, T1;
+   uint64_t T0, T1;
 } blake_8way_big_context __attribute__ ((aligned (128)));

 typedef blake_8way_big_context blake512_8way_context;
@@ -224,8 +179,4 @@ void blake512_8way_final_le( blake_8way_big_context *sc, void *hash,
 #endif  // AVX512
 #endif  // AVX2

-#ifdef __cplusplus
-}
-#endif
-
 #endif  // BLAKE_HASH_4WAY_H__
--- a/algo/blake/blake256-hash-4way.c
+++ b/algo/blake/blake256-hash-4way.c
@@ -40,26 +40,6 @@

 #include "blake-hash-4way.h"

-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#if SPH_SMALL_FOOTPRINT && !defined SPH_SMALL_FOOTPRINT_BLAKE
-#define SPH_SMALL_FOOTPRINT_BLAKE   1
-#endif
-
-#if SPH_SMALL_FOOTPRINT_BLAKE
-#define SPH_COMPACT_BLAKE_32   1
-#endif
-
-#if SPH_64 && (SPH_SMALL_FOOTPRINT_BLAKE || !SPH_64_TRUE)
-#define SPH_COMPACT_BLAKE_64   1
-#endif
-
-#ifdef _MSC_VER
-#pragma warning (disable: 4146)
-#endif
-
 // Blake-256

 static const uint32_t IV256[8] =
@@ -68,7 +48,7 @@ static const uint32_t IV256[8] =
 	0x510E527F, 0x9B05688C,	0x1F83D9AB, 0x5BE0CD19
 };

-#if SPH_COMPACT_BLAKE_32 || SPH_COMPACT_BLAKE_64
+#if 0

 // Blake-256 4 & 8 way, Blake-512 4 way

@@ -273,41 +253,27 @@ static const unsigned sigma[16][16] = {
 #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)
-
-#if SPH_COMPACT_BLAKE_32
-
-static const sph_u32 CS[16] = {
-	SPH_C32(0x243F6A88), SPH_C32(0x85A308D3),
-	SPH_C32(0x13198A2E), SPH_C32(0x03707344),
-	SPH_C32(0xA4093822), SPH_C32(0x299F31D0),
-	SPH_C32(0x082EFA98), SPH_C32(0xEC4E6C89),
-	SPH_C32(0x452821E6), SPH_C32(0x38D01377),
-	SPH_C32(0xBE5466CF), SPH_C32(0x34E90C6C),
-	SPH_C32(0xC0AC29B7), SPH_C32(0xC97C50DD),
-	SPH_C32(0x3F84D5B5), SPH_C32(0xB5470917)
-};
-
-#endif
+#define CS0   0x243F6A88
+#define CS1   0x85A308D3
+#define CS2   0x13198A2E
+#define CS3   0x03707344
+#define CS4   0xA4093822
+#define CS5   0x299F31D0
+#define CS6   0x082EFA98
+#define CS7   0xEC4E6C89
+#define CS8   0x452821E6
+#define CS9   0x38D01377
+#define CSA   0xBE5466CF
+#define CSB   0x34E90C6C
+#define CSC   0xC0AC29B7
+#define CSD   0xC97C50DD
+#define CSE   0x3F84D5B5
+#define CSF   0xB5470917

 /////////////////////////////////////////
 //
 // Blake-256 1 way SIMD
+// Only used for prehash, otherwise 4way is used with SSE2.

 #define BLAKE256_ROUND( r ) \
 { \
@@ -327,32 +293,33 @@ static const sph_u32 CS[16] = {
   V3 = mm128_shuflr32_8( _mm_xor_si128( V3, V0 ) ); \
   V2 = _mm_add_epi32( V2, V3 ); \
   V1 = mm128_ror_32( _mm_xor_si128( V1, V2 ), 7 ); \
-   V3 = mm128_shufll_32( V3 ); \
-   V2 = mm128_swap_64( V2 ); \
-   V1 = mm128_shuflr_32( V1 ); \
+   V0 = mm128_shufll_32( V0 ); \
+   V3 = mm128_swap_64( V3 ); \
+   V2 = mm128_shuflr_32( V2 ); \
   V0 = _mm_add_epi32( V0, _mm_add_epi32( V1, \
-                           _mm_set_epi32( CSx( r, F ) ^ Mx( r, E ), \
-                                          CSx( r, D ) ^ Mx( r, C ), \
+                           _mm_set_epi32( CSx( r, D ) ^ Mx( r, C ), \
                                          CSx( r, B ) ^ Mx( r, A ), \
-                                          CSx( r, 9 ) ^ Mx( r, 8 ) ) ) ); \
+                                          CSx( r, 9 ) ^ Mx( r, 8 ), \
+                                          CSx( r, F ) ^ Mx( r, E ) ) ) ); \
   V3 = mm128_swap32_16( _mm_xor_si128( V3, V0 ) ); \
   V2 = _mm_add_epi32( V2, V3 ); \
   V1 = mm128_ror_32( _mm_xor_si128( V1, V2 ), 12 ); \
   V0 = _mm_add_epi32( V0, _mm_add_epi32( V1, \
-                           _mm_set_epi32( CSx( r, E ) ^ Mx( r, F ), \
-                                          CSx( r, C ) ^ Mx( r, D ), \
+                           _mm_set_epi32( CSx( r, C ) ^ Mx( r, D ), \
                                          CSx( r, A ) ^ Mx( r, B ), \
-                                          CSx( r, 8 ) ^ Mx( r, 9 ) ) ) ); \
+                                          CSx( r, 8 ) ^ Mx( r, 9 ), \
+                                          CSx( r, E ) ^ Mx( r, F ) ) ) ); \
   V3 = mm128_shuflr32_8( _mm_xor_si128( V3, V0 ) ); \
   V2 = _mm_add_epi32( V2, V3 ); \
   V1 = mm128_ror_32( _mm_xor_si128( V1, V2 ), 7 ); \
-   V3 = mm128_shuflr_32( V3 ); \
-   V2 = mm128_swap_64( V2 ); \
-   V1 = mm128_shufll_32( V1 ); \
+   V0 = mm128_shuflr_32( V0 ); \
+   V3 = mm128_swap_64( V3 ); \
+   V2 = mm128_shufll_32( V2 ); \
 }

+// Default is 14 rounds, blakecoin & vanilla are 8.
 void blake256_transform_le( uint32_t *H, const uint32_t *buf,
-                            const uint32_t T0, const uint32_t T1 )
+                            const uint32_t T0, const uint32_t T1, int rounds )
 {
   __m128i V0, V1, V2, V3;
   uint32_t M0, M1, M2, M3, M4, M5, M6, M7, M8, M9, MA, MB, MC, MD, ME, MF;
@@ -385,12 +352,15 @@ void blake256_transform_le( uint32_t *H, const uint32_t *buf,
   BLAKE256_ROUND( 5 );
   BLAKE256_ROUND( 6 );
   BLAKE256_ROUND( 7 );
-   BLAKE256_ROUND( 8 );
-   BLAKE256_ROUND( 9 );
-   BLAKE256_ROUND( 0 );
-   BLAKE256_ROUND( 1 );
-   BLAKE256_ROUND( 2 );
-   BLAKE256_ROUND( 3 );
+   if ( rounds > 8 )     // 14
+   {
+      BLAKE256_ROUND( 8 );
+      BLAKE256_ROUND( 9 );
+      BLAKE256_ROUND( 0 );
+      BLAKE256_ROUND( 1 );
+      BLAKE256_ROUND( 2 );
+      BLAKE256_ROUND( 3 );
+   }
   casti_m128i( H, 0 ) = mm128_xor3( casti_m128i( H, 0 ), V0, V2 );
   casti_m128i( H, 1 ) = mm128_xor3( casti_m128i( H, 1 ), V1, V3 );
 }
@@ -413,34 +383,6 @@ void blake256_transform_le( uint32_t *H, const uint32_t *buf,
   b = mm128_ror_32( _mm_xor_si128( b, c ), 7 ); \
 }

-#if SPH_COMPACT_BLAKE_32
-
-// Not used
-#if 0
-
-#define ROUND_S_4WAY(r)   do { \
-	GS_4WAY(M[sigma[r][0x0]], M[sigma[r][0x1]], \
-		CS[sigma[r][0x0]], CS[sigma[r][0x1]], V0, V4, V8, VC); \
-	GS_4WAY(M[sigma[r][0x2]], M[sigma[r][0x3]], \
-		CS[sigma[r][0x2]], CS[sigma[r][0x3]], V1, V5, V9, VD); \
-	GS_4WAY(M[sigma[r][0x4]], M[sigma[r][0x5]], \
-		CS[sigma[r][0x4]], CS[sigma[r][0x5]], V2, V6, VA, VE); \
-	GS_4WAY(M[sigma[r][0x6]], M[sigma[r][0x7]], \
-		CS[sigma[r][0x6]], CS[sigma[r][0x7]], V3, V7, VB, VF); \
-	GS_4WAY(M[sigma[r][0x8]], M[sigma[r][0x9]], \
-		CS[sigma[r][0x8]], CS[sigma[r][0x9]], V0, V5, VA, VF); \
-	GS_4WAY(M[sigma[r][0xA]], M[sigma[r][0xB]], \
-		CS[sigma[r][0xA]], CS[sigma[r][0xB]], V1, V6, VB, VC); \
-	GS_4WAY(M[sigma[r][0xC]], M[sigma[r][0xD]], \
-		CS[sigma[r][0xC]], CS[sigma[r][0xD]], V2, V7, V8, VD); \
-	GS_4WAY(M[sigma[r][0xE]], M[sigma[r][0xF]], \
-		CS[sigma[r][0xE]], CS[sigma[r][0xF]], V3, V4, V9, VE); \
-} while (0)
-
-#endif
-
-#else
-
 #define ROUND_S_4WAY(r) \
 { \
 	GS_4WAY(Mx(r, 0), Mx(r, 1), CSx(r, 0), CSx(r, 1), V0, V4, V8, VC); \
@@ -453,8 +395,6 @@ void blake256_transform_le( uint32_t *H, const uint32_t *buf,
 	GS_4WAY(Mx(r, E), Mx(r, F), CSx(r, E), CSx(r, F), V3, V4, V9, VE); \
 }

-#endif
-
 #define DECL_STATE32_4WAY \
 	__m128i H0, H1, H2, H3, H4, H5, H6, H7; \
        uint32_t T0, T1;
@@ -485,56 +425,6 @@ void blake256_transform_le( uint32_t *H, const uint32_t *buf,
 		(state)->T1 = T1; \
 	} while (0)

-#if SPH_COMPACT_BLAKE_32
-// not used
-#if 0
-#define COMPRESS32_4WAY( rounds )   do { \
-	__m128i M[16]; \
-	__m128i V0, V1, V2, V3, V4, V5, V6, V7; \
-	__m128i V8, V9, VA, VB, VC, VD, VE, VF; \
-	unsigned r; \
-	V0 = H0; \
-	V1 = H1; \
-	V2 = H2; \
-	V3 = H3; \
-	V4 = H4; \
-	V5 = H5; \
-	V6 = H6; \
-	V7 = H7; \
-   V8 = _mm_xor_si128( S0, _mm_set1_epi32( CS0 ) ); \
-   V9 = _mm_xor_si128( S1, _mm_set1_epi32( CS1 ) ); \
-   VA = _mm_xor_si128( S2, _mm_set1_epi32( CS2 ) ); \
-   VB = _mm_xor_si128( S3, _mm_set1_epi32( CS3 ) ); \
-   VC = _mm_xor_si128( _mm_set1_epi32( T0 ), _mm_set1_epi32( CS4 ) ); \
-   VD = _mm_xor_si128( _mm_set1_epi32( T0 ), _mm_set1_epi32( CS5 ) ); \
-   VE = _mm_xor_si128( _mm_set1_epi32( T1 ), _mm_set1_epi32( CS6 ) ); \
-   VF = _mm_xor_si128( _mm_set1_epi32( T1 ), _mm_set1_epi32( CS7 ) ); \
-   mm128_block_bswap_32( M, buf ); \
-   mm128_block_bswap_32( M+8, buf+8 ); \
-	for (r = 0; r < rounds; r ++) \
-		ROUND_S_4WAY(r); \
-        H0 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S0, V0 ), V8 ), H0 ); \
-        H1 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S1, V1 ), V9 ), H1 ); \
-        H2 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S2, V2 ), VA ), H2 ); \
-        H3 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S3, V3 ), VB ), H3 ); \
-        H4 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S0, V4 ), VC ), H4 ); \
-        H5 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S1, V5 ), VD ), H5 ); \
-        H6 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S2, V6 ), VE ), H6 ); \
-        H7 = _mm_xor_si128( _mm_xor_si128( \
-                                   _mm_xor_si128( S3, V7 ), VF ), H7 ); \
-	} while (0)
-#endif
-
-#else
-
-// current impl

 #if defined(__SSSE3__)

@@ -634,8 +524,6 @@ void blake256_transform_le( uint32_t *H, const uint32_t *buf,
   H7 = _mm_xor_si128( _mm_xor_si128( VF, V7 ), H7 ); \
 }

-#endif
-
 #if defined (__AVX2__)

 /////////////////////////////////
@@ -922,7 +810,7 @@ void blake256_transform_le( uint32_t *H, const uint32_t *buf,

 #define DECL_STATE32_8WAY \
   __m256i H0, H1, H2, H3, H4, H5, H6, H7; \
-   sph_u32 T0, T1;
+   uint32_t T0, T1;

 #define READ_STATE32_8WAY(state) \
 do { \
@@ -1000,7 +888,7 @@ do { \
   ROUND_S_8WAY(5); \
   ROUND_S_8WAY(6); \
   ROUND_S_8WAY(7); \
-   if (rounds == 14) \
+   if (rounds > 8) \
   { \
      ROUND_S_8WAY(8); \
      ROUND_S_8WAY(9); \
@@ -1065,7 +953,7 @@ do { \
   ROUND_S_8WAY(5); \
   ROUND_S_8WAY(6); \
   ROUND_S_8WAY(7); \
-   if (rounds == 14) \
+   if (rounds > 8) \
   { \
      ROUND_S_8WAY(8); \
      ROUND_S_8WAY(9); \
@@ -1110,7 +998,7 @@ void blake256_8way_round0_prehash_le( void *midstate, const void *midhash,

 // M[ 0:3 ] contain new message data including unique nonces in M[ 3].
 // M[ 5:12, 14 ] are always zero and not needed or used.
-// M[ 4], M[ 13], M[15] are constant and are initialized here.
+// M[ 4], M[13], M[15] are constant and are initialized here.
 // M[ 5] is a special case, used as a cache for (M[13] ^ CSC).

   M[ 4] = _mm256_set1_epi32( 0x80000000 );
@@ -1175,7 +1063,7 @@ void blake256_8way_round0_prehash_le( void *midstate, const void *midhash,
 }

 void blake256_8way_final_rounds_le( void *final_hash, const void *midstate,
-                                     const void *midhash, const void *data )
+                     const void *midhash, const void *data, const int rounds )
 {
   __m256i *H = (__m256i*)final_hash;
   const __m256i *h = (const __m256i*)midhash;
@@ -1269,12 +1157,15 @@ void blake256_8way_final_rounds_le( void *final_hash, const void *midstate,
   ROUND256_8WAY_5;
   ROUND256_8WAY_6;
   ROUND256_8WAY_7;
-   ROUND256_8WAY_8;
-   ROUND256_8WAY_9;
-   ROUND256_8WAY_0;
-   ROUND256_8WAY_1;
-   ROUND256_8WAY_2;
-   ROUND256_8WAY_3;
+   if ( rounds > 8 )
+   {
+      ROUND256_8WAY_8;
+      ROUND256_8WAY_9;
+      ROUND256_8WAY_0;
+      ROUND256_8WAY_1;
+      ROUND256_8WAY_2;
+      ROUND256_8WAY_3;
+   }

   const __m256i shuf_bswap32 =
                  mm256_set2_64( 0x0c0d0e0f08090a0b, 0x0405060700010203 );
@@ -1577,7 +1468,7 @@ void blake256_8way_final_rounds_le( void *final_hash, const void *midstate,

 #define DECL_STATE32_16WAY \
   __m512i H0, H1, H2, H3, H4, H5, H6, H7; \
-   sph_u32 T0, T1;
+   uint32_t T0, T1;

 #define READ_STATE32_16WAY(state) \
 do { \
@@ -1836,8 +1727,9 @@ void blake256_16way_round0_prehash_le( void *midstate, const void *midhash,
                         _mm512_xor_si512( _mm512_set1_epi32( CSE ), M[15] ) );
 }

+// Dfault is 14 rounds, blakecoin & vanilla are 8.
 void blake256_16way_final_rounds_le( void *final_hash, const void *midstate,
-                                     const void *midhash, const void *data )
+                     const void *midhash, const void *data, const int rounds )
 {
   __m512i *H = (__m512i*)final_hash;
   const __m512i *h = (const __m512i*)midhash;
@@ -1942,12 +1834,15 @@ void blake256_16way_final_rounds_le( void *final_hash, const void *midstate,
   ROUND256_16WAY_5;
   ROUND256_16WAY_6;
   ROUND256_16WAY_7;
-   ROUND256_16WAY_8;
-   ROUND256_16WAY_9;
-   ROUND256_16WAY_0;
-   ROUND256_16WAY_1;
-   ROUND256_16WAY_2;
-   ROUND256_16WAY_3;
+   if ( rounds > 8 )
+   {
+      ROUND256_16WAY_8;
+      ROUND256_16WAY_9;
+      ROUND256_16WAY_0;
+      ROUND256_16WAY_1;
+      ROUND256_16WAY_2;
+      ROUND256_16WAY_3;
+   }

   // Byte swap final hash
   const __m512i shuf_bswap32 =
@@ -2011,7 +1906,7 @@ blake32_4way( blake_4way_small_context *ctx, const void *data,
      size_t clen = ( sizeof ctx->buf ) - bptr;

      if ( clen > blen )
-	 clen = blen;
+         clen = blen;
      memcpy( buf + vptr, data, clen );
      bptr += clen;
      data = (const unsigned char *)data + clen;
@@ -2084,11 +1979,11 @@ blake32_4way_close( blake_4way_small_context *ctx, unsigned ub, unsigned n,

 // Blake-256 8 way

-static const sph_u32 salt_zero_8way_small[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+static const uint32_t salt_zero_8way_small[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

 static void
-blake32_8way_init( blake_8way_small_context *sc, const sph_u32 *iv,
-                   const sph_u32 *salt, int rounds )
+blake32_8way_init( blake_8way_small_context *sc, const uint32_t *iv,
+                   const uint32_t *salt, int rounds )
 {
   casti_m256i( sc->H, 0 ) = _mm256_set1_epi64x( 0x6A09E6676A09E667 );
   casti_m256i( sc->H, 1 ) = _mm256_set1_epi64x( 0xBB67AE85BB67AE85 );
@@ -2135,8 +2030,8 @@ blake32_8way( blake_8way_small_context *sc, const void *data, size_t len )
      len -= clen;
      if ( ptr == buf_size )
      {
-          if ( ( T0 = SPH_T32(T0 + 512) ) < 512 )
-                T1 = SPH_T32(T1 + 1);
+          if ( ( T0 = T0 + 512 ) < 512 )
+                T1 = T1 + 1;
          COMPRESS32_8WAY( sc->rounds );
          ptr = 0;
      }
@@ -2152,7 +2047,7 @@ blake32_8way_close( blake_8way_small_context *sc, unsigned ub, unsigned n,
   __m256i buf[16];
   size_t ptr;
   unsigned bit_len;
-   sph_u32 th, tl;
+   uint32_t th, tl;

   ptr = sc->ptr;
   bit_len = ((unsigned)ptr << 3);
@@ -2162,13 +2057,13 @@ blake32_8way_close( blake_8way_small_context *sc, unsigned ub, unsigned n,

   if ( ptr == 0 )
   {
-        sc->T0 = SPH_C32(0xFFFFFE00UL);
-        sc->T1 = SPH_C32(0xFFFFFFFFUL);
+        sc->T0 = 0xFFFFFE00UL;
+        sc->T1 = 0xFFFFFFFFUL;
   }
   else if ( sc->T0 == 0 )
   {
-        sc->T0 = SPH_C32(0xFFFFFE00UL) + bit_len;
-        sc->T1 = SPH_T32(sc->T1 - 1);
+        sc->T0 = 0xFFFFFE00UL + bit_len;
+        sc->T1 = sc->T1 - 1;
   }
   else
        sc->T0 -= 512 - bit_len;
@@ -2187,8 +2082,8 @@ blake32_8way_close( blake_8way_small_context *sc, unsigned ub, unsigned n,
   {
       memset_zero_256( buf + (ptr>>2) + 1, (60-ptr) >> 2 );
       blake32_8way( sc, buf + (ptr>>2), 64 - ptr );
-       sc->T0 = SPH_C32(0xFFFFFE00UL);
-       sc->T1 = SPH_C32(0xFFFFFFFFUL);
+       sc->T0 = 0xFFFFFE00UL;
+       sc->T1 = 0xFFFFFFFFUL;
       memset_zero_256( buf, 56>>2 );
       if ( out_size_w32 == 8 )
           buf[52>>2] = _mm256_set1_epi64x( 0x0100000001000000ULL );
@@ -2231,8 +2126,8 @@ blake32_8way_le( blake_8way_small_context *sc, const void *data, size_t len )
      len -= clen;
      if ( ptr == buf_size )
      {
-          if ( ( T0 = SPH_T32(T0 + 512) ) < 512 )
-                T1 = SPH_T32(T1 + 1);
+          if ( ( T0 = T0 + 512 ) < 512 )
+                T1 = T1 + 1;
          COMPRESS32_8WAY_LE( sc->rounds );
          ptr = 0;
      }
@@ -2248,7 +2143,7 @@ blake32_8way_close_le( blake_8way_small_context *sc, unsigned ub, unsigned n,
   __m256i buf[16];
   size_t ptr;
   unsigned bit_len;
-   sph_u32 th, tl;
+   uint32_t th, tl;

   ptr = sc->ptr;
   bit_len = ((unsigned)ptr << 3);
@@ -2258,13 +2153,13 @@ blake32_8way_close_le( blake_8way_small_context *sc, unsigned ub, unsigned n,

   if ( ptr == 0 )
   {
-        sc->T0 = SPH_C32(0xFFFFFE00UL);
-        sc->T1 = SPH_C32(0xFFFFFFFFUL);
+        sc->T0 = 0xFFFFFE00UL;
+        sc->T1 = 0xFFFFFFFFUL;
   }
   else if ( sc->T0 == 0 )
   {
-        sc->T0 = SPH_C32(0xFFFFFE00UL) + bit_len;
-        sc->T1 = SPH_T32(sc->T1 - 1);
+        sc->T0 = 0xFFFFFE00UL + bit_len;
+        sc->T1 = sc->T1 - 1;
   }
   else
        sc->T0 -= 512 - bit_len;
@@ -2282,8 +2177,8 @@ blake32_8way_close_le( blake_8way_small_context *sc, unsigned ub, unsigned n,
   {
       memset_zero_256( buf + (ptr>>2) + 1, (60-ptr) >> 2 );
       blake32_8way_le( sc, buf + (ptr>>2), 64 - ptr );
-       sc->T0 = SPH_C32(0xFFFFFE00UL);
-       sc->T1 = SPH_C32(0xFFFFFFFFUL);
+       sc->T0 = 0xFFFFFE00UL;
+       sc->T1 = 0xFFFFFFFFUL;
       memset_zero_256( buf, 56>>2 );
       if ( out_size_w32 == 8 )
           buf[52>>2] = m256_one_32;
@@ -2302,8 +2197,8 @@ blake32_8way_close_le( blake_8way_small_context *sc, unsigned ub, unsigned n,
 //Blake-256 16 way AVX512

 static void
-blake32_16way_init( blake_16way_small_context *sc, const sph_u32 *iv,
-                   const sph_u32 *salt, int rounds )
+blake32_16way_init( blake_16way_small_context *sc, const uint32_t *iv,
+                   const uint32_t *salt, int rounds )
 {
   casti_m512i( sc->H, 0 ) = _mm512_set1_epi64( 0x6A09E6676A09E667 );
   casti_m512i( sc->H, 1 ) = _mm512_set1_epi64( 0xBB67AE85BB67AE85 );
@@ -2365,7 +2260,7 @@ blake32_16way_close( blake_16way_small_context *sc, unsigned ub, unsigned n,
   __m512i buf[16];
   size_t ptr;
   unsigned bit_len;
-   sph_u32 th, tl;
+   uint32_t th, tl;

   ptr = sc->ptr;
   bit_len = ((unsigned)ptr << 3);
@@ -2462,7 +2357,7 @@ blake32_16way_close_le( blake_16way_small_context *sc, unsigned ub, unsigned n,
   __m512i buf[16];
   size_t ptr;
   unsigned bit_len;
-   sph_u32 th, tl;
+   uint32_t th, tl;

   ptr = sc->ptr;
   bit_len = ((unsigned)ptr << 3);
@@ -2572,8 +2467,6 @@ blake256r8_16way_close(void *cc, void *dst)

 #endif // AVX512

-
-
 // Blake-256 4 way

 // default 14 rounds, backward copatibility
@@ -2708,9 +2601,3 @@ blake256r8_8way_close(void *cc, void *dst)
 }

 #endif
-
-#ifdef __cplusplus
-}
-#endif
-
-//#endif
--- a/algo/blake/blake2b-hash-4way.c
+++ b/algo/blake/blake2b-hash-4way.c
@@ -252,14 +252,14 @@ static void blake2b_8way_compress( blake2b_8way_ctx *ctx, int last )
   v[ 5] = ctx->h[5];
   v[ 6] = ctx->h[6];
   v[ 7] = ctx->h[7];
-   v[ 8] = m512_const1_64( 0x6A09E667F3BCC908 );
-   v[ 9] = m512_const1_64( 0xBB67AE8584CAA73B );
-   v[10] = m512_const1_64( 0x3C6EF372FE94F82B );
-   v[11] = m512_const1_64( 0xA54FF53A5F1D36F1 );
-   v[12] = m512_const1_64( 0x510E527FADE682D1 );
-   v[13] = m512_const1_64( 0x9B05688C2B3E6C1F );
-   v[14] = m512_const1_64( 0x1F83D9ABFB41BD6B );
-   v[15] = m512_const1_64( 0x5BE0CD19137E2179 );
+   v[ 8] = _mm512_set1_epi64( 0x6A09E667F3BCC908 );
+   v[ 9] = _mm512_set1_epi64( 0xBB67AE8584CAA73B );
+   v[10] = _mm512_set1_epi64( 0x3C6EF372FE94F82B );
+   v[11] = _mm512_set1_epi64( 0xA54FF53A5F1D36F1 );
+   v[12] = _mm512_set1_epi64( 0x510E527FADE682D1 );
+   v[13] = _mm512_set1_epi64( 0x9B05688C2B3E6C1F );
+   v[14] = _mm512_set1_epi64( 0x1F83D9ABFB41BD6B );
+   v[15] = _mm512_set1_epi64( 0x5BE0CD19137E2179 );

   v[12] = _mm512_xor_si512( v[12], _mm512_set1_epi64( ctx->t[0] ) );
   v[13] = _mm512_xor_si512( v[13], _mm512_set1_epi64( ctx->t[1] ) );
@@ -310,16 +310,16 @@ int blake2b_8way_init( blake2b_8way_ctx *ctx )
 {
   size_t i;

-   ctx->h[0] = m512_const1_64( 0x6A09E667F3BCC908 );
-   ctx->h[1] = m512_const1_64( 0xBB67AE8584CAA73B );
-   ctx->h[2] = m512_const1_64( 0x3C6EF372FE94F82B );
-   ctx->h[3] = m512_const1_64( 0xA54FF53A5F1D36F1 );
-   ctx->h[4] = m512_const1_64( 0x510E527FADE682D1 );
-   ctx->h[5] = m512_const1_64( 0x9B05688C2B3E6C1F );
-   ctx->h[6] = m512_const1_64( 0x1F83D9ABFB41BD6B );
-   ctx->h[7] = m512_const1_64( 0x5BE0CD19137E2179 );
+   ctx->h[0] = _mm512_set1_epi64( 0x6A09E667F3BCC908 );
+   ctx->h[1] = _mm512_set1_epi64( 0xBB67AE8584CAA73B );
+   ctx->h[2] = _mm512_set1_epi64( 0x3C6EF372FE94F82B );
+   ctx->h[3] = _mm512_set1_epi64( 0xA54FF53A5F1D36F1 );
+   ctx->h[4] = _mm512_set1_epi64( 0x510E527FADE682D1 );
+   ctx->h[5] = _mm512_set1_epi64( 0x9B05688C2B3E6C1F );
+   ctx->h[6] = _mm512_set1_epi64( 0x1F83D9ABFB41BD6B );
+   ctx->h[7] = _mm512_set1_epi64( 0x5BE0CD19137E2179 );

-   ctx->h[0] = _mm512_xor_si512( ctx->h[0], m512_const1_64( 0x01010020 ) );
+   ctx->h[0] = _mm512_xor_si512( ctx->h[0], _mm512_set1_epi64( 0x01010020 ) );

   ctx->t[0] = 0;
   ctx->t[1] = 0;
@@ -419,14 +419,14 @@ static void blake2b_4way_compress( blake2b_4way_ctx *ctx, int last )
   v[ 5] = ctx->h[5];
   v[ 6] = ctx->h[6];
   v[ 7] = ctx->h[7];
-   v[ 8] = m256_const1_64( 0x6A09E667F3BCC908 );
-   v[ 9] = m256_const1_64( 0xBB67AE8584CAA73B );
-   v[10] = m256_const1_64( 0x3C6EF372FE94F82B );
-   v[11] = m256_const1_64( 0xA54FF53A5F1D36F1 );
-   v[12] = m256_const1_64( 0x510E527FADE682D1 );
-   v[13] = m256_const1_64( 0x9B05688C2B3E6C1F );
-   v[14] = m256_const1_64( 0x1F83D9ABFB41BD6B );
-   v[15] = m256_const1_64( 0x5BE0CD19137E2179 );
+   v[ 8] = _mm256_set1_epi64x( 0x6A09E667F3BCC908 );
+   v[ 9] = _mm256_set1_epi64x( 0xBB67AE8584CAA73B );
+   v[10] = _mm256_set1_epi64x( 0x3C6EF372FE94F82B );
+   v[11] = _mm256_set1_epi64x( 0xA54FF53A5F1D36F1 );
+   v[12] = _mm256_set1_epi64x( 0x510E527FADE682D1 );
+   v[13] = _mm256_set1_epi64x( 0x9B05688C2B3E6C1F );
+   v[14] = _mm256_set1_epi64x( 0x1F83D9ABFB41BD6B );
+   v[15] = _mm256_set1_epi64x( 0x5BE0CD19137E2179 );

   v[12] = _mm256_xor_si256( v[12], _mm256_set1_epi64x( ctx->t[0] ) );
   v[13] = _mm256_xor_si256( v[13], _mm256_set1_epi64x( ctx->t[1] ) );
@@ -477,16 +477,16 @@ int blake2b_4way_init( blake2b_4way_ctx *ctx )
 {
 	size_t i;

-   ctx->h[0] = m256_const1_64( 0x6A09E667F3BCC908 );
-   ctx->h[1] = m256_const1_64( 0xBB67AE8584CAA73B );
-   ctx->h[2] = m256_const1_64( 0x3C6EF372FE94F82B );
-   ctx->h[3] = m256_const1_64( 0xA54FF53A5F1D36F1 );
-   ctx->h[4] = m256_const1_64( 0x510E527FADE682D1 );
-   ctx->h[5] = m256_const1_64( 0x9B05688C2B3E6C1F );
-   ctx->h[6] = m256_const1_64( 0x1F83D9ABFB41BD6B );
-   ctx->h[7] = m256_const1_64( 0x5BE0CD19137E2179 );
+   ctx->h[0] = _mm256_set1_epi64x( 0x6A09E667F3BCC908 );
+   ctx->h[1] = _mm256_set1_epi64x( 0xBB67AE8584CAA73B );
+   ctx->h[2] = _mm256_set1_epi64x( 0x3C6EF372FE94F82B );
+   ctx->h[3] = _mm256_set1_epi64x( 0xA54FF53A5F1D36F1 );
+   ctx->h[4] = _mm256_set1_epi64x( 0x510E527FADE682D1 );
+   ctx->h[5] = _mm256_set1_epi64x( 0x9B05688C2B3E6C1F );
+   ctx->h[6] = _mm256_set1_epi64x( 0x1F83D9ABFB41BD6B );
+   ctx->h[7] = _mm256_set1_epi64x( 0x5BE0CD19137E2179 );

-   ctx->h[0] = _mm256_xor_si256( ctx->h[0], m256_const1_64( 0x01010020 ) );
+   ctx->h[0] = _mm256_xor_si256( ctx->h[0], _mm256_set1_epi64x( 0x01010020 ) );

 	ctx->t[0] = 0;
 	ctx->t[1] = 0;
--- a/algo/blake/blake2s-hash-4way.c
+++ b/algo/blake/blake2s-hash-4way.c
@@ -62,14 +62,14 @@ int blake2s_4way_init( blake2s_4way_state *S, const uint8_t outlen )

   memset( S, 0, sizeof( blake2s_4way_state ) );

-   S->h[0] = m128_const1_64( 0x6A09E6676A09E667ULL );
-   S->h[1] = m128_const1_64( 0xBB67AE85BB67AE85ULL );
-   S->h[2] = m128_const1_64( 0x3C6EF3723C6EF372ULL );
-   S->h[3] = m128_const1_64( 0xA54FF53AA54FF53AULL );
-   S->h[4] = m128_const1_64( 0x510E527F510E527FULL );
-   S->h[5] = m128_const1_64( 0x9B05688C9B05688CULL );
-   S->h[6] = m128_const1_64( 0x1F83D9AB1F83D9ABULL );
-   S->h[7] = m128_const1_64( 0x5BE0CD195BE0CD19ULL );
+   S->h[0] = _mm_set1_epi64x( 0x6A09E6676A09E667ULL );
+   S->h[1] = _mm_set1_epi64x( 0xBB67AE85BB67AE85ULL );
+   S->h[2] = _mm_set1_epi64x( 0x3C6EF3723C6EF372ULL );
+   S->h[3] = _mm_set1_epi64x( 0xA54FF53AA54FF53AULL );
+   S->h[4] = _mm_set1_epi64x( 0x510E527F510E527FULL );
+   S->h[5] = _mm_set1_epi64x( 0x9B05688C9B05688CULL );
+   S->h[6] = _mm_set1_epi64x( 0x1F83D9AB1F83D9ABULL );
+   S->h[7] = _mm_set1_epi64x( 0x5BE0CD195BE0CD19ULL );
   
 //   for( int i = 0; i < 8; ++i )
 //      S->h[i] = _mm_set1_epi32( blake2s_IV[i] );
@@ -90,18 +90,18 @@ int blake2s_4way_compress( blake2s_4way_state *S, const __m128i* block )
   memcpy_128( m, block, 16 );
   memcpy_128( v, S->h, 8 );

-   v[ 8] = m128_const1_64( 0x6A09E6676A09E667ULL );
-   v[ 9] = m128_const1_64( 0xBB67AE85BB67AE85ULL );
-   v[10] = m128_const1_64( 0x3C6EF3723C6EF372ULL );
-   v[11] = m128_const1_64( 0xA54FF53AA54FF53AULL );
+   v[ 8] = _mm_set1_epi64x( 0x6A09E6676A09E667ULL );
+   v[ 9] = _mm_set1_epi64x( 0xBB67AE85BB67AE85ULL );
+   v[10] = _mm_set1_epi64x( 0x3C6EF3723C6EF372ULL );
+   v[11] = _mm_set1_epi64x( 0xA54FF53AA54FF53AULL );
   v[12] = _mm_xor_si128( _mm_set1_epi32( S->t[0] ),
-                          m128_const1_64( 0x510E527F510E527FULL ) );
+                          _mm_set1_epi64x( 0x510E527F510E527FULL ) );
   v[13] = _mm_xor_si128( _mm_set1_epi32( S->t[1] ),
-                          m128_const1_64( 0x9B05688C9B05688CULL ) );
+                          _mm_set1_epi64x( 0x9B05688C9B05688CULL ) );
   v[14] = _mm_xor_si128( _mm_set1_epi32( S->f[0] ),
-                          m128_const1_64( 0x1F83D9AB1F83D9ABULL ) );
+                          _mm_set1_epi64x( 0x1F83D9AB1F83D9ABULL ) );
   v[15] = _mm_xor_si128( _mm_set1_epi32( S->f[1] ),
-                          m128_const1_64( 0x5BE0CD195BE0CD19ULL ) );
+                          _mm_set1_epi64x( 0x5BE0CD195BE0CD19ULL ) );

 #define G4W( sigma0, sigma1, a, b, c, d ) \
 do { \
@@ -269,21 +269,21 @@ int blake2s_8way_compress( blake2s_8way_state *S, const __m256i *block )
   memcpy_256( m, block, 16 );
   memcpy_256( v, S->h, 8 );

-   v[ 8] = m256_const1_64( 0x6A09E6676A09E667ULL );
-   v[ 9] = m256_const1_64( 0xBB67AE85BB67AE85ULL );
-   v[10] = m256_const1_64( 0x3C6EF3723C6EF372ULL );
-   v[11] = m256_const1_64( 0xA54FF53AA54FF53AULL );
+   v[ 8] = _mm256_set1_epi64x( 0x6A09E6676A09E667ULL );
+   v[ 9] = _mm256_set1_epi64x( 0xBB67AE85BB67AE85ULL );
+   v[10] = _mm256_set1_epi64x( 0x3C6EF3723C6EF372ULL );
+   v[11] = _mm256_set1_epi64x( 0xA54FF53AA54FF53AULL );
   v[12] = _mm256_xor_si256( _mm256_set1_epi32( S->t[0] ),
-                          m256_const1_64( 0x510E527F510E527FULL ) );
+                          _mm256_set1_epi64x( 0x510E527F510E527FULL ) );

   v[13] = _mm256_xor_si256( _mm256_set1_epi32( S->t[1] ),
-                          m256_const1_64( 0x9B05688C9B05688CULL ) );
+                          _mm256_set1_epi64x( 0x9B05688C9B05688CULL ) );

   v[14] = _mm256_xor_si256( _mm256_set1_epi32( S->f[0] ),
-                          m256_const1_64( 0x1F83D9AB1F83D9ABULL ) );
+                          _mm256_set1_epi64x( 0x1F83D9AB1F83D9ABULL ) );

   v[15] = _mm256_xor_si256( _mm256_set1_epi32( S->f[1] ),
-                          m256_const1_64( 0x5BE0CD195BE0CD19ULL ) );
+                          _mm256_set1_epi64x( 0x5BE0CD195BE0CD19ULL ) );

 /*
   v[ 8] = _mm256_set1_epi32( blake2s_IV[0] );
@@ -391,14 +391,14 @@ int blake2s_8way_init( blake2s_8way_state *S, const uint8_t outlen )
   memset( P->personal, 0, sizeof( P->personal ) );

   memset( S, 0, sizeof( blake2s_8way_state ) );
-   S->h[0] = m256_const1_64( 0x6A09E6676A09E667ULL );
-   S->h[1] = m256_const1_64( 0xBB67AE85BB67AE85ULL );
-   S->h[2] = m256_const1_64( 0x3C6EF3723C6EF372ULL );
-   S->h[3] = m256_const1_64( 0xA54FF53AA54FF53AULL );
-   S->h[4] = m256_const1_64( 0x510E527F510E527FULL );
-   S->h[5] = m256_const1_64( 0x9B05688C9B05688CULL );
-   S->h[6] = m256_const1_64( 0x1F83D9AB1F83D9ABULL );
-   S->h[7] = m256_const1_64( 0x5BE0CD195BE0CD19ULL );
+   S->h[0] = _mm256_set1_epi64x( 0x6A09E6676A09E667ULL );
+   S->h[1] = _mm256_set1_epi64x( 0xBB67AE85BB67AE85ULL );
+   S->h[2] = _mm256_set1_epi64x( 0x3C6EF3723C6EF372ULL );
+   S->h[3] = _mm256_set1_epi64x( 0xA54FF53AA54FF53AULL );
+   S->h[4] = _mm256_set1_epi64x( 0x510E527F510E527FULL );
+   S->h[5] = _mm256_set1_epi64x( 0x9B05688C9B05688CULL );
+   S->h[6] = _mm256_set1_epi64x( 0x1F83D9AB1F83D9ABULL );
+   S->h[7] = _mm256_set1_epi64x( 0x5BE0CD195BE0CD19ULL );


 //   for( int i = 0; i < 8; ++i )
@@ -510,21 +510,21 @@ int blake2s_16way_compress( blake2s_16way_state *S, const __m512i *block )
   memcpy_512( m, block, 16 );
   memcpy_512( v, S->h, 8 );

-   v[ 8] = m512_const1_64( 0x6A09E6676A09E667ULL );
-   v[ 9] = m512_const1_64( 0xBB67AE85BB67AE85ULL );
-   v[10] = m512_const1_64( 0x3C6EF3723C6EF372ULL );
-   v[11] = m512_const1_64( 0xA54FF53AA54FF53AULL );
+   v[ 8] = _mm512_set1_epi64( 0x6A09E6676A09E667ULL );
+   v[ 9] = _mm512_set1_epi64( 0xBB67AE85BB67AE85ULL );
+   v[10] = _mm512_set1_epi64( 0x3C6EF3723C6EF372ULL );
+   v[11] = _mm512_set1_epi64( 0xA54FF53AA54FF53AULL );
   v[12] = _mm512_xor_si512( _mm512_set1_epi32( S->t[0] ),
-                          m512_const1_64( 0x510E527F510E527FULL ) );
+                          _mm512_set1_epi64( 0x510E527F510E527FULL ) );

   v[13] = _mm512_xor_si512( _mm512_set1_epi32( S->t[1] ),
-                          m512_const1_64( 0x9B05688C9B05688CULL ) );
+                          _mm512_set1_epi64( 0x9B05688C9B05688CULL ) );

   v[14] = _mm512_xor_si512( _mm512_set1_epi32( S->f[0] ),
-                          m512_const1_64( 0x1F83D9AB1F83D9ABULL ) );
+                          _mm512_set1_epi64( 0x1F83D9AB1F83D9ABULL ) );

   v[15] = _mm512_xor_si512( _mm512_set1_epi32( S->f[1] ),
-                          m512_const1_64( 0x5BE0CD195BE0CD19ULL ) );
+                          _mm512_set1_epi64( 0x5BE0CD195BE0CD19ULL ) );


 #define G16W( sigma0, sigma1, a, b, c, d) \
@@ -589,14 +589,14 @@ int blake2s_16way_init( blake2s_16way_state *S, const uint8_t outlen )
   memset( P->personal, 0, sizeof( P->personal ) );

   memset( S, 0, sizeof( blake2s_16way_state ) );
-   S->h[0] = m512_const1_64( 0x6A09E6676A09E667ULL );
-   S->h[1] = m512_const1_64( 0xBB67AE85BB67AE85ULL );
-   S->h[2] = m512_const1_64( 0x3C6EF3723C6EF372ULL );
-   S->h[3] = m512_const1_64( 0xA54FF53AA54FF53AULL );
-   S->h[4] = m512_const1_64( 0x510E527F510E527FULL );
-   S->h[5] = m512_const1_64( 0x9B05688C9B05688CULL );
-   S->h[6] = m512_const1_64( 0x1F83D9AB1F83D9ABULL );
-   S->h[7] = m512_const1_64( 0x5BE0CD195BE0CD19ULL );
+   S->h[0] = _mm512_set1_epi64( 0x6A09E6676A09E667ULL );
+   S->h[1] = _mm512_set1_epi64( 0xBB67AE85BB67AE85ULL );
+   S->h[2] = _mm512_set1_epi64( 0x3C6EF3723C6EF372ULL );
+   S->h[3] = _mm512_set1_epi64( 0xA54FF53AA54FF53AULL );
+   S->h[4] = _mm512_set1_epi64( 0x510E527F510E527FULL );
+   S->h[5] = _mm512_set1_epi64( 0x9B05688C9B05688CULL );
+   S->h[6] = _mm512_set1_epi64( 0x1F83D9AB1F83D9ABULL );
+   S->h[7] = _mm512_set1_epi64( 0x5BE0CD195BE0CD19ULL );

   uint32_t *p = ( uint32_t * )( P );

--- a/algo/blake/blake512-hash-4way.c
+++ b/algo/blake/blake512-hash-4way.c
@@ -1,62 +1,22 @@
-/* $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>
- */
-
 #if defined (__AVX2__)

 #include <stddef.h>
 #include <string.h>
 #include <limits.h>
-
 #include "blake-hash-4way.h"

-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#ifdef _MSC_VER
-#pragma warning (disable: 4146)
-#endif
-
 // Blake-512 common
   
 /*
-static const sph_u64 IV512[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)
+static const uint64_t IV512[8] =
+{
+  0x6A09E667F3BCC908, 0xBB67AE8584CAA73B,
+  0x3C6EF372FE94F82B, 0xA54FF53A5F1D36F1,
+  0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
+  0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179
 };

-static const sph_u64 salt_zero_big[4] = { 0, 0, 0, 0 };
+static const uint64_t salt_zero_big[4] = { 0, 0, 0, 0 };

 static const unsigned sigma[16][16] = {
 	{  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },
@@ -77,15 +37,15 @@ static const unsigned sigma[16][16] = {
 	{  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 }
 };

-static const sph_u64 CB[16] = {
-   SPH_C64(0x243F6A8885A308D3), SPH_C64(0x13198A2E03707344),
-   SPH_C64(0xA4093822299F31D0), SPH_C64(0x082EFA98EC4E6C89),
-   SPH_C64(0x452821E638D01377), SPH_C64(0xBE5466CF34E90C6C),
-   SPH_C64(0xC0AC29B7C97C50DD), SPH_C64(0x3F84D5B5B5470917),
-   SPH_C64(0x9216D5D98979FB1B), SPH_C64(0xD1310BA698DFB5AC),
-   SPH_C64(0x2FFD72DBD01ADFB7), SPH_C64(0xB8E1AFED6A267E96),
-   SPH_C64(0xBA7C9045F12C7F99), SPH_C64(0x24A19947B3916CF7),
-   SPH_C64(0x0801F2E2858EFC16), SPH_C64(0x636920D871574E69)
+static const uint64_t CB[16] = {
+   0x243F6A8885A308D3, 0x13198A2E03707344,
+   0xA4093822299F31D0, 0x082EFA98EC4E6C89,
+   0x452821E638D01377, 0xBE5466CF34E90C6C,
+   0xC0AC29B7C97C50DD, 0x3F84D5B5B5470917,
+   0x9216D5D98979FB1B, 0xD1310BA698DFB5AC,
+   0x2FFD72DBD01ADFB7, 0xB8E1AFED6A267E96,
+   0xBA7C9045F12C7F99, 0x24A19947B3916CF7,
+   0x0801F2E2858EFC16, 0x636920D871574E69

 */

@@ -1486,7 +1446,7 @@ blake64_4way( blake_4way_big_context *sc, const void *data, size_t len)
 	   if ( ptr == buf_size )
      {
 		   if ( (T0 = T0 + 1024 ) < 1024 )
-			   T1 = SPH_T64(T1 + 1);
+			   T1 = T1 + 1;
 	   	COMPRESS64_4WAY;
 		   ptr = 0;
 	   }
@@ -1538,8 +1498,8 @@ blake64_4way_close( blake_4way_big_context *sc, void *dst )
       memset_zero_256( buf + (ptr>>3) + 1, (120 - ptr) >> 3 );

       blake64_4way( sc, buf + (ptr>>3), 128 - ptr );
-       sc->T0 = SPH_C64(0xFFFFFFFFFFFFFC00ULL);
-       sc->T1 = SPH_C64(0xFFFFFFFFFFFFFFFFULL);
+       sc->T0 = 0xFFFFFFFFFFFFFC00ULL;
+       sc->T1 = 0xFFFFFFFFFFFFFFFFULL;
       memset_zero_256( buf, 112>>3 ); 
       buf[104>>3] = _mm256_set1_epi64x( 0x0100000000000000ULL );
       buf[112>>3] = _mm256_set1_epi64x( bswap_64( th ) );
@@ -1629,8 +1589,4 @@ blake512_4way_close(void *cc, void *dst)
   blake64_4way_close( cc, dst );
 }

-#ifdef __cplusplus
-}
-#endif
-
 #endif
--- a/algo/blake/blakecoin-4way.c
+++ b/algo/blake/blakecoin-4way.c
@@ -4,7 +4,149 @@
 #include <stdint.h>
 #include <memory.h>

-#if defined (BLAKECOIN_4WAY)
+#define rounds 8
+
+#if defined (BLAKECOIN_16WAY)
+
+int scanhash_blakecoin_16way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*16] __attribute__ ((aligned (64)));
+   uint32_t midstate_vars[16*16] __attribute__ ((aligned (64)));
+   __m512i block0_hash[8] __attribute__ ((aligned (64)));
+   __m512i block_buf[16] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash32_d7 =  (uint32_t*)&( ((__m512i*)hash32)[7] );
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t targ32_d7 = ptarget[7];
+   uint32_t phash[8] __attribute__ ((aligned (64))) =
+   {
+      0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+      0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+   };
+   uint32_t n = pdata[19];
+   const uint32_t first_nonce = (const uint32_t) n;
+   const uint32_t last_nonce = max_nonce - 16;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m512i sixteen = _mm512_set1_epi32( 16 );
+
+   // Prehash first block
+   blake256_transform_le( phash, pdata, 512, 0, rounds );
+
+   block0_hash[0] = _mm512_set1_epi32( phash[0] );
+   block0_hash[1] = _mm512_set1_epi32( phash[1] );
+   block0_hash[2] = _mm512_set1_epi32( phash[2] );
+   block0_hash[3] = _mm512_set1_epi32( phash[3] );
+   block0_hash[4] = _mm512_set1_epi32( phash[4] );
+   block0_hash[5] = _mm512_set1_epi32( phash[5] );
+   block0_hash[6] = _mm512_set1_epi32( phash[6] );
+   block0_hash[7] = _mm512_set1_epi32( phash[7] );
+
+   // Build vectored second block, interleave last 16 bytes of data using
+   // unique nonces.
+   block_buf[0] = _mm512_set1_epi32( pdata[16] );
+   block_buf[1] = _mm512_set1_epi32( pdata[17] );
+   block_buf[2] = _mm512_set1_epi32( pdata[18] );
+   block_buf[3] =
+             _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 );
+
+   // Partialy prehash second block without touching nonces in block_buf[3].
+   blake256_16way_round0_prehash_le( midstate_vars, block0_hash, block_buf );
+
+   do {
+      blake256_16way_final_rounds_le( hash32, midstate_vars, block0_hash,
+                                      block_buf, rounds );
+      for ( int lane = 0; lane < 16; lane++ )
+      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
+      {
+         extr_lane_16x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+         {
+            pdata[19] = n + lane;
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      block_buf[3] = _mm512_add_epi32( block_buf[3], sixteen );
+      n += 16;
+   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+#elif defined (BLAKECOIN_8WAY)
+
+int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*8] __attribute__ ((aligned (64)));
+   uint32_t midstate_vars[16*8] __attribute__ ((aligned (32)));
+   __m256i block0_hash[8] __attribute__ ((aligned (32)));
+   __m256i block_buf[16] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash32_d7 =  (uint32_t*)&( ((__m256i*)hash32)[7] );
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t targ32_d7 = ptarget[7];
+   uint32_t phash[8] __attribute__ ((aligned (32))) =
+   {
+      0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+      0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+   };
+   uint32_t n = pdata[19];
+   const uint32_t first_nonce = (const uint32_t) n;
+   const uint32_t last_nonce = max_nonce - 8;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m256i eight = _mm256_set1_epi32( 8 );
+
+   // Prehash first block
+   blake256_transform_le( phash, pdata, 512, 0, rounds );
+
+   block0_hash[0] = _mm256_set1_epi32( phash[0] );
+   block0_hash[1] = _mm256_set1_epi32( phash[1] );
+   block0_hash[2] = _mm256_set1_epi32( phash[2] );
+   block0_hash[3] = _mm256_set1_epi32( phash[3] );
+   block0_hash[4] = _mm256_set1_epi32( phash[4] );
+   block0_hash[5] = _mm256_set1_epi32( phash[5] );
+   block0_hash[6] = _mm256_set1_epi32( phash[6] );
+   block0_hash[7] = _mm256_set1_epi32( phash[7] );
+
+   // Build vectored second block, interleave last 16 bytes of data using
+   // unique nonces.
+   block_buf[0] = _mm256_set1_epi32( pdata[16] );
+   block_buf[1] = _mm256_set1_epi32( pdata[17] );
+   block_buf[2] = _mm256_set1_epi32( pdata[18] );
+   block_buf[3] = _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n );
+
+   // Partialy prehash second block without touching nonces in block_buf[3].
+   blake256_8way_round0_prehash_le( midstate_vars, block0_hash, block_buf );
+
+   do {
+      blake256_8way_final_rounds_le( hash32, midstate_vars, block0_hash,
+                                     block_buf, rounds );
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
+      {
+         extr_lane_8x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+         {
+            pdata[19] = n + lane;
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      block_buf[3] = _mm256_add_epi32( block_buf[3], eight );
+      n += 8;
+   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+   
+#elif defined (BLAKECOIN_4WAY)

 blake256r8_4way_context blakecoin_4w_ctx;

@@ -61,7 +203,8 @@ int scanhash_blakecoin_4way( struct work *work, uint32_t max_nonce,

 #endif

-#if defined(BLAKECOIN_8WAY)
+#if 0
+//#if defined(BLAKECOIN_8WAY)

 blake256r8_8way_context blakecoin_8w_ctx;

@@ -78,11 +221,84 @@ void blakecoin_8way_hash( void *state, const void *input )
                   state+160, state+192, state+224, vhash, 256 );
 }

+/*
+int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
+                             uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*8] __attribute__ ((aligned (64)));
+   uint32_t midstate_vars[16*8] __attribute__ ((aligned (64)));
+   __m256i block0_hash[8] __attribute__ ((aligned (64)));
+   __m256i block_buf[16] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
+   uint32_t phash[8] __attribute__ ((aligned (32))) =
+   {
+      0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+      0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+   };
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = (uint32_t*)work->target;
+   const uint32_t targ32_d7 = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 8;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m256i eight = _mm256_set1_epi32( 8 );
+
+   // Prehash first block
+   blake256_transform_le( phash, pdata, 512, 0, 8 );
+
+   block0_hash[0] = _mm256_set1_epi32( phash[0] );
+   block0_hash[1] = _mm256_set1_epi32( phash[1] );
+   block0_hash[2] = _mm256_set1_epi32( phash[2] );
+   block0_hash[3] = _mm256_set1_epi32( phash[3] );
+   block0_hash[4] = _mm256_set1_epi32( phash[4] );
+   block0_hash[5] = _mm256_set1_epi32( phash[5] );
+   block0_hash[6] = _mm256_set1_epi32( phash[6] );
+   block0_hash[7] = _mm256_set1_epi32( phash[7] );
+
+   // Build vectored second block, interleave last 16 bytes of data using
+   // unique nonces.
+   block_buf[0] = _mm256_set1_epi32( pdata[16] );
+   block_buf[1] = _mm256_set1_epi32( pdata[17] );
+   block_buf[2] = _mm256_set1_epi32( pdata[18] );
+   block_buf[3] = _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n );
+
+   // Partialy prehash second block without touching nonces
+   blake256_8way_round0_prehash_le( midstate_vars, block0_hash, block_buf );
+
+   do {
+      blake256_8way_final_rounds_le( hash32, midstate_vars, block0_hash, 
+                                     block_buf );
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( hash32_d7[ lane ] <= targ32_d7 )
+      {
+         extr_lane_8x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+         {
+            pdata[19] = n + lane;
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      block_buf[3] = _mm256_add_epi32( block_buf[3], eight );
+      n += 8;
+   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+*/
+
 int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
                         uint64_t *hashes_done, struct thr_info *mythr )
 {
   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t hash[8*8] __attribute__ ((aligned (32)));
+   uint32_t hash32[8*8] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   blake256r8_8way_context ctx __attribute__ ((aligned (32)));
+   uint32_t *hash32_d7 =  (uint32_t*)&( ((__m256i*)hash32)[7] );
   uint32_t *pdata = work->data;
   uint32_t *ptarget = work->target;
   const uint32_t first_nonce = pdata[19];
@@ -101,15 +317,22 @@ int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
      *noncev = mm256_bswap_32( _mm256_set_epi32( n+7, n+6, n+5, n+4,
                                                  n+3, n+2, n+1, n ) );
      pdata[19] = n;
-      blakecoin_8way_hash( hash, vdata );

-      for ( int i = 0; i < 8; i++ )
-      if (  (hash+(i<<3))[7] <= HTarget && fulltest( hash+(i<<3), ptarget )
-          && !opt_benchmark )
+      memcpy( &ctx, &blakecoin_8w_ctx, sizeof ctx );
+      blake256r8_8way_update( &ctx, (const void*)vdata + (64<<3), 16 );
+      blake256r8_8way_close( &ctx, hash32 );
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( hash32_d7[ lane ] <= HTarget )
      {
-          pdata[19] = n+i;
-          submit_solution( work, hash+(i<<3), mythr );
+         extr_lane_8x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) && !opt_benchmark ) )
+         {
+            pdata[19] = n + lane;
+            submit_solution( work, lane_hash, mythr );
+         }
      }
+     
      n += 8;
   } while ( (n < max_nonce) && !work_restart[thr_id].restart );

--- a/algo/blake/blakecoin-gate.c
+++ b/algo/blake/blakecoin-gate.c
@@ -4,10 +4,10 @@
 // vanilla uses default gen merkle root, otherwise identical to blakecoin
 bool register_vanilla_algo( algo_gate_t* gate )
 {
-#if defined(BLAKECOIN_8WAY)
+#if defined(BLAKECOIN_16WAY)
+  gate->scanhash  = (void*)&scanhash_blakecoin_16way;
+#elif defined(BLAKECOIN_8WAY)
  gate->scanhash  = (void*)&scanhash_blakecoin_8way;
-  gate->hash      = (void*)&blakecoin_8way_hash;
-
 #elif defined(BLAKECOIN_4WAY)
  gate->scanhash  = (void*)&scanhash_blakecoin_4way;
  gate->hash      = (void*)&blakecoin_4way_hash;
@@ -15,14 +15,14 @@ bool register_vanilla_algo( algo_gate_t* gate )
  gate->scanhash = (void*)&scanhash_blakecoin;
  gate->hash     = (void*)&blakecoinhash;
 #endif
-  gate->optimizations = SSE42_OPT | AVX2_OPT;
+  gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
  return true;
 }

 bool register_blakecoin_algo( algo_gate_t* gate )
 {
  register_vanilla_algo( gate );
-  gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
+  gate->gen_merkle_root = (void*)&sha256_gen_merkle_root;
  return true;
 }

--- a/algo/blake/blakecoin-gate.h
+++ b/algo/blake/blakecoin-gate.h
@@ -1,30 +1,36 @@
-#ifndef __BLAKECOIN_GATE_H__
-#define __BLAKECOIN_GATE_H__ 1
+#ifndef BLAKECOIN_GATE_H__
+#define BLAKECOIN_GATE_H__ 1

 #include "algo-gate-api.h"
 #include <stdint.h>

-#if defined(__SSE4_2__)
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define BLAKECOIN_16WAY
+#elif defined(__AVX2__)
+  #define BLAKECOIN_8WAY
+#elif defined(__SSE2__)  // always true
  #define BLAKECOIN_4WAY
 #endif
-#if defined(__AVX2__)
-  #define BLAKECOIN_8WAY
-#endif

-#if defined (BLAKECOIN_8WAY)
-void blakecoin_8way_hash(void *state, const void *input);
+#if defined (BLAKECOIN_16WAY)
+int scanhash_blakecoin_16way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined (BLAKECOIN_8WAY)
+//void blakecoin_8way_hash(void *state, const void *input);
 int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
                         uint64_t *hashes_done, struct thr_info *mythr );
-#endif

-#if defined (BLAKECOIN_4WAY)
+#elif defined (BLAKECOIN_4WAY)
 void blakecoin_4way_hash(void *state, const void *input);
 int scanhash_blakecoin_4way( struct work *work, uint32_t max_nonce,
                         uint64_t *hashes_done, struct thr_info *mythr );
-#endif
+#else  // never used

 void blakecoinhash( void *state, const void *input );
 int scanhash_blakecoin( struct work *work, uint32_t max_nonce,
                      uint64_t *hashes_done, struct thr_info *mythr );

 #endif
+
+#endif
--- a/algo/blake/blakecoin.c
+++ b/algo/blake/blakecoin.c
@@ -1,6 +1,6 @@
 #include "blakecoin-gate.h"

-#if !defined(BLAKECOIN_8WAY) && !defined(BLAKECOIN_4WAY)
+#if !defined(BLAKECOIN_16WAY) && !defined(BLAKECOIN_8WAY) && !defined(BLAKECOIN_4WAY)

 #define BLAKE32_ROUNDS 8
 #include "sph_blake.h"
@@ -12,7 +12,6 @@ void blakecoin_close(void *cc, void *dst);
 #include <string.h>
 #include <stdint.h>
 #include <memory.h>
-#include <openssl/sha.h>

 // context management is staged for efficiency.
 // 1. global initial ctx cached on startup
@@ -35,8 +34,8 @@ void blakecoinhash( void *state, const void *input )
 	uint8_t hash[64] __attribute__ ((aligned (32)));
 	uint8_t *ending = (uint8_t*) input + 64;

-        // copy cached midstate
-        memcpy( &ctx, &blake_mid_ctx, sizeof ctx );
+   // copy cached midstate
+   memcpy( &ctx, &blake_mid_ctx, sizeof ctx );
 	blakecoin( &ctx, ending, 16 );
 	blakecoin_close( &ctx, hash );
 	memcpy( state, hash, 32 );
@@ -45,8 +44,8 @@ void blakecoinhash( void *state, const void *input )
 int scanhash_blakecoin( struct work *work, uint32_t max_nonce,
                        uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
 	const uint32_t first_nonce = pdata[19];
 	uint32_t HTarget = ptarget[7];
   int thr_id = mythr->id;  // thr_id arg is deprecated
@@ -60,10 +59,10 @@ int scanhash_blakecoin( struct work *work, uint32_t max_nonce,
 		HTarget = 0x7f;

 	// we need big endian data...
-        for (int kk=0; kk < 19; kk++) 
-                be32enc(&endiandata[kk], ((uint32_t*)pdata)[kk]);
+   for (int kk=0; kk < 19; kk++) 
+      be32enc(&endiandata[kk], ((uint32_t*)pdata)[kk]);

-        blake_midstate_init( endiandata );
+   blake_midstate_init( endiandata );

 #ifdef DEBUG_ALGO
 	applog(LOG_DEBUG,"[%d] Target=%08x %08x", thr_id, ptarget[6], ptarget[7]);
--- a/algo/blake/sph-blake2s.c
+++ b/algo/blake/sph-blake2s.c
@@ -15,7 +15,7 @@
 #include <string.h>
 #include <stdio.h>

-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"
 #include "sph-blake2s.h"

 static const uint32_t blake2s_IV[8] =
--- a/algo/blake/sph_blake.h
+++ b/algo/blake/sph_blake.h
@@ -42,7 +42,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for BLAKE-224.
--- a/algo/blake/sph_blake2b.c
+++ b/algo/blake/sph_blake2b.c
@@ -31,7 +31,7 @@
 #include <stdint.h>
 #include <string.h>
 #include "simd-utils.h"
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"
 #include "sph_blake2b.h"

 // Little-endian byte access.
@@ -64,6 +64,22 @@
  V[1] = mm256_ror_64( _mm256_xor_si256( V[1], V[2] ), 63 ); \
 }

+// Pivot about V[1] instead of V[0] reduces latency.
+#define BLAKE2B_ROUND( R ) \
+{ \
+  __m256i *V = (__m256i*)v; \
+  const uint8_t *sigmaR = sigma[R]; \
+  BLAKE2B_G(  0,  1,  2,  3,  4,  5,  6,  7 ); \
+  V[0] = mm256_shufll_64( V[0] ); \
+  V[3] = mm256_swap_128( V[3] ); \
+  V[2] = mm256_shuflr_64( V[2] ); \
+  BLAKE2B_G( 14, 15,  8,  9, 10, 11, 12, 13 ); \
+  V[0] = mm256_shuflr_64( V[0] ); \
+  V[3] = mm256_swap_128( V[3] ); \
+  V[2] = mm256_shufll_64( V[2] ); \
+}
+
+/*
 #define BLAKE2B_ROUND( R ) \
 { \
  __m256i *V = (__m256i*)v; \
@@ -77,6 +93,7 @@
  V[2] = mm256_swap_128( V[2] ); \
  V[1] = mm256_shufll_64( V[1] ); \
 }
+*/

 #elif defined(__SSE2__)
 // always true
--- a/algo/bmw/bmw-hash-4way.h
+++ b/algo/bmw/bmw-hash-4way.h
@@ -41,8 +41,6 @@ extern "C"{
 #endif

 #include <stddef.h>
-
-#include "algo/sha/sph_types.h"
 #include "simd-utils.h"

 #define SPH_SIZE_bmw256   256
@@ -57,7 +55,7 @@ typedef struct {
   __m128i buf[64];
   __m128i H[16];
   size_t ptr;
-   sph_u32 bit_count;  // assume bit_count fits in 32 bits
+   uint32_t bit_count;  // assume bit_count fits in 32 bits
 } bmw_4way_small_context;

 typedef bmw_4way_small_context bmw256_4way_context;
@@ -144,7 +142,7 @@ typedef struct {
   __m256i buf[16];
   __m256i H[16];
   size_t ptr;
-   sph_u64 bit_count;
+   uint64_t bit_count;
 } bmw_4way_big_context __attribute__((aligned(128)));

 typedef bmw_4way_big_context bmw512_4way_context;
--- a/algo/bmw/bmw256-hash-4way.c
+++ b/algo/bmw/bmw256-hash-4way.c
@@ -109,7 +109,7 @@ static const uint32_t IV256[] = {
             _mm_sub_epi32( _mm_add_epi32( rol_off_32( M, j, 0 ), \
                                           rol_off_32( M, j, 3 ) ), \
                            rol_off_32( M, j, 10 ) ), \
-       _mm_set1_epi32( ( (j)+16 ) * SPH_C32(0x05555555UL) ) ), \
+       _mm_set1_epi32( ( (j)+16 ) * 0x05555555UL ) ), \
   H[ ( (j)+7 ) & 0xF ] )


@@ -451,22 +451,22 @@ static const __m128i final_s[16] =
 */
 void bmw256_4way_init( bmw256_4way_context *ctx )
 {
-   ctx->H[ 0] = m128_const1_64( 0x4041424340414243 );
-   ctx->H[ 1] = m128_const1_64( 0x4445464744454647 );
-   ctx->H[ 2] = m128_const1_64( 0x48494A4B48494A4B );
-   ctx->H[ 3] = m128_const1_64( 0x4C4D4E4F4C4D4E4F );
-   ctx->H[ 4] = m128_const1_64( 0x5051525350515253 );
-   ctx->H[ 5] = m128_const1_64( 0x5455565754555657 );
-   ctx->H[ 6] = m128_const1_64( 0x58595A5B58595A5B );
-   ctx->H[ 7] = m128_const1_64( 0x5C5D5E5F5C5D5E5F );
-   ctx->H[ 8] = m128_const1_64( 0x6061626360616263 );
-   ctx->H[ 9] = m128_const1_64( 0x6465666764656667 );
-   ctx->H[10] = m128_const1_64( 0x68696A6B68696A6B );
-   ctx->H[11] = m128_const1_64( 0x6C6D6E6F6C6D6E6F );
-   ctx->H[12] = m128_const1_64( 0x7071727370717273 );
-   ctx->H[13] = m128_const1_64( 0x7475767774757677 );
-   ctx->H[14] = m128_const1_64( 0x78797A7B78797A7B );
-   ctx->H[15] = m128_const1_64( 0x7C7D7E7F7C7D7E7F );
+   ctx->H[ 0] = _mm_set1_epi64x( 0x4041424340414243 );
+   ctx->H[ 1] = _mm_set1_epi64x( 0x4445464744454647 );
+   ctx->H[ 2] = _mm_set1_epi64x( 0x48494A4B48494A4B );
+   ctx->H[ 3] = _mm_set1_epi64x( 0x4C4D4E4F4C4D4E4F );
+   ctx->H[ 4] = _mm_set1_epi64x( 0x5051525350515253 );
+   ctx->H[ 5] = _mm_set1_epi64x( 0x5455565754555657 );
+   ctx->H[ 6] = _mm_set1_epi64x( 0x58595A5B58595A5B );
+   ctx->H[ 7] = _mm_set1_epi64x( 0x5C5D5E5F5C5D5E5F );
+   ctx->H[ 8] = _mm_set1_epi64x( 0x6061626360616263 );
+   ctx->H[ 9] = _mm_set1_epi64x( 0x6465666764656667 );
+   ctx->H[10] = _mm_set1_epi64x( 0x68696A6B68696A6B );
+   ctx->H[11] = _mm_set1_epi64x( 0x6C6D6E6F6C6D6E6F );
+   ctx->H[12] = _mm_set1_epi64x( 0x7071727370717273 );
+   ctx->H[13] = _mm_set1_epi64x( 0x7475767774757677 );
+   ctx->H[14] = _mm_set1_epi64x( 0x78797A7B78797A7B );
+   ctx->H[15] = _mm_set1_epi64x( 0x7C7D7E7F7C7D7E7F );


 //   for ( int i = 0; i < 16; i++ )
@@ -485,7 +485,7 @@ bmw32_4way(bmw_4way_small_context *sc, const void *data, size_t len)
   size_t ptr;
   const int buf_size = 64;  // bytes of one lane, compatible with len

-   sc->bit_count += (sph_u32)len << 3;
+   sc->bit_count += (uint32_t)len << 3;
   buf = sc->buf;
   ptr = sc->ptr;
   h1 = sc->H;
@@ -529,7 +529,7 @@ bmw32_4way_close(bmw_4way_small_context *sc, unsigned ub, unsigned n,

   buf = sc->buf;
   ptr = sc->ptr;
-   buf[ ptr>>2 ] = m128_const1_64( 0x0000008000000080 );
+   buf[ ptr>>2 ] = _mm_set1_epi64x( 0x0000008000000080 );
   ptr += 4;
   h = sc->H;

@@ -959,22 +959,22 @@ static const __m256i final_s8[16] =

 void bmw256_8way_init( bmw256_8way_context *ctx )
 {
-   ctx->H[ 0] = m256_const1_64( 0x4041424340414243 );
-   ctx->H[ 1] = m256_const1_64( 0x4445464744454647 );
-   ctx->H[ 2] = m256_const1_64( 0x48494A4B48494A4B );
-   ctx->H[ 3] = m256_const1_64( 0x4C4D4E4F4C4D4E4F );
-   ctx->H[ 4] = m256_const1_64( 0x5051525350515253 );
-   ctx->H[ 5] = m256_const1_64( 0x5455565754555657 );
-   ctx->H[ 6] = m256_const1_64( 0x58595A5B58595A5B );
-   ctx->H[ 7] = m256_const1_64( 0x5C5D5E5F5C5D5E5F );
-   ctx->H[ 8] = m256_const1_64( 0x6061626360616263 );
-   ctx->H[ 9] = m256_const1_64( 0x6465666764656667 );
-   ctx->H[10] = m256_const1_64( 0x68696A6B68696A6B );
-   ctx->H[11] = m256_const1_64( 0x6C6D6E6F6C6D6E6F );
-   ctx->H[12] = m256_const1_64( 0x7071727370717273 );
-   ctx->H[13] = m256_const1_64( 0x7475767774757677 );
-   ctx->H[14] = m256_const1_64( 0x78797A7B78797A7B );
-   ctx->H[15] = m256_const1_64( 0x7C7D7E7F7C7D7E7F );
+   ctx->H[ 0] = _mm256_set1_epi64x( 0x4041424340414243 );
+   ctx->H[ 1] = _mm256_set1_epi64x( 0x4445464744454647 );
+   ctx->H[ 2] = _mm256_set1_epi64x( 0x48494A4B48494A4B );
+   ctx->H[ 3] = _mm256_set1_epi64x( 0x4C4D4E4F4C4D4E4F );
+   ctx->H[ 4] = _mm256_set1_epi64x( 0x5051525350515253 );
+   ctx->H[ 5] = _mm256_set1_epi64x( 0x5455565754555657 );
+   ctx->H[ 6] = _mm256_set1_epi64x( 0x58595A5B58595A5B );
+   ctx->H[ 7] = _mm256_set1_epi64x( 0x5C5D5E5F5C5D5E5F );
+   ctx->H[ 8] = _mm256_set1_epi64x( 0x6061626360616263 );
+   ctx->H[ 9] = _mm256_set1_epi64x( 0x6465666764656667 );
+   ctx->H[10] = _mm256_set1_epi64x( 0x68696A6B68696A6B );
+   ctx->H[11] = _mm256_set1_epi64x( 0x6C6D6E6F6C6D6E6F );
+   ctx->H[12] = _mm256_set1_epi64x( 0x7071727370717273 );
+   ctx->H[13] = _mm256_set1_epi64x( 0x7475767774757677 );
+   ctx->H[14] = _mm256_set1_epi64x( 0x78797A7B78797A7B );
+   ctx->H[15] = _mm256_set1_epi64x( 0x7C7D7E7F7C7D7E7F );
   ctx->ptr       = 0;
   ctx->bit_count = 0;
 }
@@ -1030,7 +1030,7 @@ void bmw256_8way_close( bmw256_8way_context *ctx, void *dst )

   buf = ctx->buf;
   ptr = ctx->ptr;
-   buf[ ptr>>2 ] = m256_const1_64( 0x0000008000000080 );
+   buf[ ptr>>2 ] = _mm256_set1_epi64x( 0x0000008000000080 );
   ptr += 4;
   h = ctx->H;

@@ -1460,22 +1460,22 @@ static const __m512i final_s16[16] =

 void bmw256_16way_init( bmw256_16way_context *ctx )
 {
-   ctx->H[ 0] = m512_const1_64( 0x4041424340414243 );
-   ctx->H[ 1] = m512_const1_64( 0x4445464744454647 );
-   ctx->H[ 2] = m512_const1_64( 0x48494A4B48494A4B );
-   ctx->H[ 3] = m512_const1_64( 0x4C4D4E4F4C4D4E4F );
-   ctx->H[ 4] = m512_const1_64( 0x5051525350515253 );
-   ctx->H[ 5] = m512_const1_64( 0x5455565754555657 );
-   ctx->H[ 6] = m512_const1_64( 0x58595A5B58595A5B );
-   ctx->H[ 7] = m512_const1_64( 0x5C5D5E5F5C5D5E5F );
-   ctx->H[ 8] = m512_const1_64( 0x6061626360616263 );
-   ctx->H[ 9] = m512_const1_64( 0x6465666764656667 );
-   ctx->H[10] = m512_const1_64( 0x68696A6B68696A6B );
-   ctx->H[11] = m512_const1_64( 0x6C6D6E6F6C6D6E6F );
-   ctx->H[12] = m512_const1_64( 0x7071727370717273 );
-   ctx->H[13] = m512_const1_64( 0x7475767774757677 );
-   ctx->H[14] = m512_const1_64( 0x78797A7B78797A7B );
-   ctx->H[15] = m512_const1_64( 0x7C7D7E7F7C7D7E7F );
+   ctx->H[ 0] = _mm512_set1_epi64( 0x4041424340414243 );
+   ctx->H[ 1] = _mm512_set1_epi64( 0x4445464744454647 );
+   ctx->H[ 2] = _mm512_set1_epi64( 0x48494A4B48494A4B );
+   ctx->H[ 3] = _mm512_set1_epi64( 0x4C4D4E4F4C4D4E4F );
+   ctx->H[ 4] = _mm512_set1_epi64( 0x5051525350515253 );
+   ctx->H[ 5] = _mm512_set1_epi64( 0x5455565754555657 );
+   ctx->H[ 6] = _mm512_set1_epi64( 0x58595A5B58595A5B );
+   ctx->H[ 7] = _mm512_set1_epi64( 0x5C5D5E5F5C5D5E5F );
+   ctx->H[ 8] = _mm512_set1_epi64( 0x6061626360616263 );
+   ctx->H[ 9] = _mm512_set1_epi64( 0x6465666764656667 );
+   ctx->H[10] = _mm512_set1_epi64( 0x68696A6B68696A6B );
+   ctx->H[11] = _mm512_set1_epi64( 0x6C6D6E6F6C6D6E6F );
+   ctx->H[12] = _mm512_set1_epi64( 0x7071727370717273 );
+   ctx->H[13] = _mm512_set1_epi64( 0x7475767774757677 );
+   ctx->H[14] = _mm512_set1_epi64( 0x78797A7B78797A7B );
+   ctx->H[15] = _mm512_set1_epi64( 0x7C7D7E7F7C7D7E7F );
   ctx->ptr       = 0;
   ctx->bit_count = 0;
 }
@@ -1531,7 +1531,7 @@ void bmw256_16way_close( bmw256_16way_context *ctx, void *dst )

   buf = ctx->buf;
   ptr = ctx->ptr;
-   buf[ ptr>>2 ] = m512_const1_64( 0x0000008000000080 );
+   buf[ ptr>>2 ] = _mm512_set1_epi64( 0x0000008000000080 );
   ptr += 4;
   h = ctx->H;

--- a/algo/bmw/bmw512-hash-4way.c
+++ b/algo/bmw/bmw512-hash-4way.c
@@ -45,15 +45,15 @@ extern "C"{

 #define LPAR   (

-static const sph_u64 IV512[] = {
-        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)
+static const uint64_t IV512[] = {
+        0x8081828384858687, 0x88898A8B8C8D8E8F,
+        0x9091929394959697, 0x98999A9B9C9D9E9F,
+        0xA0A1A2A3A4A5A6A7, 0xA8A9AAABACADAEAF,
+        0xB0B1B2B3B4B5B6B7, 0xB8B9BABBBCBDBEBF,
+        0xC0C1C2C3C4C5C6C7, 0xC8C9CACBCCCDCECF,
+        0xD0D1D2D3D4D5D6D7, 0xD8D9DADBDCDDDEDF,
+        0xE0E1E2E3E4E5E6E7, 0xE8E9EAEBECEDEEEF,
+        0xF0F1F2F3F4F5F6F7, 0xF8F9FAFBFCFDFEFF
 };

 #if defined(__SSE2__)
@@ -894,24 +894,24 @@ static const __m256i final_b[16] =
 };

 static void
-bmw64_4way_init( bmw_4way_big_context *sc, const sph_u64 *iv )
+bmw64_4way_init( bmw_4way_big_context *sc, const uint64_t *iv )
 {
-   sc->H[ 0] = m256_const1_64( 0x8081828384858687 );
-   sc->H[ 1] = m256_const1_64( 0x88898A8B8C8D8E8F );
-   sc->H[ 2] = m256_const1_64( 0x9091929394959697 );
-   sc->H[ 3] = m256_const1_64( 0x98999A9B9C9D9E9F );
-   sc->H[ 4] = m256_const1_64( 0xA0A1A2A3A4A5A6A7 );
-   sc->H[ 5] = m256_const1_64( 0xA8A9AAABACADAEAF );
-   sc->H[ 6] = m256_const1_64( 0xB0B1B2B3B4B5B6B7 );
-   sc->H[ 7] = m256_const1_64( 0xB8B9BABBBCBDBEBF );
-   sc->H[ 8] = m256_const1_64( 0xC0C1C2C3C4C5C6C7 );
-   sc->H[ 9] = m256_const1_64( 0xC8C9CACBCCCDCECF );
-   sc->H[10] = m256_const1_64( 0xD0D1D2D3D4D5D6D7 );
-   sc->H[11] = m256_const1_64( 0xD8D9DADBDCDDDEDF );
-   sc->H[12] = m256_const1_64( 0xE0E1E2E3E4E5E6E7 );
-   sc->H[13] = m256_const1_64( 0xE8E9EAEBECEDEEEF );
-   sc->H[14] = m256_const1_64( 0xF0F1F2F3F4F5F6F7 );
-   sc->H[15] = m256_const1_64( 0xF8F9FAFBFCFDFEFF );
+   sc->H[ 0] = _mm256_set1_epi64x( 0x8081828384858687 );
+   sc->H[ 1] = _mm256_set1_epi64x( 0x88898A8B8C8D8E8F );
+   sc->H[ 2] = _mm256_set1_epi64x( 0x9091929394959697 );
+   sc->H[ 3] = _mm256_set1_epi64x( 0x98999A9B9C9D9E9F );
+   sc->H[ 4] = _mm256_set1_epi64x( 0xA0A1A2A3A4A5A6A7 );
+   sc->H[ 5] = _mm256_set1_epi64x( 0xA8A9AAABACADAEAF );
+   sc->H[ 6] = _mm256_set1_epi64x( 0xB0B1B2B3B4B5B6B7 );
+   sc->H[ 7] = _mm256_set1_epi64x( 0xB8B9BABBBCBDBEBF );
+   sc->H[ 8] = _mm256_set1_epi64x( 0xC0C1C2C3C4C5C6C7 );
+   sc->H[ 9] = _mm256_set1_epi64x( 0xC8C9CACBCCCDCECF );
+   sc->H[10] = _mm256_set1_epi64x( 0xD0D1D2D3D4D5D6D7 );
+   sc->H[11] = _mm256_set1_epi64x( 0xD8D9DADBDCDDDEDF );
+   sc->H[12] = _mm256_set1_epi64x( 0xE0E1E2E3E4E5E6E7 );
+   sc->H[13] = _mm256_set1_epi64x( 0xE8E9EAEBECEDEEEF );
+   sc->H[14] = _mm256_set1_epi64x( 0xF0F1F2F3F4F5F6F7 );
+   sc->H[15] = _mm256_set1_epi64x( 0xF8F9FAFBFCFDFEFF );
   sc->ptr = 0;
   sc->bit_count = 0;
 }
@@ -926,7 +926,7 @@ bmw64_4way( bmw_4way_big_context *sc, const void *data, size_t len )
   size_t ptr;
   const int buf_size = 128;  // bytes of one lane, compatible with len

-   sc->bit_count += (sph_u64)len << 3;
+   sc->bit_count += (uint64_t)len << 3;
   buf = sc->buf;
   ptr = sc->ptr;
   h1 = sc->H;
@@ -967,7 +967,7 @@ bmw64_4way_close(bmw_4way_big_context *sc, unsigned ub, unsigned n,

   buf = sc->buf;
   ptr = sc->ptr;
-   buf[ ptr>>3 ] = m256_const1_64( 0x80 );
+   buf[ ptr>>3 ] = _mm256_set1_epi64x( 0x80 );
   ptr += 8;
   h = sc->H;

@@ -1377,24 +1377,24 @@ static const __m512i final_b8[16] =


 void bmw512_8way_init( bmw512_8way_context *ctx )
-//bmw64_4way_init( bmw_4way_big_context *sc, const sph_u64 *iv )
+//bmw64_4way_init( bmw_4way_big_context *sc, const uint64_t *iv )
 {
-   ctx->H[ 0] = m512_const1_64( 0x8081828384858687 );
-   ctx->H[ 1] = m512_const1_64( 0x88898A8B8C8D8E8F );
-   ctx->H[ 2] = m512_const1_64( 0x9091929394959697 );
-   ctx->H[ 3] = m512_const1_64( 0x98999A9B9C9D9E9F );
-   ctx->H[ 4] = m512_const1_64( 0xA0A1A2A3A4A5A6A7 );
-   ctx->H[ 5] = m512_const1_64( 0xA8A9AAABACADAEAF );
-   ctx->H[ 6] = m512_const1_64( 0xB0B1B2B3B4B5B6B7 );
-   ctx->H[ 7] = m512_const1_64( 0xB8B9BABBBCBDBEBF );
-   ctx->H[ 8] = m512_const1_64( 0xC0C1C2C3C4C5C6C7 );
-   ctx->H[ 9] = m512_const1_64( 0xC8C9CACBCCCDCECF );
-   ctx->H[10] = m512_const1_64( 0xD0D1D2D3D4D5D6D7 );
-   ctx->H[11] = m512_const1_64( 0xD8D9DADBDCDDDEDF );
-   ctx->H[12] = m512_const1_64( 0xE0E1E2E3E4E5E6E7 );
-   ctx->H[13] = m512_const1_64( 0xE8E9EAEBECEDEEEF );
-   ctx->H[14] = m512_const1_64( 0xF0F1F2F3F4F5F6F7 );
-   ctx->H[15] = m512_const1_64( 0xF8F9FAFBFCFDFEFF );
+   ctx->H[ 0] = _mm512_set1_epi64( 0x8081828384858687 );
+   ctx->H[ 1] = _mm512_set1_epi64( 0x88898A8B8C8D8E8F );
+   ctx->H[ 2] = _mm512_set1_epi64( 0x9091929394959697 );
+   ctx->H[ 3] = _mm512_set1_epi64( 0x98999A9B9C9D9E9F );
+   ctx->H[ 4] = _mm512_set1_epi64( 0xA0A1A2A3A4A5A6A7 );
+   ctx->H[ 5] = _mm512_set1_epi64( 0xA8A9AAABACADAEAF );
+   ctx->H[ 6] = _mm512_set1_epi64( 0xB0B1B2B3B4B5B6B7 );
+   ctx->H[ 7] = _mm512_set1_epi64( 0xB8B9BABBBCBDBEBF );
+   ctx->H[ 8] = _mm512_set1_epi64( 0xC0C1C2C3C4C5C6C7 );
+   ctx->H[ 9] = _mm512_set1_epi64( 0xC8C9CACBCCCDCECF );
+   ctx->H[10] = _mm512_set1_epi64( 0xD0D1D2D3D4D5D6D7 );
+   ctx->H[11] = _mm512_set1_epi64( 0xD8D9DADBDCDDDEDF );
+   ctx->H[12] = _mm512_set1_epi64( 0xE0E1E2E3E4E5E6E7 );
+   ctx->H[13] = _mm512_set1_epi64( 0xE8E9EAEBECEDEEEF );
+   ctx->H[14] = _mm512_set1_epi64( 0xF0F1F2F3F4F5F6F7 );
+   ctx->H[15] = _mm512_set1_epi64( 0xF8F9FAFBFCFDFEFF );
   ctx->ptr = 0;
   ctx->bit_count = 0;
 }
@@ -1448,7 +1448,7 @@ void bmw512_8way_close( bmw512_8way_context *ctx, void *dst )

   buf = ctx->buf;
   ptr = ctx->ptr;
-   buf[ ptr>>3 ] = m512_const1_64( 0x80 );
+   buf[ ptr>>3 ] = _mm512_set1_epi64( 0x80 );
   ptr += 8;
   h = ctx->H;

@@ -1483,22 +1483,22 @@ void bmw512_8way_full( bmw512_8way_context *ctx, void *out, const void *data,

 // Init

-   H[ 0] = m512_const1_64( 0x8081828384858687 );
-   H[ 1] = m512_const1_64( 0x88898A8B8C8D8E8F );
-   H[ 2] = m512_const1_64( 0x9091929394959697 );
-   H[ 3] = m512_const1_64( 0x98999A9B9C9D9E9F );
-   H[ 4] = m512_const1_64( 0xA0A1A2A3A4A5A6A7 );
-   H[ 5] = m512_const1_64( 0xA8A9AAABACADAEAF );
-   H[ 6] = m512_const1_64( 0xB0B1B2B3B4B5B6B7 );
-   H[ 7] = m512_const1_64( 0xB8B9BABBBCBDBEBF );
-   H[ 8] = m512_const1_64( 0xC0C1C2C3C4C5C6C7 );
-   H[ 9] = m512_const1_64( 0xC8C9CACBCCCDCECF );
-   H[10] = m512_const1_64( 0xD0D1D2D3D4D5D6D7 );
-   H[11] = m512_const1_64( 0xD8D9DADBDCDDDEDF );
-   H[12] = m512_const1_64( 0xE0E1E2E3E4E5E6E7 );
-   H[13] = m512_const1_64( 0xE8E9EAEBECEDEEEF );
-   H[14] = m512_const1_64( 0xF0F1F2F3F4F5F6F7 );
-   H[15] = m512_const1_64( 0xF8F9FAFBFCFDFEFF );
+   H[ 0] = _mm512_set1_epi64( 0x8081828384858687 );
+   H[ 1] = _mm512_set1_epi64( 0x88898A8B8C8D8E8F );
+   H[ 2] = _mm512_set1_epi64( 0x9091929394959697 );
+   H[ 3] = _mm512_set1_epi64( 0x98999A9B9C9D9E9F );
+   H[ 4] = _mm512_set1_epi64( 0xA0A1A2A3A4A5A6A7 );
+   H[ 5] = _mm512_set1_epi64( 0xA8A9AAABACADAEAF );
+   H[ 6] = _mm512_set1_epi64( 0xB0B1B2B3B4B5B6B7 );
+   H[ 7] = _mm512_set1_epi64( 0xB8B9BABBBCBDBEBF );
+   H[ 8] = _mm512_set1_epi64( 0xC0C1C2C3C4C5C6C7 );
+   H[ 9] = _mm512_set1_epi64( 0xC8C9CACBCCCDCECF );
+   H[10] = _mm512_set1_epi64( 0xD0D1D2D3D4D5D6D7 );
+   H[11] = _mm512_set1_epi64( 0xD8D9DADBDCDDDEDF );
+   H[12] = _mm512_set1_epi64( 0xE0E1E2E3E4E5E6E7 );
+   H[13] = _mm512_set1_epi64( 0xE8E9EAEBECEDEEEF );
+   H[14] = _mm512_set1_epi64( 0xF0F1F2F3F4F5F6F7 );
+   H[15] = _mm512_set1_epi64( 0xF8F9FAFBFCFDFEFF );

 // Update

@@ -1530,7 +1530,7 @@ void bmw512_8way_full( bmw512_8way_context *ctx, void *out, const void *data,
   __m512i h1[16], h2[16];
   size_t u, v;

-   buf[ ptr>>3 ] = m512_const1_64( 0x80 );
+   buf[ ptr>>3 ] = _mm512_set1_epi64( 0x80 );
   ptr += 8;

   if (  ptr > (buf_size - 8) )
--- a/algo/bmw/sph_bmw.h
+++ b/algo/bmw/sph_bmw.h
@@ -41,7 +41,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for BMW-224.
--- a/algo/cubehash/cube-hash-2way.c
+++ b/algo/cubehash/cube-hash-2way.c
@@ -423,21 +423,6 @@ int cube_4way_update_close( cube_4way_context *sp, void *output,

 // 2 way 128 

-// This isn't expected to be used with AVX512 so HW rotate intruction
-// is assumed not avaiable.
-// Use double buffering to optimize serial bit rotations. Full double
-// buffering isn't practical because it needs twice as many registers
-// with AVX2 having only half as many as AVX512.
-#define ROL2( out0, out1, in0, in1, c ) \
-{ \
- __m256i t0 = _mm256_slli_epi32( in0, c ); \
- __m256i t1 = _mm256_slli_epi32( in1, c ); \
- out0 = _mm256_srli_epi32( in0, 32-(c) ); \
- out1 = _mm256_srli_epi32( in1, 32-(c) ); \
- out0 = _mm256_or_si256( out0, t0 ); \
- out1 = _mm256_or_si256( out1, t1 ); \
-}
-
 static void transform_2way( cube_2way_context *sp )
 {
    int r;
@@ -460,8 +445,10 @@ static void transform_2way( cube_2way_context *sp )
        x5 = _mm256_add_epi32( x1, x5 );
        x6 = _mm256_add_epi32( x2, x6 );
        x7 = _mm256_add_epi32( x3, x7 );
-        ROL2( y0, y1, x2, x3, 7 );
-        ROL2( x2, x3, x0, x1, 7 );
+        y0 = mm256_rol_32( x2, 7 );
+        y1 = mm256_rol_32( x3, 7 );
+        x2 = mm256_rol_32( x0, 7 );
+        x3 = mm256_rol_32( x1, 7 );
        x0 = _mm256_xor_si256( y0, x4 );
        x1 = _mm256_xor_si256( y1, x5 );
        x2 = _mm256_xor_si256( x2, x6 );
@@ -474,8 +461,10 @@ static void transform_2way( cube_2way_context *sp )
        x5 = _mm256_add_epi32( x1, x5 );
        x6 = _mm256_add_epi32( x2, x6 );
        x7 = _mm256_add_epi32( x3, x7 );
-        ROL2( y0, x1, x1, x0, 11 );
-        ROL2( y1, x3, x3, x2, 11 );
+        y0 = mm256_rol_32( x1, 11 );
+        x1 = mm256_rol_32( x0, 11 );
+        y1 = mm256_rol_32( x3, 11 );
+        x3 = mm256_rol_32( x2, 11 );
        x0 = _mm256_xor_si256( y0, x4 );
        x1 = _mm256_xor_si256( x1, x5 );
        x2 = _mm256_xor_si256( y1, x6 );
--- a/algo/cubehash/cubehash_sse2.c
+++ b/algo/cubehash/cubehash_sse2.c
@@ -9,7 +9,6 @@
 #include <immintrin.h>
 #endif
 #include "cubehash_sse2.h"
-#include "algo/sha/sha3-defs.h"
 #include <stdbool.h>
 #include <unistd.h>
 #include <memory.h>
@@ -32,7 +31,7 @@ static void transform( cubehashParam *sp )
    { 
        x1 = _mm512_add_epi32( x0, x1 );
        x0 = mm512_swap_256( x0 );
-        x0 = mm512_rol_32(  x0, 7 );
+        x0 = mm512_rol_32( x0, 7 );
        x0 = _mm512_xor_si512( x0, x1 );
        x1 = mm512_swap128_64( x1 );
        x1 = _mm512_add_epi32( x0, x1 );
@@ -58,19 +57,18 @@ static void transform( cubehashParam *sp )
    { 
        x2 = _mm256_add_epi32( x0, x2 );
        x3 = _mm256_add_epi32( x1, x3 );
-        y0 = x0;
-        x0 = mm256_rol_32( x1, 7 );
-        x1 = mm256_rol_32( y0, 7 );
-        x0 = _mm256_xor_si256( x0, x2 );
-        x1 = _mm256_xor_si256( x1, x3 );
+        y0 = mm256_rol_32( x1, 7 );
+        y1 = mm256_rol_32( x0, 7 );
+        x0 = _mm256_xor_si256( y0, x2 );
+        x1 = _mm256_xor_si256( y1, x3 );
        x2 = mm256_swap128_64( x2 );
        x3 = mm256_swap128_64( x3 );
        x2 = _mm256_add_epi32( x0, x2 );
        x3 = _mm256_add_epi32( x1, x3 );
-        y0 = mm256_swap_128( x0 );
-        y1 = mm256_swap_128( x1 );
-        x0 = mm256_rol_32( y0, 11 );
-        x1 = mm256_rol_32( y1, 11 );
+        x0 = mm256_swap_128( x0 );
+        x1 = mm256_swap_128( x1 );
+        x0 = mm256_rol_32( x0, 11 );
+        x1 = mm256_rol_32( x1, 11 );
        x0 = _mm256_xor_si256( x0, x2 );
        x1 = _mm256_xor_si256( x1, x3 );
        x2 = mm256_swap64_32( x2 );
@@ -94,47 +92,48 @@ static void transform( cubehashParam *sp )
    x6 = _mm_load_si128( (__m128i*)sp->x + 6 );
    x7 = _mm_load_si128( (__m128i*)sp->x + 7 );

-    for (r = 0; r < rounds; ++r) {
-	x4 = _mm_add_epi32(x0, x4);
-	x5 = _mm_add_epi32(x1, x5);
-	x6 = _mm_add_epi32(x2, x6);
-	x7 = _mm_add_epi32(x3, x7);
-	y0 = x2;
-	y1 = x3;
-	y2 = x0;
-	y3 = x1;
-	x0 = _mm_xor_si128(_mm_slli_epi32(y0, 7), _mm_srli_epi32(y0, 25));
-	x1 = _mm_xor_si128(_mm_slli_epi32(y1, 7), _mm_srli_epi32(y1, 25));
-	x2 = _mm_xor_si128(_mm_slli_epi32(y2, 7), _mm_srli_epi32(y2, 25));
-	x3 = _mm_xor_si128(_mm_slli_epi32(y3, 7), _mm_srli_epi32(y3, 25));
-	x0 = _mm_xor_si128(x0, x4);
-	x1 = _mm_xor_si128(x1, x5);
-	x2 = _mm_xor_si128(x2, x6);
-	x3 = _mm_xor_si128(x3, x7);
-	x4 = _mm_shuffle_epi32(x4, 0x4e);
-	x5 = _mm_shuffle_epi32(x5, 0x4e);
-	x6 = _mm_shuffle_epi32(x6, 0x4e);
-	x7 = _mm_shuffle_epi32(x7, 0x4e);
-	x4 = _mm_add_epi32(x0, x4);
-	x5 = _mm_add_epi32(x1, x5);
-	x6 = _mm_add_epi32(x2, x6);
-	x7 = _mm_add_epi32(x3, x7);
-	y0 = x1;
-	y1 = x0;
-	y2 = x3;
-	y3 = x2;
-	x0 = _mm_xor_si128(_mm_slli_epi32(y0, 11), _mm_srli_epi32(y0, 21));
-	x1 = _mm_xor_si128(_mm_slli_epi32(y1, 11), _mm_srli_epi32(y1, 21));
-	x2 = _mm_xor_si128(_mm_slli_epi32(y2, 11), _mm_srli_epi32(y2, 21));
-	x3 = _mm_xor_si128(_mm_slli_epi32(y3, 11), _mm_srli_epi32(y3, 21));
-	x0 = _mm_xor_si128(x0, x4);
-	x1 = _mm_xor_si128(x1, x5);
-	x2 = _mm_xor_si128(x2, x6);
-	x3 = _mm_xor_si128(x3, x7);
-	x4 = _mm_shuffle_epi32(x4, 0xb1);
-	x5 = _mm_shuffle_epi32(x5, 0xb1);
-	x6 = _mm_shuffle_epi32(x6, 0xb1);
-	x7 = _mm_shuffle_epi32(x7, 0xb1);
+    for ( r = 0; r < rounds; ++r )
+    {
+       x4 = _mm_add_epi32( x0, x4 );
+       x5 = _mm_add_epi32( x1, x5 );
+       x6 = _mm_add_epi32( x2, x6 );
+       x7 = _mm_add_epi32( x3, x7 );
+       y0 = x2;
+       y1 = x3;
+       y2 = x0;
+       y3 = x1;
+       x0 = mm128_rol_32( y0, 7 );
+       x1 = mm128_rol_32( y1, 7 );
+       x2 = mm128_rol_32( y2, 7 );
+       x3 = mm128_rol_32( y3, 7 );
+       x0 = _mm_xor_si128( x0, x4 );
+       x1 = _mm_xor_si128( x1, x5 );
+       x2 = _mm_xor_si128( x2, x6 );
+       x3 = _mm_xor_si128( x3, x7 );
+       x4 = _mm_shuffle_epi32( x4, 0x4e );
+       x5 = _mm_shuffle_epi32( x5, 0x4e );
+       x6 = _mm_shuffle_epi32( x6, 0x4e );
+       x7 = _mm_shuffle_epi32( x7, 0x4e );
+       x4 = _mm_add_epi32( x0, x4 );
+       x5 = _mm_add_epi32( x1, x5 );
+       x6 = _mm_add_epi32( x2, x6 );
+       x7 = _mm_add_epi32( x3, x7 );
+       y0 = x1;
+       y1 = x0;
+       y2 = x3;
+       y3 = x2;
+       x0 = mm128_rol_32( y0, 11 );
+       x1 = mm128_rol_32( y1, 11 );
+       x2 = mm128_rol_32( y2, 11 );
+       x3 = mm128_rol_32( y3, 11 );
+	    x0 = _mm_xor_si128( x0, x4 );
+	    x1 = _mm_xor_si128( x1, x5 );
+	    x2 = _mm_xor_si128( x2, x6 );
+	    x3 = _mm_xor_si128( x3, x7 );
+	    x4 = _mm_shuffle_epi32( x4, 0xb1 );
+	    x5 = _mm_shuffle_epi32( x5, 0xb1 );
+	    x6 = _mm_shuffle_epi32( x6, 0xb1 );
+	    x7 = _mm_shuffle_epi32( x7, 0xb1 );
    }

    _mm_store_si128( (__m128i*)sp->x,     x0 );
@@ -180,25 +179,25 @@ int cubehashInit(cubehashParam *sp, int hashbitlen, int rounds, int blockbytes)
    if ( hashbitlen == 512 )
    {

-       x[0] = m128_const_64( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
-       x[1] = m128_const_64( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
-       x[2] = m128_const_64( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
-       x[3] = m128_const_64( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
-       x[4] = m128_const_64( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
-       x[5] = m128_const_64( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
-       x[6] = m128_const_64( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
-       x[7] = m128_const_64( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
+       x[0] = _mm_set_epi64x( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
+       x[1] = _mm_set_epi64x( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
+       x[2] = _mm_set_epi64x( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
+       x[3] = _mm_set_epi64x( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
+       x[4] = _mm_set_epi64x( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
+       x[5] = _mm_set_epi64x( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
+       x[6] = _mm_set_epi64x( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
+       x[7] = _mm_set_epi64x( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
    }
    else
    {
-       x[0] = m128_const_64( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
-       x[1] = m128_const_64( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
-       x[2] = m128_const_64( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
-       x[3] = m128_const_64( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
-       x[4] = m128_const_64( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
-       x[5] = m128_const_64( 0x93CB628565C892FD, 0x5FA2560309392549 );
-       x[6] = m128_const_64( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
-       x[7] = m128_const_64( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
+       x[0] = _mm_set_epi64x( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
+       x[1] = _mm_set_epi64x( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
+       x[2] = _mm_set_epi64x( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
+       x[3] = _mm_set_epi64x( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
+       x[4] = _mm_set_epi64x( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
+       x[5] = _mm_set_epi64x( 0x93CB628565C892FD, 0x5FA2560309392549 );
+       x[6] = _mm_set_epi64x( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
+       x[7] = _mm_set_epi64x( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
    }   

    return SUCCESS;
@@ -234,10 +233,10 @@ int cubehashDigest( cubehashParam *sp, byte *digest )

    // pos is zero for 64 byte data, 1 for 80 byte data.
    sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ],
-                                      m128_const_64( 0, 0x80 ) );
+                                      _mm_set_epi64x( 0, 0x80 ) );
    transform( sp );

-    sp->x[7] = _mm_xor_si128( sp->x[7], m128_const_64( 0x100000000, 0 ) );
+    sp->x[7] = _mm_xor_si128( sp->x[7], _mm_set_epi64x( 0x100000000, 0 ) );
    transform( sp );
    transform( sp );
    transform( sp );
@@ -279,10 +278,10 @@ int cubehashUpdateDigest( cubehashParam *sp, byte *digest,

    // pos is zero for 64 byte data, 1 for 80 byte data.
    sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ],
-                                      m128_const_64( 0, 0x80 ) );
+                                      _mm_set_epi64x( 0, 0x80 ) );
    transform( sp );

-    sp->x[7] = _mm_xor_si128( sp->x[7], m128_const_64( 0x100000000, 0 ) );
+    sp->x[7] = _mm_xor_si128( sp->x[7], _mm_set_epi64x( 0x100000000, 0 ) );

    transform( sp );
    transform( sp );
@@ -313,25 +312,25 @@ int cubehash_full( cubehashParam *sp, byte *digest, int hashbitlen,
    if ( hashbitlen == 512 )
    {

-       x[0] = m128_const_64( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
-       x[1] = m128_const_64( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
-       x[2] = m128_const_64( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
-       x[3] = m128_const_64( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
-       x[4] = m128_const_64( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
-       x[5] = m128_const_64( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
-       x[6] = m128_const_64( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
-       x[7] = m128_const_64( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
+       x[0] = _mm_set_epi64x( 0x4167D83E2D538B8B, 0x50F494D42AEA2A61 );
+       x[1] = _mm_set_epi64x( 0x50AC5695CC39968E, 0xC701CF8C3FEE2313 );
+       x[2] = _mm_set_epi64x( 0x825B453797CF0BEF, 0xA647A8B34D42C787 );
+       x[3] = _mm_set_epi64x( 0xA23911AED0E5CD33, 0xF22090C4EEF864D2 );
+       x[4] = _mm_set_epi64x( 0xB64445321B017BEF, 0x148FE485FCD398D9 );
+       x[5] = _mm_set_epi64x( 0x0DBADEA991FA7934, 0x2FF5781C6A536159 );
+       x[6] = _mm_set_epi64x( 0xBC796576B1C62456, 0xA5A70E75D65C8A2B );
+       x[7] = _mm_set_epi64x( 0xD43E3B447795D246, 0xE7989AF11921C8F7 );
    }
    else
    {
-       x[0] = m128_const_64( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
-       x[1] = m128_const_64( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
-       x[2] = m128_const_64( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
-       x[3] = m128_const_64( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
-       x[4] = m128_const_64( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
-       x[5] = m128_const_64( 0x93CB628565C892FD, 0x5FA2560309392549 );
-       x[6] = m128_const_64( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
-       x[7] = m128_const_64( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
+       x[0] = _mm_set_epi64x( 0x35481EAE63117E71, 0xCCD6F29FEA2BD4B4 );
+       x[1] = _mm_set_epi64x( 0xF4CC12BE7E624131, 0xE5D94E6322512D5B );
+       x[2] = _mm_set_epi64x( 0x3361DA8CD0720C35, 0x42AF2070C2D0B696 );
+       x[3] = _mm_set_epi64x( 0x40E5FBAB4680AC00, 0x8EF8AD8328CCECA4 );
+       x[4] = _mm_set_epi64x( 0xF0B266796C859D41, 0x6107FBD5D89041C3 );
+       x[5] = _mm_set_epi64x( 0x93CB628565C892FD, 0x5FA2560309392549 );
+       x[6] = _mm_set_epi64x( 0x85254725774ABFDD, 0x9E4B4E602AF2B5AE );
+       x[7] = _mm_set_epi64x( 0xD6032C0A9CDAF8AF, 0x4AB6AAD615815AEB );
    }


@@ -358,10 +357,10 @@ int cubehash_full( cubehashParam *sp, byte *digest, int hashbitlen,

    // pos is zero for 64 byte data, 1 for 80 byte data.
    sp->x[ sp->pos ] = _mm_xor_si128( sp->x[ sp->pos ],
-                                      m128_const_64( 0, 0x80 ) );
+                                      _mm_set_epi64x( 0, 0x80 ) );
    transform( sp );

-    sp->x[7] = _mm_xor_si128( sp->x[7], m128_const_64( 0x100000000, 0 ) );
+    sp->x[7] = _mm_xor_si128( sp->x[7], _mm_set_epi64x( 0x100000000, 0 ) );

    transform( sp );
    transform( sp );
--- a/algo/cubehash/cubehash_sse2.h
+++ b/algo/cubehash/cubehash_sse2.h
@@ -3,7 +3,7 @@

 #include "compat.h"
 #include <stdint.h>
-#include "algo/sha/sha3-defs.h"
+#include "compat/sha3-defs.h"

 #define	OPTIMIZE_SSE2

--- a/algo/cubehash/sph_cubehash.h
+++ b/algo/cubehash/sph_cubehash.h
@@ -42,7 +42,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for CubeHash-224.
--- a/algo/echo/aes_ni/hash.c
+++ b/algo/echo/aes_ni/hash.c
@@ -566,16 +566,16 @@ HashReturn echo_full( hashState_echo *state, BitSequence *hashval,
         state->uHashSize = 256;
         state->uBlockLength = 192;
         state->uRounds = 8;
-         state->hashsize = m128_const_64( 0, 0x100 );
-         state->const1536 = m128_const_64( 0, 0x600 );
+         state->hashsize = _mm_set_epi64x( 0, 0x100 );
+         state->const1536 = _mm_set_epi64x( 0, 0x600 );
         break;

      case 512:
         state->uHashSize = 512;
         state->uBlockLength = 128;
         state->uRounds = 10;
-         state->hashsize = m128_const_64( 0, 0x200 );
-         state->const1536 = m128_const_64( 0, 0x400 );
+         state->hashsize = _mm_set_epi64x( 0, 0x200 );
+         state->const1536 = _mm_set_epi64x( 0, 0x400 );
         break;

      default:
--- a/algo/echo/aes_ni/hash_api.h
+++ b/algo/echo/aes_ni/hash_api.h
@@ -22,7 +22,7 @@
 #endif


-#include "algo/sha/sha3_common.h"
+#include "compat/sha3_common.h"

 #include <emmintrin.h>

--- a/algo/echo/echo-hash-4way.c
+++ b/algo/echo/echo-hash-4way.c
@@ -469,8 +469,7 @@ int echo_4way_full( echo_4way_context *ctx, void *hashval, int nHashSize,
   t1 = _mm256_and_si256( t1, lsbmask_2way ); \
   t2 = _mm256_shuffle_epi8( mul2mask_2way, t1 ); \
   s2 = _mm256_xor_si256( s2, t2 );\
-   state2[ 0 ][ j ] = _mm256_xor_si256( state2[ 0 ][ j ], \
-                              _mm256_xor_si256( s2, state1[ 1 ][ j1 ] ) ); \
+   state2[ 0 ][ j ] = mm256_xor3( state2[ 0 ][ j ], s2, state1[ 1 ][ j1 ] ); \
   state2[ 1 ][ j ] = _mm256_xor_si256( state2[ 1 ][ j ], s2 ); \
   state2[ 2 ][ j ] = _mm256_xor_si256( state2[ 2 ][ j ], state1[ 1 ][ j1 ] ); \
   state2[ 3 ][ j ] = _mm256_xor_si256( state2[ 3 ][ j ], state1[ 1 ][ j1 ] ); \
@@ -480,8 +479,7 @@ int echo_4way_full( echo_4way_context *ctx, void *hashval, int nHashSize,
   t2 = _mm256_shuffle_epi8( mul2mask_2way, t1 ); \
   s2 = _mm256_xor_si256( s2, t2 ); \
   state2[ 0 ][ j ] = _mm256_xor_si256( state2[ 0 ][ j ], state1[ 2 ][ j2 ] ); \
-   state2[ 1 ][ j ] = _mm256_xor_si256( state2[ 1 ][ j ], \
-                            _mm256_xor_si256( s2, state1[ 2 ][ j2 ] ) ); \
+   state2[ 1 ][ j ] = mm256_xor3( state2[ 1 ][ j ], s2, state1[ 2 ][ j2 ] ); \
   state2[ 2 ][ j ] = _mm256_xor_si256( state2[ 2 ][ j ], s2 ); \
   state2[ 3 ][ j ] = _mm256_xor_si256( state2[ 3][ j ], state1[ 2 ][ j2 ] ); \
   s2 = _mm256_add_epi8( state1[ 3 ][ j3 ], state1[ 3 ][ j3 ] ); \
@@ -491,8 +489,7 @@ int echo_4way_full( echo_4way_context *ctx, void *hashval, int nHashSize,
   s2 = _mm256_xor_si256( s2, t2 ); \
   state2[ 0 ][ j ] = _mm256_xor_si256( state2[ 0 ][ j ], state1[ 3 ][ j3 ] ); \
   state2[ 1 ][ j ] = _mm256_xor_si256( state2[ 1 ][ j ], state1[ 3 ][ j3 ] ); \
-   state2[ 2 ][ j ] = _mm256_xor_si256( state2[ 2 ][ j ], \
-                            _mm256_xor_si256( s2, state1[ 3 ][ j3] ) ); \
+   state2[ 2 ][ j ] = mm256_xor3( state2[ 2 ][ j ], s2, state1[ 3 ][ j3] ); \
   state2[ 3 ][ j ] = _mm256_xor_si256( state2[ 3 ][ j ], s2 ); \
 } while(0)

--- a/algo/echo/sph_echo.c
+++ b/algo/echo/sph_echo.c
@@ -73,7 +73,7 @@ extern "C"{
 #endif

 #define AES_BIG_ENDIAN   0
-#include "algo/sha/aes_helper.c"
+#include "compat/aes_helper.c"

 #if SPH_ECHO_64

--- a/algo/echo/sph_echo.h
+++ b/algo/echo/sph_echo.h
@@ -43,7 +43,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for ECHO-224.
--- a/algo/fugue/fugue-aesni.c
+++ b/algo/fugue/fugue-aesni.c
@@ -33,11 +33,11 @@ MYALIGN const unsigned long long _supermix4b[]	= {0x07020d08080e0d0d, 0x07070908
 MYALIGN const unsigned long long _supermix4c[]	= {0x0706050403020000, 0x0302000007060504};
 MYALIGN const unsigned long long _supermix7a[]	= {0x010c0b060d080702, 0x0904030e03000104};
 MYALIGN const unsigned long long _supermix7b[]	= {0x8080808080808080, 0x0504070605040f06};
-MYALIGN const unsigned long long _k_n[] = {0x4E4E4E4E4E4E4E4E, 0x1B1B1B1B0E0E0E0E};
-MYALIGN const unsigned char _shift_one_mask[]   = {7, 4, 5, 6, 11, 8, 9, 10, 15, 12, 13, 14, 3, 0, 1, 2};
-MYALIGN const unsigned char _shift_four_mask[]  = {13, 14, 15, 12, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8};
-MYALIGN const unsigned char _shift_seven_mask[] = {10, 11, 8, 9, 14, 15, 12, 13, 2, 3, 0, 1, 6, 7, 4, 5};
-MYALIGN const unsigned char _aes_shift_rows[]   = {0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11};
+//MYALIGN const unsigned long long _k_n[] = {0x4E4E4E4E4E4E4E4E, 0x1B1B1B1B0E0E0E0E};
+//MYALIGN const unsigned char _shift_one_mask[]   = {7, 4, 5, 6, 11, 8, 9, 10, 15, 12, 13, 14, 3, 0, 1, 2};
+//MYALIGN const unsigned char _shift_four_mask[]  = {13, 14, 15, 12, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8};
+//MYALIGN const unsigned char _shift_seven_mask[] = {10, 11, 8, 9, 14, 15, 12, 13, 2, 3, 0, 1, 6, 7, 4, 5};
+//MYALIGN const unsigned char _aes_shift_rows[]   = {0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11};
 MYALIGN const unsigned int _inv_shift_rows[] = {0x070a0d00, 0x0b0e0104, 0x0f020508, 0x0306090c};
 MYALIGN const unsigned int _mul2mask[] = {0x1b1b0000, 0x00000000, 0x00000000, 0x00000000};
 MYALIGN const unsigned int _mul4mask[] = {0x2d361b00, 0x00000000, 0x00000000, 0x00000000};
@@ -131,7 +131,7 @@ MYALIGN const unsigned int _IV512[] = {
   t1 = _mm_srli_epi16(t0, 6);\
   t1 = _mm_and_si128(t1, M128(_lsbmask2));\
   t3 = _mm_xor_si128(t3, _mm_shuffle_epi8(M128(_mul2mask), t1));\
-   t0  = _mm_xor_si128(t4, _mm_shuffle_epi8(M128(_mul4mask), t1))
+   t0 = _mm_xor_si128(t4, _mm_shuffle_epi8(M128(_mul4mask), t1))

 /*
 #define PRESUPERMIX(x, t1, s1, s2, t2)\
--- a/algo/fugue/fugue-aesni.h
+++ b/algo/fugue/fugue-aesni.h
@@ -20,7 +20,7 @@
 #error "Unsupported configuration, AES needs SSE4.1. Compile without AES."
 #endif

-#include "algo/sha/sha3_common.h"
+#include "compat/sha3_common.h"
 #include "simd-utils.h"


--- a/algo/fugue/sph_fugue.h
+++ b/algo/fugue/sph_fugue.h
@@ -2,7 +2,7 @@
 #define SPH_FUGUE_H__

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 #ifdef __cplusplus
 extern "C"{
--- a/algo/gost/sph_gost.h
+++ b/algo/gost/sph_gost.h
@@ -41,7 +41,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for GOST-256.
--- a/algo/groestl/aes_ni/groestl-intr-aes.h
+++ b/algo/groestl/aes_ni/groestl-intr-aes.h
@@ -139,7 +139,7 @@ static const __m128i SUBSH_MASK7 = { 0x06090c0f0205080b, 0x0e0104070a0d0003 };
  \
  /* compute z_i : double x_i using temp xmm8 and 1B xmm9 */\
  /* compute w_i : add y_{i+4} */\
-  b1 = m128_const1_64( 0x1b1b1b1b1b1b1b1b );\
+  b1 = _mm_set1_epi64x( 0x1b1b1b1b1b1b1b1b );\
  MUL2(a0, b0, b1);\
  a0 = _mm_xor_si128(a0, TEMP0);\
  MUL2(a1, b0, b1);\
@@ -237,7 +237,7 @@ static const __m128i SUBSH_MASK7 = { 0x06090c0f0205080b, 0x0e0104070a0d0003 };
  \
  /* compute z_i : double x_i using temp xmm8 and 1B xmm9 */\
  /* compute w_i : add y_{i+4} */\
-  b1 = m128_const1_64( 0x1b1b1b1b1b1b1b1b );\
+  b1 = _mm_set1_epi64x( 0x1b1b1b1b1b1b1b1b );\
  MUL2(a0, b0, b1);\
  a0 = _mm_xor_si128(a0, TEMP0);\
  MUL2(a1, b0, b1);\
--- a/algo/groestl/aes_ni/groestl256-intr-aes.h
+++ b/algo/groestl/aes_ni/groestl256-intr-aes.h
@@ -128,7 +128,7 @@ static const __m128i SUBSH_MASK7 = { 0x090c000306080b07, 0x02050f0a0d01040e };
  \
  /* compute z_i : double x_i using temp xmm8 and 1B xmm9 */\
  /* compute w_i : add y_{i+4} */\
-  b1 = m128_const1_64( 0x1b1b1b1b1b1b1b1b );\
+  b1 = _mm_set1_epi64x( 0x1b1b1b1b1b1b1b1b );\
  MUL2(a0, b0, b1);\
  a0 = _mm_xor_si128(a0, TEMP0);\
  MUL2(a1, b0, b1);\
@@ -226,7 +226,7 @@ static const __m128i SUBSH_MASK7 = { 0x090c000306080b07, 0x02050f0a0d01040e };
  \
  /* compute z_i : double x_i using temp xmm8 and 1B xmm9 */\
  /* compute w_i : add y_{i+4} */\
-  b1 = m128_const1_64( 0x1b1b1b1b1b1b1b1b );\
+  b1 = _mm_set1_epi64x( 0x1b1b1b1b1b1b1b1b );\
  MUL2(a0, b0, b1);\
  a0 = _mm_xor_si128(a0, TEMP0);\
  MUL2(a1, b0, b1);\
@@ -275,7 +275,7 @@ static const __m128i SUBSH_MASK7 = { 0x090c000306080b07, 0x02050f0a0d01040e };
 */
 #define ROUND(i, a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7){\
  /* AddRoundConstant */\
-  b1 = m128_const_64( 0xffffffffffffffff, 0 ); \
+  b1 = _mm_set_epi64x( 0xffffffffffffffff, 0 ); \
  a0 = _mm_xor_si128( a0, casti_m128i( round_const_l0, i ) ); \
  a1 = _mm_xor_si128( a1, b1 ); \
  a2 = _mm_xor_si128( a2, b1 ); \
--- a/algo/groestl/aes_ni/hash-groestl.c
+++ b/algo/groestl/aes_ni/hash-groestl.c
@@ -31,7 +31,7 @@ HashReturn_gr init_groestl( hashState_groestl* ctx, int hashlen )
  }

  // The only non-zero in the IV is len. It can be hard coded.
-  ctx->chaining[ 6 ] = m128_const_64( 0x0200000000000000, 0 );
+  ctx->chaining[ 6 ] = _mm_set_epi64x( 0x0200000000000000, 0 );

  ctx->buf_ptr = 0;
  ctx->rem_ptr = 0;
@@ -48,7 +48,7 @@ HashReturn_gr reinit_groestl( hashState_groestl* ctx )
     ctx->chaining[i] = _mm_setzero_si128();
     ctx->buffer[i]   = _mm_setzero_si128();
  }
-  ctx->chaining[ 6 ] = m128_const_64( 0x0200000000000000, 0 );
+  ctx->chaining[ 6 ] = _mm_set_epi64x( 0x0200000000000000, 0 );
  ctx->buf_ptr = 0;
  ctx->rem_ptr = 0;

@@ -116,7 +116,7 @@ HashReturn_gr final_groestl( hashState_groestl* ctx, void* output )
   else
   {
       // add first padding
-       ctx->buffer[rem_ptr] = m128_const_64( 0, 0x80 );
+       ctx->buffer[rem_ptr] = _mm_set_epi64x( 0, 0x80 );
       // add zero padding
       for ( i = rem_ptr + 1; i < SIZE512 - 1; i++ )
           ctx->buffer[i] = _mm_setzero_si128();
@@ -148,7 +148,7 @@ int groestl512_full( hashState_groestl* ctx, void* output,
      ctx->chaining[i] = _mm_setzero_si128();
      ctx->buffer[i]   = _mm_setzero_si128();
   }
-   ctx->chaining[ 6 ] = m128_const_64( 0x0200000000000000, 0 );
+   ctx->chaining[ 6 ] = _mm_set_epi64x( 0x0200000000000000, 0 );
   ctx->buf_ptr = 0;

   // --- update ---
@@ -182,7 +182,7 @@ int groestl512_full( hashState_groestl* ctx, void* output,
   else
   {
       // add first padding
-       ctx->buffer[i] = m128_const_64( 0, 0x80 );
+       ctx->buffer[i] = _mm_set_epi64x( 0, 0x80 );
       // add zero padding
       for ( i += 1; i < SIZE512 - 1; i++ )
           ctx->buffer[i] = _mm_setzero_si128();
@@ -239,7 +239,7 @@ HashReturn_gr update_and_final_groestl( hashState_groestl* ctx, void* output,
   else
   {
       // add first padding
-       ctx->buffer[i] = m128_const_64( 0, 0x80 );
+       ctx->buffer[i] = _mm_set_epi64x( 0, 0x80 );
       // add zero padding
       for ( i += 1; i < SIZE512 - 1; i++ )
           ctx->buffer[i] = _mm_setzero_si128();
--- a/algo/groestl/aes_ni/hash-groestl.h
+++ b/algo/groestl/aes_ni/hash-groestl.h
@@ -20,8 +20,8 @@
 #define LENGTH (512)

 #include "brg_endian.h"
-#define NEED_UINT_64T
-#include "algo/sha/brg_types.h"
+//#define NEED_UINT_64T
+#include "compat/brg_types.h"

 /* some sizes (number of bytes) */
 #define ROWS (8)
--- a/algo/groestl/aes_ni/hash-groestl256.c
+++ b/algo/groestl/aes_ni/hash-groestl256.c
@@ -46,7 +46,7 @@ HashReturn_gr reinit_groestl256(hashState_groestl256* ctx)
     ctx->buffer[i]   = _mm_setzero_si128();
  }

-  ctx->chaining[ 3 ] = m128_const_64( 0, 0x0100000000000000 );
+  ctx->chaining[ 3 ] = _mm_set_epi64x( 0, 0x0100000000000000 );

  ctx->buf_ptr = 0;
  ctx->rem_ptr = 0;
--- a/algo/groestl/aes_ni/hash-groestl256.h
+++ b/algo/groestl/aes_ni/hash-groestl256.h
@@ -34,8 +34,7 @@ typedef crypto_uint64 u64;
 //#define LENGTH (512)

 #include "brg_endian.h"
-#define NEED_UINT_64T
-#include "algo/sha/brg_types.h"
+#include "compat/brg_types.h"

 #ifdef IACA_TRACE
  #include IACA_MARKS
--- a/algo/groestl/groestl-gate.c
+++ b/algo/groestl/groestl-gate.c
@@ -17,7 +17,7 @@ bool register_dmd_gr_algo( algo_gate_t *gate )
 bool register_groestl_algo( algo_gate_t* gate )
 {
    register_dmd_gr_algo( gate );
-    gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
+    gate->gen_merkle_root = (void*)&sha256_gen_merkle_root;
    return true;
 };

--- a/algo/groestl/groestl256-hash-4way.h
+++ b/algo/groestl/groestl256-hash-4way.h
@@ -22,10 +22,6 @@

 #define LENGTH (256)

-//#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)
--- a/algo/groestl/groestl256-intr-4way.h
+++ b/algo/groestl/groestl256-intr-4way.h
@@ -539,7 +539,7 @@ static const __m256i SUBSH_MASK7_2WAY =
  j = _mm256_cmpgt_epi8(j, i );\
  i = _mm256_add_epi8(i, i);\
  j = _mm256_and_si256(j, k);\
-  i = _mm256_xor_si256(i, j);\
+  i = mm256_xorand( i, j, k );\
 }

 #define MixBytes_2way(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7){\
@@ -550,7 +550,7 @@ static const __m256i SUBSH_MASK7_2WAY =
  b0 = a2;\
  a1 = _mm256_xor_si256(a1, a2);\
  b1 = a3;\
-  a2 = _mm256_xor_si256(a2, a3);\
+  TEMP2 = _mm256_xor_si256(a2, a3);\
  b2 = a4;\
  a3 = _mm256_xor_si256(a3, a4);\
  b3 = a5;\
@@ -562,34 +562,20 @@ static const __m256i SUBSH_MASK7_2WAY =
  a7 = _mm256_xor_si256(a7, b6);\
  \
  /* build y4 y5 y6 ... in regs xmm8, xmm9, xmm10 by adding t_i*/\
-  b0 = _mm256_xor_si256(b0, a4);\
-  b6 = _mm256_xor_si256(b6, a4);\
-  b1 = _mm256_xor_si256(b1, a5);\
-  b7 = _mm256_xor_si256(b7, a5);\
-  b2 = _mm256_xor_si256(b2, a6);\
-  b0 = _mm256_xor_si256(b0, a6);\
-  /* spill values y_4, y_5 to memory */\
-  TEMP0 = b0;\
-  b3 = _mm256_xor_si256(b3, a7);\
-  b1 = _mm256_xor_si256(b1, a7);\
-  TEMP1 = b1;\
-  b4 = _mm256_xor_si256(b4, a0);\
-  b2 = _mm256_xor_si256(b2, a0);\
-  /* save values t0, t1, t2 to xmm8, xmm9 and memory */\
-  b0 = a0;\
-  b5 = _mm256_xor_si256(b5, a1);\
-  b3 = _mm256_xor_si256(b3, a1);\
-  b1 = a1;\
-  b6 = _mm256_xor_si256(b6, a2);\
-  b4 = _mm256_xor_si256(b4, a2);\
-  TEMP2 = a2;\
-  b7 = _mm256_xor_si256(b7, a3);\
-  b5 = _mm256_xor_si256(b5, a3);\
-  \
+  TEMP0 = mm256_xor3( b0, a4, a6 ); \
+  TEMP1 = mm256_xor3( b1, a5, a7 ); \
+  b2 = mm256_xor3( b2, a6, a0 ); \
+  b0 = a0; \
+  b3 = mm256_xor3( b3, a7, a1 ); \
+  b1 = a1; \
+  b6 = mm256_xor3( b6, a4, TEMP2 ); \
+  b4 = mm256_xor3( b4, a0, TEMP2 ); \
+  b7 = mm256_xor3( b7, a5, a3 ); \
+  b5 = mm256_xor3( b5, a1, a3 ); \
  /* compute x_i = t_i + t_{i+3} */\
  a0 = _mm256_xor_si256(a0, a3);\
  a1 = _mm256_xor_si256(a1, a4);\
-  a2 = _mm256_xor_si256(a2, a5);\
+  a2 = _mm256_xor_si256( TEMP2, a5);\
  a3 = _mm256_xor_si256(a3, a6);\
  a4 = _mm256_xor_si256(a4, a7);\
  a5 = _mm256_xor_si256(a5, b0);\
@@ -671,7 +657,6 @@ static const __m256i SUBSH_MASK7_2WAY =
  \
  /* MixBytes */\
  MixBytes_2way(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7);\
-\
 }

 /* 10 rounds, P and Q in parallel */
--- a/algo/groestl/groestl512-intr-4way.h
+++ b/algo/groestl/groestl512-intr-4way.h
@@ -710,7 +710,7 @@ static const __m256i SUBSH_MASK7_2WAY =
  b0 = a2;\
  a1 = _mm256_xor_si256(a1, a2);\
  b1 = a3;\
-  a2 = _mm256_xor_si256(a2, a3);\
+  TEMP2 = _mm256_xor_si256(a2, a3);\
  b2 = a4;\
  a3 = _mm256_xor_si256(a3, a4);\
  b3 = a5;\
@@ -722,34 +722,23 @@ static const __m256i SUBSH_MASK7_2WAY =
  a7 = _mm256_xor_si256(a7, b6);\
  \
  /* build y4 y5 y6 ... in regs xmm8, xmm9, xmm10 by adding t_i*/\
-  b0 = _mm256_xor_si256(b0, a4);\
-  b6 = _mm256_xor_si256(b6, a4);\
-  b1 = _mm256_xor_si256(b1, a5);\
-  b7 = _mm256_xor_si256(b7, a5);\
-  b2 = _mm256_xor_si256(b2, a6);\
-  b0 = _mm256_xor_si256(b0, a6);\
+  TEMP0 = mm256_xor3( b0, a4, a6 ); \
  /* spill values y_4, y_5 to memory */\
-  TEMP0 = b0;\
-  b3 = _mm256_xor_si256(b3, a7);\
-  b1 = _mm256_xor_si256(b1, a7);\
-  TEMP1 = b1;\
-  b4 = _mm256_xor_si256(b4, a0);\
-  b2 = _mm256_xor_si256(b2, a0);\
+  TEMP1 = mm256_xor3( b1, a5, a7 ); \
+  b2 = mm256_xor3( b2, a6, a0 ); \
  /* save values t0, t1, t2 to xmm8, xmm9 and memory */\
-  b0 = a0;\
-  b5 = _mm256_xor_si256(b5, a1);\
-  b3 = _mm256_xor_si256(b3, a1);\
-  b1 = a1;\
-  b6 = _mm256_xor_si256(b6, a2);\
-  b4 = _mm256_xor_si256(b4, a2);\
-  TEMP2 = a2;\
-  b7 = _mm256_xor_si256(b7, a3);\
-  b5 = _mm256_xor_si256(b5, a3);\
+  b0 = a0; \
+  b3 = mm256_xor3( b3, a7, a1 ); \
+  b1 = a1; \
+  b6 = mm256_xor3( b6, a4, TEMP2 ); \
+  b4 = mm256_xor3( b4, a0, TEMP2 ); \
+  b7 = mm256_xor3( b7, a5, a3 ); \
+  b5 = mm256_xor3( b5, a1, a3 ); \
  \
  /* compute x_i = t_i + t_{i+3} */\
  a0 = _mm256_xor_si256(a0, a3);\
  a1 = _mm256_xor_si256(a1, a4);\
-  a2 = _mm256_xor_si256(a2, a5);\
+  a2 = _mm256_xor_si256( TEMP2, a5);\
  a3 = _mm256_xor_si256(a3, a6);\
  a4 = _mm256_xor_si256(a4, a7);\
  a5 = _mm256_xor_si256(a5, b0);\
--- a/algo/groestl/myrgr-4way.c
+++ b/algo/groestl/myrgr-4way.c
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include <string.h>
 #include "aes_ni/hash-groestl.h"
-#include "algo/sha/sha-hash-4way.h"
+#include "algo/sha/sha256-hash.h"
 #if defined(__VAES__)
  #include "groestl512-hash-4way.h"
 #endif
--- a/algo/groestl/sph_groestl.h
+++ b/algo/groestl/sph_groestl.h
@@ -40,7 +40,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 #if !defined(__AES__)   
 /**
--- a/algo/hamsi/hamsi-hash-4way.c
+++ b/algo/hamsi/hamsi-hash-4way.c
--- a/algo/hamsi/hamsi-hash-4way.h
+++ b/algo/hamsi/hamsi-hash-4way.h
@@ -36,44 +36,64 @@
 #define HAMSI_4WAY_H__

 #include <stddef.h>
-#include "algo/sha/sph_types.h"

 #if defined (__AVX2__)

 #include "simd-utils.h"

-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#define SPH_SIZE_hamsi512   512
+// Hamsi-512 4x64

 // Partial is only scalar but needs pointer ref for hamsi-helper
 // deprecate partial_len
-typedef struct {
+typedef struct
+{
   __m256i h[8];
   __m256i buf[1];
   size_t partial_len;
-   sph_u32 count_high, count_low;
+   uint32_t count_high, count_low;
 } hamsi_4way_big_context;
-
 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
 void hamsi512_4way_close( hamsi512_4way_context *sc, void *dst );

+#define hamsi512_4x64_context   hamsi512_4way_context
+#define hamsi512_4x64_init      hamsi512_4way_init
+#define hamsi512_4x64_update    hamsi512_4way_update
+#define hamsi512_4x64_close     hamsi512_4way_close
+
+// Hamsi-512 8x32
+
+typedef struct
+{
+   __m256i h[16];
+   __m256i buf[2];
+   size_t partial_len;
+   uint32_t count_high, count_low;
+} hamsi_8x32_big_context;
+typedef hamsi_8x32_big_context hamsi512_8x32_context;
+
+void hamsi512_8x32_init( hamsi512_8x32_context *sc );
+void hamsi512_8x32_update( hamsi512_8x32_context *sc, const void *data,
+      size_t len );
+void hamsi512_8x32_close( hamsi512_8x32_context *sc, void *dst );
+void hamsi512_8x32_full( hamsi512_8x32_context *sc, void *dst, const void *data,
+      size_t len );
+
+#endif
+
 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)

+// Hamsi-512 8x64
+
 typedef struct {
   __m512i h[8];
   __m512i buf[1];
   size_t partial_len;
-   sph_u32 count_high, count_low;
+   uint32_t count_high, count_low;
 } hamsi_8way_big_context;
-
 typedef hamsi_8way_big_context hamsi512_8way_context;

 void hamsi512_8way_init( hamsi512_8way_context *sc );
@@ -81,15 +101,29 @@ void hamsi512_8way_update( hamsi512_8way_context *sc, const void *data,
                           size_t len );
 void hamsi512_8way_close( hamsi512_8way_context *sc, void *dst );

+#define hamsi512_8x64_context   hamsi512_8way_context
+#define hamsi512_8x64_init      hamsi512_8way_init
+#define hamsi512_8x64_update    hamsi512_8way_update
+#define hamsi512_8x64_close     hamsi512_8way_close

-
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+// Hamsi-512 16x32
+
+typedef struct
+{
+   __m512i h[16];
+   __m512i buf[2];
+   size_t partial_len;
+   uint32_t count_high, count_low;
+} hamsi_16x32_big_context;
+typedef hamsi_16x32_big_context hamsi512_16x32_context;
+
+void hamsi512_16x32_init( hamsi512_16x32_context *sc );
+void hamsi512_16x32_update( hamsi512_16x32_context *sc, const void *data,
+                           size_t len );
+void hamsi512_16way_close( hamsi512_16x32_context *sc, void *dst );
+void hamsi512_16x32_full( hamsi512_16x32_context *sc, void *dst,
+                          const void *data, size_t len );
+
+#endif   // AVX512

 #endif
--- a/algo/hamsi/sph_hamsi.h
+++ b/algo/hamsi/sph_hamsi.h
@@ -36,7 +36,7 @@
 #define SPH_HAMSI_H__

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 #ifdef __cplusplus
 extern "C"{
--- a/algo/haval/haval-4way-helper.c
+++ b/algo/haval/haval-4way-helper.c
@@ -48,7 +48,7 @@ SPH_XCAT(SPH_XCAT(haval, PASSES), _4way_update)
   while ( len > 0 )
   {
      unsigned clen;
-      sph_u32 clow, clow2;
+      uint32_t clow, clow2;

      clen = 128U - current;
      if ( clen > len )
@@ -67,7 +67,7 @@ SPH_XCAT(SPH_XCAT(haval, PASSES), _4way_update)
         current = 0;
      }
      clow = sc->count_low;
-      clow2 = SPH_T32(clow + clen);
+      clow2 = clow + clen;
      sc->count_low = clow2;
      if ( clow2 < clow )
         sc->count_high ++;
--- a/algo/haval/haval-hash-4way.c
+++ b/algo/haval/haval-hash-4way.c
@@ -52,6 +52,56 @@ extern "C"{
 #define SPH_SMALL_FOOTPRINT_HAVAL   1
 //#endif

+#if defined(__AVX512VL__)
+
+// ( ~( a ^ b ) ) & c
+#define mm128_andnotxor( a, b, c ) \
+   _mm_ternarylogic_epi32( a, b, c, 0x82  )
+
+#else
+
+#define mm128_andnotxor( a, b, c ) \
+   _mm_andnot_si128( _mm_xor_si128( a, b ), c )
+
+#endif
+
+#define F1(x6, x5, x4, x3, x2, x1, x0) \
+ mm128_xor3( x0, mm128_andxor( x1, x0, x4 ), \
+                 _mm_xor_si128( _mm_and_si128( x2, x5 ), \
+                                _mm_and_si128( x3, x6 ) ) ) \
+
+#define F2(x6, x5, x4, x3, x2, x1, x0) \
+   mm128_xor3( mm128_andxor( x2, _mm_andnot_si128( x3, x1 ), \
+                       mm128_xor3( _mm_and_si128( x4, x5 ), x6, x0 )  ), \
+               mm128_andxor( x4, x1, x5 ), \
+               mm128_xorand( x0, x3, x5 ) ) \
+
+#define F3(x6, x5, x4, x3, x2, x1, x0) \
+  mm128_xor3( x0, \
+              _mm_and_si128( x3, \
+                         mm128_xor3( _mm_and_si128( x1, x2 ), x6, x0 ) ), \
+              _mm_xor_si128( _mm_and_si128( x1, x4 ), \
+                             _mm_and_si128( x2, x5 ) ) )
+
+#define F4(x6, x5, x4, x3, x2, x1, x0) \
+  mm128_xor3( \
+      mm128_andxor( x3, x5, \
+                    _mm_xor_si128( _mm_and_si128( x1, x2 ), \
+                                      _mm_or_si128( x4, x6 ) ) ), \
+      _mm_and_si128( x4, \
+                        mm128_xor3( x0, _mm_andnot_si128( x2, x5 ), \
+                                    _mm_xor_si128( x1, x6 ) ) ), \
+      mm128_xorand( x0, x2, x6 ) )
+
+#define F5(x6, x5, x4, x3, x2, x1, x0) \
+   _mm_xor_si128( \
+         mm128_andnotxor( mm128_and3( x1, x2, x3 ), x5, x0 ), \
+         mm128_xor3( _mm_and_si128( x1, x4 ), \
+                     _mm_and_si128( x2, x5 ), \
+                     _mm_and_si128( x3, x6 ) ) )
+  
+
+/*
 #define F1(x6, x5, x4, x3, x2, x1, x0) \
   _mm_xor_si128( x0, \
       _mm_xor_si128( _mm_and_si128(_mm_xor_si128( x0, x4 ), x1 ), \
@@ -96,6 +146,7 @@ extern "C"{
      _mm_xor_si128( _mm_xor_si128( _mm_and_si128( x1, x4 ), \
                                    _mm_and_si128( x2, x5 ) ), \
                                    _mm_and_si128( x3, x6 ) ) )
+*/

 /*
 * The macros below integrate the phi() permutations, depending on the
@@ -241,7 +292,9 @@ static const unsigned MP5[32] = {
 	 2, 23, 16, 22,  4,  1, 25, 15
 };

-static const sph_u32 RK2[32] = {
+#define SPH_C32(x) (x)
+
+static const uint32_t RK2[32] = {
 	SPH_C32(0x452821E6), SPH_C32(0x38D01377),
 	SPH_C32(0xBE5466CF), SPH_C32(0x34E90C6C),
 	SPH_C32(0xC0AC29B7), SPH_C32(0xC97C50DD),
@@ -260,7 +313,7 @@ static const sph_u32 RK2[32] = {
 	SPH_C32(0x7B54A41D), SPH_C32(0xC25A59B5)
 };

-static const sph_u32 RK3[32] = {
+static const uint32_t RK3[32] = {
 	SPH_C32(0x9C30D539), SPH_C32(0x2AF26013),
 	SPH_C32(0xC5D1B023), SPH_C32(0x286085F0),
 	SPH_C32(0xCA417918), SPH_C32(0xB8DB38EF),
@@ -279,7 +332,7 @@ static const sph_u32 RK3[32] = {
 	SPH_C32(0xAFD6BA33), SPH_C32(0x6C24CF5C)
 };

-static const sph_u32 RK4[32] = {
+static const uint32_t RK4[32] = {
 	SPH_C32(0x7A325381), SPH_C32(0x28958677),
 	SPH_C32(0x3B8F4898), SPH_C32(0x6B4BB9AF),
 	SPH_C32(0xC4BFE81B), SPH_C32(0x66282193),
@@ -298,7 +351,7 @@ static const sph_u32 RK4[32] = {
 	SPH_C32(0x6EEF0B6C), SPH_C32(0x137A3BE4)
 };

-static const sph_u32 RK5[32] = {
+static const uint32_t RK5[32] = {
 	SPH_C32(0xBA3BF050), SPH_C32(0x7EFB2A98),
 	SPH_C32(0xA1F1651D), SPH_C32(0x39AF0176),
 	SPH_C32(0x66CA593E), SPH_C32(0x82430E88),
@@ -740,14 +793,14 @@ do { \
 static void
 haval_8way_init( haval_8way_context *sc, unsigned olen, unsigned passes )
 {
-   sc->s0 = m256_const1_32( 0x243F6A88UL );
-   sc->s1 = m256_const1_32( 0x85A308D3UL );
-   sc->s2 = m256_const1_32( 0x13198A2EUL );
-   sc->s3 = m256_const1_32( 0x03707344UL );
-   sc->s4 = m256_const1_32( 0xA4093822UL );
-   sc->s5 = m256_const1_32( 0x299F31D0UL );
-   sc->s6 = m256_const1_32( 0x082EFA98UL );
-   sc->s7 = m256_const1_32( 0xEC4E6C89UL );
+   sc->s0 = _mm256_set1_epi32( 0x243F6A88UL );
+   sc->s1 = _mm256_set1_epi32( 0x85A308D3UL );
+   sc->s2 = _mm256_set1_epi32( 0x13198A2EUL );
+   sc->s3 = _mm256_set1_epi32( 0x03707344UL );
+   sc->s4 = _mm256_set1_epi32( 0xA4093822UL );
+   sc->s5 = _mm256_set1_epi32( 0x299F31D0UL );
+   sc->s6 = _mm256_set1_epi32( 0x082EFA98UL );
+   sc->s7 = _mm256_set1_epi32( 0xEC4E6C89UL );
   sc->olen = olen;
   sc->passes = passes;
   sc->count_high = 0;
--- a/algo/haval/haval-hash-4way.h
+++ b/algo/haval/haval-hash-4way.h
@@ -68,7 +68,6 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
 #include "simd-utils.h"

 #define SPH_SIZE_haval256_5   256
@@ -77,7 +76,7 @@ typedef struct {
   __m128i buf[32];
   __m128i s0, s1, s2, s3, s4, s5, s6, s7;
   unsigned olen, passes;
-   sph_u32 count_high, count_low;
+   uint32_t count_high, count_low;
 } haval_4way_context;

 typedef haval_4way_context haval256_5_4way_context;
--- a/algo/haval/sph-haval.h
+++ b/algo/haval/sph-haval.h
@@ -66,7 +66,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for HAVAL-128/3.
--- a/algo/jh/jh-hash-4way.c
+++ b/algo/jh/jh-hash-4way.c
@@ -76,19 +76,31 @@ do { \

 #endif

+#if defined(__AVX512VL__)
+//TODO enable for AVX10_256, not used with AVX512VL
+
+#define notxorandnot( a, b, c ) \
+   _mm256_ternarylogic_epi64( a, b, c, 0x2d )
+
+#else
+
+#define notxorandnot( a, b, c ) \
+   _mm256_xor_si256( mm256_not( a ), _mm256_andnot_si256( b, c ) )
+
+#endif
+
 #define Sb(x0, x1, x2, x3, c) \
 do { \
-   const __m256i cc = _mm256_set1_epi64x( c ); \
-    x3 = mm256_not( x3 ); \
-    x0 = _mm256_xor_si256( x0, _mm256_andnot_si256( x2, cc ) ); \
-    tmp = _mm256_xor_si256( cc, _mm256_and_si256( x0, x1 ) ); \
-    x0 = _mm256_xor_si256( x0, _mm256_and_si256( x2, x3 ) ); \
-    x3 = _mm256_xor_si256( x3, _mm256_andnot_si256( x1, x2 ) ); \
-    x1 = _mm256_xor_si256( x1, _mm256_and_si256( x0, x2 ) ); \
-    x2 = _mm256_xor_si256( x2, _mm256_andnot_si256( x3, x0 ) ); \
-    x0 = _mm256_xor_si256( x0, _mm256_or_si256( x1, x3 ) ); \
-    x3 = _mm256_xor_si256( x3, _mm256_and_si256( x1, x2 ) ); \
-    x1 = _mm256_xor_si256( x1, _mm256_and_si256( tmp, x0 ) ); \
+    const __m256i cc = _mm256_set1_epi64x( c ); \
+    x0 = mm256_xorandnot( x0, x2, cc ); \
+    tmp = mm256_xorand( cc, x0, x1 ); \
+    x0 = mm256_xorandnot( x0, x3, x2 ); \
+    x3 = notxorandnot( x3, x1, x2 ); \
+    x1 = mm256_xorand( x1, x0, x2 ); \
+    x2 = mm256_xorandnot( x2, x3, x0 ); \
+    x0 = mm256_xoror( x0, x1, x3 ); \
+    x3 = mm256_xorand( x3, x1, x2 ); \
+    x1 = mm256_xorand( x1, tmp, x0 ); \
    x2 = _mm256_xor_si256( x2, tmp ); \
 } while (0)

@@ -96,11 +108,11 @@ do { \
 do { \
    x4 = _mm256_xor_si256( x4, x1 ); \
    x5 = _mm256_xor_si256( x5, x2 ); \
-    x6 = _mm256_xor_si256( x6, _mm256_xor_si256( x3, x0 ) ); \
+    x6 = mm256_xor3( x6, x3, x0 ); \
    x7 = _mm256_xor_si256( x7, x0 ); \
    x0 = _mm256_xor_si256( x0, x5 ); \
    x1 = _mm256_xor_si256( x1, x6 ); \
-    x2 = _mm256_xor_si256( x2, _mm256_xor_si256( x7, x4 ) ); \
+    x2 = mm256_xor3( x2, x7, x4 ); \
    x3 = _mm256_xor_si256( x3, x4 ); \
 } while (0)

@@ -323,12 +335,12 @@ do { \
 } while (0)


-#define W80(x)   Wz_8W(x, m512_const1_64( 0x5555555555555555 ),  1 )
-#define W81(x)   Wz_8W(x, m512_const1_64( 0x3333333333333333 ),  2 )
-#define W82(x)   Wz_8W(x, m512_const1_64( 0x0F0F0F0F0F0F0F0F ),  4 )
-#define W83(x)   Wz_8W(x, m512_const1_64( 0x00FF00FF00FF00FF ),  8 ) 
-#define W84(x)   Wz_8W(x, m512_const1_64( 0x0000FFFF0000FFFF ), 16 )
-#define W85(x)   Wz_8W(x, m512_const1_64( 0x00000000FFFFFFFF ), 32 )
+#define W80(x)   Wz_8W(x, _mm512_set1_epi64( 0x5555555555555555 ),  1 )
+#define W81(x)   Wz_8W(x, _mm512_set1_epi64( 0x3333333333333333 ),  2 )
+#define W82(x)   Wz_8W(x, _mm512_set1_epi64( 0x0F0F0F0F0F0F0F0F ),  4 )
+#define W83(x)   Wz_8W(x, _mm512_set1_epi64( 0x00FF00FF00FF00FF ),  8 ) 
+#define W84(x)   Wz_8W(x, _mm512_set1_epi64( 0x0000FFFF0000FFFF ), 16 )
+#define W85(x)   Wz_8W(x, _mm512_set1_epi64( 0x00000000FFFFFFFF ), 32 )
 #define W86(x) \
 do { \
   __m512i t = x ## h; \
@@ -352,12 +364,12 @@ do { \
   x ## l = _mm256_or_si256( _mm256_and_si256((x ## l >> (n)), (c)), t ); \
 } while (0)

-#define W0(x)   Wz(x, m256_const1_64( 0x5555555555555555 ),  1 )
-#define W1(x)   Wz(x, m256_const1_64( 0x3333333333333333 ),  2 )
-#define W2(x)   Wz(x, m256_const1_64( 0x0F0F0F0F0F0F0F0F ),  4 )
-#define W3(x)   Wz(x, m256_const1_64( 0x00FF00FF00FF00FF ),  8 ) 
-#define W4(x)   Wz(x, m256_const1_64( 0x0000FFFF0000FFFF ), 16 )
-#define W5(x)   Wz(x, m256_const1_64( 0x00000000FFFFFFFF ), 32 )
+#define W0(x)   Wz(x, _mm256_set1_epi64x( 0x5555555555555555 ),  1 )
+#define W1(x)   Wz(x, _mm256_set1_epi64x( 0x3333333333333333 ),  2 )
+#define W2(x)   Wz(x, _mm256_set1_epi64x( 0x0F0F0F0F0F0F0F0F ),  4 )
+#define W3(x)   Wz(x, _mm256_set1_epi64x( 0x00FF00FF00FF00FF ),  8 ) 
+#define W4(x)   Wz(x, _mm256_set1_epi64x( 0x0000FFFF0000FFFF ), 16 )
+#define W5(x)   Wz(x, _mm256_set1_epi64x( 0x00000000FFFFFFFF ), 32 )
 #define W6(x) \
 do { \
   __m256i t = x ## h; \
@@ -624,22 +636,22 @@ static const sph_u64 IV512[] = {
 void jh256_8way_init( jh_8way_context *sc )
 {
    // bswapped IV256
-    sc->H[ 0] = m512_const1_64( 0xebd3202c41a398eb );
-    sc->H[ 1] = m512_const1_64( 0xc145b29c7bbecd92 );
-    sc->H[ 2] = m512_const1_64( 0xfac7d4609151931c );
-    sc->H[ 3] = m512_const1_64( 0x038a507ed6820026 );
-    sc->H[ 4] = m512_const1_64( 0x45b92677269e23a4 );
-    sc->H[ 5] = m512_const1_64( 0x77941ad4481afbe0 );
-    sc->H[ 6] = m512_const1_64( 0x7a176b0226abb5cd );
-    sc->H[ 7] = m512_const1_64( 0xa82fff0f4224f056 );
-    sc->H[ 8] = m512_const1_64( 0x754d2e7f8996a371 );
-    sc->H[ 9] = m512_const1_64( 0x62e27df70849141d );
-    sc->H[10] = m512_const1_64( 0x948f2476f7957627 );
-    sc->H[11] = m512_const1_64( 0x6c29804757b6d587 );
-    sc->H[12] = m512_const1_64( 0x6c0d8eac2d275e5c );
-    sc->H[13] = m512_const1_64( 0x0f7a0557c6508451 );
-    sc->H[14] = m512_const1_64( 0xea12247067d3e47b );
-    sc->H[15] = m512_const1_64( 0x69d71cd313abe389 );
+    sc->H[ 0] = _mm512_set1_epi64( 0xebd3202c41a398eb );
+    sc->H[ 1] = _mm512_set1_epi64( 0xc145b29c7bbecd92 );
+    sc->H[ 2] = _mm512_set1_epi64( 0xfac7d4609151931c );
+    sc->H[ 3] = _mm512_set1_epi64( 0x038a507ed6820026 );
+    sc->H[ 4] = _mm512_set1_epi64( 0x45b92677269e23a4 );
+    sc->H[ 5] = _mm512_set1_epi64( 0x77941ad4481afbe0 );
+    sc->H[ 6] = _mm512_set1_epi64( 0x7a176b0226abb5cd );
+    sc->H[ 7] = _mm512_set1_epi64( 0xa82fff0f4224f056 );
+    sc->H[ 8] = _mm512_set1_epi64( 0x754d2e7f8996a371 );
+    sc->H[ 9] = _mm512_set1_epi64( 0x62e27df70849141d );
+    sc->H[10] = _mm512_set1_epi64( 0x948f2476f7957627 );
+    sc->H[11] = _mm512_set1_epi64( 0x6c29804757b6d587 );
+    sc->H[12] = _mm512_set1_epi64( 0x6c0d8eac2d275e5c );
+    sc->H[13] = _mm512_set1_epi64( 0x0f7a0557c6508451 );
+    sc->H[14] = _mm512_set1_epi64( 0xea12247067d3e47b );
+    sc->H[15] = _mm512_set1_epi64( 0x69d71cd313abe389 );
    sc->ptr = 0;
    sc->block_count = 0;
 }
@@ -647,22 +659,22 @@ void jh256_8way_init( jh_8way_context *sc )
 void jh512_8way_init( jh_8way_context *sc )
 {
    // bswapped IV512
-    sc->H[ 0] = m512_const1_64( 0x17aa003e964bd16f );
-    sc->H[ 1] = m512_const1_64( 0x43d5157a052e6a63 );
-    sc->H[ 2] = m512_const1_64( 0x0bef970c8d5e228a );
-    sc->H[ 3] = m512_const1_64( 0x61c3b3f2591234e9 );
-    sc->H[ 4] = m512_const1_64( 0x1e806f53c1a01d89 );
-    sc->H[ 5] = m512_const1_64( 0x806d2bea6b05a92a );
-    sc->H[ 6] = m512_const1_64( 0xa6ba7520dbcc8e58 );
-    sc->H[ 7] = m512_const1_64( 0xf73bf8ba763a0fa9 );
-    sc->H[ 8] = m512_const1_64( 0x694ae34105e66901 );
-    sc->H[ 9] = m512_const1_64( 0x5ae66f2e8e8ab546 );
-    sc->H[10] = m512_const1_64( 0x243c84c1d0a74710 );
-    sc->H[11] = m512_const1_64( 0x99c15a2db1716e3b );
-    sc->H[12] = m512_const1_64( 0x56f8b19decf657cf );
-    sc->H[13] = m512_const1_64( 0x56b116577c8806a7 );
-    sc->H[14] = m512_const1_64( 0xfb1785e6dffcc2e3 );
-    sc->H[15] = m512_const1_64( 0x4bdd8ccc78465a54 );
+    sc->H[ 0] = _mm512_set1_epi64( 0x17aa003e964bd16f );
+    sc->H[ 1] = _mm512_set1_epi64( 0x43d5157a052e6a63 );
+    sc->H[ 2] = _mm512_set1_epi64( 0x0bef970c8d5e228a );
+    sc->H[ 3] = _mm512_set1_epi64( 0x61c3b3f2591234e9 );
+    sc->H[ 4] = _mm512_set1_epi64( 0x1e806f53c1a01d89 );
+    sc->H[ 5] = _mm512_set1_epi64( 0x806d2bea6b05a92a );
+    sc->H[ 6] = _mm512_set1_epi64( 0xa6ba7520dbcc8e58 );
+    sc->H[ 7] = _mm512_set1_epi64( 0xf73bf8ba763a0fa9 );
+    sc->H[ 8] = _mm512_set1_epi64( 0x694ae34105e66901 );
+    sc->H[ 9] = _mm512_set1_epi64( 0x5ae66f2e8e8ab546 );
+    sc->H[10] = _mm512_set1_epi64( 0x243c84c1d0a74710 );
+    sc->H[11] = _mm512_set1_epi64( 0x99c15a2db1716e3b );
+    sc->H[12] = _mm512_set1_epi64( 0x56f8b19decf657cf );
+    sc->H[13] = _mm512_set1_epi64( 0x56b116577c8806a7 );
+    sc->H[14] = _mm512_set1_epi64( 0xfb1785e6dffcc2e3 );
+    sc->H[15] = _mm512_set1_epi64( 0x4bdd8ccc78465a54 );
    sc->ptr = 0;
    sc->block_count = 0;
 }
@@ -721,7 +733,7 @@ jh_8way_close( jh_8way_context *sc, unsigned ub, unsigned n, void *dst,
   size_t numz, u;
   uint64_t l0, l1;

-   buf[0] = m512_const1_64( 0x80ULL );
+   buf[0] = _mm512_set1_epi64( 0x80ULL );

   if ( sc->ptr == 0 )
       numz = 48;
@@ -772,22 +784,22 @@ jh512_8way_close(void *cc, void *dst)
 void jh256_4way_init( jh_4way_context *sc )
 {
    // bswapped IV256
-    sc->H[ 0] = m256_const1_64( 0xebd3202c41a398eb );
-    sc->H[ 1] = m256_const1_64( 0xc145b29c7bbecd92 );
-    sc->H[ 2] = m256_const1_64( 0xfac7d4609151931c );
-    sc->H[ 3] = m256_const1_64( 0x038a507ed6820026 );
-    sc->H[ 4] = m256_const1_64( 0x45b92677269e23a4 );
-    sc->H[ 5] = m256_const1_64( 0x77941ad4481afbe0 );
-    sc->H[ 6] = m256_const1_64( 0x7a176b0226abb5cd );
-    sc->H[ 7] = m256_const1_64( 0xa82fff0f4224f056 );
-    sc->H[ 8] = m256_const1_64( 0x754d2e7f8996a371 );
-    sc->H[ 9] = m256_const1_64( 0x62e27df70849141d );
-    sc->H[10] = m256_const1_64( 0x948f2476f7957627 );
-    sc->H[11] = m256_const1_64( 0x6c29804757b6d587 );
-    sc->H[12] = m256_const1_64( 0x6c0d8eac2d275e5c );
-    sc->H[13] = m256_const1_64( 0x0f7a0557c6508451 );
-    sc->H[14] = m256_const1_64( 0xea12247067d3e47b );
-    sc->H[15] = m256_const1_64( 0x69d71cd313abe389 );
+    sc->H[ 0] = _mm256_set1_epi64x( 0xebd3202c41a398eb );
+    sc->H[ 1] = _mm256_set1_epi64x( 0xc145b29c7bbecd92 );
+    sc->H[ 2] = _mm256_set1_epi64x( 0xfac7d4609151931c );
+    sc->H[ 3] = _mm256_set1_epi64x( 0x038a507ed6820026 );
+    sc->H[ 4] = _mm256_set1_epi64x( 0x45b92677269e23a4 );
+    sc->H[ 5] = _mm256_set1_epi64x( 0x77941ad4481afbe0 );
+    sc->H[ 6] = _mm256_set1_epi64x( 0x7a176b0226abb5cd );
+    sc->H[ 7] = _mm256_set1_epi64x( 0xa82fff0f4224f056 );
+    sc->H[ 8] = _mm256_set1_epi64x( 0x754d2e7f8996a371 );
+    sc->H[ 9] = _mm256_set1_epi64x( 0x62e27df70849141d );
+    sc->H[10] = _mm256_set1_epi64x( 0x948f2476f7957627 );
+    sc->H[11] = _mm256_set1_epi64x( 0x6c29804757b6d587 );
+    sc->H[12] = _mm256_set1_epi64x( 0x6c0d8eac2d275e5c );
+    sc->H[13] = _mm256_set1_epi64x( 0x0f7a0557c6508451 );
+    sc->H[14] = _mm256_set1_epi64x( 0xea12247067d3e47b );
+    sc->H[15] = _mm256_set1_epi64x( 0x69d71cd313abe389 );
    sc->ptr = 0;
    sc->block_count = 0;
 }
@@ -795,22 +807,22 @@ void jh256_4way_init( jh_4way_context *sc )
 void jh512_4way_init( jh_4way_context *sc )
 {
    // bswapped IV512
-    sc->H[ 0] = m256_const1_64( 0x17aa003e964bd16f );
-    sc->H[ 1] = m256_const1_64( 0x43d5157a052e6a63 );
-    sc->H[ 2] = m256_const1_64( 0x0bef970c8d5e228a );
-    sc->H[ 3] = m256_const1_64( 0x61c3b3f2591234e9 );
-    sc->H[ 4] = m256_const1_64( 0x1e806f53c1a01d89 );
-    sc->H[ 5] = m256_const1_64( 0x806d2bea6b05a92a );
-    sc->H[ 6] = m256_const1_64( 0xa6ba7520dbcc8e58 );
-    sc->H[ 7] = m256_const1_64( 0xf73bf8ba763a0fa9 );
-    sc->H[ 8] = m256_const1_64( 0x694ae34105e66901 );
-    sc->H[ 9] = m256_const1_64( 0x5ae66f2e8e8ab546 );
-    sc->H[10] = m256_const1_64( 0x243c84c1d0a74710 );
-    sc->H[11] = m256_const1_64( 0x99c15a2db1716e3b );
-    sc->H[12] = m256_const1_64( 0x56f8b19decf657cf );
-    sc->H[13] = m256_const1_64( 0x56b116577c8806a7 );
-    sc->H[14] = m256_const1_64( 0xfb1785e6dffcc2e3 );
-    sc->H[15] = m256_const1_64( 0x4bdd8ccc78465a54 );
+    sc->H[ 0] = _mm256_set1_epi64x( 0x17aa003e964bd16f );
+    sc->H[ 1] = _mm256_set1_epi64x( 0x43d5157a052e6a63 );
+    sc->H[ 2] = _mm256_set1_epi64x( 0x0bef970c8d5e228a );
+    sc->H[ 3] = _mm256_set1_epi64x( 0x61c3b3f2591234e9 );
+    sc->H[ 4] = _mm256_set1_epi64x( 0x1e806f53c1a01d89 );
+    sc->H[ 5] = _mm256_set1_epi64x( 0x806d2bea6b05a92a );
+    sc->H[ 6] = _mm256_set1_epi64x( 0xa6ba7520dbcc8e58 );
+    sc->H[ 7] = _mm256_set1_epi64x( 0xf73bf8ba763a0fa9 );
+    sc->H[ 8] = _mm256_set1_epi64x( 0x694ae34105e66901 );
+    sc->H[ 9] = _mm256_set1_epi64x( 0x5ae66f2e8e8ab546 );
+    sc->H[10] = _mm256_set1_epi64x( 0x243c84c1d0a74710 );
+    sc->H[11] = _mm256_set1_epi64x( 0x99c15a2db1716e3b );
+    sc->H[12] = _mm256_set1_epi64x( 0x56f8b19decf657cf );
+    sc->H[13] = _mm256_set1_epi64x( 0x56b116577c8806a7 );
+    sc->H[14] = _mm256_set1_epi64x( 0xfb1785e6dffcc2e3 );
+    sc->H[15] = _mm256_set1_epi64x( 0x4bdd8ccc78465a54 );
    sc->ptr = 0;
    sc->block_count = 0;
 }
@@ -869,7 +881,7 @@ jh_4way_close( jh_4way_context *sc, unsigned ub, unsigned n, void *dst,
   size_t numz, u;
   uint64_t l0, l1;

-   buf[0] = m256_const1_64( 0x80ULL );
+   buf[0] = _mm256_set1_epi64x( 0x80ULL );

   if ( sc->ptr == 0 )
       numz = 48;
--- a/algo/jh/sph_jh.h
+++ b/algo/jh/sph_jh.h
@@ -41,7 +41,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for JH-224.
--- a/algo/keccak/keccak-4way.c
+++ b/algo/keccak/keccak-4way.c
@@ -2,7 +2,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
-#include "sph_keccak.h"
 #include "keccak-hash-4way.h"

 #if defined(KECCAK_8WAY)
@@ -49,7 +48,7 @@ int scanhash_keccak_8way( struct work *work, uint32_t max_nonce,
          }
      }
      *noncev = _mm512_add_epi32( *noncev,
-                                  m512_const1_64( 0x0000000800000000 ) );
+                                  _mm512_set1_epi64( 0x0000000800000000 ) );
      n += 8;

   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
@@ -101,7 +100,7 @@ int scanhash_keccak_4way( struct work *work, uint32_t max_nonce,
          }
      }
      *noncev = _mm256_add_epi32( *noncev,
-                                  m256_const1_64( 0x0000000400000000 ) );
+                                  _mm256_set1_epi64x( 0x0000000400000000 ) );
      n += 4;
   } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
   pdata[19] = n;
--- a/algo/keccak/keccak-gate.c
+++ b/algo/keccak/keccak-gate.c
@@ -9,7 +9,7 @@ int hard_coded_eb = 1;
 bool register_keccak_algo( algo_gate_t* gate )
 {
  gate->optimizations = AVX2_OPT | AVX512_OPT;
-  gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
+  gate->gen_merkle_root = (void*)&sha256_gen_merkle_root;
  opt_target_factor = 128.0;
 #if defined (KECCAK_8WAY)
  gate->scanhash  = (void*)&scanhash_keccak_8way;
--- a/algo/keccak/keccak-hash-4way.c
+++ b/algo/keccak/keccak-hash-4way.c
@@ -180,15 +180,15 @@ static void keccak64_8way_close( keccak64_ctx_m512i *kc, void *dst,
    if ( kc->ptr == (lim - 8) )
    {
        const uint64_t t = eb | 0x8000000000000000;
-        u.tmp[0] = m512_const1_64( t );
+        u.tmp[0] = _mm512_set1_epi64( t );
        j = 8;
    }
    else
    {
        j = lim - kc->ptr;
-        u.tmp[0] = m512_const1_64( eb );
+        u.tmp[0] = _mm512_set1_epi64( eb );
        memset_zero_512( u.tmp + 1, (j>>3) - 2 );
-        u.tmp[ (j>>3) - 1] = m512_const1_64( 0x8000000000000000 );
+        u.tmp[ (j>>3) - 1] = _mm512_set1_epi64( 0x8000000000000000 );
    }
    keccak64_8way_core( kc, u.tmp, j, lim );
    /* Finalize the "lane complement" */
@@ -264,8 +264,8 @@ keccak512_8way_close(void *cc, void *dst)
 #define OR64(d, a, b)      (d = _mm256_or_si256(a,b))
 #define NOT64(d, s)        (d = mm256_not( s ) )
 #define ROL64(d, v, n)     (d = mm256_rol_64(v, n))
-#define XOROR(d, a, b, c)  (d = _mm256_xor_si256(a, _mm256_or_si256(b, c)))
-#define XORAND(d, a, b, c) (d = _mm256_xor_si256(a, _mm256_and_si256(b, c)))
+#define XOROR(d, a, b, c)  (d = mm256_xoror( a, b, c ) )
+#define XORAND(d, a, b, c) (d = mm256_xorand( a, b, c ) )
 #define XOR3( d, a, b, c ) (d = mm256_xor3( a, b, c ))

 #include "keccak-macros.c"
@@ -368,15 +368,15 @@ static void keccak64_close( keccak64_ctx_m256i *kc, void *dst, size_t byte_len,
    if ( kc->ptr == (lim - 8) )
    {
        const uint64_t t = eb | 0x8000000000000000;
-        u.tmp[0] = m256_const1_64( t );
+        u.tmp[0] = _mm256_set1_epi64x( t );
        j = 8;
    }
    else
    {
        j = lim - kc->ptr;
-        u.tmp[0] = m256_const1_64( eb );
+        u.tmp[0] = _mm256_set1_epi64x( eb );
        memset_zero_256( u.tmp + 1, (j>>3) - 2 );
-        u.tmp[ (j>>3) - 1] = m256_const1_64( 0x8000000000000000 );
+        u.tmp[ (j>>3) - 1] = _mm256_set1_epi64x( 0x8000000000000000 );
    }
    keccak64_core( kc, u.tmp, j, lim );
    /* Finalize the "lane complement" */
--- a/algo/keccak/keccak-hash-4way.h
+++ b/algo/keccak/keccak-hash-4way.h
@@ -1,45 +1,6 @@
-/* $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 KECCAK_HASH_4WAY_H__
 #define KECCAK_HASH_4WAY_H__

-#ifdef __cplusplus
-extern "C"{
-#endif
-
 #ifdef  __AVX2__

 #include <stddef.h>
@@ -100,8 +61,4 @@ void keccak512_4way_addbits_and_close(

 #endif

-#ifdef __cplusplus
-}
-#endif
-
 #endif
--- a/algo/keccak/sha3d-4way.c
+++ b/algo/keccak/sha3d-4way.c
@@ -2,7 +2,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
-#include "sph_keccak.h"
 #include "keccak-hash-4way.h"

 #if defined(KECCAK_8WAY)
@@ -56,7 +55,7 @@ int scanhash_sha3d_8way( struct work *work, uint32_t max_nonce,
          }
      }
      *noncev = _mm512_add_epi32( *noncev,
-                                  m512_const1_64( 0x0000000800000000 ) );
+                                  _mm512_set1_epi64( 0x0000000800000000 ) );
      n += 8;

   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );
@@ -115,7 +114,7 @@ int scanhash_sha3d_4way( struct work *work, uint32_t max_nonce,
          }
      }
      *noncev = _mm256_add_epi32( *noncev,
-                                  m256_const1_64( 0x0000000400000000 ) );
+                                  _mm256_set1_epi64x( 0x0000000400000000 ) );
      n += 4;
   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );
   pdata[19] = n;
--- a/algo/keccak/sph_keccak.h
+++ b/algo/keccak/sph_keccak.h
@@ -41,7 +41,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for Keccak-224.
--- a/algo/lanehash/lane.h
+++ b/algo/lanehash/lane.h
@@ -23,7 +23,6 @@
 #define LANE_H

 #include <string.h>
-//#include "algo/sha/sha3-defs.h"
 #include <stdint.h>

 typedef unsigned char BitSequence;
--- a/algo/luffa/luffa-hash-2way.c
+++ b/algo/luffa/luffa-hash-2way.c
@@ -7,8 +7,10 @@

 #include "simd-utils.h"

+#define uint32 uint32_t
+
 /* initial values of chaining variables */
-static const uint32 IV[40] __attribute((aligned(64))) = {
+static const uint32_t IV[40] __attribute((aligned(64))) = {
    0xdbf78465,0x4eaa6fb4,0x44b051e0,0x6d251e69,
    0xdef610bb,0xee058139,0x90152df4,0x6e292011,
    0xde099fa3,0x70eee9a0,0xd9d2f256,0xc3b44b95,
@@ -22,7 +24,7 @@ static const uint32 IV[40] __attribute((aligned(64))) = {
 };

 /* Round Constants */
-static const uint32 CNS_INIT[128] __attribute((aligned(64))) = {
+static const uint32_t CNS_INIT[128] __attribute((aligned(64))) = {
    0xb213afa5,0xfc20d9d2,0xb6de10ed,0x303994a6,
    0xe028c9bf,0xe25e72c1,0x01685f3d,0xe0337818,
    0xc84ebe95,0x34552e25,0x70f47aae,0xc0e65299,
@@ -69,7 +71,7 @@ static const uint32 CNS_INIT[128] __attribute((aligned(64))) = {
 #define MULT24W( a0, a1 ) \
 { \
  __m512i b = _mm512_xor_si512( a0, \
-                     _mm512_maskz_shuffle_epi32( 0xbbbb, a1, 16 ) ); \
+                     _mm512_maskz_shuffle_epi32( 0xbbbb, a1, 0x10 ) ); \
  a0 = _mm512_alignr_epi8( a1,  b, 4 ); \
  a1 = _mm512_alignr_epi8(  b, a1, 4 ); \
 }
@@ -107,49 +109,37 @@ static const uint32 CNS_INIT[128] __attribute((aligned(64))) = {
    ADD_CONSTANT4W( x0, x4, c0, c1 );

 #define STEP_PART24W( a0, a1, t0, t1, c0, c1 ) \
-    a1 = _mm512_shuffle_epi32( a1, 147 ); \
-    t0 = _mm512_load_si512( &a1 ); \
-    a1 = _mm512_unpacklo_epi32( a1, a0 ); \
+    t0 = _mm512_shuffle_epi32( a1, 147 ); \
+    a1 = _mm512_unpacklo_epi32( t0, a0 ); \
    t0 = _mm512_unpackhi_epi32( t0, a0 ); \
    t1 = _mm512_shuffle_epi32( t0, 78 ); \
    a0 = _mm512_shuffle_epi32( a1, 78 ); \
    SUBCRUMB4W( t1, t0, a0, a1 ); \
    t0 = _mm512_unpacklo_epi32( t0, t1 ); \
    a1 = _mm512_unpacklo_epi32( a1, a0 ); \
-    a0 = _mm512_load_si512( &a1 ); \
-    a0 = _mm512_unpackhi_epi64( a0, t0 ); \
+    a0 = _mm512_unpackhi_epi64( a1, t0 ); \
    a1 = _mm512_unpacklo_epi64( a1, t0 ); \
    a1 = _mm512_shuffle_epi32( a1, 57 ); \
    MIXWORD4W( a0, a1 ); \
    ADD_CONSTANT4W( a0, a1, c0, c1 );

 #define NMLTOM10244W(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3)\
-    s1 = _mm512_load_si512(&r3);\
-    q1 = _mm512_load_si512(&p3);\
-    s3 = _mm512_load_si512(&r3);\
-    q3 = _mm512_load_si512(&p3);\
-    s1 = _mm512_unpackhi_epi32(s1,r2);\
-    q1 = _mm512_unpackhi_epi32(q1,p2);\
-    s3 = _mm512_unpacklo_epi32(s3,r2);\
-    q3 = _mm512_unpacklo_epi32(q3,p2);\
-    s0 = _mm512_load_si512(&s1);\
-    q0 = _mm512_load_si512(&q1);\
-    s2 = _mm512_load_si512(&s3);\
-    q2 = _mm512_load_si512(&q3);\
-    r3 = _mm512_load_si512(&r1);\
-    p3 = _mm512_load_si512(&p1);\
-    r1 = _mm512_unpacklo_epi32(r1,r0);\
-    p1 = _mm512_unpacklo_epi32(p1,p0);\
-    r3 = _mm512_unpackhi_epi32(r3,r0);\
-    p3 = _mm512_unpackhi_epi32(p3,p0);\
-    s0 = _mm512_unpackhi_epi64(s0,r3);\
-    q0 = _mm512_unpackhi_epi64(q0,p3);\
-    s1 = _mm512_unpacklo_epi64(s1,r3);\
-    q1 = _mm512_unpacklo_epi64(q1,p3);\
-    s2 = _mm512_unpackhi_epi64(s2,r1);\
-    q2 = _mm512_unpackhi_epi64(q2,p1);\
-    s3 = _mm512_unpacklo_epi64(s3,r1);\
-    q3 = _mm512_unpacklo_epi64(q3,p1);
+    s1 = _mm512_unpackhi_epi32( r3, r2 ); \
+    q1 = _mm512_unpackhi_epi32( p3, p2 ); \
+    s3 = _mm512_unpacklo_epi32( r3, r2 ); \
+    q3 = _mm512_unpacklo_epi32( p3, p2 ); \
+    r3 = _mm512_unpackhi_epi32( r1, r0 ); \
+    r1 = _mm512_unpacklo_epi32( r1, r0 ); \
+    p3 = _mm512_unpackhi_epi32( p1, p0 ); \
+    p1 = _mm512_unpacklo_epi32( p1, p0 ); \
+    s0 = _mm512_unpackhi_epi64( s1, r3 ); \
+    q0 = _mm512_unpackhi_epi64( q1 ,p3 ); \
+    s1 = _mm512_unpacklo_epi64( s1, r3 ); \
+    q1 = _mm512_unpacklo_epi64( q1, p3 ); \
+    s2 = _mm512_unpackhi_epi64( s3, r1 ); \
+    q2 = _mm512_unpackhi_epi64( q3, p1 ); \
+    s3 = _mm512_unpacklo_epi64( s3, r1 ); \
+    q3 = _mm512_unpacklo_epi64( q3, p1 );

 #define MIXTON10244W(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3)\
    NMLTOM10244W(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3);
@@ -198,11 +188,8 @@ void rnd512_4way( luffa_4way_context *state, const __m512i *msg )
    chainv[7] = _mm512_xor_si512(chainv[7], chainv[9]);

    MULT24W( chainv[8], chainv[9] );
-    chainv[8] = _mm512_xor_si512( chainv[8], t0 );
-    chainv[9] = _mm512_xor_si512( chainv[9], t1 );
-
-    t0 = chainv[8];
-    t1 = chainv[9];
+    t0 = chainv[8] = _mm512_xor_si512( chainv[8], t0 );
+    t1 = chainv[9] = _mm512_xor_si512( chainv[9], t1 );

    MULT24W( chainv[8], chainv[9] );
    chainv[8] = _mm512_xor_si512( chainv[8], chainv[6] );
@@ -538,10 +525,39 @@ int luffa_4way_update_close( luffa_4way_context *state,
    a = _mm256_xor_si256( a, c0 ); \
    b = _mm256_xor_si256( b, c1 );

+//TODO Enable for AVX10_256, not used with AVX512 or AVX10_512
+#if defined(__AVX512VL__) 
+
+#define MULT2( a0, a1 ) \
+{ \
+  __m256i b = _mm256_xor_si256( a0, \
+                     _mm256_maskz_shuffle_epi32( 0xbb, a1, 0x10 ) ); \
+  a0 = _mm256_alignr_epi8( a1,  b, 4 ); \
+  a1 = _mm256_alignr_epi8(  b, a1, 4 ); \
+}
+
+#define SUBCRUMB( a0, a1, a2, a3 ) \
+{ \
+    __m256i t = a0; \
+    a0 = mm256_xoror( a3, a0, a1 ); \
+    a2 = _mm256_xor_si256( a2, a3 ); \
+    a1 = _mm256_ternarylogic_epi64( a1, a3, t, 0x87 ); /* a1 xnor (a3 & t) */ \
+    a3 = mm256_xorand( a2, a3, t ); \
+    a2 = mm256_xorand( a1, a2, a0); \
+    a1 = _mm256_or_si256( a1, a3 ); \
+    a3 = _mm256_xor_si256( a3, a2 ); \
+    t  = _mm256_xor_si256( t, a1 ); \
+    a2 = _mm256_and_si256( a2, a1 ); \
+    a1 = mm256_xnor( a1, a0 ); \
+    a0 = t; \
+}
+
+#else
+
 #define MULT2( a0, a1 ) \
 { \
  __m256i b = _mm256_xor_si256( a0, _mm256_shuffle_epi32( \
-                         _mm256_blend_epi32( a1, m256_zero, 0xee ), 16 ) ); \
+                         _mm256_blend_epi32( a1, m256_zero, 0xee ), 0x10 ) ); \
  a0 = _mm256_alignr_epi8( a1,  b, 4 ); \
  a1 = _mm256_alignr_epi8(  b, a1, 4 ); \
 }
@@ -567,26 +583,14 @@ int luffa_4way_update_close( luffa_4way_context *state,
    a0 = t; \
 }

+#endif
+
 #define MIXWORD( a, b ) \
-{ \
-    __m256i t1, t2; \
-    b  = _mm256_xor_si256( a,b ); \
-    t1 = _mm256_slli_epi32( a,  2 ); \
-    t2 = _mm256_srli_epi32( a, 30 ); \
-    a  = _mm256_or_si256( t1, t2 ); \
-    a  = _mm256_xor_si256( a, b ); \
-    t1 = _mm256_slli_epi32( b, 14 ); \
-    t2 = _mm256_srli_epi32( b, 18 ); \
-    b  = _mm256_or_si256( t1, t2 ); \
-    b  = _mm256_xor_si256( a, b ); \
-    t1 = _mm256_slli_epi32( a, 10 ); \
-    t2 = _mm256_srli_epi32( a, 22 ); \
-    a  = _mm256_or_si256( t1,t2 ); \
-    a  = _mm256_xor_si256( a,b ); \
-    t1 = _mm256_slli_epi32( b,1 ); \
-    t2 = _mm256_srli_epi32( b,31 ); \
-    b  = _mm256_or_si256( t1, t2 ); \
-}
+    b = _mm256_xor_si256( a, b ); \
+    a = _mm256_xor_si256( b, mm256_rol_32( a,  2 ) ); \
+    b = _mm256_xor_si256( a, mm256_rol_32( b, 14 ) ); \
+    a = _mm256_xor_si256( b, mm256_rol_32( a, 10 ) ); \
+    b = mm256_rol_32( b, 1 );

 #define STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, c0, c1 ) \
    SUBCRUMB( x0, x1, x2, x3 ); \
@@ -598,49 +602,37 @@ int luffa_4way_update_close( luffa_4way_context *state,
    ADD_CONSTANT( x0, x4, c0, c1 );

 #define STEP_PART2( a0, a1, t0, t1, c0, c1 ) \
-    a1 = _mm256_shuffle_epi32( a1, 147); \
-    t0 = _mm256_load_si256( &a1 ); \
-    a1 = _mm256_unpacklo_epi32( a1, a0 ); \
+    t0 = _mm256_shuffle_epi32( a1, 147 ); \
+    a1 = _mm256_unpacklo_epi32( t0, a0 ); \
    t0 = _mm256_unpackhi_epi32( t0, a0 ); \
    t1 = _mm256_shuffle_epi32( t0, 78 ); \
    a0 = _mm256_shuffle_epi32( a1, 78 ); \
-    SUBCRUMB( t1, t0, a0, a1 );\
+    SUBCRUMB( t1, t0, a0, a1 ); \
    t0 = _mm256_unpacklo_epi32( t0, t1 ); \
    a1 = _mm256_unpacklo_epi32( a1, a0 ); \
-    a0 = _mm256_load_si256( &a1 ); \
-    a0 = _mm256_unpackhi_epi64( a0, t0 ); \
+    a0 = _mm256_unpackhi_epi64( a1, t0 ); \
    a1 = _mm256_unpacklo_epi64( a1, t0 ); \
    a1 = _mm256_shuffle_epi32( a1, 57 ); \
    MIXWORD( a0, a1 ); \
    ADD_CONSTANT( a0, a1, c0, c1 );

 #define NMLTOM1024(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3)\
-    s1 = _mm256_load_si256(&r3);\
-    q1 = _mm256_load_si256(&p3);\
-    s3 = _mm256_load_si256(&r3);\
-    q3 = _mm256_load_si256(&p3);\
-    s1 = _mm256_unpackhi_epi32(s1,r2);\
-    q1 = _mm256_unpackhi_epi32(q1,p2);\
-    s3 = _mm256_unpacklo_epi32(s3,r2);\
-    q3 = _mm256_unpacklo_epi32(q3,p2);\
-    s0 = _mm256_load_si256(&s1);\
-    q0 = _mm256_load_si256(&q1);\
-    s2 = _mm256_load_si256(&s3);\
-    q2 = _mm256_load_si256(&q3);\
-    r3 = _mm256_load_si256(&r1);\
-    p3 = _mm256_load_si256(&p1);\
-    r1 = _mm256_unpacklo_epi32(r1,r0);\
-    p1 = _mm256_unpacklo_epi32(p1,p0);\
-    r3 = _mm256_unpackhi_epi32(r3,r0);\
-    p3 = _mm256_unpackhi_epi32(p3,p0);\
-    s0 = _mm256_unpackhi_epi64(s0,r3);\
-    q0 = _mm256_unpackhi_epi64(q0,p3);\
-    s1 = _mm256_unpacklo_epi64(s1,r3);\
-    q1 = _mm256_unpacklo_epi64(q1,p3);\
-    s2 = _mm256_unpackhi_epi64(s2,r1);\
-    q2 = _mm256_unpackhi_epi64(q2,p1);\
-    s3 = _mm256_unpacklo_epi64(s3,r1);\
-    q3 = _mm256_unpacklo_epi64(q3,p1);
+    s1 = _mm256_unpackhi_epi32( r3, r2 ); \
+    q1 = _mm256_unpackhi_epi32( p3, p2 ); \
+    s3 = _mm256_unpacklo_epi32( r3, r2 ); \
+    q3 = _mm256_unpacklo_epi32( p3, p2 ); \
+    r3 = _mm256_unpackhi_epi32( r1, r0 ); \
+    r1 = _mm256_unpacklo_epi32( r1, r0 ); \
+    p3 = _mm256_unpackhi_epi32( p1, p0 ); \
+    p1 = _mm256_unpacklo_epi32( p1, p0 ); \
+    s0 = _mm256_unpackhi_epi64( s1, r3 ); \
+    q0 = _mm256_unpackhi_epi64( q1 ,p3 ); \
+    s1 = _mm256_unpacklo_epi64( s1, r3 ); \
+    q1 = _mm256_unpacklo_epi64( q1, p3 ); \
+    s2 = _mm256_unpackhi_epi64( s3, r1 ); \
+    q2 = _mm256_unpackhi_epi64( q3, p1 ); \
+    s3 = _mm256_unpacklo_epi64( s3, r1 ); \
+    q3 = _mm256_unpacklo_epi64( q3, p1 );

 #define MIXTON1024(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3)\
    NMLTOM1024(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3);
@@ -656,17 +648,10 @@ void rnd512_2way( luffa_2way_context *state, const __m256i *msg )
    __m256i *chainv = state->chainv;
    __m256i x0, x1, x2, x3, x4, x5, x6, x7;

-    t0 = chainv[0];
-    t1 = chainv[1];
-
-    t0 = _mm256_xor_si256( t0, chainv[2] );
-    t1 = _mm256_xor_si256( t1, chainv[3] );
-    t0 = _mm256_xor_si256( t0, chainv[4] );
-    t1 = _mm256_xor_si256( t1, chainv[5] );
-    t0 = _mm256_xor_si256( t0, chainv[6] );
-    t1 = _mm256_xor_si256( t1, chainv[7] );
-    t0 = _mm256_xor_si256( t0, chainv[8] );
-    t1 = _mm256_xor_si256( t1, chainv[9] );
+    t0 = mm256_xor3( chainv[0], chainv[2], chainv[4] );
+    t1 = mm256_xor3( chainv[1], chainv[3], chainv[5] );
+    t0 = mm256_xor3( t0, chainv[6], chainv[8] );
+    t1 = mm256_xor3( t1, chainv[7], chainv[9] );

    MULT2( t0, t1 );

@@ -701,11 +686,8 @@ void rnd512_2way( luffa_2way_context *state, const __m256i *msg )
    chainv[7] = _mm256_xor_si256(chainv[7], chainv[9]);

    MULT2( chainv[8], chainv[9] );
-    chainv[8] = _mm256_xor_si256( chainv[8], t0 );
-    chainv[9] = _mm256_xor_si256( chainv[9], t1 );
-
-    t0 = chainv[8];
-    t1 = chainv[9];
+    t0 = chainv[8] = _mm256_xor_si256( chainv[8], t0 );
+    t1 = chainv[9] = _mm256_xor_si256( chainv[9], t1 );

    MULT2( chainv[8], chainv[9] );
    chainv[8] = _mm256_xor_si256( chainv[8], chainv[6] );
@@ -794,29 +776,22 @@ void finalization512_2way( luffa_2way_context *state, uint32 *b )
 {
    uint32 hash[8*2] __attribute((aligned(64)));
    __m256i* chainv = state->chainv;
-    __m256i t[2];
+    __m256i t0, t1;
    const __m256i shuff_bswap32 = mm256_set2_64( 0x0c0d0e0f08090a0b,
                                                 0x0405060700010203 );
    /*---- blank round with m=0 ----*/
    rnd512_2way( state, NULL );

-    t[0] = chainv[0];
-    t[1] = chainv[1];
+    t0 = mm256_xor3( chainv[0], chainv[2], chainv[4] );
+    t1 = mm256_xor3( chainv[1], chainv[3], chainv[5] );
+    t0 = mm256_xor3( t0, chainv[6], chainv[8] );
+    t1 = mm256_xor3( t1, chainv[7], chainv[9] );

-    t[0] = _mm256_xor_si256( t[0], chainv[2] );
-    t[1] = _mm256_xor_si256( t[1], chainv[3] );
-    t[0] = _mm256_xor_si256( t[0], chainv[4] );
-    t[1] = _mm256_xor_si256( t[1], chainv[5] );
-    t[0] = _mm256_xor_si256( t[0], chainv[6] );
-    t[1] = _mm256_xor_si256( t[1], chainv[7] );
-    t[0] = _mm256_xor_si256( t[0], chainv[8] );
-    t[1] = _mm256_xor_si256( t[1], chainv[9] );
+    t0 = _mm256_shuffle_epi32( t0, 27 );
+    t1 = _mm256_shuffle_epi32( t1, 27 );

-    t[0] = _mm256_shuffle_epi32( t[0], 27 );
-    t[1] = _mm256_shuffle_epi32( t[1], 27 );
-
-    _mm256_store_si256( (__m256i*)&hash[0], t[0] );
-    _mm256_store_si256( (__m256i*)&hash[8], t[1] );
+    _mm256_store_si256( (__m256i*)&hash[0], t0 );
+    _mm256_store_si256( (__m256i*)&hash[8], t1 );

    casti_m256i( b, 0 ) = _mm256_shuffle_epi8(
                                  casti_m256i( hash, 0 ), shuff_bswap32 );
@@ -825,22 +800,16 @@ void finalization512_2way( luffa_2way_context *state, uint32 *b )

    rnd512_2way( state, NULL );

-    t[0] = chainv[0];
-    t[1] = chainv[1];
-    t[0] = _mm256_xor_si256( t[0], chainv[2] );
-    t[1] = _mm256_xor_si256( t[1], chainv[3] );
-    t[0] = _mm256_xor_si256( t[0], chainv[4] );
-    t[1] = _mm256_xor_si256( t[1], chainv[5] );
-    t[0] = _mm256_xor_si256( t[0], chainv[6] );
-    t[1] = _mm256_xor_si256( t[1], chainv[7] );
-    t[0] = _mm256_xor_si256( t[0], chainv[8] );
-    t[1] = _mm256_xor_si256( t[1], chainv[9] );
+    t0 = mm256_xor3( chainv[0], chainv[2], chainv[4] );
+    t1 = mm256_xor3( chainv[1], chainv[3], chainv[5] );
+    t0 = mm256_xor3( t0, chainv[6], chainv[8] );
+    t1 = mm256_xor3( t1, chainv[7], chainv[9] );
+    
+    t0 = _mm256_shuffle_epi32( t0, 27 );
+    t1 = _mm256_shuffle_epi32( t1, 27 );

-    t[0] = _mm256_shuffle_epi32( t[0], 27 );
-    t[1] = _mm256_shuffle_epi32( t[1], 27 );
-
-    _mm256_store_si256( (__m256i*)&hash[0], t[0] );
-    _mm256_store_si256( (__m256i*)&hash[8], t[1] );
+    _mm256_store_si256( (__m256i*)&hash[0], t0 );
+    _mm256_store_si256( (__m256i*)&hash[8], t1 );

    casti_m256i( b, 2 ) = _mm256_shuffle_epi8( 
                                  casti_m256i( hash, 0 ), shuff_bswap32 );
--- a/algo/luffa/luffa-hash-2way.h
+++ b/algo/luffa/luffa-hash-2way.h
@@ -23,7 +23,7 @@
 #if defined(__AVX2__)

 #include <immintrin.h>
-#include "algo/sha/sha3-defs.h"
+//#include "algo/sha/sha3-defs.h"
 #include "simd-utils.h"

 /* The length of digests*/
@@ -54,7 +54,7 @@
 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)

 typedef struct {
-    uint32 buffer[8*4];
+    uint32_t buffer[8*4];
    __m512i chainv[10];   /* Chaining values */
    int hashbitlen;
    int rembytes;
@@ -82,7 +82,7 @@ int luffa512_4way_update_close( luffa_4way_context *state, void *output,
 #endif

 typedef struct {
-    uint32 buffer[8*2];
+    uint32_t buffer[8*2];
    __m256i chainv[10];   /* Chaining values */
    int hashbitlen;
    int rembytes;
--- a/algo/luffa/luffa_for_sse2.c
+++ b/algo/luffa/luffa_for_sse2.c
@@ -22,20 +22,29 @@
 #include "simd-utils.h"
 #include "luffa_for_sse2.h"

+#define cns(i)  ( ( (__m128i*)CNS_INIT)[i] )
+
+#define ADD_CONSTANT( a, b, c0 ,c1 ) \
+    a = _mm_xor_si128( a, c0 ); \
+    b = _mm_xor_si128( b, c1 ); \
+
 #if defined(__AVX512VL__)
+//TODO enable for AVX10_512 AVX10_256

 #define MULT2( a0, a1 ) \
 { \
-  __m128i b = _mm_xor_si128( a0, _mm_maskz_shuffle_epi32( 0xb, a1, 0x10 ) ); \
-  a0 = _mm_alignr_epi32( a1, b, 1 ); \
-  a1 = _mm_alignr_epi32( b, a1, 1 ); \
+  __m128i b = _mm_xor_si128( a0, \
+                      _mm_maskz_shuffle_epi32( 0xb, a1, 0x10 ) ); \
+  a0 = _mm_alignr_epi8( a1, b, 4 ); \
+  a1 = _mm_alignr_epi8( b, a1, 4 ); \
 }

 #elif defined(__SSE4_1__)

 #define MULT2( a0, a1 ) do \
 { \
-  __m128i b = _mm_xor_si128( a0, _mm_shuffle_epi32( mm128_mask_32( a1, 0xe ), 0x10 ) ); \
+  __m128i b = _mm_xor_si128( a0, \
+                      _mm_shuffle_epi32( mm128_mask_32( a1, 0xe ), 0x10 ) ); \
  a0 = _mm_alignr_epi8( a1, b, 4 ); \
  a1 = _mm_alignr_epi8( b, a1, 4 ); \
 } while(0)
@@ -44,79 +53,88 @@

 #define MULT2( a0, a1 ) do \
 { \
-  __m128i b = _mm_xor_si128( a0, _mm_shuffle_epi32( _mm_and_si128( a1, MASK ), 0x10 ) ); \
-  a0 = _mm_or_si128( _mm_srli_si128( b, 4 ), _mm_slli_si128( a1, 12 ) ); \
-  a1 = _mm_or_si128( _mm_srli_si128( a1, 4 ), _mm_slli_si128( b, 12 ) ); \
+  __m128i b = _mm_xor_si128( a0, \
+                      _mm_shuffle_epi32( _mm_and_si128( a1, MASK ), 0x10 ) ); \
+  a0 = _mm_or_si128( _mm_srli_si128(  b, 4 ), _mm_slli_si128( a1, 12 ) ); \
+  a1 = _mm_or_si128( _mm_srli_si128( a1, 4 ), _mm_slli_si128(  b, 12 ) ); \
 } while(0)

 #endif

-#define STEP_PART(x,c,t)\
-    SUBCRUMB(*x,*(x+1),*(x+2),*(x+3),*t);\
-    SUBCRUMB(*(x+5),*(x+6),*(x+7),*(x+4),*t);\
-    MIXWORD(*x,*(x+4),*t,*(t+1));\
-    MIXWORD(*(x+1),*(x+5),*t,*(t+1));\
-    MIXWORD(*(x+2),*(x+6),*t,*(t+1));\
-    MIXWORD(*(x+3),*(x+7),*t,*(t+1));\
-    ADD_CONSTANT(*x, *(x+4), *c, *(c+1));
+#if defined(__AVX512VL__)
+//TODO enable for AVX10_512 AVX10_256

-#define STEP_PART2(a0,a1,t0,t1,c0,c1,tmp0,tmp1)\
-    a1 = _mm_shuffle_epi32(a1,147);\
-    t0 = _mm_load_si128(&a1);\
-    a1 = _mm_unpacklo_epi32(a1,a0);\
-    t0 = _mm_unpackhi_epi32(t0,a0);\
-    t1 = _mm_shuffle_epi32(t0,78);\
-    a0 = _mm_shuffle_epi32(a1,78);\
-    SUBCRUMB(t1,t0,a0,a1,tmp0);\
-    t0 = _mm_unpacklo_epi32(t0,t1);\
-    a1 = _mm_unpacklo_epi32(a1,a0);\
-    a0 = _mm_load_si128(&a1);\
-    a0 = _mm_unpackhi_epi64(a0,t0);\
-    a1 = _mm_unpacklo_epi64(a1,t0);\
-    a1 = _mm_shuffle_epi32(a1,57);\
-    MIXWORD(a0,a1,tmp0,tmp1);\
-    ADD_CONSTANT(a0,a1,c0,c1);
+#define SUBCRUMB( a0, a1, a2, a3 ) \
+{ \
+    __m128i t = a0; \
+    a0 = mm128_xoror( a3, a0, a1 ); \
+    a2 = _mm_xor_si128( a2, a3 ); \
+    a1 = _mm_ternarylogic_epi64( a1, a3, t, 0x87 ); /* a1 xnor (a3 & t) */ \
+    a3 = mm128_xorand( a2, a3, t ); \
+    a2 = mm128_xorand( a1, a2, a0 ); \
+    a1 = _mm_or_si128( a1, a3 ); \
+    a3 = _mm_xor_si128( a3, a2 ); \
+    t  = _mm_xor_si128( t, a1 ); \
+    a2 = _mm_and_si128( a2, a1 ); \
+    a1 = mm128_xnor( a1, a0 ); \
+    a0 = t; \
+}

-#define SUBCRUMB(a0,a1,a2,a3,t)\
-    t  = _mm_load_si128(&a0);\
-    a0 = _mm_or_si128(a0,a1);\
-    a2 = _mm_xor_si128(a2,a3);\
-    a1 = mm128_not( a1 );\
-    a0 = _mm_xor_si128(a0,a3);\
-    a3 = _mm_and_si128(a3,t);\
-    a1 = _mm_xor_si128(a1,a3);\
-    a3 = _mm_xor_si128(a3,a2);\
-    a2 = _mm_and_si128(a2,a0);\
-    a0 = mm128_not( a0 );\
-    a2 = _mm_xor_si128(a2,a1);\
-    a1 = _mm_or_si128(a1,a3);\
-    t  = _mm_xor_si128(t,a1);\
-    a3 = _mm_xor_si128(a3,a2);\
-    a2 = _mm_and_si128(a2,a1);\
-    a1 = _mm_xor_si128(a1,a0);\
-    a0 = _mm_load_si128(&t);\
+#else

-#define MIXWORD(a,b,t1,t2)\
-    b = _mm_xor_si128(a,b);\
-    t1 = _mm_slli_epi32(a,2);\
-    t2 = _mm_srli_epi32(a,30);\
-    a = _mm_or_si128(t1,t2);\
-    a = _mm_xor_si128(a,b);\
-    t1 = _mm_slli_epi32(b,14);\
-    t2 = _mm_srli_epi32(b,18);\
-    b = _mm_or_si128(t1,t2);\
-    b = _mm_xor_si128(a,b);\
-    t1 = _mm_slli_epi32(a,10);\
-    t2 = _mm_srli_epi32(a,22);\
-    a = _mm_or_si128(t1,t2);\
-    a = _mm_xor_si128(a,b);\
-    t1 = _mm_slli_epi32(b,1);\
-    t2 = _mm_srli_epi32(b,31);\
-    b = _mm_or_si128(t1,t2);
+#define SUBCRUMB( a0, a1, a2, a3 ) \
+{ \
+    __m128i t = a0; \
+    a0 = _mm_or_si128( a0, a1 ); \
+    a2 = _mm_xor_si128( a2, a3 ); \
+    a1 = mm128_not( a1 ); \
+    a0 = _mm_xor_si128( a0, a3 ); \
+    a3 = _mm_and_si128( a3, t ); \
+    a1 = _mm_xor_si128( a1, a3 ); \
+    a3 = _mm_xor_si128( a3, a2 ); \
+    a2 = _mm_and_si128( a2, a0 ); \
+    a0 = mm128_not( a0 ); \
+    a2 = _mm_xor_si128( a2, a1 ); \
+    a1 = _mm_or_si128(  a1, a3 ); \
+    t  = _mm_xor_si128( t , a1 ); \
+    a3 = _mm_xor_si128( a3, a2 ); \
+    a2 = _mm_and_si128( a2, a1 ); \
+    a1 = _mm_xor_si128( a1, a0 ); \
+    a0 = t; \
+}

-#define ADD_CONSTANT(a,b,c0,c1)\
-    a = _mm_xor_si128(a,c0);\
-    b = _mm_xor_si128(b,c1);\
+#endif
+
+#define MIXWORD( a, b ) \
+    b = _mm_xor_si128( a, b ); \
+    a = _mm_xor_si128( b, mm128_rol_32( a, 2 ) ); \
+    b = _mm_xor_si128( a, mm128_rol_32( b, 14 ) ); \
+    a = _mm_xor_si128( b, mm128_rol_32( a, 10 ) ); \
+    b = mm128_rol_32( b, 1 );
+
+#define STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, c0, c1 ) \
+    SUBCRUMB( x0, x1, x2, x3 ); \
+    SUBCRUMB( x5, x6, x7, x4 ); \
+    MIXWORD( x0, x4 ); \
+    MIXWORD( x1, x5 ); \
+    MIXWORD( x2, x6 ); \
+    MIXWORD( x3, x7 ); \
+    ADD_CONSTANT( x0, x4, c0, c1 );
+
+#define STEP_PART2( a0, a1, t0, t1, c0, c1 ) \
+    t0 = _mm_shuffle_epi32( a1, 147 ); \
+    a1 = _mm_unpacklo_epi32( t0, a0 ); \
+    t0 = _mm_unpackhi_epi32( t0, a0 ); \
+    t1 = _mm_shuffle_epi32( t0, 78 ); \
+    a0 = _mm_shuffle_epi32( a1, 78 ); \
+    SUBCRUMB( t1, t0, a0, a1 ); \
+    t0 = _mm_unpacklo_epi32( t0, t1 ); \
+    a1 = _mm_unpacklo_epi32( a1, a0 ); \
+    a0 = _mm_unpackhi_epi64( a1, t0 ); \
+    a1 = _mm_unpacklo_epi64( a1, t0 ); \
+    a1 = _mm_shuffle_epi32( a1, 57 ); \
+    MIXWORD( a0, a1 ); \
+    ADD_CONSTANT( a0, a1, c0, c1 );

 #define NMLTOM768(r0,r1,r2,s0,s1,s2,s3,p0,p1,p2,q0,q1,q2,q3)\
    s2 = _mm_load_si128(&r1);\
@@ -177,32 +195,22 @@
    q1 = _mm_load_si128(&p1);\

 #define NMLTOM1024(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3)\
-    s1 = _mm_load_si128(&r3);\
-    q1 = _mm_load_si128(&p3);\
-    s3 = _mm_load_si128(&r3);\
-    q3 = _mm_load_si128(&p3);\
-    s1 = _mm_unpackhi_epi32(s1,r2);\
-    q1 = _mm_unpackhi_epi32(q1,p2);\
-    s3 = _mm_unpacklo_epi32(s3,r2);\
-    q3 = _mm_unpacklo_epi32(q3,p2);\
-    s0 = _mm_load_si128(&s1);\
-    q0 = _mm_load_si128(&q1);\
-    s2 = _mm_load_si128(&s3);\
-    q2 = _mm_load_si128(&q3);\
-    r3 = _mm_load_si128(&r1);\
-    p3 = _mm_load_si128(&p1);\
-    r1 = _mm_unpacklo_epi32(r1,r0);\
-    p1 = _mm_unpacklo_epi32(p1,p0);\
-    r3 = _mm_unpackhi_epi32(r3,r0);\
-    p3 = _mm_unpackhi_epi32(p3,p0);\
-    s0 = _mm_unpackhi_epi64(s0,r3);\
-    q0 = _mm_unpackhi_epi64(q0,p3);\
-    s1 = _mm_unpacklo_epi64(s1,r3);\
-    q1 = _mm_unpacklo_epi64(q1,p3);\
-    s2 = _mm_unpackhi_epi64(s2,r1);\
-    q2 = _mm_unpackhi_epi64(q2,p1);\
-    s3 = _mm_unpacklo_epi64(s3,r1);\
-    q3 = _mm_unpacklo_epi64(q3,p1);
+    s1 = _mm_unpackhi_epi32( r3, r2 ); \
+    q1 = _mm_unpackhi_epi32( p3, p2 ); \
+    s3 = _mm_unpacklo_epi32( r3, r2 ); \
+    q3 = _mm_unpacklo_epi32( p3, p2 ); \
+    r3 = _mm_unpackhi_epi32( r1, r0 ); \
+    r1 = _mm_unpacklo_epi32( r1, r0 ); \
+    p3 = _mm_unpackhi_epi32( p1, p0 ); \
+    p1 = _mm_unpacklo_epi32( p1, p0 ); \
+    s0 = _mm_unpackhi_epi64( s1, r3 ); \
+    q0 = _mm_unpackhi_epi64( q1 ,p3 ); \
+    s1 = _mm_unpacklo_epi64( s1, r3 ); \
+    q1 = _mm_unpacklo_epi64( q1, p3 ); \
+    s2 = _mm_unpackhi_epi64( s3, r1 ); \
+    q2 = _mm_unpackhi_epi64( q3, p1 ); \
+    s3 = _mm_unpacklo_epi64( s3, r1 ); \
+    q3 = _mm_unpacklo_epi64( q3, p1 );

 #define MIXTON1024(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3)\
    NMLTOM1024(r0,r1,r2,r3,s0,s1,s2,s3,p0,p1,p2,p3,q0,q1,q2,q3);
@@ -306,8 +314,7 @@ HashReturn update_luffa( hashState_luffa *state, const BitSequence *data,
      // remaining data bytes
      casti_m128i( state->buffer, 0 ) = mm128_bswap_32( cast_m128i( data ) );
      // padding of partial block
-      casti_m128i( state->buffer, 1 ) =
-            _mm_set_epi8( 0,0,0,0, 0,0,0,0, 0,0,0,0, 0x80,0,0,0 );
+      casti_m128i( state->buffer, 1 ) =  _mm_set_epi32( 0, 0, 0, 0x80000000 );
    }

    return SUCCESS;
@@ -325,8 +332,7 @@ HashReturn final_luffa(hashState_luffa *state, BitSequence *hashval)
    else
    {
      // empty pad block, constant data
-     rnd512( state, _mm_setzero_si128(),
-                       _mm_set_epi8( 0,0,0,0, 0,0,0,0, 0,0,0,0, 0x80,0,0,0 ) );
+     rnd512( state, _mm_setzero_si128(), _mm_set_epi32( 0, 0, 0, 0x80000000 ) );
    }

    finalization512(state, (uint32*) hashval);
@@ -423,163 +429,119 @@ int luffa_full( hashState_luffa *state, BitSequence* output, int hashbitlen,

 static void rnd512( hashState_luffa *state, __m128i msg1, __m128i msg0 )
 {
-    __m128i t[2];
+    __m128i t0, t1;
    __m128i *chainv = state->chainv;
-    __m128i tmp[2];
-    __m128i x[8];
+    __m128i x0, x1, x2, x3, x4, x5, x6, x7; 

-    t[0] = chainv[0];
-    t[1] = chainv[1];
+    t0 = mm128_xor3( chainv[0], chainv[2], chainv[4] );
+    t1 = mm128_xor3( chainv[1], chainv[3], chainv[5] );
+    t0 = mm128_xor3( t0, chainv[6], chainv[8] );
+    t1 = mm128_xor3( t1, chainv[7], chainv[9] );

-    t[0] = _mm_xor_si128( t[0], chainv[2] );
-    t[1] = _mm_xor_si128( t[1], chainv[3] );
-    t[0] = _mm_xor_si128( t[0], chainv[4] );
-    t[1] = _mm_xor_si128( t[1], chainv[5] );
-    t[0] = _mm_xor_si128( t[0], chainv[6] );
-    t[1] = _mm_xor_si128( t[1], chainv[7] );
-    t[0] = _mm_xor_si128( t[0], chainv[8] );
-    t[1] = _mm_xor_si128( t[1], chainv[9] );
-
-    MULT2( t[0], t[1] );
+    MULT2( t0, t1 );

    msg0 = _mm_shuffle_epi32( msg0, 27 );
    msg1 = _mm_shuffle_epi32( msg1, 27 );

-    chainv[0] = _mm_xor_si128( chainv[0], t[0] );
-    chainv[1] = _mm_xor_si128( chainv[1], t[1] );
-    chainv[2] = _mm_xor_si128( chainv[2], t[0] );
-    chainv[3] = _mm_xor_si128( chainv[3], t[1] );
-    chainv[4] = _mm_xor_si128( chainv[4], t[0] );
-    chainv[5] = _mm_xor_si128( chainv[5], t[1] );
-    chainv[6] = _mm_xor_si128( chainv[6], t[0] );
-    chainv[7] = _mm_xor_si128( chainv[7], t[1] );
-    chainv[8] = _mm_xor_si128( chainv[8], t[0] );
-    chainv[9] = _mm_xor_si128( chainv[9], t[1] );
+    chainv[0] = _mm_xor_si128( chainv[0], t0 );
+    chainv[1] = _mm_xor_si128( chainv[1], t1 );
+    chainv[2] = _mm_xor_si128( chainv[2], t0 );
+    chainv[3] = _mm_xor_si128( chainv[3], t1 );
+    chainv[4] = _mm_xor_si128( chainv[4], t0 );
+    chainv[5] = _mm_xor_si128( chainv[5], t1 );
+    chainv[6] = _mm_xor_si128( chainv[6], t0 );
+    chainv[7] = _mm_xor_si128( chainv[7], t1 );
+    chainv[8] = _mm_xor_si128( chainv[8], t0 );
+    chainv[9] = _mm_xor_si128( chainv[9], t1 );

-    t[0] = chainv[0];
-    t[1] = chainv[1];
+    t0 = chainv[0];
+    t1 = chainv[1];

    MULT2( chainv[0], chainv[1]);
-
    chainv[0] = _mm_xor_si128( chainv[0], chainv[2] );
    chainv[1] = _mm_xor_si128( chainv[1], chainv[3] );

    MULT2( chainv[2], chainv[3]);
-
    chainv[2] = _mm_xor_si128(chainv[2], chainv[4]);
    chainv[3] = _mm_xor_si128(chainv[3], chainv[5]);

    MULT2( chainv[4], chainv[5]);
-
    chainv[4] = _mm_xor_si128(chainv[4], chainv[6]);
    chainv[5] = _mm_xor_si128(chainv[5], chainv[7]);

    MULT2( chainv[6], chainv[7]);
-
    chainv[6] = _mm_xor_si128(chainv[6], chainv[8]);
    chainv[7] = _mm_xor_si128(chainv[7], chainv[9]);

    MULT2( chainv[8], chainv[9]);
-
-    chainv[8] = _mm_xor_si128( chainv[8], t[0] );
-    chainv[9] = _mm_xor_si128( chainv[9], t[1] );
-
-    t[0] = chainv[8];
-    t[1] = chainv[9];
+    t0 = chainv[8] = _mm_xor_si128( chainv[8], t0 );
+    t1 = chainv[9] = _mm_xor_si128( chainv[9], t1 );

    MULT2( chainv[8], chainv[9]);
-
    chainv[8] = _mm_xor_si128( chainv[8], chainv[6] );
    chainv[9] = _mm_xor_si128( chainv[9], chainv[7] );

    MULT2( chainv[6], chainv[7]);
-
    chainv[6] = _mm_xor_si128( chainv[6], chainv[4] );
    chainv[7] = _mm_xor_si128( chainv[7], chainv[5] );

    MULT2( chainv[4], chainv[5]);
-
    chainv[4] = _mm_xor_si128( chainv[4], chainv[2] );
    chainv[5] = _mm_xor_si128( chainv[5], chainv[3] );

    MULT2( chainv[2], chainv[3] );
-
    chainv[2] = _mm_xor_si128( chainv[2], chainv[0] );
    chainv[3] = _mm_xor_si128( chainv[3], chainv[1] );

    MULT2( chainv[0], chainv[1] );
-
-    chainv[0] = _mm_xor_si128( _mm_xor_si128( chainv[0], t[0] ), msg0 );
-    chainv[1] = _mm_xor_si128( _mm_xor_si128( chainv[1], t[1] ), msg1 );
+    chainv[0] = _mm_xor_si128( _mm_xor_si128( chainv[0], t0 ), msg0 );
+    chainv[1] = _mm_xor_si128( _mm_xor_si128( chainv[1], t1 ), msg1 );

    MULT2( msg0, msg1);
-
    chainv[2] = _mm_xor_si128( chainv[2], msg0 );
    chainv[3] = _mm_xor_si128( chainv[3], msg1 );

    MULT2( msg0, msg1);
-
    chainv[4] = _mm_xor_si128( chainv[4], msg0 );
    chainv[5] = _mm_xor_si128( chainv[5], msg1 );

    MULT2( msg0, msg1);
-
    chainv[6] = _mm_xor_si128( chainv[6], msg0 );
    chainv[7] = _mm_xor_si128( chainv[7], msg1 );

    MULT2( msg0, msg1);
-
    chainv[8] = _mm_xor_si128( chainv[8], msg0 );
    chainv[9] = _mm_xor_si128( chainv[9], msg1 );

    MULT2( msg0, msg1);
+    chainv[3] = mm128_rol_32( chainv[3], 1 );    
+    chainv[5] = mm128_rol_32( chainv[5], 2 );
+    chainv[7] = mm128_rol_32( chainv[7], 3 );
+    chainv[9] = mm128_rol_32( chainv[9], 4 );
+    
+    NMLTOM1024( chainv[0], chainv[2], chainv[4], chainv[6], x0, x1, x2, x3,
+                chainv[1], chainv[3], chainv[5], chainv[7], x4, x5, x6, x7 );

-    chainv[3] = _mm_or_si128( _mm_slli_epi32(chainv[3], 1),
-                              _mm_srli_epi32(chainv[3], 31) );
-    chainv[5] = _mm_or_si128( _mm_slli_epi32(chainv[5], 2),
-                              _mm_srli_epi32(chainv[5], 30) );
-    chainv[7] = _mm_or_si128( _mm_slli_epi32(chainv[7], 3),
-                              _mm_srli_epi32(chainv[7], 29) );
-    chainv[9] = _mm_or_si128( _mm_slli_epi32(chainv[9], 4),
-                              _mm_srli_epi32(chainv[9], 28) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns( 0), cns( 1) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns( 2), cns( 3) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns( 4), cns( 5) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns( 6), cns( 7) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns( 8), cns( 9) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns(10), cns(11) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns(12), cns(13) );
+    STEP_PART( x0, x1, x2, x3, x4, x5, x6, x7, cns(14), cns(15) );
+    
+    MIXTON1024( x0, x1, x2, x3, chainv[0], chainv[2], chainv[4], chainv[6],
+                x4, x5, x6, x7, chainv[1], chainv[3], chainv[5], chainv[7]);

-
-    NMLTOM1024( chainv[0], chainv[2], chainv[4], chainv[6],
-                x[0], x[1], x[2], x[3],
-                chainv[1],chainv[3],chainv[5],chainv[7],
-                x[4], x[5], x[6], x[7] );
-
-    STEP_PART( &x[0], &CNS128[ 0], &tmp[0] );
-    STEP_PART( &x[0], &CNS128[ 2], &tmp[0] );
-    STEP_PART( &x[0], &CNS128[ 4], &tmp[0] );
-    STEP_PART( &x[0], &CNS128[ 6], &tmp[0] );
-    STEP_PART( &x[0], &CNS128[ 8], &tmp[0] );
-    STEP_PART( &x[0], &CNS128[10], &tmp[0] );
-    STEP_PART( &x[0], &CNS128[12], &tmp[0] );
-    STEP_PART( &x[0], &CNS128[14], &tmp[0] );
-
-    MIXTON1024( x[0], x[1], x[2], x[3],
-                chainv[0], chainv[2], chainv[4],chainv[6],
-                x[4], x[5], x[6], x[7],
-                chainv[1],chainv[3],chainv[5],chainv[7]);
-
-    /* Process last 256-bit block */
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[16], CNS128[17],
-                tmp[0], tmp[1] );
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[18], CNS128[19],
-                tmp[0], tmp[1] );
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[20], CNS128[21],
-                tmp[0], tmp[1] );
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[22], CNS128[23],
-                tmp[0], tmp[1] );
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[24], CNS128[25],
-                tmp[0], tmp[1] );
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[26], CNS128[27],
-                tmp[0], tmp[1] );
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[28], CNS128[29],
-                tmp[0], tmp[1] );
-    STEP_PART2( chainv[8], chainv[9], t[0], t[1], CNS128[30], CNS128[31],
-                tmp[0], tmp[1] );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(16), cns(17) );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(18), cns(19) );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(20), cns(21) );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(22), cns(23) );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(24), cns(25) );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(26), cns(27) );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(28), cns(29) );
+    STEP_PART2( chainv[8], chainv[9], t0, t1, cns(30), cns(31) );
 }


@@ -588,51 +550,6 @@ static void rnd512( hashState_luffa *state, __m128i msg1, __m128i msg0 )
 /* state: hash context    */
 /* b[8]: hash values      */

-#if defined (__AVX2__)
-
-static void finalization512( hashState_luffa *state, uint32 *b )
-{
-    uint32   hash[8] __attribute((aligned(64)));
-    __m256i* chainv = (__m256i*)state->chainv;
-    __m256i  t;
-    const __m128i zero = m128_zero;
-    const __m256i shuff_bswap32 = _mm256_set_epi64x( 0x1c1d1e1f18191a1b,
-                                                     0x1415161710111213,
-                                                     0x0c0d0e0f08090a0b,
-                                                     0x0405060700010203 );
-
-    rnd512( state, zero, zero );
-
-    t = chainv[0];
-    t = _mm256_xor_si256( t, chainv[1] );
-    t = _mm256_xor_si256( t, chainv[2] );
-    t = _mm256_xor_si256( t, chainv[3] );
-    t = _mm256_xor_si256( t, chainv[4] );
-
-    t = _mm256_shuffle_epi32( t, 27 );
-
-    _mm256_store_si256( (__m256i*)hash, t );
-
-    casti_m256i( b, 0 ) = _mm256_shuffle_epi8(
-                                 casti_m256i( hash, 0 ), shuff_bswap32 );
-
-    rnd512( state, zero, zero );
-
-    t = chainv[0];
-    t = _mm256_xor_si256( t, chainv[1] );
-    t = _mm256_xor_si256( t, chainv[2] );
-    t = _mm256_xor_si256( t, chainv[3] );
-    t = _mm256_xor_si256( t, chainv[4] );
-    t = _mm256_shuffle_epi32( t, 27 );
-
-    _mm256_store_si256( (__m256i*)hash, t );
-
-    casti_m256i( b, 1 ) = _mm256_shuffle_epi8( 
-                                 casti_m256i( hash, 0 ), shuff_bswap32 );
-}
-
-#else
-
 static void finalization512( hashState_luffa *state, uint32 *b )
 {
    uint32 hash[8] __attribute((aligned(64)));
@@ -685,6 +602,5 @@ static void finalization512( hashState_luffa *state, uint32 *b )
    casti_m128i( b, 2 ) = mm128_bswap_32( casti_m128i( hash, 0 ) );
    casti_m128i( b, 3 ) = mm128_bswap_32( casti_m128i( hash, 1 ) );
 }
-#endif

 /***************************************************/
--- a/algo/luffa/luffa_for_sse2.h
+++ b/algo/luffa/luffa_for_sse2.h
@@ -22,7 +22,7 @@
 */

 #include <emmintrin.h>
-#include "algo/sha/sha3-defs.h"
+#include "compat/sha3-defs.h"
 /* The length of digests*/
 #define DIGEST_BIT_LEN_224 224
 #define DIGEST_BIT_LEN_256 256
--- a/algo/luffa/sph_luffa.h
+++ b/algo/luffa/sph_luffa.h
@@ -41,7 +41,7 @@ extern "C"{
 #endif

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for Luffa-224.
--- a/algo/lyra2/allium-4way.c
+++ b/algo/lyra2/allium-4way.c
@@ -48,7 +48,7 @@ static void allium_16way_hash( void *state, const void *midstate_vars,
   uint32_t hash15[8] __attribute__ ((aligned (32)));
   allium_16way_ctx_holder ctx __attribute__ ((aligned (64)));

-   blake256_16way_final_rounds_le( vhash, midstate_vars, midhash, block );
+   blake256_16way_final_rounds_le( vhash, midstate_vars, midhash, block, 14 );

   dintrlv_16x32( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                  hash8, hash9, hash10, hash11, hash12, hash13, hash14, hash15,
@@ -212,12 +212,12 @@ int scanhash_allium_16way( struct work *work, uint32_t max_nonce,
   const uint32_t last_nonce = max_nonce - 16;
   const int thr_id = mythr->id;
   const bool bench = opt_benchmark;
-   const __m512i sixteen = m512_const1_32( 16 );
+   const __m512i sixteen = _mm512_set1_epi32( 16 );

   if ( bench ) ( (uint32_t*)ptarget )[7] = 0x0000ff;

   // Prehash first block.
-   blake256_transform_le( phash, pdata, 512, 0 );
+   blake256_transform_le( phash, pdata, 512, 0, 14 );

   // Interleave hash for second block prehash.
   block0_hash[0] = _mm512_set1_epi32( phash[0] );
@@ -286,7 +286,7 @@ static void allium_8way_hash( void *hash, const void *midstate_vars,
   uint64_t *hash7 = (uint64_t*)hash+28;
   allium_8way_ctx_holder ctx __attribute__ ((aligned (64))); 

-   blake256_8way_final_rounds_le( vhashA, midstate_vars, midhash, block );
+   blake256_8way_final_rounds_le( vhashA, midstate_vars, midhash, block, 14 );

   dintrlv_8x32( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                 vhashA, 256 );
@@ -398,10 +398,10 @@ int scanhash_allium_8way( struct work *work, uint32_t max_nonce,
   uint32_t n = first_nonce;
   const int thr_id = mythr->id;  
   const bool bench = opt_benchmark;
-   const __m256i eight = m256_const1_32( 8 );
+   const __m256i eight = _mm256_set1_epi32( 8 );

   // Prehash first block
-   blake256_transform_le( phash, pdata, 512, 0 );
+   blake256_transform_le( phash, pdata, 512, 0, 14 );

   block0_hash[0] = _mm256_set1_epi32( phash[0] );
   block0_hash[1] = _mm256_set1_epi32( phash[1] );
--- a/algo/lyra2/lyra2.h
+++ b/algo/lyra2/lyra2.h
@@ -21,9 +21,8 @@
 #define LYRA2_H_

 #include <stdint.h>
-#include "algo/sha/sha3-defs.h"

-//typedef unsigned char byte;
+typedef unsigned char byte;

 //Block length required so Blake2's Initialization Vector (IV) is not overwritten (THIS SHOULD NOT BE MODIFIED)
 #define BLOCK_LEN_BLAKE2_SAFE_INT64 8                                   //512 bits (=64 bytes, =8 uint64_t)
--- a/algo/lyra2/lyra2rev2-4way.c
+++ b/algo/lyra2/lyra2rev2-4way.c
@@ -203,7 +203,7 @@ int scanhash_lyra2rev2_16way( struct work *work, const uint32_t max_nonce,
             submit_solution( work, lane_hash, mythr );
         }
      }
-      *noncev = _mm512_add_epi32( *noncev, m512_const1_32( 16 ) );
+      *noncev = _mm512_add_epi32( *noncev, _mm512_set1_epi32( 16 ) );
      n += 16;
   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );
   pdata[19] = n;
@@ -345,7 +345,7 @@ int scanhash_lyra2rev2_8way( struct work *work, const uint32_t max_nonce,
             submit_solution( work, lane_hash, mythr );
         }
      }
-      *noncev = _mm256_add_epi32( *noncev, m256_const1_32( 8 ) );
+      *noncev = _mm256_add_epi32( *noncev, _mm256_set1_epi32( 8 ) );
      n += 8;
   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );
   pdata[19] = n;
--- a/algo/lyra2/lyra2rev2.c
+++ b/algo/lyra2/lyra2rev2.c
@@ -4,7 +4,6 @@

 #include <memory.h>
 #include "algo/blake/sph_blake.h"
-#include "algo/cubehash/sph_cubehash.h"
 #include "algo/keccak/sph_keccak.h"
 #include "algo/skein/sph_skein.h"
 #include "algo/bmw/sph_bmw.h"
--- a/algo/lyra2/lyra2rev3-4way.c
+++ b/algo/lyra2/lyra2rev3-4way.c
@@ -287,7 +287,7 @@ int scanhash_lyra2rev3_8way( struct work *work, const uint32_t max_nonce,
             submit_solution( work, lane_hash, mythr );
         }
      }
-      *noncev = _mm256_add_epi32( *noncev, m256_const1_32( 8 ) );
+      *noncev = _mm256_add_epi32( *noncev, _mm256_set1_epi32( 8 ) );
      n += 8;
   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );
   pdata[19] = n;
@@ -389,7 +389,7 @@ int scanhash_lyra2rev3_4way( struct work *work, const uint32_t max_nonce,
              submit_solution( work, lane_hash, mythr );
 	      }
      }
-      *noncev = _mm_add_epi32( *noncev, m128_const1_32( 4 ) );
+      *noncev = _mm_add_epi32( *noncev, _mm_set1_epi32( 4 ) );
      n += 4;
   } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
   pdata[19] = n;
--- a/algo/lyra2/lyra2rev3.c
+++ b/algo/lyra2/lyra2rev3.c
@@ -4,7 +4,6 @@

 #include <memory.h>
 #include "algo/blake/sph_blake.h"
-#include "algo/cubehash/sph_cubehash.h"
 #include "algo/bmw/sph_bmw.h"
 #include "algo/cubehash/cubehash_sse2.h" 
 //#include "lyra2.h"
--- a/algo/lyra2/lyra2z-4way.c
+++ b/algo/lyra2/lyra2z-4way.c
@@ -35,7 +35,7 @@ static void lyra2z_16way_hash( void *state, const void *midstate_vars,
    uint32_t hash14[8] __attribute__ ((aligned (32)));
    uint32_t hash15[8] __attribute__ ((aligned (32)));

-    blake256_16way_final_rounds_le( vhash, midstate_vars, midhash, block );
+    blake256_16way_final_rounds_le( vhash, midstate_vars, midhash, block, 14 );

    dintrlv_16x32( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
              hash8, hash9, hash10, hash11 ,hash12, hash13, hash14, hash15,
@@ -103,12 +103,12 @@ int scanhash_lyra2z_16way( struct work *work, uint32_t max_nonce,
   const uint32_t last_nonce = max_nonce - 16;
   const int thr_id = mythr->id;
   const bool bench = opt_benchmark;
-   const __m512i sixteen = m512_const1_32( 16 );
+   const __m512i sixteen = _mm512_set1_epi32( 16 );

   if ( bench ) ( (uint32_t*)ptarget )[7] = 0x0000ff;

   // Prehash first block
-   blake256_transform_le( phash, pdata, 512, 0 );
+   blake256_transform_le( phash, pdata, 512, 0, 14 );

   block0_hash[0] = _mm512_set1_epi32( phash[0] );
   block0_hash[1] = _mm512_set1_epi32( phash[1] );
@@ -170,7 +170,7 @@ static void lyra2z_8way_hash( void *state, const void *midstate_vars,
     uint32_t hash7[8] __attribute__ ((aligned (32)));
     uint32_t vhash[8*8] __attribute__ ((aligned (64)));

-     blake256_8way_final_rounds_le( vhash, midstate_vars, midhash, block );
+     blake256_8way_final_rounds_le( vhash, midstate_vars, midhash, block, 14 );

     dintrlv_8x32( hash0, hash1, hash2, hash3,
                   hash4, hash5, hash6, hash7, vhash, 256 );
@@ -213,10 +213,10 @@ int scanhash_lyra2z_8way( struct work *work, uint32_t max_nonce,
   uint32_t n = first_nonce;
   const int thr_id = mythr->id;
   const bool bench = opt_benchmark;
-   const __m256i eight = m256_const1_32( 8 );
+   const __m256i eight = _mm256_set1_epi32( 8 );

   // Prehash first block
-   blake256_transform_le( phash, pdata, 512, 0 );
+   blake256_transform_le( phash, pdata, 512, 0, 14 );

   block0_hash[0] = _mm256_set1_epi32( phash[0] );
   block0_hash[1] = _mm256_set1_epi32( phash[1] );
@@ -328,7 +328,7 @@ int scanhash_lyra2z_4way( struct work *work, uint32_t max_nonce,
           submit_solution( work, lane_hash, mythr );
        }
      }
-      *noncev = _mm_add_epi32( *noncev, m128_const1_32( 4 ) );
+      *noncev = _mm_add_epi32( *noncev, _mm_set1_epi32( 4 ) );
      n += 4;
   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );

--- a/algo/lyra2/sponge.c
+++ b/algo/lyra2/sponge.c
@@ -62,10 +62,10 @@ inline void initState( uint64_t State[/*16*/] )
  state[1] = zero;
  state[2] = zero;
  state[3] = zero;
-  state[4] = m128_const_64( 0xbb67ae8584caa73bULL, 0x6a09e667f3bcc908ULL );
-  state[5] = m128_const_64( 0xa54ff53a5f1d36f1ULL, 0x3c6ef372fe94f82bULL );
-  state[6] = m128_const_64( 0x9b05688c2b3e6c1fULL, 0x510e527fade682d1ULL );
-  state[7] = m128_const_64( 0x5be0cd19137e2179ULL, 0x1f83d9abfb41bd6bULL );
+  state[4] = _mm_set_epi64x( 0xbb67ae8584caa73bULL, 0x6a09e667f3bcc908ULL );
+  state[5] = _mm_set_epi64x( 0xa54ff53a5f1d36f1ULL, 0x3c6ef372fe94f82bULL );
+  state[6] = _mm_set_epi64x( 0x9b05688c2b3e6c1fULL, 0x510e527fade682d1ULL );
+  state[7] = _mm_set_epi64x( 0x5be0cd19137e2179ULL, 0x1f83d9abfb41bd6bULL );

 #else
    //First 512 bis are zeros
@@ -299,10 +299,10 @@ inline void absorbBlockBlake2Safe( uint64_t *State, const uint64_t *In,
  state1 =
  state2 =
  state3 = m128_zero;
-  state4 = m128_const_64( 0xbb67ae8584caa73bULL, 0x6a09e667f3bcc908ULL );
-  state5 = m128_const_64( 0xa54ff53a5f1d36f1ULL, 0x3c6ef372fe94f82bULL );
-  state6 = m128_const_64( 0x9b05688c2b3e6c1fULL, 0x510e527fade682d1ULL );
-  state7 = m128_const_64( 0x5be0cd19137e2179ULL, 0x1f83d9abfb41bd6bULL );
+  state4 = _mm_set_epi64x( 0xbb67ae8584caa73bULL, 0x6a09e667f3bcc908ULL );
+  state5 = _mm_set_epi64x( 0xa54ff53a5f1d36f1ULL, 0x3c6ef372fe94f82bULL );
+  state6 = _mm_set_epi64x( 0x9b05688c2b3e6c1fULL, 0x510e527fade682d1ULL );
+  state7 = _mm_set_epi64x( 0x5be0cd19137e2179ULL, 0x1f83d9abfb41bd6bULL );

  for ( int i = 0; i < nBlocks; i++ )
  { 
--- a/algo/lyra2/sponge.h
+++ b/algo/lyra2/sponge.h
@@ -43,27 +43,29 @@ static const uint64_t blake2b_IV[8] =
  0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
 };

-/*Blake2b's rotation*/
-static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
-    return ( w >> c ) | ( w << ( 64 - c ) );
-}
-
-// serial data is only 32 bytes so AVX2 is the limit for that dimension.
-// However, 2 way parallel looks trivial to code for AVX512 except for
-// a data dependency with rowa.
-
 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)

 #define G2W_4X64(a,b,c,d) \
   a = _mm512_add_epi64( a, b ); \
-   d = mm512_ror_64( _mm512_xor_si512( d, a ), 32 ); \
+   d = _mm512_ror_epi64( _mm512_xor_si512( d, a ), 32 ); \
   c = _mm512_add_epi64( c, d ); \
-   b = mm512_ror_64( _mm512_xor_si512( b, c ), 24 ); \
+   b = _mm512_ror_epi64( _mm512_xor_si512( b, c ), 24 ); \
   a = _mm512_add_epi64( a, b ); \
-   d = mm512_ror_64( _mm512_xor_si512( d, a ), 16 ); \
+   d = _mm512_ror_epi64( _mm512_xor_si512( d, a ), 16 ); \
   c = _mm512_add_epi64( c, d ); \
-   b = mm512_ror_64( _mm512_xor_si512( b, c ), 63 );
+   b = _mm512_ror_epi64( _mm512_xor_si512( b, c ), 63 );

+#define LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   G2W_4X64( s0, s1, s2, s3 ); \
+   s0 = mm512_shufll256_64( s0 ); \
+   s3 = mm512_swap256_128( s3); \
+   s2 = mm512_shuflr256_64( s2 ); \
+   G2W_4X64( s0, s1, s2, s3 ); \
+   s0 = mm512_shuflr256_64( s0 ); \
+   s3 = mm512_swap256_128( s3 ); \
+   s2 = mm512_shufll256_64( s2 ); 
+
+/*
 #define LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
   G2W_4X64( s0, s1, s2, s3 ); \
   s3 = mm512_shufll256_64( s3 ); \
@@ -73,6 +75,7 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
   s3 = mm512_shuflr256_64( s3 ); \
   s1 = mm512_shufll256_64( s1 ); \
   s2 = mm512_swap256_128( s2 ); 
+*/

 #define LYRA_12_ROUNDS_2WAY_AVX512( s0, s1, s2, s3 ) \
   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
@@ -88,13 +91,10 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 )

-
 #endif  // AVX512

-#if defined __AVX2__
+#if defined(__AVX2__)

-// process 4 columns in parallel
-// returns void, updates all args
 #define G_4X64(a,b,c,d) \
   a = _mm256_add_epi64( a, b ); \
   d = mm256_swap64_32( _mm256_xor_si256( d, a ) ); \
@@ -105,6 +105,18 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
   c = _mm256_add_epi64( c, d ); \
   b = mm256_ror_64( _mm256_xor_si256( b, c ), 63 );

+// Pivot about s1 instead of s0 reduces latency.
+#define LYRA_ROUND_AVX2( s0, s1, s2, s3 ) \
+   G_4X64( s0, s1, s2, s3 ); \
+   s0 = mm256_shufll_64( s0 ); \
+   s3 = mm256_swap_128( s3); \
+   s2 = mm256_shuflr_64( s2 ); \
+   G_4X64( s0, s1, s2, s3 ); \
+   s0 = mm256_shuflr_64( s0 ); \
+   s3 = mm256_swap_128( s3 ); \
+   s2 = mm256_shufll_64( s2 );
+
+/*
 #define LYRA_ROUND_AVX2( s0, s1, s2, s3 ) \
   G_4X64( s0, s1, s2, s3 ); \
   s3 = mm256_shufll_64( s3 ); \
@@ -114,6 +126,7 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
   s3 = mm256_shuflr_64( s3 ); \
   s1 = mm256_shufll_64( s1 ); \
   s2 = mm256_swap_128( s2 );
+*/

 #define LYRA_12_ROUNDS_AVX2( s0, s1, s2, s3 ) \
   LYRA_ROUND_AVX2( s0, s1, s2, s3 ) \
@@ -182,8 +195,13 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){

 #endif // AVX2 else SSE2

-// Scalar
-//Blake2b's G function
+/*
+// Scalar, not used.
+
+static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
+    return ( w >> c ) | ( w << ( 64 - c ) );
+}
+
 #define G(r,i,a,b,c,d) \
  do { \
    a = a + b; \
@@ -196,8 +214,6 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
    b = rotr64(b ^ c, 63); \
  } while(0)

-
-/*One Round of the Blake2b's compression function*/
 #define ROUND_LYRA(r)  \
    G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
    G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
@@ -207,6 +223,7 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
    G(r,5,v[ 1],v[ 6],v[11],v[12]); \
    G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
    G(r,7,v[ 3],v[ 4],v[ 9],v[14]);
+*/

 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)

--- a/algo/panama/sph_panama.h
+++ b/algo/panama/sph_panama.h
@@ -58,7 +58,7 @@
 #define SPH_PANAMA_H__

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for PANAMA.
--- a/algo/quark/anime-4way.c
+++ b/algo/quark/anime-4way.c
@@ -51,7 +51,7 @@ void anime_8way_hash( void *state, const void *input )
    __m512i* vhA = (__m512i*)vhashA;
    __m512i* vhB = (__m512i*)vhashB;
    __m512i* vhC = (__m512i*)vhashC;
-    const __m512i bit3_mask = m512_const1_64( 8 );
+    const __m512i bit3_mask = _mm512_set1_epi64( 8 );
    __mmask8 vh_mask;
    anime_8way_context_overlay ctx __attribute__ ((aligned (64)));

@@ -209,7 +209,7 @@ int scanhash_anime_8way( struct work *work, uint32_t max_nonce,
          }
       }
       *noncev = _mm512_add_epi32( *noncev,
-                                   m512_const1_64( 0x0000000800000000 ) );
+                                   _mm512_set1_epi64( 0x0000000800000000 ) );
       n += 8;
    } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
    pdata[19] = n;
@@ -248,7 +248,7 @@ void anime_4way_hash( void *state, const void *input )
    __m256i* vhB = (__m256i*)vhashB;
    __m256i vh_mask;
    int h_mask;
-    const __m256i bit3_mask = m256_const1_64( 8 );
+    const __m256i bit3_mask = _mm256_set1_epi64x( 8 );
    const __m256i zero = _mm256_setzero_si256();
    anime_4way_context_overlay ctx __attribute__ ((aligned (64)));

@@ -388,7 +388,7 @@ int scanhash_anime_4way( struct work *work, uint32_t max_nonce,
          }
       }
       *noncev = _mm256_add_epi32( *noncev,
-                                   m256_const1_64( 0x0000000400000000 ) );
+                                   _mm256_set1_epi64x( 0x0000000400000000 ) );
       n += 4;
    } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
    pdata[19] = n;
--- a/algo/quark/hmq1725-4way.c
+++ b/algo/quark/hmq1725-4way.c
@@ -21,7 +21,7 @@
 #include "algo/shabal/shabal-hash-4way.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/haval-hash-4way.h"
-#include "algo/sha/sha-hash-4way.h"
+#include "algo/sha/sha512-hash.h"
 #if defined(__VAES__)
  #include "algo/groestl/groestl512-hash-4way.h"
  #include "algo/shavite/shavite-hash-4way.h"
@@ -75,7 +75,7 @@ extern void hmq1725_8way_hash(void *state, const void *input)
   uint32_t hash7 [16]    __attribute__ ((aligned (32)));
   hmq1725_8way_context_overlay ctx __attribute__ ((aligned (64)));
   __mmask8 vh_mask;
-   const __m512i vmask = m512_const1_64( 24 );
+   const __m512i vmask = _mm512_set1_epi64( 24 );
   const uint32_t mask = 24;
   __m512i* vh  = (__m512i*)vhash;
   __m512i* vhA = (__m512i*)vhashA;
@@ -593,7 +593,7 @@ int scanhash_hmq1725_8way( struct work *work, uint32_t max_nonce,
          }
       }
       *noncev = _mm512_add_epi32( *noncev,
-                                   m512_const1_64( 0x0000000800000000 ) );
+                                   _mm512_set1_epi64( 0x0000000800000000 ) );
       n += 8;
    } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );

@@ -647,7 +647,7 @@ extern void hmq1725_4way_hash(void *state, const void *input)
   hmq1725_4way_context_overlay ctx __attribute__ ((aligned (64)));
   __m256i vh_mask;     
   int h_mask;
-   const __m256i vmask = m256_const1_64( 24 );
+   const __m256i vmask = _mm256_set1_epi64x( 24 );
   const uint32_t mask = 24;
   __m256i* vh  = (__m256i*)vhash;
   __m256i* vhA = (__m256i*)vhashA;
@@ -1041,7 +1041,7 @@ int scanhash_hmq1725_4way( struct work *work, uint32_t max_nonce,
          }
       }
       *noncev = _mm256_add_epi32( *noncev,
-                                   m256_const1_64( 0x0000000400000000 ) );
+                                   _mm256_set1_epi64x( 0x0000000400000000 ) );
       n += 4;
    } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
    pdata[19] = n;
--- a/algo/quark/quark-4way.c
+++ b/algo/quark/quark-4way.c
@@ -67,7 +67,7 @@ void quark_8way_hash( void *state, const void *input )
    __mmask8 vh_mask;
    quark_8way_ctx_holder ctx;
    const uint32_t mask = 8;
-    const __m512i bit3_mask = m512_const1_64( mask );
+    const __m512i bit3_mask = _mm512_set1_epi64( mask );

    memcpy( &ctx, &quark_8way_ctx, sizeof(quark_8way_ctx) );

@@ -224,7 +224,7 @@ int scanhash_quark_8way( struct work *work, uint32_t max_nonce,
          }
       }
       *noncev = _mm512_add_epi32( *noncev,
-                                  m512_const1_64( 0x0000000800000000 ) );
+                                  _mm512_set1_epi64( 0x0000000800000000 ) );
       n += 8;
    } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );

@@ -271,7 +271,7 @@ void quark_4way_hash( void *state, const void *input )
    __m256i vh_mask;
    int h_mask;
    quark_4way_ctx_holder ctx;
-    const __m256i bit3_mask = m256_const1_64( 8 );
+    const __m256i bit3_mask = _mm256_set1_epi64x( 8 );
    const __m256i zero = _mm256_setzero_si256();

    memcpy( &ctx, &quark_4way_ctx, sizeof(quark_4way_ctx) );
@@ -397,7 +397,7 @@ int scanhash_quark_4way( struct work *work, uint32_t max_nonce,
          }
       }
       *noncev = _mm256_add_epi32( *noncev,
-                                  m256_const1_64( 0x0000000400000000 ) );
+                                  _mm256_set1_epi64x( 0x0000000400000000 ) );
       n += 4;
    } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );

--- a/algo/ripemd/lbry-4way.c
+++ b/algo/ripemd/lbry-4way.c
@@ -3,7 +3,8 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-#include "algo/sha/sha-hash-4way.h"
+#include "algo/sha/sha256-hash.h"
+#include "algo/sha/sha512-hash.h"
 #include "ripemd-hash-4way.h"

 #define LBRY_INPUT_SIZE 112
--- a/algo/ripemd/ripemd-hash-4way.c
+++ b/algo/ripemd/ripemd-hash-4way.c
@@ -47,7 +47,7 @@ static const uint32_t IV[5] =
 do{ \
   a = _mm_add_epi32( mm128_rol_32( _mm_add_epi32( _mm_add_epi32( \
                _mm_add_epi32( a, f( b ,c, d ) ), r ), \
-                                 m128_const1_64( k ) ), s ), e ); \
+                                 _mm_set1_epi64x( k ) ), s ), e ); \
   c = mm128_rol_32( c, 10 );\
 } while (0)

@@ -251,11 +251,11 @@ static void ripemd160_4way_round( ripemd160_4way_context *sc )

 void ripemd160_4way_init( ripemd160_4way_context *sc )
 {
-   sc->val[0] = m128_const1_64( 0x6745230167452301 );
-   sc->val[1] = m128_const1_64( 0xEFCDAB89EFCDAB89 );
-   sc->val[2] = m128_const1_64( 0x98BADCFE98BADCFE );
-   sc->val[3] = m128_const1_64( 0x1032547610325476 );
-   sc->val[4] = m128_const1_64( 0xC3D2E1F0C3D2E1F0 );
+   sc->val[0] = _mm_set1_epi64x( 0x6745230167452301 );
+   sc->val[1] = _mm_set1_epi64x( 0xEFCDAB89EFCDAB89 );
+   sc->val[2] = _mm_set1_epi64x( 0x98BADCFE98BADCFE );
+   sc->val[3] = _mm_set1_epi64x( 0x1032547610325476 );
+   sc->val[4] = _mm_set1_epi64x( 0xC3D2E1F0C3D2E1F0 );
   sc->count_high = sc->count_low = 0;
 }

@@ -347,7 +347,7 @@ void ripemd160_4way_close( ripemd160_4way_context  *sc, void *dst )
 do{ \
   a = _mm256_add_epi32( mm256_rol_32( _mm256_add_epi32( _mm256_add_epi32( \
                _mm256_add_epi32( a, f( b ,c, d ) ), r ), \
-                                 m256_const1_64( k ) ), s ), e ); \
+                                 _mm256_set1_epi64x( k ) ), s ), e ); \
   c = mm256_rol_32( c, 10 );\
 } while (0)
    
@@ -552,11 +552,11 @@ static void ripemd160_8way_round( ripemd160_8way_context *sc )

 void ripemd160_8way_init( ripemd160_8way_context *sc )
 {
-   sc->val[0] = m256_const1_64( 0x6745230167452301 );
-   sc->val[1] = m256_const1_64( 0xEFCDAB89EFCDAB89 );
-   sc->val[2] = m256_const1_64( 0x98BADCFE98BADCFE );
-   sc->val[3] = m256_const1_64( 0x1032547610325476 );
-   sc->val[4] = m256_const1_64( 0xC3D2E1F0C3D2E1F0 );
+   sc->val[0] = _mm256_set1_epi64x( 0x6745230167452301 );
+   sc->val[1] = _mm256_set1_epi64x( 0xEFCDAB89EFCDAB89 );
+   sc->val[2] = _mm256_set1_epi64x( 0x98BADCFE98BADCFE );
+   sc->val[3] = _mm256_set1_epi64x( 0x1032547610325476 );
+   sc->val[4] = _mm256_set1_epi64x( 0xC3D2E1F0C3D2E1F0 );
   sc->count_high = sc->count_low = 0;
 }

@@ -649,7 +649,7 @@ void ripemd160_8way_close( ripemd160_8way_context  *sc, void *dst )
 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 ); \
+                                 _mm512_set1_epi64( k ) ), s ), e ); \
   c = mm512_rol_32( c, 10 );\
 } while (0)

@@ -853,11 +853,11 @@ static void ripemd160_16way_round( ripemd160_16way_context *sc )

 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->val[0] = _mm512_set1_epi64( 0x6745230167452301 );
+   sc->val[1] = _mm512_set1_epi64( 0xEFCDAB89EFCDAB89 );
+   sc->val[2] = _mm512_set1_epi64( 0x98BADCFE98BADCFE );
+   sc->val[3] = _mm512_set1_epi64( 0x1032547610325476 );
+   sc->val[4] = _mm512_set1_epi64( 0xC3D2E1F0C3D2E1F0 );
   sc->count_high = sc->count_low = 0;
 }

@@ -902,7 +902,7 @@ void ripemd160_16way_close( ripemd160_16way_context  *sc, void *dst )
   const int pad = block_size - 8;

   ptr = (unsigned)sc->count_low & ( block_size - 1U);
-   sc->buf[ ptr>>2 ] = m512_const1_32( 0x80 );
+   sc->buf[ ptr>>2 ] = _mm512_set1_epi32( 0x80 );
   ptr += 4;

   if ( ptr > pad )
--- a/algo/ripemd/ripemd-hash-4way.h
+++ b/algo/ripemd/ripemd-hash-4way.h
@@ -2,7 +2,6 @@
 #define RIPEMD_HASH_4WAY_H__

 #include <stddef.h>
-#include "algo/sha/sph_types.h"

 #if defined(__SSE4_2__)

--- a/algo/ripemd/sph_ripemd.h
+++ b/algo/ripemd/sph_ripemd.h
@@ -57,7 +57,7 @@
 #define SPH_RIPEMD_H__

 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"

 /**
 * Output size (in bits) for RIPEMD.
--- a/algo/scrypt/scrypt.c
+++ b/algo/scrypt/scrypt.c
@@ -31,7 +31,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <inttypes.h>
-#include "algo/sha/sha-hash-4way.h"
 #include "algo/sha/sha256-hash.h"
 #include <mm_malloc.h>
 #include "malloc-huge.h"
--- a/algo/sha/hmac-sha256-hash-4way.h
+++ b/algo/sha/hmac-sha256-hash-4way.h
@@ -36,7 +36,7 @@
 #include <sys/types.h>
 #include <stdint.h>
 #include "simd-utils.h"
-#include "sha-hash-4way.h"
+#include "sha256-hash.h"

 typedef struct _hmac_sha256_4way_context
 {
--- a/algo/sha/sha-hash-4way.h
+++ b/algo/sha/sha-hash-4way.h
@@ -1,168 +0,0 @@
-/* $Id: sph_sha2.h 216 2010-06-08 09:46:57Z tp $ */
-/**
- * SHA-224, SHA-256, SHA-384 and SHA-512 interface.
- *
- * SHA-256 has been published in FIPS 180-2, now amended with a change
- * notice to include SHA-224 as well (which is a simple variation on
- * SHA-256). SHA-384 and SHA-512 are also defined in FIPS 180-2. FIPS
- * standards can be found at:
- *    http://csrc.nist.gov/publications/fips/
- *
- * ==========================(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_sha2.h
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#ifndef SHA2_HASH_4WAY_H__
-#define SHA2_HASH_4WAY_H__ 1
-
-#include <stddef.h>
-#include "simd-utils.h"
-
-#if defined(__SSE2__)
-
-// SHA-256 4 way
-
-typedef struct {
-   __m128i buf[64>>2];
-   __m128i val[8];
-   uint32_t count_high, count_low;
-} sha256_4way_context __attribute__ ((aligned (64)));
-
-void sha256_4way_init( sha256_4way_context *sc );
-void sha256_4way_update( sha256_4way_context *sc, const void *data,
-                         size_t len );
-void sha256_4way_close( sha256_4way_context *sc, void *dst );
-void sha256_4way_full( void *dst, const void *data, size_t len );
-void sha256_4way_transform_le( __m128i *state_out,  const __m128i *data,
-                            const __m128i *state_in );
-void sha256_4way_transform_be( __m128i *state_out,  const __m128i *data,
-                            const __m128i *state_in );
-void sha256_4way_prehash_3rounds( __m128i *state_mid, __m128i *X,
-                                   const __m128i *W, const __m128i *state_in );
-void sha256_4way_final_rounds( __m128i *state_out, const __m128i *data,
-        const __m128i *state_in, const __m128i *state_mid, const __m128i *X );
-int sha256_4way_transform_le_short( __m128i *state_out, const __m128i *data,
-                                     const __m128i *state_in );
-
-#endif  // SSE2
-
-#if defined (__AVX2__)
-
-// SHA-256 8 way
-
-typedef struct {
-   __m256i buf[64>>2];
-   __m256i val[8];
-   uint32_t count_high, count_low;
-} sha256_8way_context __attribute__ ((aligned (128)));
-
-void sha256_8way_init( sha256_8way_context *sc );
-void sha256_8way_update( sha256_8way_context *sc, const void *data, size_t len );
-void sha256_8way_close( sha256_8way_context *sc, void *dst );
-void sha256_8way_full( void *dst, const void *data, size_t len );
-void sha256_8way_transform_le( __m256i *state_out, const __m256i *data,
-                               const __m256i *state_in );
-void sha256_8way_transform_be( __m256i *state_out, const __m256i *data,
-                               const __m256i *state_in );
-
-void sha256_8way_prehash_3rounds( __m256i *state_mid, __m256i *X,
-                                 const __m256i *W, const __m256i *state_in );
-void sha256_8way_final_rounds( __m256i *state_out, const __m256i *data,
-        const __m256i *state_in, const __m256i *state_mid, const __m256i *X );
-int sha256_8way_transform_le_short( __m256i *state_out, const __m256i *data,
-                                     const __m256i *state_in );
-
-#endif  // AVX2
-
-#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
-
-// SHA-256 16 way
-
-typedef struct {
-   __m512i buf[64>>2];
-   __m512i val[8];
-   uint32_t count_high, count_low;
-} sha256_16way_context __attribute__ ((aligned (128)));
-
-void sha256_16way_init( sha256_16way_context *sc );
-void sha256_16way_update( sha256_16way_context *sc, const void *data, size_t len );
-void sha256_16way_close( sha256_16way_context *sc, void *dst );
-void sha256_16way_full( void *dst, const void *data, size_t len );
-void sha256_16way_transform_le( __m512i *state_out, const __m512i *data,
-                             const __m512i *state_in );
-void sha256_16way_transform_be( __m512i *state_out, const __m512i *data,
-                             const __m512i *state_in );
-void sha256_16way_prehash_3rounds( __m512i *state_mid, __m512i *X,
-                                  const __m512i *W, const __m512i *state_in );
-void sha256_16way_final_rounds( __m512i *state_out, const __m512i *data,
-        const __m512i *state_in, const __m512i *state_mid, const __m512i *X );
-
-int sha256_16way_transform_le_short( __m512i *state_out, const __m512i *data,
-                                     const __m512i *state_in );
-
-#endif // AVX512
-
-#if defined (__AVX2__)
-
-// SHA-512 4 way
-
-typedef struct {
-   __m256i buf[128>>3];
-   __m256i val[8];
-   uint64_t count;
-   bool initialized;
-} sha512_4way_context __attribute__ ((aligned (128)));
-
-void sha512_4way_init( sha512_4way_context *sc);
-void sha512_4way_update( sha512_4way_context *sc, const void *data,
-                         size_t len );
-void sha512_4way_close( sha512_4way_context *sc, void *dst );
-void sha512_4way_full( void *dst, const void *data, size_t len );
-
-#endif  // AVX2
-
-#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
-
-// SHA-512 8 way
-
-typedef struct {
-   __m512i buf[128>>3];
-   __m512i val[8];
-   uint64_t count;
-   bool initialized;
-} sha512_8way_context __attribute__ ((aligned (128)));
-
-void sha512_8way_init( sha512_8way_context *sc);
-void sha512_8way_update( sha512_8way_context *sc, const void *data, 
-                         size_t len );
-void sha512_8way_close( sha512_8way_context *sc, void *dst );
-void sha512_8way_full( void *dst, const void *data, size_t len );
-
-#endif  // AVX512
-
-#endif  // SHA256_4WAY_H__
--- a/algo/sha/sha2.c
+++ b/algo/sha/sha2.c
@@ -658,43 +658,14 @@ int scanhash_sha256d_pooler( struct work *work,	uint32_t max_nonce,
 	return 0;
 }

-/*
-int scanhash_SHA256d( struct work *work, const uint32_t max_nonce,
-                      uint64_t *hashes_done, struct thr_info *mythr )
-{
-   uint32_t _ALIGN(128) hash[8];
-   uint32_t _ALIGN(64) data[20];
-   uint32_t *pdata = work->data;
-   const uint32_t *ptarget = work->target;
-   uint32_t n = pdata[19] - 1;
-   const uint32_t first_nonce = pdata[19];
-   const uint32_t Htarg = ptarget[7];
-   int thr_id = mythr->id;
-
-   memcpy( data, pdata, 80 );
-
-   do {
-      data[19] = ++n;
-      sha256d( (unsigned char*)hash, (const unsigned char*)data, 80 );
-      if ( unlikely( swab32( hash[7] ) <= Htarg ) )
-      {
-         pdata[19] = n;
-         sha256d_80_swap(hash, pdata);
-         if ( fulltest( hash, ptarget ) && !opt_benchmark )
-            submit_solution( work, hash, mythr );
-      }
-   } while ( likely( n < max_nonce && !work_restart[thr_id].restart ) );
-   *hashes_done = n - first_nonce + 1;
-   pdata[19] = n;
-   return 0;
-}
-*/
-
 bool register_sha256d_algo( algo_gate_t* gate )
 {
   gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
 #if defined(SHA256D_16WAY)
   gate->scanhash = (void*)&scanhash_sha256d_16way;
+#elif defined(SHA256D_SHA)
+   gate->optimizations = SHA_OPT;
+   gate->scanhash = (void*)&scanhash_sha256d_sha;
 //#elif defined(SHA256D_8WAY)
 //   gate->scanhash = (void*)&scanhash_sha256d_8way;
 #else
--- a/algo/sha/sha256-hash-2way-ni.c
+++ b/algo/sha/sha256-hash-2way-ni.c
@@ -1,689 +0,0 @@
-/*   Intel SHA extensions using C intrinsics               */
-/*   Written and place in public domain by Jeffrey Walton  */
-/*   Based on code from Intel, and by Sean Gulley for      */
-/*   the miTLS project.                                    */
-
-// A stripped down version with byte swapping removed. 
-
-#if defined(__SHA__)
-
-#include "sha256-hash.h"
-
-void sha256_ni2way_transform_le( uint32_t *out_X, uint32_t*out_Y,
-                              const void *msg_X, const void *msg_Y,
-                              const uint32_t *in_X, const uint32_t *in_Y )
-{
-    __m128i STATE0_X, STATE1_X, STATE0_Y, STATE1_Y;
-    __m128i MSG_X, MSG_Y, TMP_X, TMP_Y;
-    __m128i TMSG0_X, TMSG1_X, TMSG2_X, TMSG3_X;
-    __m128i TMSG0_Y, TMSG1_Y, TMSG2_Y, TMSG3_Y;
-    __m128i ABEF_SAVE_X, CDGH_SAVE_X,ABEF_SAVE_Y, CDGH_SAVE_Y;
-
-    // Load initial values
-    TMP_X = _mm_load_si128((__m128i*) &in_X[0]);
-    STATE1_X = _mm_load_si128((__m128i*) &in_X[4]);
-    TMP_Y = _mm_load_si128((__m128i*) &in_Y[0]);
-    STATE1_Y = _mm_load_si128((__m128i*) &in_Y[4]);
-
-    TMP_X = _mm_shuffle_epi32(TMP_X, 0xB1); // CDAB
-    TMP_Y = _mm_shuffle_epi32(TMP_Y, 0xB1); // CDAB
-    STATE1_X = _mm_shuffle_epi32(STATE1_X, 0x1B); // EFGH
-    STATE1_Y = _mm_shuffle_epi32(STATE1_Y, 0x1B); // EFGH
-    STATE0_X = _mm_alignr_epi8(TMP_X, STATE1_X, 8); // ABEF
-    STATE0_Y = _mm_alignr_epi8(TMP_Y, STATE1_Y, 8); // ABEF
-    STATE1_X = _mm_blend_epi16(STATE1_X, TMP_X, 0xF0); // CDGH
-    STATE1_Y = _mm_blend_epi16(STATE1_Y, TMP_Y, 0xF0); // CDGH
-
-    // Save current hash
-    ABEF_SAVE_X = STATE0_X;
-    ABEF_SAVE_Y = STATE0_Y;
-    CDGH_SAVE_X = STATE1_X;
-    CDGH_SAVE_Y = STATE1_Y;
-
-    // Rounds 0-3
-    TMSG0_X = _mm_load_si128((const __m128i*) (msg_X));
-    TMSG0_Y = _mm_load_si128((const __m128i*) (msg_Y));
-    TMP_X = _mm_set_epi64x(0xE9B5DBA5B5C0FBCFULL, 0x71374491428A2F98ULL);
-    MSG_X = _mm_add_epi32( TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32( TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Rounds 4-7
-    TMSG1_X = _mm_load_si128((const __m128i*) (msg_X+16));
-    TMSG1_Y = _mm_load_si128((const __m128i*) (msg_Y+16));
-    TMP_X = _mm_set_epi64x(0xAB1C5ED5923F82A4ULL, 0x59F111F13956C25BULL);
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG0_X = _mm_sha256msg1_epu32(TMSG0_X, TMSG1_X);
-    TMSG0_Y = _mm_sha256msg1_epu32(TMSG0_Y, TMSG1_Y);
-
-    // Rounds 8-11
-    TMSG2_X = _mm_load_si128((const __m128i*) (msg_X+32));
-    TMSG2_Y = _mm_load_si128((const __m128i*) (msg_Y+32));
-    TMP_X = _mm_set_epi64x(0x550C7DC3243185BEULL, 0x12835B01D807AA98ULL);
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG1_X = _mm_sha256msg1_epu32(TMSG1_X, TMSG2_X);
-    TMSG1_Y = _mm_sha256msg1_epu32(TMSG1_Y, TMSG2_Y);
-
-    // Rounds 12-15
-    TMSG3_X = _mm_load_si128((const __m128i*) (msg_X+48));
-    TMSG3_Y = _mm_load_si128((const __m128i*) (msg_Y+48));
-    TMP_X = _mm_set_epi64x(0xC19BF1749BDC06A7ULL, 0x80DEB1FE72BE5D74ULL);
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG3_X, TMSG2_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG3_Y, TMSG2_Y, 4);
-    TMSG0_X = _mm_add_epi32(TMSG0_X, TMP_X);
-    TMSG0_Y = _mm_add_epi32(TMSG0_Y, TMP_Y);
-    TMSG0_X = _mm_sha256msg2_epu32(TMSG0_X, TMSG3_X);
-    TMSG0_Y = _mm_sha256msg2_epu32(TMSG0_Y, TMSG3_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG2_X = _mm_sha256msg1_epu32(TMSG2_X, TMSG3_X);
-    TMSG2_Y = _mm_sha256msg1_epu32(TMSG2_Y, TMSG3_Y);
-
-    // Rounds 16-19
-    TMP_X = _mm_set_epi64x(0x240CA1CC0FC19DC6ULL, 0xEFBE4786E49B69C1ULL);
-    MSG_X = _mm_add_epi32(TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG0_X, TMSG3_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG0_Y, TMSG3_Y, 4);
-    TMSG1_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    TMSG1_Y = _mm_add_epi32(TMSG1_Y, TMP_Y);
-    TMSG1_X = _mm_sha256msg2_epu32(TMSG1_X, TMSG0_X);
-    TMSG1_Y = _mm_sha256msg2_epu32(TMSG1_Y, TMSG0_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG3_X = _mm_sha256msg1_epu32(TMSG3_X, TMSG0_X);
-    TMSG3_Y = _mm_sha256msg1_epu32(TMSG3_Y, TMSG0_Y);
-
-    // Rounds 20-23
-    TMP_X = _mm_set_epi64x(0x76F988DA5CB0A9DCULL, 0x4A7484AA2DE92C6FULL);
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG1_X, TMSG0_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG1_Y, TMSG0_Y, 4);
-    TMSG2_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    TMSG2_Y = _mm_add_epi32(TMSG2_Y, TMP_Y);
-    TMSG2_X = _mm_sha256msg2_epu32(TMSG2_X, TMSG1_X);
-    TMSG2_Y = _mm_sha256msg2_epu32(TMSG2_Y, TMSG1_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG0_X = _mm_sha256msg1_epu32(TMSG0_X, TMSG1_X);
-    TMSG0_Y = _mm_sha256msg1_epu32(TMSG0_Y, TMSG1_Y);
-
-    // Rounds 24-27
-    TMP_X = _mm_set_epi64x(0xBF597FC7B00327C8ULL, 0xA831C66D983E5152ULL);
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG2_X, TMSG1_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG2_Y, TMSG1_Y, 4);
-    TMSG3_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    TMSG3_Y = _mm_add_epi32(TMSG3_Y, TMP_Y);
-    TMSG3_X = _mm_sha256msg2_epu32(TMSG3_X, TMSG2_X);
-    TMSG3_Y = _mm_sha256msg2_epu32(TMSG3_Y, TMSG2_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG1_X = _mm_sha256msg1_epu32(TMSG1_X, TMSG2_X);
-    TMSG1_Y = _mm_sha256msg1_epu32(TMSG1_Y, TMSG2_Y);
-
-    // Rounds 28-31
-    TMP_X = _mm_set_epi64x(0x1429296706CA6351ULL,  0xD5A79147C6E00BF3ULL);
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG3_X, TMSG2_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG3_Y, TMSG2_Y, 4);
-    TMSG0_X = _mm_add_epi32(TMSG0_X, TMP_X);
-    TMSG0_Y = _mm_add_epi32(TMSG0_Y, TMP_Y);
-    TMSG0_X = _mm_sha256msg2_epu32(TMSG0_X, TMSG3_X);
-    TMSG0_Y = _mm_sha256msg2_epu32(TMSG0_Y, TMSG3_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG2_X = _mm_sha256msg1_epu32(TMSG2_X, TMSG3_X);
-    TMSG2_Y = _mm_sha256msg1_epu32(TMSG2_Y, TMSG3_Y);
-
-    // Rounds 32-35
-    TMP_X = _mm_set_epi64x(0x53380D134D2C6DFCULL, 0x2E1B213827B70A85ULL);
-    MSG_X = _mm_add_epi32(TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG0_X, TMSG3_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG0_Y, TMSG3_Y, 4);
-    TMSG1_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    TMSG1_Y = _mm_add_epi32(TMSG1_Y, TMP_Y);
-    TMSG1_X = _mm_sha256msg2_epu32(TMSG1_X, TMSG0_X);
-    TMSG1_Y = _mm_sha256msg2_epu32(TMSG1_Y, TMSG0_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG3_X = _mm_sha256msg1_epu32(TMSG3_X, TMSG0_X);
-    TMSG3_Y = _mm_sha256msg1_epu32(TMSG3_Y, TMSG0_Y);
-
-    // Rounds 36-39
-    TMP_X = _mm_set_epi64x(0x92722C8581C2C92EULL, 0x766A0ABB650A7354ULL);
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG1_X, TMSG0_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG1_Y, TMSG0_Y, 4);
-    TMSG2_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    TMSG2_Y = _mm_add_epi32(TMSG2_Y, TMP_Y);
-    TMSG2_X = _mm_sha256msg2_epu32(TMSG2_X, TMSG1_X);
-    TMSG2_Y = _mm_sha256msg2_epu32(TMSG2_Y, TMSG1_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG0_X = _mm_sha256msg1_epu32(TMSG0_X, TMSG1_X);
-    TMSG0_Y = _mm_sha256msg1_epu32(TMSG0_Y, TMSG1_Y);
-
-    // Rounds 40-43
-    TMP_X = _mm_set_epi64x(0xC76C51A3C24B8B70ULL, 0xA81A664BA2BFE8A1ULL);
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG2_X, TMSG1_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG2_Y, TMSG1_Y, 4);
-    TMSG3_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    TMSG3_Y = _mm_add_epi32(TMSG3_Y, TMP_Y);
-    TMSG3_X = _mm_sha256msg2_epu32(TMSG3_X, TMSG2_X);
-    TMSG3_Y = _mm_sha256msg2_epu32(TMSG3_Y, TMSG2_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG1_X = _mm_sha256msg1_epu32(TMSG1_X, TMSG2_X);
-    TMSG1_Y = _mm_sha256msg1_epu32(TMSG1_Y, TMSG2_Y);
-
-    // Rounds 44-47
-    TMP_X = _mm_set_epi64x(0x106AA070F40E3585ULL, 0xD6990624D192E819ULL);
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG3_X, TMSG2_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG3_Y, TMSG2_Y, 4);
-    TMSG0_X = _mm_add_epi32(TMSG0_X, TMP_X);
-    TMSG0_Y = _mm_add_epi32(TMSG0_Y, TMP_Y);
-    TMSG0_X = _mm_sha256msg2_epu32(TMSG0_X, TMSG3_X);
-    TMSG0_Y = _mm_sha256msg2_epu32(TMSG0_Y, TMSG3_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG2_X = _mm_sha256msg1_epu32(TMSG2_X, TMSG3_X);
-    TMSG2_Y = _mm_sha256msg1_epu32(TMSG2_Y, TMSG3_Y);
-
-    // Rounds 48-51
-    TMP_X = _mm_set_epi64x(0x34B0BCB52748774CULL, 0x1E376C0819A4C116ULL);
-    MSG_X = _mm_add_epi32(TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG0_X, TMSG3_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG0_Y, TMSG3_Y, 4);
-    TMSG1_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    TMSG1_Y = _mm_add_epi32(TMSG1_Y, TMP_Y);
-    TMSG1_X = _mm_sha256msg2_epu32(TMSG1_X, TMSG0_X);
-    TMSG1_Y = _mm_sha256msg2_epu32(TMSG1_Y, TMSG0_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG3_X = _mm_sha256msg1_epu32(TMSG3_X, TMSG0_X);
-    TMSG3_Y = _mm_sha256msg1_epu32(TMSG3_Y, TMSG0_Y);
-
-    // Rounds 52-55
-    TMP_X = _mm_set_epi64x(0x682E6FF35B9CCA4FULL, 0x4ED8AA4A391C0CB3ULL);
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG1_X, TMSG0_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG1_Y, TMSG0_Y, 4);
-    TMSG2_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    TMSG2_Y = _mm_add_epi32(TMSG2_Y, TMP_Y);
-    TMSG2_X = _mm_sha256msg2_epu32(TMSG2_X, TMSG1_X);
-    TMSG2_Y = _mm_sha256msg2_epu32(TMSG2_Y, TMSG1_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Rounds 56-59
-    TMP_X = _mm_set_epi64x(0x8CC7020884C87814ULL, 0x78A5636F748F82EEULL);
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG2_X, TMSG1_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG2_Y, TMSG1_Y, 4);
-    TMSG3_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    TMSG3_Y = _mm_add_epi32(TMSG3_Y, TMP_Y);
-    TMSG3_X = _mm_sha256msg2_epu32(TMSG3_X, TMSG2_X);
-    TMSG3_Y = _mm_sha256msg2_epu32(TMSG3_Y, TMSG2_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Rounds 60-63
-    TMP_X = _mm_set_epi64x(0xC67178F2BEF9A3F7ULL, 0xA4506CEB90BEFFFAULL);
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Add values back to state
-    STATE0_X = _mm_add_epi32(STATE0_X, ABEF_SAVE_X);
-    STATE1_X = _mm_add_epi32(STATE1_X, CDGH_SAVE_X);
-    STATE0_Y = _mm_add_epi32(STATE0_Y, ABEF_SAVE_Y);
-    STATE1_Y = _mm_add_epi32(STATE1_Y, CDGH_SAVE_Y);
-
-    TMP_X = _mm_shuffle_epi32(STATE0_X, 0x1B); // FEBA
-    TMP_Y = _mm_shuffle_epi32(STATE0_Y, 0x1B); // FEBA
-    STATE1_X = _mm_shuffle_epi32(STATE1_X, 0xB1); // DCHG
-    STATE1_Y = _mm_shuffle_epi32(STATE1_Y, 0xB1); // DCHG
-    STATE0_X = _mm_blend_epi16(TMP_X, STATE1_X, 0xF0); // DCBA
-    STATE0_Y = _mm_blend_epi16(TMP_Y, STATE1_Y, 0xF0); // DCBA
-    STATE1_X = _mm_alignr_epi8(STATE1_X, TMP_X, 8); // ABEF
-    STATE1_Y = _mm_alignr_epi8(STATE1_Y, TMP_Y, 8); // ABEF
-
-    // Save state
-    _mm_store_si128((__m128i*) &out_X[0], STATE0_X);
-    _mm_store_si128((__m128i*) &out_X[4], STATE1_X);
-    _mm_store_si128((__m128i*) &out_Y[0], STATE0_Y);
-    _mm_store_si128((__m128i*) &out_Y[4], STATE1_Y);
-}
-
-void sha256_ni2way_transform_be( uint32_t *out_X, uint32_t*out_Y,
-                              const void *msg_X, const void *msg_Y,
-                              const uint32_t *in_X, const uint32_t *in_Y )
-{
-    __m128i STATE0_X, STATE1_X, STATE0_Y, STATE1_Y;
-    __m128i MSG_X, MSG_Y, TMP_X, TMP_Y, MASK;
-    __m128i TMSG0_X, TMSG1_X, TMSG2_X, TMSG3_X;
-    __m128i TMSG0_Y, TMSG1_Y, TMSG2_Y, TMSG3_Y;
-    __m128i ABEF_SAVE_X, CDGH_SAVE_X, ABEF_SAVE_Y, CDGH_SAVE_Y;
-
-    // Load initial values
-    TMP_X = _mm_load_si128((__m128i*) &in_X[0]);
-    STATE1_X = _mm_load_si128((__m128i*) &in_X[4]);
-    TMP_Y = _mm_load_si128((__m128i*) &in_Y[0]);
-    STATE1_Y = _mm_load_si128((__m128i*) &in_Y[4]);
-    MASK = _mm_set_epi64x(0x0c0d0e0f08090a0bULL, 0x0405060700010203ULL);
-
-    TMP_X = _mm_shuffle_epi32(TMP_X, 0xB1); // CDAB
-    TMP_Y = _mm_shuffle_epi32(TMP_Y, 0xB1); // CDAB
-    STATE1_X = _mm_shuffle_epi32(STATE1_X, 0x1B); // EFGH
-    STATE1_Y = _mm_shuffle_epi32(STATE1_Y, 0x1B); // EFGH
-    STATE0_X = _mm_alignr_epi8(TMP_X, STATE1_X, 8); // ABEF
-    STATE0_Y = _mm_alignr_epi8(TMP_Y, STATE1_Y, 8); // ABEF
-    STATE1_X = _mm_blend_epi16(STATE1_X, TMP_X, 0xF0); // CDGH
-    STATE1_Y = _mm_blend_epi16(STATE1_Y, TMP_Y, 0xF0); // CDGH
-
-    // Save current hash
-    ABEF_SAVE_X = STATE0_X;
-    ABEF_SAVE_Y = STATE0_Y;
-    CDGH_SAVE_X = STATE1_X;
-    CDGH_SAVE_Y = STATE1_Y;
-
-    // Rounds 0-3
-    TMSG0_X = _mm_load_si128((const __m128i*) (msg_X));
-    TMSG0_Y = _mm_load_si128((const __m128i*) (msg_Y));
-    TMP_X = _mm_set_epi64x(0xE9B5DBA5B5C0FBCFULL, 0x71374491428A2F98ULL);
-    TMSG0_X = _mm_shuffle_epi8( TMSG0_X, MASK );
-    TMSG0_Y = _mm_shuffle_epi8( TMSG0_Y, MASK );
-    MSG_X = _mm_add_epi32( TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32( TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Rounds 4-7
-    TMSG1_X = _mm_load_si128((const __m128i*) (msg_X+16));
-    TMSG1_Y = _mm_load_si128((const __m128i*) (msg_Y+16));
-    TMP_X = _mm_set_epi64x(0xAB1C5ED5923F82A4ULL, 0x59F111F13956C25BULL);
-    TMSG1_X = _mm_shuffle_epi8( TMSG1_X, MASK );
-    TMSG1_Y = _mm_shuffle_epi8( TMSG1_Y, MASK );
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG0_X = _mm_sha256msg1_epu32(TMSG0_X, TMSG1_X);
-    TMSG0_Y = _mm_sha256msg1_epu32(TMSG0_Y, TMSG1_Y);
-
-    // Rounds 8-11
-    TMSG2_X = _mm_load_si128((const __m128i*) (msg_X+32));
-    TMSG2_Y = _mm_load_si128((const __m128i*) (msg_Y+32));
-    TMP_X = _mm_set_epi64x(0x550C7DC3243185BEULL, 0x12835B01D807AA98ULL);
-    TMSG2_X = _mm_shuffle_epi8( TMSG2_X, MASK );
-    TMSG2_Y = _mm_shuffle_epi8( TMSG2_Y, MASK );
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG1_X = _mm_sha256msg1_epu32(TMSG1_X, TMSG2_X);
-    TMSG1_Y = _mm_sha256msg1_epu32(TMSG1_Y, TMSG2_Y);
-
-    // Rounds 12-15
-    TMSG3_X = _mm_load_si128((const __m128i*) (msg_X+48));
-    TMSG3_Y = _mm_load_si128((const __m128i*) (msg_Y+48));
-    TMP_X = _mm_set_epi64x(0xC19BF1749BDC06A7ULL, 0x80DEB1FE72BE5D74ULL);
-    TMSG3_X = _mm_shuffle_epi8( TMSG3_X, MASK );
-    TMSG3_Y = _mm_shuffle_epi8( TMSG3_Y, MASK );
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG3_X, TMSG2_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG3_Y, TMSG2_Y, 4);
-    TMSG0_X = _mm_add_epi32(TMSG0_X, TMP_X);
-    TMSG0_Y = _mm_add_epi32(TMSG0_Y, TMP_Y);
-    TMSG0_X = _mm_sha256msg2_epu32(TMSG0_X, TMSG3_X);
-    TMSG0_Y = _mm_sha256msg2_epu32(TMSG0_Y, TMSG3_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG2_X = _mm_sha256msg1_epu32(TMSG2_X, TMSG3_X);
-    TMSG2_Y = _mm_sha256msg1_epu32(TMSG2_Y, TMSG3_Y);
-
-    // Rounds 16-19
-    TMP_X = _mm_set_epi64x(0x240CA1CC0FC19DC6ULL, 0xEFBE4786E49B69C1ULL);
-    MSG_X = _mm_add_epi32(TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG0_X, TMSG3_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG0_Y, TMSG3_Y, 4);
-    TMSG1_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    TMSG1_Y = _mm_add_epi32(TMSG1_Y, TMP_Y);
-    TMSG1_X = _mm_sha256msg2_epu32(TMSG1_X, TMSG0_X);
-    TMSG1_Y = _mm_sha256msg2_epu32(TMSG1_Y, TMSG0_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG3_X = _mm_sha256msg1_epu32(TMSG3_X, TMSG0_X);
-    TMSG3_Y = _mm_sha256msg1_epu32(TMSG3_Y, TMSG0_Y);
-
-    // Rounds 20-23
-    TMP_X = _mm_set_epi64x(0x76F988DA5CB0A9DCULL, 0x4A7484AA2DE92C6FULL);
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG1_X, TMSG0_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG1_Y, TMSG0_Y, 4);
-    TMSG2_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    TMSG2_Y = _mm_add_epi32(TMSG2_Y, TMP_Y);
-    TMSG2_X = _mm_sha256msg2_epu32(TMSG2_X, TMSG1_X);
-    TMSG2_Y = _mm_sha256msg2_epu32(TMSG2_Y, TMSG1_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG0_X = _mm_sha256msg1_epu32(TMSG0_X, TMSG1_X);
-    TMSG0_Y = _mm_sha256msg1_epu32(TMSG0_Y, TMSG1_Y);
-
-    // Rounds 24-27
-    TMP_X = _mm_set_epi64x(0xBF597FC7B00327C8ULL, 0xA831C66D983E5152ULL);
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG2_X, TMSG1_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG2_Y, TMSG1_Y, 4);
-    TMSG3_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    TMSG3_Y = _mm_add_epi32(TMSG3_Y, TMP_Y);
-    TMSG3_X = _mm_sha256msg2_epu32(TMSG3_X, TMSG2_X);
-    TMSG3_Y = _mm_sha256msg2_epu32(TMSG3_Y, TMSG2_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG1_X = _mm_sha256msg1_epu32(TMSG1_X, TMSG2_X);
-    TMSG1_Y = _mm_sha256msg1_epu32(TMSG1_Y, TMSG2_Y);
-
-    // Rounds 28-31
-    TMP_X = _mm_set_epi64x(0x1429296706CA6351ULL,  0xD5A79147C6E00BF3ULL);
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG3_X, TMSG2_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG3_Y, TMSG2_Y, 4);
-    TMSG0_X = _mm_add_epi32(TMSG0_X, TMP_X);
-    TMSG0_Y = _mm_add_epi32(TMSG0_Y, TMP_Y);
-    TMSG0_X = _mm_sha256msg2_epu32(TMSG0_X, TMSG3_X);
-    TMSG0_Y = _mm_sha256msg2_epu32(TMSG0_Y, TMSG3_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG2_X = _mm_sha256msg1_epu32(TMSG2_X, TMSG3_X);
-    TMSG2_Y = _mm_sha256msg1_epu32(TMSG2_Y, TMSG3_Y);
-
-    // Rounds 32-35
-    TMP_X = _mm_set_epi64x(0x53380D134D2C6DFCULL, 0x2E1B213827B70A85ULL);
-    MSG_X = _mm_add_epi32(TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG0_X, TMSG3_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG0_Y, TMSG3_Y, 4);
-    TMSG1_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    TMSG1_Y = _mm_add_epi32(TMSG1_Y, TMP_Y);
-    TMSG1_X = _mm_sha256msg2_epu32(TMSG1_X, TMSG0_X);
-    TMSG1_Y = _mm_sha256msg2_epu32(TMSG1_Y, TMSG0_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG3_X = _mm_sha256msg1_epu32(TMSG3_X, TMSG0_X);
-    TMSG3_Y = _mm_sha256msg1_epu32(TMSG3_Y, TMSG0_Y);
-
-    // Rounds 36-39
-    TMP_X = _mm_set_epi64x(0x92722C8581C2C92EULL, 0x766A0ABB650A7354ULL);
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG1_X, TMSG0_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG1_Y, TMSG0_Y, 4);
-    TMSG2_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    TMSG2_Y = _mm_add_epi32(TMSG2_Y, TMP_Y);
-    TMSG2_X = _mm_sha256msg2_epu32(TMSG2_X, TMSG1_X);
-    TMSG2_Y = _mm_sha256msg2_epu32(TMSG2_Y, TMSG1_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG0_X = _mm_sha256msg1_epu32(TMSG0_X, TMSG1_X);
-    TMSG0_Y = _mm_sha256msg1_epu32(TMSG0_Y, TMSG1_Y);
-
-    // Rounds 40-43
-    TMP_X = _mm_set_epi64x(0xC76C51A3C24B8B70ULL, 0xA81A664BA2BFE8A1ULL);
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG2_X, TMSG1_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG2_Y, TMSG1_Y, 4);
-    TMSG3_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    TMSG3_Y = _mm_add_epi32(TMSG3_Y, TMP_Y);
-    TMSG3_X = _mm_sha256msg2_epu32(TMSG3_X, TMSG2_X);
-    TMSG3_Y = _mm_sha256msg2_epu32(TMSG3_Y, TMSG2_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG1_X = _mm_sha256msg1_epu32(TMSG1_X, TMSG2_X);
-    TMSG1_Y = _mm_sha256msg1_epu32(TMSG1_Y, TMSG2_Y);
-
-    // Rounds 44-47
-    TMP_X = _mm_set_epi64x(0x106AA070F40E3585ULL, 0xD6990624D192E819ULL);
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG3_X, TMSG2_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG3_Y, TMSG2_Y, 4);
-    TMSG0_X = _mm_add_epi32(TMSG0_X, TMP_X);
-    TMSG0_Y = _mm_add_epi32(TMSG0_Y, TMP_Y);
-    TMSG0_X = _mm_sha256msg2_epu32(TMSG0_X, TMSG3_X);
-    TMSG0_Y = _mm_sha256msg2_epu32(TMSG0_Y, TMSG3_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG2_X = _mm_sha256msg1_epu32(TMSG2_X, TMSG3_X);
-    TMSG2_Y = _mm_sha256msg1_epu32(TMSG2_Y, TMSG3_Y);
-
-    // Rounds 48-51
-    TMP_X = _mm_set_epi64x(0x34B0BCB52748774CULL, 0x1E376C0819A4C116ULL);
-    MSG_X = _mm_add_epi32(TMSG0_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG0_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG0_X, TMSG3_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG0_Y, TMSG3_Y, 4);
-    TMSG1_X = _mm_add_epi32(TMSG1_X, TMP_X);
-    TMSG1_Y = _mm_add_epi32(TMSG1_Y, TMP_Y);
-    TMSG1_X = _mm_sha256msg2_epu32(TMSG1_X, TMSG0_X);
-    TMSG1_Y = _mm_sha256msg2_epu32(TMSG1_Y, TMSG0_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-    TMSG3_X = _mm_sha256msg1_epu32(TMSG3_X, TMSG0_X);
-    TMSG3_Y = _mm_sha256msg1_epu32(TMSG3_Y, TMSG0_Y);
-
-    // Rounds 52-55
-    TMP_X = _mm_set_epi64x(0x682E6FF35B9CCA4FULL, 0x4ED8AA4A391C0CB3ULL);
-    MSG_X = _mm_add_epi32(TMSG1_X, TMP_X );
-    MSG_Y = _mm_add_epi32(TMSG1_Y, TMP_X );
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG1_X, TMSG0_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG1_Y, TMSG0_Y, 4);
-    TMSG2_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    TMSG2_Y = _mm_add_epi32(TMSG2_Y, TMP_Y);
-    TMSG2_X = _mm_sha256msg2_epu32(TMSG2_X, TMSG1_X);
-    TMSG2_Y = _mm_sha256msg2_epu32(TMSG2_Y, TMSG1_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Rounds 56-59
-    TMP_X = _mm_set_epi64x(0x8CC7020884C87814ULL, 0x78A5636F748F82EEULL);
-    MSG_X = _mm_add_epi32(TMSG2_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG2_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    TMP_X = _mm_alignr_epi8(TMSG2_X, TMSG1_X, 4);
-    TMP_Y = _mm_alignr_epi8(TMSG2_Y, TMSG1_Y, 4);
-    TMSG3_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    TMSG3_Y = _mm_add_epi32(TMSG3_Y, TMP_Y);
-    TMSG3_X = _mm_sha256msg2_epu32(TMSG3_X, TMSG2_X);
-    TMSG3_Y = _mm_sha256msg2_epu32(TMSG3_Y, TMSG2_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Rounds 60-63
-    TMP_X = _mm_set_epi64x(0xC67178F2BEF9A3F7ULL, 0xA4506CEB90BEFFFAULL);
-    MSG_X = _mm_add_epi32(TMSG3_X, TMP_X);
-    MSG_Y = _mm_add_epi32(TMSG3_Y, TMP_X);
-    STATE1_X = _mm_sha256rnds2_epu32(STATE1_X, STATE0_X, MSG_X);
-    STATE1_Y = _mm_sha256rnds2_epu32(STATE1_Y, STATE0_Y, MSG_Y);
-    MSG_X = _mm_shuffle_epi32(MSG_X, 0x0E);
-    MSG_Y = _mm_shuffle_epi32(MSG_Y, 0x0E);
-    STATE0_X = _mm_sha256rnds2_epu32(STATE0_X, STATE1_X, MSG_X);
-    STATE0_Y = _mm_sha256rnds2_epu32(STATE0_Y, STATE1_Y, MSG_Y);
-
-    // Add values back to state
-    STATE0_X = _mm_add_epi32(STATE0_X, ABEF_SAVE_X);
-    STATE1_X = _mm_add_epi32(STATE1_X, CDGH_SAVE_X);
-    STATE0_Y = _mm_add_epi32(STATE0_Y, ABEF_SAVE_Y);
-    STATE1_Y = _mm_add_epi32(STATE1_Y, CDGH_SAVE_Y);
-
-    TMP_X = _mm_shuffle_epi32(STATE0_X, 0x1B); // FEBA
-    TMP_Y = _mm_shuffle_epi32(STATE0_Y, 0x1B); // FEBA
-    STATE1_X = _mm_shuffle_epi32(STATE1_X, 0xB1); // DCHG
-    STATE1_Y = _mm_shuffle_epi32(STATE1_Y, 0xB1); // DCHG
-    STATE0_X = _mm_blend_epi16(TMP_X, STATE1_X, 0xF0); // DCBA
-    STATE0_Y = _mm_blend_epi16(TMP_Y, STATE1_Y, 0xF0); // DCBA
-    STATE1_X = _mm_alignr_epi8(STATE1_X, TMP_X, 8); // ABEF
-    STATE1_Y = _mm_alignr_epi8(STATE1_Y, TMP_Y, 8); // ABEF
-
-    // Save state
-    _mm_store_si128((__m128i*) &out_X[0], STATE0_X);
-    _mm_store_si128((__m128i*) &out_X[4], STATE1_X);
-    _mm_store_si128((__m128i*) &out_Y[0], STATE0_Y);
-    _mm_store_si128((__m128i*) &out_Y[4], STATE1_Y);
-}
-
-
-#endif
-
--- a/algo/sha/sha256-hash-4way.c
+++ b/algo/sha/sha256-hash-4way.c
--- a/algo/sha/sha256-hash-opt.c
+++ b/algo/sha/sha256-hash-opt.c
@@ -1,388 +0,0 @@
-/*   Intel SHA extensions using C intrinsics               */
-/*   Written and place in public domain by Jeffrey Walton  */
-/*   Based on code from Intel, and by Sean Gulley for      */
-/*   the miTLS project.                                    */
-
-// A stripped down version with byte swapping removed. 
-
-#if defined(__SHA__)
-
-#include "sha256-hash.h"
-
-void sha256_opt_transform_le( uint32_t *state_out, const void *input,
-                           const uint32_t *state_in )
-{
-    __m128i STATE0, STATE1;
-    __m128i MSG, TMP;
-    __m128i TMSG0, TMSG1, TMSG2, TMSG3;
-    __m128i ABEF_SAVE, CDGH_SAVE;
-
-    // Load initial values
-    TMP = _mm_load_si128((__m128i*) &state_in[0]);
-    STATE1 = _mm_load_si128((__m128i*) &state_in[4]);
-//    MASK = _mm_set_epi64x(0x0c0d0e0f08090a0bULL, 0x0405060700010203ULL);
-
-    TMP = _mm_shuffle_epi32(TMP, 0xB1); // CDAB
-    STATE1 = _mm_shuffle_epi32(STATE1, 0x1B); // EFGH
-    STATE0 = _mm_alignr_epi8(TMP, STATE1, 8); // ABEF
-    STATE1 = _mm_blend_epi16(STATE1, TMP, 0xF0); // CDGH
-
-    // Save current hash
-    ABEF_SAVE = STATE0;
-    CDGH_SAVE = STATE1;
-
-    // Rounds 0-3
-    TMSG0 = _mm_load_si128((const __m128i*) (input+0));
-//    TMSG0 = _mm_shuffle_epi8(MSG, MASK);
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0xE9B5DBA5B5C0FBCFULL, 0x71374491428A2F98ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Rounds 4-7
-    TMSG1 = _mm_load_si128((const __m128i*) (input+16));
-//    TMSG1 = _mm_shuffle_epi8(TMSG1, MASK);
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0xAB1C5ED5923F82A4ULL, 0x59F111F13956C25BULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
-
-    // Rounds 8-11
-    TMSG2 = _mm_load_si128((const __m128i*) (input+32));
-//    TMSG2 = _mm_shuffle_epi8(TMSG2, MASK);
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0x550C7DC3243185BEULL, 0x12835B01D807AA98ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
-
-    // Rounds 12-15
-    TMSG3 = _mm_load_si128((const __m128i*) (input+48));
-//    TMSG3 = _mm_shuffle_epi8(TMSG3, MASK);
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0xC19BF1749BDC06A7ULL, 0x80DEB1FE72BE5D74ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
-    TMSG0 = _mm_add_epi32(TMSG0, TMP);
-    TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
-
-    // Rounds 16-19
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0x240CA1CC0FC19DC6ULL, 0xEFBE4786E49B69C1ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
-    TMSG1 = _mm_add_epi32(TMSG1, TMP);
-    TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
-
-    // Rounds 20-23
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0x76F988DA5CB0A9DCULL, 0x4A7484AA2DE92C6FULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
-    TMSG2 = _mm_add_epi32(TMSG2, TMP);
-    TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
-
-    // Rounds 24-27
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0xBF597FC7B00327C8ULL, 0xA831C66D983E5152ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
-    TMSG3 = _mm_add_epi32(TMSG3, TMP);
-    TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
-
-    // Rounds 28-31
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0x1429296706CA6351ULL,  0xD5A79147C6E00BF3ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
-    TMSG0 = _mm_add_epi32(TMSG0, TMP);
-    TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
-
-    // Rounds 32-35
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0x53380D134D2C6DFCULL, 0x2E1B213827B70A85ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
-    TMSG1 = _mm_add_epi32(TMSG1, TMP);
-    TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
-
-    // Rounds 36-39
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0x92722C8581C2C92EULL, 0x766A0ABB650A7354ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
-    TMSG2 = _mm_add_epi32(TMSG2, TMP);
-    TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
-
-    // Rounds 40-43
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0xC76C51A3C24B8B70ULL, 0xA81A664BA2BFE8A1ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
-    TMSG3 = _mm_add_epi32(TMSG3, TMP);
-    TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
-
-    // Rounds 44-47
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0x106AA070F40E3585ULL, 0xD6990624D192E819ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
-    TMSG0 = _mm_add_epi32(TMSG0, TMP);
-    TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
-
-    // Rounds 48-51
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0x34B0BCB52748774CULL, 0x1E376C0819A4C116ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
-    TMSG1 = _mm_add_epi32(TMSG1, TMP);
-    TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
-
-    // Rounds 52-55
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0x682E6FF35B9CCA4FULL, 0x4ED8AA4A391C0CB3ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
-    TMSG2 = _mm_add_epi32(TMSG2, TMP);
-    TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Rounds 56-59
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0x8CC7020884C87814ULL, 0x78A5636F748F82EEULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
-    TMSG3 = _mm_add_epi32(TMSG3, TMP);
-    TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Rounds 60-63
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0xC67178F2BEF9A3F7ULL, 0xA4506CEB90BEFFFAULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Add values back to state
-    STATE0 = _mm_add_epi32(STATE0, ABEF_SAVE);
-    STATE1 = _mm_add_epi32(STATE1, CDGH_SAVE);
-
-    TMP = _mm_shuffle_epi32(STATE0, 0x1B); // FEBA
-    STATE1 = _mm_shuffle_epi32(STATE1, 0xB1); // DCHG
-    STATE0 = _mm_blend_epi16(TMP, STATE1, 0xF0); // DCBA
-    STATE1 = _mm_alignr_epi8(STATE1, TMP, 8); // ABEF
-
-    // Save state
-    _mm_store_si128((__m128i*) &state_out[0], STATE0);
-    _mm_store_si128((__m128i*) &state_out[4], STATE1);
-}
-
-
-void sha256_opt_transform_be( uint32_t *state_out, const void *input,
-                           const uint32_t *state_in )
-{
-    __m128i STATE0, STATE1;
-    __m128i MSG, TMP, MASK;
-    __m128i TMSG0, TMSG1, TMSG2, TMSG3;
-    __m128i ABEF_SAVE, CDGH_SAVE;
-
-    // Load initial values
-    TMP = _mm_load_si128((__m128i*) &state_in[0]);
-    STATE1 = _mm_load_si128((__m128i*) &state_in[4]);
-    MASK = _mm_set_epi64x(0x0c0d0e0f08090a0bULL, 0x0405060700010203ULL);
-
-    TMP = _mm_shuffle_epi32(TMP, 0xB1); // CDAB
-    STATE1 = _mm_shuffle_epi32(STATE1, 0x1B); // EFGH
-    STATE0 = _mm_alignr_epi8(TMP, STATE1, 8); // ABEF
-    STATE1 = _mm_blend_epi16(STATE1, TMP, 0xF0); // CDGH
-
-    // Save current hash
-    ABEF_SAVE = STATE0;
-    CDGH_SAVE = STATE1;
-
-    // Rounds 0-3
-    TMSG0 = _mm_load_si128((const __m128i*) (input+0));
-    TMSG0 = _mm_shuffle_epi8( TMSG0, MASK );
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0xE9B5DBA5B5C0FBCFULL, 0x71374491428A2F98ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Rounds 4-7
-    TMSG1 = _mm_load_si128((const __m128i*) (input+16));
-    TMSG1 = _mm_shuffle_epi8(TMSG1, MASK);
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0xAB1C5ED5923F82A4ULL, 0x59F111F13956C25BULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
-    // Rounds 8-11
-    TMSG2 = _mm_load_si128((const __m128i*) (input+32));
-    TMSG2 = _mm_shuffle_epi8(TMSG2, MASK);
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0x550C7DC3243185BEULL, 0x12835B01D807AA98ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
-
-    // Rounds 12-15
-    TMSG3 = _mm_load_si128((const __m128i*) (input+48));
-    TMSG3 = _mm_shuffle_epi8(TMSG3, MASK);
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0xC19BF1749BDC06A7ULL, 0x80DEB1FE72BE5D74ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
-    TMSG0 = _mm_add_epi32(TMSG0, TMP);
-    TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
-
-    // Rounds 16-19
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0x240CA1CC0FC19DC6ULL, 0xEFBE4786E49B69C1ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
-    TMSG1 = _mm_add_epi32(TMSG1, TMP);
-    TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
-
-    // Rounds 20-23
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0x76F988DA5CB0A9DCULL, 0x4A7484AA2DE92C6FULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
-    TMSG2 = _mm_add_epi32(TMSG2, TMP);
-    TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
-
-    // Rounds 24-27
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0xBF597FC7B00327C8ULL, 0xA831C66D983E5152ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
-    TMSG3 = _mm_add_epi32(TMSG3, TMP);
-    TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
-
-    // Rounds 28-31
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0x1429296706CA6351ULL,  0xD5A79147C6E00BF3ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
-    TMSG0 = _mm_add_epi32(TMSG0, TMP);
-    TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
-
-    // Rounds 32-35
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0x53380D134D2C6DFCULL, 0x2E1B213827B70A85ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
-    TMSG1 = _mm_add_epi32(TMSG1, TMP);
-    TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
-
-    // Rounds 36-39
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0x92722C8581C2C92EULL, 0x766A0ABB650A7354ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
-    TMSG2 = _mm_add_epi32(TMSG2, TMP);
-    TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG0 = _mm_sha256msg1_epu32(TMSG0, TMSG1);
-
-    // Rounds 40-43
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0xC76C51A3C24B8B70ULL, 0xA81A664BA2BFE8A1ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
-    TMSG3 = _mm_add_epi32(TMSG3, TMP);
-    TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG1 = _mm_sha256msg1_epu32(TMSG1, TMSG2);
-
-    // Rounds 44-47
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0x106AA070F40E3585ULL, 0xD6990624D192E819ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG3, TMSG2, 4);
-    TMSG0 = _mm_add_epi32(TMSG0, TMP);
-    TMSG0 = _mm_sha256msg2_epu32(TMSG0, TMSG3);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG2 = _mm_sha256msg1_epu32(TMSG2, TMSG3);
-
-    // Rounds 48-51
-    MSG = _mm_add_epi32(TMSG0, _mm_set_epi64x(0x34B0BCB52748774CULL, 0x1E376C0819A4C116ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG0, TMSG3, 4);
-    TMSG1 = _mm_add_epi32(TMSG1, TMP);
-    TMSG1 = _mm_sha256msg2_epu32(TMSG1, TMSG0);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-    TMSG3 = _mm_sha256msg1_epu32(TMSG3, TMSG0);
-
-    // Rounds 52-55
-    MSG = _mm_add_epi32(TMSG1, _mm_set_epi64x(0x682E6FF35B9CCA4FULL, 0x4ED8AA4A391C0CB3ULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG1, TMSG0, 4);
-    TMSG2 = _mm_add_epi32(TMSG2, TMP);
-    TMSG2 = _mm_sha256msg2_epu32(TMSG2, TMSG1);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Rounds 56-59
-    MSG = _mm_add_epi32(TMSG2, _mm_set_epi64x(0x8CC7020884C87814ULL, 0x78A5636F748F82EEULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    TMP = _mm_alignr_epi8(TMSG2, TMSG1, 4);
-    TMSG3 = _mm_add_epi32(TMSG3, TMP);
-    TMSG3 = _mm_sha256msg2_epu32(TMSG3, TMSG2);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Rounds 60-63
-    MSG = _mm_add_epi32(TMSG3, _mm_set_epi64x(0xC67178F2BEF9A3F7ULL, 0xA4506CEB90BEFFFAULL));
-    STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
-    MSG = _mm_shuffle_epi32(MSG, 0x0E);
-    STATE0 = _mm_sha256rnds2_epu32(STATE0, STATE1, MSG);
-
-    // Add values back to state
-    STATE0 = _mm_add_epi32(STATE0, ABEF_SAVE);
-    STATE1 = _mm_add_epi32(STATE1, CDGH_SAVE);
-
-    TMP = _mm_shuffle_epi32(STATE0, 0x1B); // FEBA
-    STATE1 = _mm_shuffle_epi32(STATE1, 0xB1); // DCHG
-    STATE0 = _mm_blend_epi16(TMP, STATE1, 0xF0); // DCBA
-    STATE1 = _mm_alignr_epi8(STATE1, TMP, 8); // ABEF
-
-    // Save state
-    _mm_store_si128((__m128i*) &state_out[0], STATE0);
-    _mm_store_si128((__m128i*) &state_out[4], STATE1);
-}
-
-#endif
--- a/algo/sha/sha256-hash.c
+++ b/algo/sha/sha256-hash.c
--- a/algo/sha/sha256-hash.h
+++ b/algo/sha/sha256-hash.h
@@ -4,17 +4,18 @@
 #include <stddef.h>
 #include "simd-utils.h"
 #include "cpuminer-config.h"
-#include "sph_sha2.h"
-

 // generic interface 

-typedef struct {
+typedef struct
+{
   unsigned char buf[64];    /* first field, for alignment */
   uint32_t state[8];
   uint64_t count;
 } sha256_context __attribute__((aligned(64)));

+static const uint32_t SHA256_IV[8];
+
 void sha256_full( void *hash, const void *data, size_t len );
 void sha256_update( sha256_context *ctx, const void *data, size_t len );
 void sha256_final( sha256_context *ctx, void *hash );
@@ -41,20 +42,113 @@ void sha256_ni2way_transform_be( uint32_t *out_X, uint32_t*out_Y,
                              const void *msg_X, const void *msg_Y,
                              const uint32_t *in_X, const uint32_t *in_Y );

+void sha256_ni_prehash_3rounds( uint32_t *ostate, const void *msg,
+                              uint32_t *sstate, const uint32_t *istate );
+
+void sha256_ni2way_final_rounds( uint32_t *state_out_X, uint32_t *state_out_Y,
+                 const void *msg_X, const void *msg_Y,
+                 const uint32_t *state_mid_X, const uint32_t *state_mid_Y,
+                 const uint32_t *state_save_X, const uint32_t *state_save_Y );
+
 // Select target
 // with SHA...
 #define sha256_transform_le sha256_opt_transform_le
 #define sha256_transform_be sha256_opt_transform_be

 #else
-
 // without SHA...
+#include "sph_sha2.h"
+
 #define sha256_transform_le sph_sha256_transform_le
 #define sha256_transform_be sph_sha256_transform_be

 #endif

-// SHA can't do only 3 rounds
-#define sha256_prehash_3rounds sph_sha256_prehash_3rounds
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// SHA-256 16 way
+
+typedef struct
+{
+   __m512i buf[64>>2];
+   __m512i val[8];
+   uint32_t count_high, count_low;
+} sha256_16way_context __attribute__ ((aligned (128)));
+
+void sha256_16way_init( sha256_16way_context *sc );
+void sha256_16way_update( sha256_16way_context *sc, const void *data, size_t len );
+void sha256_16way_close( sha256_16way_context *sc, void *dst );
+void sha256_16way_full( void *dst, const void *data, size_t len );
+void sha256_16way_transform_le( __m512i *state_out, const __m512i *data,
+                             const __m512i *state_in );
+void sha256_16way_transform_be( __m512i *state_out, const __m512i *data,
+                             const __m512i *state_in );
+void sha256_16way_prehash_3rounds( __m512i *state_mid, __m512i *X,
+                                  const __m512i *W, const __m512i *state_in );
+void sha256_16way_final_rounds( __m512i *state_out, const __m512i *data,
+        const __m512i *state_in, const __m512i *state_mid, const __m512i *X );
+
+int sha256_16way_transform_le_short( __m512i *state_out, const __m512i *data,
+                            const __m512i *state_in, const uint32_t *target );
+
+#endif // AVX512
+
+#if defined (__AVX2__)
+
+// SHA-256 8 way
+
+typedef struct
+{
+   __m256i buf[64>>2];
+   __m256i val[8];
+   uint32_t count_high, count_low;
+} sha256_8way_context __attribute__ ((aligned (64)));
+
+void sha256_8way_init( sha256_8way_context *sc );
+void sha256_8way_update( sha256_8way_context *sc, const void *data, size_t len );
+void sha256_8way_close( sha256_8way_context *sc, void *dst );
+void sha256_8way_full( void *dst, const void *data, size_t len );
+void sha256_8way_transform_le( __m256i *state_out, const __m256i *data,
+                               const __m256i *state_in );
+void sha256_8way_transform_be( __m256i *state_out, const __m256i *data,
+                               const __m256i *state_in );
+
+void sha256_8way_prehash_3rounds( __m256i *state_mid, __m256i *X,
+                                 const __m256i *W, const __m256i *state_in );
+void sha256_8way_final_rounds( __m256i *state_out, const __m256i *data,
+        const __m256i *state_in, const __m256i *state_mid, const __m256i *X );
+int sha256_8way_transform_le_short( __m256i *state_out, const __m256i *data,
+                             const __m256i *state_in, const uint32_t *target );
+
+#endif  // AVX2
+
+#if defined(__SSE2__)
+
+// SHA-256 4 way
+
+typedef struct
+{
+   __m128i buf[64>>2];
+   __m128i val[8];
+   uint32_t count_high, count_low;
+} sha256_4way_context __attribute__ ((aligned (32)));
+
+void sha256_4way_init( sha256_4way_context *sc );
+void sha256_4way_update( sha256_4way_context *sc, const void *data,
+                         size_t len );
+void sha256_4way_close( sha256_4way_context *sc, void *dst );
+void sha256_4way_full( void *dst, const void *data, size_t len );
+void sha256_4way_transform_le( __m128i *state_out,  const __m128i *data,
+                            const __m128i *state_in );
+void sha256_4way_transform_be( __m128i *state_out,  const __m128i *data,
+                            const __m128i *state_in );
+void sha256_4way_prehash_3rounds( __m128i *state_mid, __m128i *X,
+                                   const __m128i *W, const __m128i *state_in );
+void sha256_4way_final_rounds( __m128i *state_out, const __m128i *data,
+        const __m128i *state_in, const __m128i *state_mid, const __m128i *X );
+int sha256_4way_transform_le_short( __m128i *state_out, const __m128i *data,
+                                   const __m128i *state_in, const uint32_t *target );
+
+#endif  // SSE2

 #endif
--- a/algo/sha/sha256d-4way.c
+++ b/algo/sha/sha256d-4way.c
@@ -3,94 +3,196 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-#include "sha-hash-4way.h"
+#include "sha256-hash.h"
+
+static const uint32_t sha256_iv[8] __attribute__ ((aligned (32))) =
+{
+   0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+   0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+};
+
+#if defined(SHA256D_SHA)
+
+int scanhash_sha256d_sha( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t block1a[16] __attribute__ ((aligned (64)));
+   uint32_t block1b[16] __attribute__ ((aligned (64)));
+   uint32_t block2a[16] __attribute__ ((aligned (64)));
+   uint32_t block2b[16] __attribute__ ((aligned (64)));
+   uint32_t hasha[8]    __attribute__ ((aligned (32)));
+   uint32_t hashb[8]    __attribute__ ((aligned (32)));
+   uint32_t mstatea[8]  __attribute__ ((aligned (32)));
+   uint32_t mstateb[8]  __attribute__ ((aligned (32)));
+   uint32_t sstate[8]   __attribute__ ((aligned (32)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 2;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m128i shuf_bswap32 =
+           _mm_set_epi64x( 0x0c0d0e0f08090a0bULL, 0x0405060700010203ULL );
+
+   // hash first 64 byte block of data
+   sha256_opt_transform_le( mstatea, pdata, sha256_iv );
+
+   // fill & pad second bock without nonce
+   memcpy( block1a, pdata + 16, 12 );
+   memcpy( block1b, pdata + 16, 12 );
+   block1a[ 3] = 0;
+   block1b[ 3] = 0;
+   block1a[ 4] = block1b[ 4] = 0x80000000;
+   memset( block1a + 5, 0, 40 );
+   memset( block1b + 5, 0, 40 );
+   block1a[15] = block1b[15] = 80*8; // bit count
+
+   sha256_ni_prehash_3rounds( mstateb, block1a, sstate, mstatea);
+
+   // Pad third block
+   block2a[ 8] = block2b[ 8] = 0x80000000;
+   memset( block2a + 9, 0, 24 );
+   memset( block2b + 9, 0, 24 );
+   block2a[15] = block2b[15] = 32*8; // bit count
+
+   do
+   {
+      // Insert nonce for second block
+      block1a[3] = n;
+      block1b[3] = n+1;
+      sha256_ni2way_final_rounds( block2a, block2b, block1a, block1b,
+                                  mstateb, mstateb, sstate, sstate );
+
+      sha256_ni2way_transform_le( hasha, hashb, block2a, block2b,
+                                  sha256_iv, sha256_iv );
+
+      if ( unlikely( bswap_32( hasha[7] ) <= ptarget[7] ) )
+      {
+          casti_m128i( hasha, 0 ) =
+               _mm_shuffle_epi8( casti_m128i( hasha, 0 ), shuf_bswap32 );
+          casti_m128i( hasha, 1 ) =
+               _mm_shuffle_epi8( casti_m128i( hasha, 1 ), shuf_bswap32 );
+          if ( likely( valid_hash( hasha, ptarget ) && !bench ) )
+          {
+             pdata[19] = n;
+             submit_solution( work, hasha, mythr );
+          }
+      }
+      if ( unlikely( bswap_32( hashb[7] ) <= ptarget[7] ) )
+      {
+         casti_m128i( hashb, 0 ) =
+               _mm_shuffle_epi8( casti_m128i( hashb, 0 ), shuf_bswap32 );
+         casti_m128i( hashb, 1 ) =
+               _mm_shuffle_epi8( casti_m128i( hashb, 1 ), shuf_bswap32 );
+         if ( likely( valid_hash( hashb, ptarget ) && !bench ) )
+         {
+            pdata[19] = n+1;
+            submit_solution( work, hashb, mythr );
+         }
+      }
+      n += 2;
+   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
+
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+#endif

 #if defined(SHA256D_16WAY)

 int scanhash_sha256d_16way( struct work *work, const uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr )
 {
-   __m512i  vdata[32]    __attribute__ ((aligned (128)));
-   __m512i  block[16]    __attribute__ ((aligned (64)));
+   __m512i  block[16]    __attribute__ ((aligned (128)));
+   __m512i  buf[16]      __attribute__ ((aligned (64)));
   __m512i  hash32[8]    __attribute__ ((aligned (64)));
-   __m512i  initstate[8] __attribute__ ((aligned (64)));
-   __m512i  midstate1[8] __attribute__ ((aligned (64)));
-   __m512i  midstate2[8] __attribute__ ((aligned (64)));
-   __m512i  mexp_pre[16] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
+   __m512i  mstate1[8]   __attribute__ ((aligned (64)));
+   __m512i  mstate2[8]   __attribute__ ((aligned (64)));
+   __m512i  istate[8]    __attribute__ ((aligned (64)));
+   __m512i  mexp_pre[8]  __attribute__ ((aligned (64)));
+   uint32_t phash[8]     __attribute__ ((aligned (32)));
   uint32_t *pdata = work->data;
   const uint32_t *ptarget = work->target;
-   const uint32_t targ32_d7 = ptarget[7];
   const uint32_t first_nonce = pdata[19];
   const uint32_t last_nonce = max_nonce - 16;
+   const __m512i last_byte = _mm512_set1_epi32( 0x80000000 );
   uint32_t n = first_nonce;
-   __m512i *noncev = vdata + 19;
   const int thr_id = mythr->id;
+   const __m512i sixteen = _mm512_set1_epi32( 16 );
   const bool bench = opt_benchmark;
-   const __m512i last_byte = m512_const1_32( 0x80000000 );
-   const __m512i sixteen = m512_const1_32( 16 );
+   const __m256i bswap_shuf = mm256_bcast_m128( _mm_set_epi64x(
+                                0x0c0d0e0f08090a0b, 0x0405060700010203 ) );

-   for ( int i = 0; i < 19; i++ )
-       vdata[i] = m512_const1_32( pdata[i] );
+   // prehash first block directly from pdata
+   sha256_transform_le( phash, pdata, sha256_iv );

-   *noncev = _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 );
+   // vectorize block 0 hash for second block
+   mstate1[0] = _mm512_set1_epi32( phash[0] );
+   mstate1[1] = _mm512_set1_epi32( phash[1] );
+   mstate1[2] = _mm512_set1_epi32( phash[2] );
+   mstate1[3] = _mm512_set1_epi32( phash[3] );
+   mstate1[4] = _mm512_set1_epi32( phash[4] );
+   mstate1[5] = _mm512_set1_epi32( phash[5] );
+   mstate1[6] = _mm512_set1_epi32( phash[6] );
+   mstate1[7] = _mm512_set1_epi32( phash[7] );

-   vdata[16+4] = last_byte;
-   memset_zero_512( vdata+16 + 5, 10 );
-   vdata[16+15] = m512_const1_32( 80*8 ); // bit count
+   // second message block data, with nonce & padding
+   buf[0] = _mm512_set1_epi32( pdata[16] );
+   buf[1] = _mm512_set1_epi32( pdata[17] );
+   buf[2] = _mm512_set1_epi32( pdata[18] );
+   buf[3] = _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 );
+   buf[4] = last_byte;
+   memset_zero_512( buf+5, 10 );
+   buf[15] = _mm512_set1_epi32( 80*8 );  // bit count

+   // partially pre-expand & prehash second message block, avoiding the nonces
+   sha256_16way_prehash_3rounds( mstate2, mexp_pre, buf, mstate1 );
+
+   // vectorize IV for second hash
+   istate[0] = _mm512_set1_epi32( sha256_iv[0] );
+   istate[1] = _mm512_set1_epi32( sha256_iv[1] );
+   istate[2] = _mm512_set1_epi32( sha256_iv[2] );
+   istate[3] = _mm512_set1_epi32( sha256_iv[3] );
+   istate[4] = _mm512_set1_epi32( sha256_iv[4] );
+   istate[5] = _mm512_set1_epi32( sha256_iv[5] );
+   istate[6] = _mm512_set1_epi32( sha256_iv[6] );
+   istate[7] = _mm512_set1_epi32( sha256_iv[7] );
+
+   // initialize padding for second hash
   block[ 8] = last_byte;
-   memset_zero_512( block + 9, 6 );
-   block[15] = m512_const1_32( 32*8 ); // bit count
-   
-   // initialize state
-   initstate[0] = m512_const1_64( 0x6A09E6676A09E667 );
-   initstate[1] = m512_const1_64( 0xBB67AE85BB67AE85 );
-   initstate[2] = m512_const1_64( 0x3C6EF3723C6EF372 );
-   initstate[3] = m512_const1_64( 0xA54FF53AA54FF53A );
-   initstate[4] = m512_const1_64( 0x510E527F510E527F );
-   initstate[5] = m512_const1_64( 0x9B05688C9B05688C );
-   initstate[6] = m512_const1_64( 0x1F83D9AB1F83D9AB );
-   initstate[7] = m512_const1_64( 0x5BE0CD195BE0CD19 );
-
-   sha256_16way_transform_le( midstate1, vdata, initstate );
-
-   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_16way_prehash_3rounds( midstate2, mexp_pre, vdata+16, midstate1 );
+   memset_zero_512( block+9, 6 );
+   block[15] = _mm512_set1_epi32( 32*8 ); // bit count

   do
   {
-      // 1. final 16 bytes of data, with padding
-      sha256_16way_final_rounds( block, vdata+16, midstate1, midstate2,
-                                 mexp_pre );
-
-      // 2. 32 byte hash from 1.
-      if ( sha256_16way_transform_le_short( hash32, block, initstate ) )
+      sha256_16way_final_rounds( block, buf, mstate1, mstate2, mexp_pre );
+      if ( unlikely( sha256_16way_transform_le_short(
+                                  hash32, block, istate, ptarget ) ) )
      {
-         // byte swap final hash for testing
-         mm512_block_bswap_32( hash32, hash32 );
-
         for ( int lane = 0; lane < 16; lane++ )
-         if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
         {
-            extr_lane_16x32( lane_hash, hash32, lane, 256 );
-            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+            extr_lane_16x32( phash, hash32, lane, 256 );
+            casti_m256i( phash, 0 ) =
+                   _mm256_shuffle_epi8( casti_m256i( phash, 0 ), bswap_shuf ); 
+            if ( likely( valid_hash( phash, ptarget ) && !bench ) )
            {
-               pdata[19] = n + lane;
-               submit_solution( work, lane_hash, mythr );
+              pdata[19] = n + lane;
+              submit_solution( work, phash, mythr );
            }
         }
      }
-      *noncev = _mm512_add_epi32( *noncev, sixteen );
+      buf[3] = _mm512_add_epi32( buf[3], sixteen );
      n += 16;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
   pdata[19] = n;
   *hashes_done = n - first_nonce;
   return 0;
 }
-
+   
 #endif

 #if defined(SHA256D_8WAY)
@@ -101,78 +203,72 @@ int scanhash_sha256d_8way( struct work *work, const uint32_t max_nonce,
   __m256i  vdata[32]    __attribute__ ((aligned (64)));
   __m256i  block[16]    __attribute__ ((aligned (32)));
   __m256i  hash32[8]    __attribute__ ((aligned (32)));
-   __m256i  initstate[8] __attribute__ ((aligned (32)));
-   __m256i  midstate1[8] __attribute__ ((aligned (32)));
-   __m256i  midstate2[8] __attribute__ ((aligned (32)));
-   __m256i  mexp_pre[16] __attribute__ ((aligned (32)));
+   __m256i  istate[8]    __attribute__ ((aligned (32)));
+   __m256i  mstate1[8]   __attribute__ ((aligned (32)));
+   __m256i  mstate2[8]   __attribute__ ((aligned (32)));
+   __m256i  mexp_pre[8]  __attribute__ ((aligned (32)));
   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
-   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
   uint32_t *pdata = work->data;
   const uint32_t *ptarget = work->target;
-   const uint32_t targ32_d7 = ptarget[7];
   const uint32_t first_nonce = pdata[19];
   const uint32_t last_nonce = max_nonce - 8;
   uint32_t n = first_nonce;
   __m256i *noncev = vdata + 19;
   const int thr_id = mythr->id;
   const bool bench = opt_benchmark;
-   const __m256i last_byte = m256_const1_32( 0x80000000 );
-   const __m256i eight = m256_const1_32( 8 );
+   const __m256i last_byte = _mm256_set1_epi32( 0x80000000 );
+   const __m256i eight = _mm256_set1_epi32( 8 );
+   const __m256i bswap_shuf = mm256_bcast_m128( _mm_set_epi64x(
+                                0x0c0d0e0f08090a0b, 0x0405060700010203 ) );

   for ( int i = 0; i < 19; i++ )
-      vdata[i] = m256_const1_32( pdata[i] );
+      vdata[i] = _mm256_set1_epi32( pdata[i] );

   *noncev = _mm256_set_epi32( n+ 7, n+ 6, n+ 5, n+ 4, n+ 3, n+ 2, n+1, n );

   vdata[16+4] = last_byte;
   memset_zero_256( vdata+16 + 5, 10 );
-   vdata[16+15] = m256_const1_32( 80*8 ); // bit count
+   vdata[16+15] = _mm256_set1_epi32( 80*8 );

   block[ 8] = last_byte;
   memset_zero_256( block + 9, 6 );
-   block[15] = m256_const1_32( 32*8 ); // bit count
+   block[15] = _mm256_set1_epi32( 32*8 ); 
   
-   // initialize state
-   initstate[0] = m256_const1_64( 0x6A09E6676A09E667 );
-   initstate[1] = m256_const1_64( 0xBB67AE85BB67AE85 );
-   initstate[2] = m256_const1_64( 0x3C6EF3723C6EF372 );
-   initstate[3] = m256_const1_64( 0xA54FF53AA54FF53A );
-   initstate[4] = m256_const1_64( 0x510E527F510E527F );
-   initstate[5] = m256_const1_64( 0x9B05688C9B05688C );
-   initstate[6] = m256_const1_64( 0x1F83D9AB1F83D9AB );
-   initstate[7] = m256_const1_64( 0x5BE0CD195BE0CD19 );
+   // initialize state for second hash
+   istate[0] = _mm256_set1_epi32( sha256_iv[0] );
+   istate[1] = _mm256_set1_epi32( sha256_iv[1] );
+   istate[2] = _mm256_set1_epi32( sha256_iv[2] );
+   istate[3] = _mm256_set1_epi32( sha256_iv[3] );
+   istate[4] = _mm256_set1_epi32( sha256_iv[4] );
+   istate[5] = _mm256_set1_epi32( sha256_iv[5] );
+   istate[6] = _mm256_set1_epi32( sha256_iv[6] );
+   istate[7] = _mm256_set1_epi32( sha256_iv[7] );
+
+   sha256_8way_transform_le( mstate1, vdata, istate );

-   sha256_8way_transform_le( midstate1, vdata, initstate );
-   
   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_8way_prehash_3rounds( midstate2, mexp_pre, vdata + 16, midstate1 );
-
+   sha256_8way_prehash_3rounds( mstate2, mexp_pre, vdata + 16, mstate1 );
+   
   do
   {
-      // 1. final 16 bytes of data, with padding
-      sha256_8way_final_rounds( block, vdata+16, midstate1, midstate2,
-                                mexp_pre );
-
-      // 2. 32 byte hash from 1.
-      if ( unlikely(
-               sha256_8way_transform_le_short( hash32, block, initstate ) ) )
+      sha256_8way_final_rounds( block, vdata+16, mstate1, mstate2, mexp_pre );
+      if ( unlikely( sha256_8way_transform_le_short( hash32, block,
+                                                     istate, ptarget ) ) )
      {
-         // byte swap final hash for testing
-         mm256_block_bswap_32( hash32, hash32 );
-
         for ( int lane = 0; lane < 8; lane++ )
-         if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
         {
            extr_lane_8x32( lane_hash, hash32, lane, 256 );
+            casti_m256i( lane_hash, 0 ) =
+               _mm256_shuffle_epi8( casti_m256i( lane_hash, 0 ), bswap_shuf );
            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
            {
               pdata[19] = n + lane;
               submit_solution( work, lane_hash, mythr );
            }
         }
-       }
-       *noncev = _mm256_add_epi32( *noncev, eight );
-       n += 8;
+      }
+      *noncev = _mm256_add_epi32( *noncev, eight );
+      n += 8;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
   pdata[19] = n;
   *hashes_done = n - first_nonce;
@@ -186,14 +282,12 @@ int scanhash_sha256d_8way( struct work *work, const uint32_t max_nonce,
 int scanhash_sha256d_4way( struct work *work, const uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr )
 {
-   __m128i  vdata[32]     __attribute__ ((aligned (64)));
-   __m128i  block[16]     __attribute__ ((aligned (32)));
-   __m128i  hash32[8]     __attribute__ ((aligned (32)));
-   __m128i  initstate[8]  __attribute__ ((aligned (32)));
-   __m128i  midstate1[8]   __attribute__ ((aligned (32)));
-   __m128i  midstate2[8]  __attribute__ ((aligned (32)));
-   __m128i  mexp_pre[16]  __attribute__ ((aligned (32)));
-   uint32_t lane_hash[8]  __attribute__ ((aligned (32)));
+   __m128i  vdata[32]    __attribute__ ((aligned (64)));
+   __m128i  block[16]    __attribute__ ((aligned (32)));
+   __m128i  hash32[8]    __attribute__ ((aligned (32)));
+   __m128i  istate[8] __attribute__ ((aligned (32)));
+   __m128i  mstate[8]  __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
   uint32_t *pdata = work->data;
   const uint32_t *ptarget = work->target;
@@ -204,59 +298,50 @@ int scanhash_sha256d_4way( struct work *work, const uint32_t max_nonce,
   __m128i *noncev = vdata + 19;
   const int thr_id = mythr->id;
   const bool bench = opt_benchmark;
-   const __m128i last_byte = m128_const1_32( 0x80000000 );
-   const __m128i four = m128_const1_32( 4 );
+   const __m128i last_byte = _mm_set1_epi32( 0x80000000 );
+   const __m128i four = _mm_set1_epi32( 4 );

   for ( int i = 0; i < 19; i++ )
-       vdata[i] = m128_const1_32( pdata[i] );
+       vdata[i] = _mm_set1_epi32( pdata[i] );

   *noncev = _mm_set_epi32( n+ 3, n+ 2, n+1, n );

   vdata[16+4] = last_byte;
   memset_zero_128( vdata+16 + 5, 10 );
-   vdata[16+15] = m128_const1_32( 80*8 ); // bit count
+   vdata[16+15] = _mm_set1_epi32( 80*8 );

   block[ 8] = last_byte;
   memset_zero_128( block + 9, 6 );
-   block[15] = m128_const1_32( 32*8 ); // bit count
-
+   block[15] = _mm_set1_epi32( 32*8 );
+   
   // initialize state
-   initstate[0] = m128_const1_64( 0x6A09E6676A09E667 );
-   initstate[1] = m128_const1_64( 0xBB67AE85BB67AE85 );
-   initstate[2] = m128_const1_64( 0x3C6EF3723C6EF372 );
-   initstate[3] = m128_const1_64( 0xA54FF53AA54FF53A );
-   initstate[4] = m128_const1_64( 0x510E527F510E527F );
-   initstate[5] = m128_const1_64( 0x9B05688C9B05688C );
-   initstate[6] = m128_const1_64( 0x1F83D9AB1F83D9AB );
-   initstate[7] = m128_const1_64( 0x5BE0CD195BE0CD19 );
+   istate[0] = _mm_set1_epi32( sha256_iv[0] );
+   istate[1] = _mm_set1_epi32( sha256_iv[1] );
+   istate[2] = _mm_set1_epi32( sha256_iv[2] );
+   istate[3] = _mm_set1_epi32( sha256_iv[3] );
+   istate[4] = _mm_set1_epi32( sha256_iv[4] );
+   istate[5] = _mm_set1_epi32( sha256_iv[5] );
+   istate[6] = _mm_set1_epi32( sha256_iv[6] );
+   istate[7] = _mm_set1_epi32( sha256_iv[7] );

   // hash first 64 bytes of data
-   sha256_4way_transform_le( midstate1, vdata, initstate );
-   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_4way_prehash_3rounds( midstate2, mexp_pre, vdata + 16, midstate1 );
+   sha256_4way_transform_le( mstate, vdata, istate );

   do
   {
-      // 1. final 16 bytes of data, with padding
-      sha256_4way_final_rounds( block, vdata+16, midstate1, midstate2,
-                                mexp_pre );
+      sha256_4way_transform_le( block,  vdata+16, mstate  );
+      sha256_4way_transform_le( hash32, block, istate );

-      // 2. 32 byte hash from 1.
-      if ( unlikely(
-              sha256_4way_transform_le_short( hash32, block, initstate ) ) )
+      mm128_block_bswap_32( hash32, hash32 );
+
+      for ( int lane = 0; lane < 4; lane++ )
+      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
      {
-         // byte swap final hash for testing
-         mm128_block_bswap_32( hash32, hash32 );
-
-         for ( int lane = 0; lane < 4; lane++ )
-         if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
+         extr_lane_4x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
         {
-            extr_lane_4x32( lane_hash, hash32, lane, 256 );
-            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
-            {
-               pdata[19] = n + lane;
-               submit_solution( work, lane_hash, mythr );
-            }
+            pdata[19] = n + lane;
+            submit_solution( work, lane_hash, mythr );
         }
      }
      *noncev = _mm_add_epi32( *noncev, four );
@@ -269,20 +354,4 @@ int scanhash_sha256d_4way( struct work *work, const uint32_t max_nonce,

 #endif

-/*
-bool register_sha256d_algo( algo_gate_t* gate )
-{
-   gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
-#if defined(SHA256D_16WAY)
-   gate->scanhash = (void*)&scanhash_sha256d_16way;
-#elif defined(SHA256D_8WAY)
-   gate->scanhash = (void*)&scanhash_sha256d_8way;
-#elif defined(SHA256D_4WAY)
-   gate->scanhash = (void*)&scanhash_sha256d_4way;
-#endif
-   
-//   gate->hash     = (void*)&sha256d;
-   return true;
-};
-*/

--- a/algo/sha/sha256d-4way.h
+++ b/algo/sha/sha256d-4way.h
@@ -6,6 +6,8 @@

 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
  #define SHA256D_16WAY 1
+#elif defined(__SHA__)
+  #define SHA256D_SHA 1
 #elif defined(__AVX2__)
  #define SHA256D_8WAY 1
 #else
@@ -32,15 +34,12 @@ int scanhash_sha256d_4way( struct work *work, uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr );
 #endif

+#if defined(SHA256D_SHA)

-/*
-#if defined(__SHA__)
-
-int scanhash_sha256d( struct work *work, uint32_t max_nonce,
-                      uint64_t *hashes_done, struct thr_info *mythr );
-
-#endif
-*/
+int scanhash_sha256d_sha( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif

 #endif

--- a/algo/sha/sha256dt.c
+++ b/algo/sha/sha256dt.c
@@ -3,96 +3,206 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-#include "sha-hash-4way.h"
+#include "sha256-hash.h"

 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
  #define SHA256DT_16WAY 1
+#elif defined(__SHA__)
+  #define SHA256DT_SHA 1
 #elif defined(__AVX2__)
  #define SHA256DT_8WAY 1
 #else
  #define SHA256DT_4WAY 1
 #endif

+static const uint32_t sha256dt_iv[8]  __attribute__ ((aligned (32))) =
+   {
+      0xdfa9bf2c, 0xb72074d4, 0x6bb01122, 0xd338e869,
+      0xaa3ff126, 0x475bbf30, 0x8fd52e5b, 0x9f75c9ad
+   };
+
+#if defined(SHA256DT_SHA)
+
+int scanhash_sha256dt_sha( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t block1a[16] __attribute__ ((aligned (64)));
+   uint32_t block1b[16] __attribute__ ((aligned (64)));
+   uint32_t block2a[16] __attribute__ ((aligned (64)));
+   uint32_t block2b[16] __attribute__ ((aligned (64)));
+   uint32_t hasha[8]    __attribute__ ((aligned (32)));
+   uint32_t hashb[8]    __attribute__ ((aligned (32)));
+   uint32_t mstatea[8]  __attribute__ ((aligned (32)));
+   uint32_t mstateb[8]  __attribute__ ((aligned (32)));
+   uint32_t sstate[8]   __attribute__ ((aligned (32)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 2;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m128i shuf_bswap32 =
+           _mm_set_epi64x( 0x0c0d0e0f08090a0bULL, 0x0405060700010203ULL );
+
+   // hash first 64 byte block of data
+   sha256_opt_transform_le( mstatea, pdata, sha256dt_iv );
+
+   // fill & pad second bock without nonce
+   memcpy( block1a, pdata + 16, 12 );
+   memcpy( block1b, pdata + 16, 12 );
+   block1a[ 3] = 0;
+   block1b[ 3] = 0;
+   block1a[ 4] = block1b[ 4] = 0x80000000;
+   memset( block1a + 5, 0, 40 );
+   memset( block1b + 5, 0, 40 );
+   block1a[15] = block1b[15] = 0x480; // funky bit count
+
+   sha256_ni_prehash_3rounds( mstateb, block1a, sstate, mstatea);
+
+   // Pad third block
+   block2a[ 8] = block2b[ 8] = 0x80000000;
+   memset( block2a + 9, 0, 24 );
+   memset( block2b + 9, 0, 24 );
+   block2a[15] = block2b[15] = 0x300; // bit count
+
+   do
+   {
+      // Insert nonce for second block
+      block1a[3] = n;
+      block1b[3] = n+1;
+      sha256_ni2way_final_rounds( block2a, block2b, block1a, block1b,
+                                  mstateb, mstateb, sstate, sstate );
+
+      sha256_ni2way_transform_le( hasha, hashb, block2a, block2b,
+                                  sha256dt_iv, sha256dt_iv );
+
+      if ( unlikely( bswap_32( hasha[7] ) <= ptarget[7] ) )
+      {
+          casti_m128i( hasha, 0 ) =
+               _mm_shuffle_epi8( casti_m128i( hasha, 0 ), shuf_bswap32 );
+          casti_m128i( hasha, 1 ) =
+               _mm_shuffle_epi8( casti_m128i( hasha, 1 ), shuf_bswap32 );
+          if ( likely( valid_hash( hasha, ptarget ) && !bench ) )
+          {
+             pdata[19] = n;
+             submit_solution( work, hasha, mythr );
+          }
+      }
+      if ( unlikely( bswap_32( hashb[7] ) <= ptarget[7] ) )
+      {
+         casti_m128i( hashb, 0 ) =
+               _mm_shuffle_epi8( casti_m128i( hashb, 0 ), shuf_bswap32 );
+         casti_m128i( hashb, 1 ) =
+               _mm_shuffle_epi8( casti_m128i( hashb, 1 ), shuf_bswap32 );
+         if ( likely( valid_hash( hashb, ptarget ) && !bench ) )
+         {
+            pdata[19] = n+1;
+            submit_solution( work, hashb, mythr );
+         }
+      }
+      n += 2;
+   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
+
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+#endif
+
 #if defined(SHA256DT_16WAY)

 int scanhash_sha256dt_16way( struct work *work, const uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr )
 {
-   __m512i  vdata[32]    __attribute__ ((aligned (128)));
-   __m512i  block[16]    __attribute__ ((aligned (64)));
+   __m512i  block[16]    __attribute__ ((aligned (128)));
+   __m512i  buf[16]      __attribute__ ((aligned (64)));
   __m512i  hash32[8]    __attribute__ ((aligned (64)));
-   __m512i  initstate[8] __attribute__ ((aligned (64)));
-   __m512i  midstate1[8] __attribute__ ((aligned (64)));
-   __m512i  midstate2[8] __attribute__ ((aligned (64)));
-   __m512i  mexp_pre[16] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
+   __m512i  mstate1[8]   __attribute__ ((aligned (64)));
+   __m512i  mstate2[8]   __attribute__ ((aligned (64)));
+   __m512i  istate[8]    __attribute__ ((aligned (64)));
+   __m512i  mexp_pre[8]  __attribute__ ((aligned (64)));
+   uint32_t phash[8]     __attribute__ ((aligned (32)));
   uint32_t *pdata = work->data;
   const uint32_t *ptarget = work->target;
-   const uint32_t targ32_d7 = ptarget[7];
   const uint32_t first_nonce = pdata[19];
   const uint32_t last_nonce = max_nonce - 16;
-   uint32_t n = first_nonce;
-   __m512i *noncev = vdata + 19; 
-   const int thr_id = mythr->id;
-   const bool bench = opt_benchmark;
   const __m512i last_byte = _mm512_set1_epi32( 0x80000000 );
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
   const __m512i sixteen = _mm512_set1_epi32( 16 );
+   const bool bench = opt_benchmark;
+   const __m256i bswap_shuf = mm256_bcast_m128( _mm_set_epi64x(
+                                0x0c0d0e0f08090a0b, 0x0405060700010203 ) );

-   for ( int i = 0; i < 19; i++ )
-      vdata[i] = _mm512_set1_epi32( pdata[i] );
+   // prehash first block directly from pdata
+   sha256_transform_le( phash, pdata, sha256dt_iv );

-   *noncev = _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 );
+   // vectorize block 0 hash for second block
+   mstate1[0] = _mm512_set1_epi32( phash[0] );
+   mstate1[1] = _mm512_set1_epi32( phash[1] );
+   mstate1[2] = _mm512_set1_epi32( phash[2] );
+   mstate1[3] = _mm512_set1_epi32( phash[3] );
+   mstate1[4] = _mm512_set1_epi32( phash[4] );
+   mstate1[5] = _mm512_set1_epi32( phash[5] );
+   mstate1[6] = _mm512_set1_epi32( phash[6] );
+   mstate1[7] = _mm512_set1_epi32( phash[7] );

-   vdata[16+4] = last_byte;
-   memset_zero_512( vdata+16 + 5, 10 );
-   vdata[16+15] = _mm512_set1_epi32( 0x480 ); 
-   
+   // second message block data, with nonce & padding
+   buf[0] = _mm512_set1_epi32( pdata[16] );
+   buf[1] = _mm512_set1_epi32( pdata[17] );
+   buf[2] = _mm512_set1_epi32( pdata[18] );
+   buf[3] = _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 );
+   buf[4] = last_byte;
+   memset_zero_512( buf+5, 10 );
+   buf[15] = _mm512_set1_epi32( 0x480 ); // sha256dt funky bit count
+
+   // partially pre-expand & prehash second message block, avoiding the nonces
+   sha256_16way_prehash_3rounds( mstate2, mexp_pre, buf, mstate1 );
+
+   // vectorize IV for second hash
+   istate[0] = _mm512_set1_epi32( sha256dt_iv[0] );
+   istate[1] = _mm512_set1_epi32( sha256dt_iv[1] );
+   istate[2] = _mm512_set1_epi32( sha256dt_iv[2] );
+   istate[3] = _mm512_set1_epi32( sha256dt_iv[3] );
+   istate[4] = _mm512_set1_epi32( sha256dt_iv[4] );
+   istate[5] = _mm512_set1_epi32( sha256dt_iv[5] );
+   istate[6] = _mm512_set1_epi32( sha256dt_iv[6] );
+   istate[7] = _mm512_set1_epi32( sha256dt_iv[7] );
+
+   // initialize padding for second hash
   block[ 8] = last_byte;
-   memset_zero_512( block + 9, 6 );
-   block[15] = _mm512_set1_epi32( 0x300 ); 
-   
-   initstate[0] = _mm512_set1_epi64( 0xdfa9bf2cdfa9bf2c );
-   initstate[1] = _mm512_set1_epi64( 0xb72074d4b72074d4 );
-   initstate[2] = _mm512_set1_epi64( 0x6bb011226bb01122 );
-   initstate[3] = _mm512_set1_epi64( 0xd338e869d338e869 );
-   initstate[4] = _mm512_set1_epi64( 0xaa3ff126aa3ff126 );
-   initstate[5] = _mm512_set1_epi64( 0x475bbf30475bbf30 );
-   initstate[6] = _mm512_set1_epi64( 0x8fd52e5b8fd52e5b );
-   initstate[7] = _mm512_set1_epi64( 0x9f75c9ad9f75c9ad );
-
-   sha256_16way_transform_le( midstate1, vdata, initstate );
-   
-   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_16way_prehash_3rounds( midstate2, mexp_pre, vdata+16, midstate1 );
+   memset_zero_512( block+9, 6 );
+   block[15] = _mm512_set1_epi32( 0x300 ); // bit count

   do
   {
-      sha256_16way_final_rounds( block, vdata+16, midstate1, midstate2,
-                                 mexp_pre );
-      sha256_16way_transform_le( hash32, block, initstate );
-      mm512_block_bswap_32( hash32, hash32 );    
-
-      for ( int lane = 0; lane < 16; lane++ )
-      if ( hash32_d7[ lane ] <= targ32_d7 )
+      sha256_16way_final_rounds( block, buf, mstate1, mstate2, mexp_pre );
+      if ( unlikely( sha256_16way_transform_le_short(
+                                  hash32, block, istate, ptarget ) ) )
      {
-         extr_lane_16x32( lane_hash, hash32, lane, 256 );
-         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+         for ( int lane = 0; lane < 16; lane++ )
         {
-            pdata[19] = n + lane;
-            submit_solution( work, lane_hash, mythr );
+            extr_lane_16x32( phash, hash32, lane, 256 );
+            casti_m256i( phash, 0 ) =
+                   _mm256_shuffle_epi8( casti_m256i( phash, 0 ), bswap_shuf ); 
+            if ( likely( valid_hash( phash, ptarget ) && !bench ) )
+            {
+              pdata[19] = n + lane;
+              submit_solution( work, phash, mythr );
+            }
         }
      }
-      *noncev = _mm512_add_epi32( *noncev, sixteen );
+      buf[3] = _mm512_add_epi32( buf[3], sixteen );
      n += 16;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
   pdata[19] = n;
   *hashes_done = n - first_nonce;
   return 0;
 }
-
-
+   
 #endif

 #if defined(SHA256DT_8WAY)
@@ -103,15 +213,13 @@ int scanhash_sha256dt_8way( struct work *work, const uint32_t max_nonce,
   __m256i  vdata[32]    __attribute__ ((aligned (64)));
   __m256i  block[16]    __attribute__ ((aligned (32)));
   __m256i  hash32[8]    __attribute__ ((aligned (32)));
-   __m256i  initstate[8] __attribute__ ((aligned (32)));
-   __m256i  midstate1[8] __attribute__ ((aligned (32)));
-   __m256i  midstate2[8] __attribute__ ((aligned (32)));
-   __m256i  mexp_pre[16] __attribute__ ((aligned (32)));
+   __m256i  istate[8]    __attribute__ ((aligned (32)));
+   __m256i  mstate1[8]   __attribute__ ((aligned (32)));
+   __m256i  mstate2[8]   __attribute__ ((aligned (32)));
+   __m256i  mexp_pre[8]  __attribute__ ((aligned (32)));
   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
-   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
   uint32_t *pdata = work->data;
   const uint32_t *ptarget = work->target;
-   const uint32_t targ32_d7 = ptarget[7];
   const uint32_t first_nonce = pdata[19];
   const uint32_t last_nonce = max_nonce - 8;
   uint32_t n = first_nonce;
@@ -120,6 +228,8 @@ int scanhash_sha256dt_8way( struct work *work, const uint32_t max_nonce,
   const bool bench = opt_benchmark;
   const __m256i last_byte = _mm256_set1_epi32( 0x80000000 );
   const __m256i eight = _mm256_set1_epi32( 8 );
+   const __m256i bswap_shuf = mm256_bcast_m128( _mm_set_epi64x(
+                                0x0c0d0e0f08090a0b, 0x0405060700010203 ) );

   for ( int i = 0; i < 19; i++ )
      vdata[i] = _mm256_set1_epi32( pdata[i] );
@@ -134,36 +244,37 @@ int scanhash_sha256dt_8way( struct work *work, const uint32_t max_nonce,
   memset_zero_256( block + 9, 6 );
   block[15] = _mm256_set1_epi32( 0x300 ); 
   
-   // initialize state
-   initstate[0] = _mm256_set1_epi64x( 0xdfa9bf2cdfa9bf2c );
-   initstate[1] = _mm256_set1_epi64x( 0xb72074d4b72074d4 );
-   initstate[2] = _mm256_set1_epi64x( 0x6bb011226bb01122 );
-   initstate[3] = _mm256_set1_epi64x( 0xd338e869d338e869 );
-   initstate[4] = _mm256_set1_epi64x( 0xaa3ff126aa3ff126 );
-   initstate[5] = _mm256_set1_epi64x( 0x475bbf30475bbf30 );
-   initstate[6] = _mm256_set1_epi64x( 0x8fd52e5b8fd52e5b );
-   initstate[7] = _mm256_set1_epi64x( 0x9f75c9ad9f75c9ad );
+   // initialize state for swecond hash
+   istate[0] = _mm256_set1_epi64x( 0xdfa9bf2cdfa9bf2c );
+   istate[1] = _mm256_set1_epi64x( 0xb72074d4b72074d4 );
+   istate[2] = _mm256_set1_epi64x( 0x6bb011226bb01122 );
+   istate[3] = _mm256_set1_epi64x( 0xd338e869d338e869 );
+   istate[4] = _mm256_set1_epi64x( 0xaa3ff126aa3ff126 );
+   istate[5] = _mm256_set1_epi64x( 0x475bbf30475bbf30 );
+   istate[6] = _mm256_set1_epi64x( 0x8fd52e5b8fd52e5b );
+   istate[7] = _mm256_set1_epi64x( 0x9f75c9ad9f75c9ad );

-   sha256_8way_transform_le( midstate1, vdata, initstate );
+   sha256_8way_transform_le( mstate1, vdata, istate );

   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_8way_prehash_3rounds( midstate2, mexp_pre, vdata + 16, midstate1 );
+   sha256_8way_prehash_3rounds( mstate2, mexp_pre, vdata + 16, mstate1 );
   
   do
   {
-      sha256_8way_final_rounds( block, vdata+16, midstate1, midstate2,
-                                mexp_pre );
-      sha256_8way_transform_le( hash32, block, initstate );
-      mm256_block_bswap_32( hash32, hash32 );
-
-      for ( int lane = 0; lane < 8; lane++ )
-      if ( hash32_d7[ lane ] <= targ32_d7 )
+      sha256_8way_final_rounds( block, vdata+16, mstate1, mstate2, mexp_pre );
+      if ( unlikely( sha256_8way_transform_le_short( hash32, block,
+                                                     istate, ptarget ) ) )
      {
-         extr_lane_8x32( lane_hash, hash32, lane, 256 );
-         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+         for ( int lane = 0; lane < 8; lane++ )
         {
-            pdata[19] = n + lane;
-            submit_solution( work, lane_hash, mythr );
+            extr_lane_8x32( lane_hash, hash32, lane, 256 );
+            casti_m256i( lane_hash, 0 ) =
+               _mm256_shuffle_epi8( casti_m256i( lane_hash, 0 ), bswap_shuf );
+            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+            {
+               pdata[19] = n + lane;
+               submit_solution( work, lane_hash, mythr );
+            }
         }
      }
      *noncev = _mm256_add_epi32( *noncev, eight );
@@ -176,7 +287,6 @@ int scanhash_sha256dt_8way( struct work *work, const uint32_t max_nonce,

 #endif

-
 #if defined(SHA256DT_4WAY)

 int scanhash_sha256dt_4way( struct work *work, const uint32_t max_nonce,
@@ -230,21 +340,25 @@ int scanhash_sha256dt_4way( struct work *work, const uint32_t max_nonce,
   do
   {
      sha256_4way_transform_le( block,  vdata+16, midstate  );
-      sha256_4way_transform_le( hash32, block,    initstate );
-      mm128_block_bswap_32( hash32, hash32 );
+      sha256_4way_transform_le( hash32, block, initstate );

-      for ( int lane = 0; lane < 4; lane++ )
-      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
-      {
-         extr_lane_4x32( lane_hash, hash32, lane, 256 );
-         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+//      if ( sha256_4way_transform_le_short( hash32, block, initstate, ptarget ) )
+//      {
+         mm128_block_bswap_32( hash32, hash32 );
+
+         for ( int lane = 0; lane < 4; lane++ )
+         if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
         {
-            pdata[19] = n + lane;
-            submit_solution( work, lane_hash, mythr );
+            extr_lane_4x32( lane_hash, hash32, lane, 256 );
+            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+            {
+               pdata[19] = n + lane;
+               submit_solution( work, lane_hash, mythr );
+            }
         }
-       }
-       *noncev = _mm_add_epi32( *noncev, four );
-       n += 4;
+//      }
+      *noncev = _mm_add_epi32( *noncev, four );
+      n += 4;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
   pdata[19] = n;
   *hashes_done = n - first_nonce;
@@ -257,11 +371,14 @@ bool register_sha256dt_algo( algo_gate_t* gate )
 {
    gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
 #if defined(SHA256DT_16WAY)
-    gate->scanhash   = (void*)&scanhash_sha256dt_16way;
+    gate->scanhash = (void*)&scanhash_sha256dt_16way;
+#elif defined(SHA256DT_SHA)
+    gate->optimizations = SHA_OPT;
+    gate->scanhash = (void*)&scanhash_sha256dt_sha;    
 #elif defined(SHA256DT_8WAY)
-    gate->scanhash   = (void*)&scanhash_sha256dt_8way;
+    gate->scanhash = (void*)&scanhash_sha256dt_8way;
 #else
-    gate->scanhash   = (void*)&scanhash_sha256dt_4way;
+    gate->scanhash = (void*)&scanhash_sha256dt_4way;
 #endif
    return true;
 }
--- a/algo/sha/sha256q-4way.c
+++ b/algo/sha/sha256q-4way.c
@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-#include "sha-hash-4way.h"
+#include "sha256-hash.h"

 #if defined(SHA256T_16WAY)

@@ -68,7 +68,7 @@ int scanhash_sha256q_16way( struct work *work, const uint32_t max_nonce,
           submit_solution( work, lane_hash, mythr );
        }
      }
-      *noncev = _mm512_add_epi32( *noncev, m512_const1_32( 16 ) );
+      *noncev = _mm512_add_epi32( *noncev, _mm512_set1_epi32( 16 ) );
      n += 16;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
   pdata[19] = n;
@@ -140,7 +140,7 @@ int scanhash_sha256q_8way( struct work *work, const uint32_t max_nonce,
           submit_solution( work, lane_hash, mythr );
        }
      }
-      *noncev = _mm256_add_epi32( *noncev, m256_const1_32( 8 ) );
+      *noncev = _mm256_add_epi32( *noncev, _mm256_set1_epi32( 8 ) );
      n += 8;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
   pdata[19] = n;
--- a/algo/sha/sha256t-4way.c
+++ b/algo/sha/sha256t-4way.c
@@ -3,90 +3,104 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-#include "sha-hash-4way.h"
+#include "sha256-hash.h"
+
+   static const uint32_t sha256_iv[8]  __attribute__ ((aligned (32))) =
+   {
+      0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+      0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+   };

 #if defined(SHA256T_16WAY)

 int scanhash_sha256t_16way( struct work *work, const uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr )
 {
-   __m512i  vdata[32]    __attribute__ ((aligned (128)));
+   __m512i  hash32[8]    __attribute__ ((aligned (128)));
   __m512i  block[16]    __attribute__ ((aligned (64)));
-   __m512i  hash32[8]    __attribute__ ((aligned (64)));
-   __m512i  initstate[8] __attribute__ ((aligned (64)));
-   __m512i  midstate1[8] __attribute__ ((aligned (64)));
-   __m512i  midstate2[8] __attribute__ ((aligned (64)));
-   __m512i  mexp_pre[16] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
+   __m512i  buf[16]      __attribute__ ((aligned (64)));
+   __m512i  mstate1[8]   __attribute__ ((aligned (64)));
+   __m512i  mstate2[8]   __attribute__ ((aligned (64)));
+   __m512i  istate[8]    __attribute__ ((aligned (64)));
+   __m512i  mexp_pre[8]  __attribute__ ((aligned (64)));
+   uint32_t phash[8]     __attribute__ ((aligned (32)));
   uint32_t *pdata = work->data;
-   const uint32_t *ptarget = work->target;
+   uint32_t *ptarget = work->target;
+   uint32_t *hash32_d7 = (uint32_t*)&(hash32[7]);
   const uint32_t targ32_d7 = ptarget[7];
   const uint32_t first_nonce = pdata[19];
   const uint32_t last_nonce = max_nonce - 16;
+   const __m512i last_byte = _mm512_set1_epi32( 0x80000000 );
   uint32_t n = first_nonce;
-   __m512i *noncev = vdata + 19; 
   const int thr_id = mythr->id;
+   const __m512i sixteen = _mm512_set1_epi32( 16 );
   const bool bench = opt_benchmark;
-   const __m512i last_byte = m512_const1_32( 0x80000000 );
-   const __m512i sixteen = m512_const1_32( 16 );
+   const __m256i bswap_shuf = mm256_bcast_m128( _mm_set_epi64x(
+                                0x0c0d0e0f08090a0b, 0x0405060700010203 ) );

-   for ( int i = 0; i < 19; i++ )
-      vdata[i] = m512_const1_32( pdata[i] );
+   // prehash first block directly from pdata
+   sha256_transform_le( phash, pdata, sha256_iv );

-   *noncev = _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 );
+   // vectorize block 0 hash for second block
+   mstate1[0] = _mm512_set1_epi32( phash[0] );
+   mstate1[1] = _mm512_set1_epi32( phash[1] );
+   mstate1[2] = _mm512_set1_epi32( phash[2] );
+   mstate1[3] = _mm512_set1_epi32( phash[3] );
+   mstate1[4] = _mm512_set1_epi32( phash[4] );
+   mstate1[5] = _mm512_set1_epi32( phash[5] );
+   mstate1[6] = _mm512_set1_epi32( phash[6] );
+   mstate1[7] = _mm512_set1_epi32( phash[7] );

-   vdata[16+4] = last_byte;
-   memset_zero_512( vdata+16 + 5, 10 );
-   vdata[16+15] = m512_const1_32( 80*8 ); // bit count
-   
+   // second message block data, with nonce & padding   
+   buf[0] = _mm512_set1_epi32( pdata[16] );
+   buf[1] = _mm512_set1_epi32( pdata[17] );
+   buf[2] = _mm512_set1_epi32( pdata[18] );
+   buf[3] = _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 );
+   buf[4] = last_byte;
+   memset_zero_512( buf+5, 10 );
+   buf[15] = _mm512_set1_epi32( 80*8 ); // bit count
+
+   // partially pre-expand & prehash second message block, avoiding the nonces
+   sha256_16way_prehash_3rounds( mstate2, mexp_pre, buf, mstate1 );
+
+   // vectorize IV for 2nd & 3rd sha256
+   istate[0] = _mm512_set1_epi32( sha256_iv[0] );
+   istate[1] = _mm512_set1_epi32( sha256_iv[1] );
+   istate[2] = _mm512_set1_epi32( sha256_iv[2] );
+   istate[3] = _mm512_set1_epi32( sha256_iv[3] );
+   istate[4] = _mm512_set1_epi32( sha256_iv[4] );
+   istate[5] = _mm512_set1_epi32( sha256_iv[5] );
+   istate[6] = _mm512_set1_epi32( sha256_iv[6] );
+   istate[7] = _mm512_set1_epi32( sha256_iv[7] );
+
+   // initialize padding for 2nd & 3rd sha256
   block[ 8] = last_byte;
   memset_zero_512( block + 9, 6 );
-   block[15] = m512_const1_32( 32*8 ); // bit count
-   
-   initstate[0] = m512_const1_64( 0x6A09E6676A09E667 );
-   initstate[1] = m512_const1_64( 0xBB67AE85BB67AE85 );
-   initstate[2] = m512_const1_64( 0x3C6EF3723C6EF372 );
-   initstate[3] = m512_const1_64( 0xA54FF53AA54FF53A );
-   initstate[4] = m512_const1_64( 0x510E527F510E527F );
-   initstate[5] = m512_const1_64( 0x9B05688C9B05688C );
-   initstate[6] = m512_const1_64( 0x1F83D9AB1F83D9AB );
-   initstate[7] = m512_const1_64( 0x5BE0CD195BE0CD19 );
-
-   sha256_16way_transform_le( midstate1, vdata, initstate );
-   
-   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_16way_prehash_3rounds( midstate2, mexp_pre, vdata+16, midstate1 );
+   block[15] = _mm512_set1_epi32( 32*8 ); // bit count

   do
   {
-      // 1. final 16 bytes of data, pre-padded
-      sha256_16way_final_rounds( block, vdata+16, midstate1, midstate2,
-                                 mexp_pre );
+      sha256_16way_final_rounds( block, buf, mstate1, mstate2, mexp_pre );

-      // 2. 32 byte hash from 1.
-      sha256_16way_transform_le( block, block, initstate );
+      sha256_16way_transform_le( block, block, istate );

-      // 3. 32 byte hash from 2.
-      if ( unlikely(
-               sha256_16way_transform_le_short( hash32, block, initstate ) ) )
+      if ( sha256_16way_transform_le_short( hash32, block, istate, ptarget ) )
      {
-         // byte swap final hash for testing
-         mm512_block_bswap_32( hash32, hash32 );    
-
         for ( int lane = 0; lane < 16; lane++ )
-         if ( hash32_d7[ lane ] <= targ32_d7 )
+         if ( bswap_32( hash32_d7[ lane ] ) <= targ32_d7 )
         {
-            extr_lane_16x32( lane_hash, hash32, lane, 256 );
-            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+            extr_lane_16x32( phash, hash32, lane, 256 );
+            casti_m256i( phash, 0 ) =
+                _mm256_shuffle_epi8( casti_m256i( phash, 0 ), bswap_shuf );
+            if ( likely( valid_hash( phash, ptarget ) && !bench ) )
            {
               pdata[19] = n + lane;
-               submit_solution( work, lane_hash, mythr );
+               submit_solution( work, phash, mythr );
            }
         }
      }
-      *noncev = _mm512_add_epi32( *noncev, sixteen );
+      buf[3] = _mm512_add_epi32( buf[3], sixteen );
      n += 16;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
   pdata[19] = n;
@@ -94,83 +108,171 @@ int scanhash_sha256t_16way( struct work *work, const uint32_t max_nonce,
   return 0;
 }

+#endif
+
+#if defined(__SHA__)
+
+int scanhash_sha256t_sha( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t block1a[16] __attribute__ ((aligned (64)));
+   uint32_t block1b[16] __attribute__ ((aligned (64)));
+   uint32_t block2a[16] __attribute__ ((aligned (64)));
+   uint32_t block2b[16] __attribute__ ((aligned (64)));
+   uint32_t hasha[8]   __attribute__ ((aligned (32)));
+   uint32_t hashb[8]   __attribute__ ((aligned (32)));
+   uint32_t mstatea[8] __attribute__ ((aligned (32)));
+   uint32_t mstateb[8] __attribute__ ((aligned (32)));
+   uint32_t sstate[8]  __attribute__ ((aligned (32)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 2;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m128i shuf_bswap32 =
+           _mm_set_epi64x( 0x0c0d0e0f08090a0bULL, 0x0405060700010203ULL );
+
+   // hash first 64 byte block of data
+   sha256_opt_transform_le( mstatea, pdata, sha256_iv );
+
+   // fill & pad second bock without nonce
+   memcpy( block1a, pdata + 16, 12 );
+   memcpy( block1b, pdata + 16, 12 );
+   block1a[ 3] = 0;
+   block1b[ 3] = 0;
+   block1a[ 4] = block1b[ 4] = 0x80000000;
+   memset( block1a + 5, 0, 40 );
+   memset( block1b + 5, 0, 40 );
+   block1a[15] = block1b[15] = 0x480; // funky bit count
+
+   sha256_ni_prehash_3rounds( mstateb, block1a, sstate, mstatea);
+
+   // Pad third block
+   block2a[ 8] = block2b[ 8] = 0x80000000;
+   memset( block2a + 9, 0, 24 );
+   memset( block2b + 9, 0, 24 );
+   block2a[15] = block2b[15] = 80*8; // bit count
+
+   do
+   {
+      // Insert nonce for second block
+      block1a[3] = n;
+      block1b[3] = n+1;
+      sha256_ni2way_final_rounds( block2a, block2b, block1a, block1b,
+                                  mstateb, mstateb, sstate, sstate );
+      sha256_ni2way_transform_le( block2a, block2b, block2a, block2b,
+                                  sha256_iv, sha256_iv );
+      sha256_ni2way_transform_le( hasha, hashb, block2a, block2b,
+                                  sha256_iv, sha256_iv );
+
+      if ( unlikely( bswap_32( hasha[7] ) <= ptarget[7] ) )
+      {
+          casti_m128i( hasha, 0 ) =
+               _mm_shuffle_epi8( casti_m128i( hasha, 0 ), shuf_bswap32 );
+          casti_m128i( hasha, 1 ) =
+               _mm_shuffle_epi8( casti_m128i( hasha, 1 ), shuf_bswap32 );
+          if ( likely( valid_hash( hasha, ptarget ) && !bench ) )
+          {
+             pdata[19] = n;
+             submit_solution( work, hasha, mythr );
+          }
+      }
+      if ( unlikely( bswap_32( hashb[7] ) <= ptarget[7] ) )
+      {
+         casti_m128i( hashb, 0 ) =
+               _mm_shuffle_epi8( casti_m128i( hashb, 0 ), shuf_bswap32 );
+         casti_m128i( hashb, 1 ) =
+               _mm_shuffle_epi8( casti_m128i( hashb, 1 ), shuf_bswap32 );
+         if ( likely( valid_hash( hashb, ptarget ) && !bench ) )
+         {
+            pdata[19] = n+1;
+            submit_solution( work, hashb, mythr );
+         }
+      }
+      n += 2;
+   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
+
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}

 #endif

 #if defined(SHA256T_8WAY)
-
+   
 int scanhash_sha256t_8way( struct work *work, const uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr )
 {
   __m256i  vdata[32]    __attribute__ ((aligned (64)));
   __m256i  block[16]    __attribute__ ((aligned (32)));
   __m256i  hash32[8]    __attribute__ ((aligned (32)));
-   __m256i  initstate[8] __attribute__ ((aligned (32)));
-   __m256i  midstate1[8] __attribute__ ((aligned (32)));
-   __m256i  midstate2[8] __attribute__ ((aligned (32)));
-   __m256i  mexp_pre[16] __attribute__ ((aligned (32)));
+   __m256i  istate[8]    __attribute__ ((aligned (32)));
+   __m256i  mstate1[8]   __attribute__ ((aligned (32)));
+   __m256i  mstate2[8]   __attribute__ ((aligned (32)));
+   __m256i  mexp_pre[8]  __attribute__ ((aligned (32)));
   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
-   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
   uint32_t *pdata = work->data;
   const uint32_t *ptarget = work->target;
-   const uint32_t targ32_d7 = ptarget[7];
   const uint32_t first_nonce = pdata[19];
   const uint32_t last_nonce = max_nonce - 8;
   uint32_t n = first_nonce;
   __m256i *noncev = vdata + 19;
   const int thr_id = mythr->id;
   const bool bench = opt_benchmark;
-   const __m256i last_byte = m256_const1_32( 0x80000000 );
-   const __m256i eight = m256_const1_32( 8 );
+   const __m256i last_byte = _mm256_set1_epi32( 0x80000000 );
+   const __m256i eight = _mm256_set1_epi32( 8 );
+   const __m256i bswap_shuf = mm256_bcast_m128( _mm_set_epi64x(
+                                0x0c0d0e0f08090a0b, 0x0405060700010203 ) );

   for ( int i = 0; i < 19; i++ )
-      vdata[i] = m256_const1_32( pdata[i] );
+      vdata[i] = _mm256_set1_epi32( pdata[i] );

   *noncev = _mm256_set_epi32( n+ 7, n+ 6, n+ 5, n+ 4, n+ 3, n+ 2, n+1, n );

   vdata[16+4] = last_byte;
   memset_zero_256( vdata+16 + 5, 10 );
-   vdata[16+15] = m256_const1_32( 80*8 ); // bit count
+   vdata[16+15] = _mm256_set1_epi32( 80*8 ); // bit count

   block[ 8] = last_byte;
   memset_zero_256( block + 9, 6 );
-   block[15] = m256_const1_32( 32*8 ); // bit count
-   
-   // initialize state
-   initstate[0] = m256_const1_64( 0x6A09E6676A09E667 );
-   initstate[1] = m256_const1_64( 0xBB67AE85BB67AE85 );
-   initstate[2] = m256_const1_64( 0x3C6EF3723C6EF372 );
-   initstate[3] = m256_const1_64( 0xA54FF53AA54FF53A );
-   initstate[4] = m256_const1_64( 0x510E527F510E527F );
-   initstate[5] = m256_const1_64( 0x9B05688C9B05688C );
-   initstate[6] = m256_const1_64( 0x1F83D9AB1F83D9AB );
-   initstate[7] = m256_const1_64( 0x5BE0CD195BE0CD19 );
+   block[15] = _mm256_set1_epi32( 32*8 ); // bit count

-   sha256_8way_transform_le( midstate1, vdata, initstate );
+   // initialize state
+   istate[0] = _mm256_set1_epi64x( 0x6A09E6676A09E667 );
+   istate[1] = _mm256_set1_epi64x( 0xBB67AE85BB67AE85 );
+   istate[2] = _mm256_set1_epi64x( 0x3C6EF3723C6EF372 );
+   istate[3] = _mm256_set1_epi64x( 0xA54FF53AA54FF53A );
+   istate[4] = _mm256_set1_epi64x( 0x510E527F510E527F );
+   istate[5] = _mm256_set1_epi64x( 0x9B05688C9B05688C );
+   istate[6] = _mm256_set1_epi64x( 0x1F83D9AB1F83D9AB );
+   istate[7] = _mm256_set1_epi64x( 0x5BE0CD195BE0CD19 );
+
+   sha256_8way_transform_le( mstate1, vdata, istate );

   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_8way_prehash_3rounds( midstate2, mexp_pre, vdata + 16, midstate1 );
-   
+   sha256_8way_prehash_3rounds( mstate2, mexp_pre, vdata + 16, mstate1 );
+
   do
   {
      // 1. final 16 bytes of data, with padding
-      sha256_8way_final_rounds( block, vdata+16, midstate1, midstate2,
+      sha256_8way_final_rounds( block, vdata+16, mstate1, mstate2,
                                mexp_pre );

      // 2. 32 byte hash from 1.
-      sha256_8way_transform_le( block, block, initstate );
+      sha256_8way_transform_le( block, block, istate );

      // 3. 32 byte hash from 2.
-      if ( unlikely(
-               sha256_8way_transform_le_short( hash32, block, initstate ) ) )
+      if ( unlikely( sha256_8way_transform_le_short(
+                                    hash32, block, istate, ptarget ) ) )
      {
-         // byte swap final hash for testing
-         mm256_block_bswap_32( hash32, hash32 );
-
         for ( int lane = 0; lane < 8; lane++ )
-         if ( hash32_d7[ lane ] <= targ32_d7 )
         {
            extr_lane_8x32( lane_hash, hash32, lane, 256 );
+            casti_m256i( lane_hash, 0 ) =
+             _mm256_shuffle_epi8( casti_m256i( lane_hash, 0 ), bswap_shuf );
            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
            {
               pdata[19] = n + lane;
@@ -188,109 +290,18 @@ int scanhash_sha256t_8way( struct work *work, const uint32_t max_nonce,

 #endif

-
 #if defined(SHA256T_4WAY)

-// Optimizations are slower with AVX/SSE2
-// https://github.com/JayDDee/cpuminer-opt/issues/344
-/*
-int scanhash_sha256t_4way( struct work *work, const uint32_t max_nonce,
-                           uint64_t *hashes_done, struct thr_info *mythr )
-{
-   __m128i  vdata[32]     __attribute__ ((aligned (64)));
-   __m128i  block[16]     __attribute__ ((aligned (32)));
-   __m128i  hash32[8]     __attribute__ ((aligned (32)));
-   __m128i  initstate[8]  __attribute__ ((aligned (32)));
-   __m128i  midstate1[8]  __attribute__ ((aligned (32)));
-   __m128i  midstate2[8]  __attribute__ ((aligned (32)));
-   __m128i  mexp_pre[16]  __attribute__ ((aligned (32)));
-   uint32_t lane_hash[8]  __attribute__ ((aligned (32)));
-   uint32_t *hash32_d7 = (uint32_t*)&( hash32[7] );
-   uint32_t *pdata = work->data;
-   const uint32_t *ptarget = work->target;
-   const uint32_t targ32_d7 = ptarget[7];
-   const uint32_t first_nonce = pdata[19];
-   const uint32_t last_nonce = max_nonce - 4;
-   uint32_t n = first_nonce;
-   __m128i *noncev = vdata + 19;
-   const int thr_id = mythr->id;
-   const bool bench = opt_benchmark;
-   const __m128i last_byte = m128_const1_32( 0x80000000 );
-   const __m128i four = m128_const1_32( 4 );
-
-   for ( int i = 0; i < 19; i++ )
-       vdata[i] = m128_const1_32( pdata[i] );
-
-   *noncev = _mm_set_epi32( n+ 3, n+ 2, n+1, n );
-
-   vdata[16+4] = last_byte;
-   memset_zero_128( vdata+16 + 5, 10 );
-   vdata[16+15] = m128_const1_32( 80*8 ); // bit count
-
-   block[ 8] = last_byte;
-   memset_zero_128( block + 9, 6 );
-   block[15] = m128_const1_32( 32*8 ); // bit count
-   
-   // initialize state
-   initstate[0] = m128_const1_64( 0x6A09E6676A09E667 );
-   initstate[1] = m128_const1_64( 0xBB67AE85BB67AE85 );
-   initstate[2] = m128_const1_64( 0x3C6EF3723C6EF372 );
-   initstate[3] = m128_const1_64( 0xA54FF53AA54FF53A );
-   initstate[4] = m128_const1_64( 0x510E527F510E527F );
-   initstate[5] = m128_const1_64( 0x9B05688C9B05688C );
-   initstate[6] = m128_const1_64( 0x1F83D9AB1F83D9AB );
-   initstate[7] = m128_const1_64( 0x5BE0CD195BE0CD19 );
-
-   // hash first 64 bytes of data
-   sha256_4way_transform_le( midstate1, vdata, initstate );
-
-   // Do 3 rounds on the first 12 bytes of the next block
-   sha256_4way_prehash_3rounds( midstate2, mexp_pre, vdata + 16, midstate1 );
-
-   do
-   {
-      // 1. final 16 bytes of data, with padding
-      sha256_4way_final_rounds( block, vdata+16, midstate1, midstate2,
-                                mexp_pre );
-
-      // 2. 32 byte hash from 1.
-      sha256_4way_transform_le( block, block, initstate );
-
-      // 3. 32 byte hash from 2.
-      if ( unlikely(
-              sha256_4way_transform_le_short( hash32, block, initstate ) ) )
-      {   
-         // byte swap final hash for testing
-         mm128_block_bswap_32( hash32, hash32 );
-
-         for ( int lane = 0; lane < 4; lane++ )
-         if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
-         {
-            extr_lane_4x32( lane_hash, hash32, lane, 256 );
-            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
-            {
-               pdata[19] = n + lane;
-               submit_solution( work, lane_hash, mythr );
-            }
-         }
-      }
-      *noncev = _mm_add_epi32( *noncev, four );
-      n += 4;
-   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
-   pdata[19] = n;
-   *hashes_done = n - first_nonce;
-   return 0;
-}
-*/
-
 int scanhash_sha256t_4way( struct work *work, const uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr )
 {
   __m128i  vdata[32]    __attribute__ ((aligned (64)));
   __m128i  block[16]    __attribute__ ((aligned (32)));
   __m128i  hash32[8]    __attribute__ ((aligned (32)));
-   __m128i  initstate[8] __attribute__ ((aligned (32)));
-   __m128i  midstate[8]  __attribute__ ((aligned (32)));
+   __m128i  istate[8]    __attribute__ ((aligned (32)));
+   __m128i  mstate[8]   __attribute__ ((aligned (32)));
+//   __m128i  mstate2[8]   __attribute__ ((aligned (32)));
+//   __m128i  mexp_pre[8]  __attribute__ ((aligned (32)));
   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
   uint32_t *hash32_d7 =  (uint32_t*)&( hash32[7] );
   uint32_t *pdata = work->data;
@@ -302,52 +313,61 @@ int scanhash_sha256t_4way( struct work *work, const uint32_t max_nonce,
   __m128i *noncev = vdata + 19;
   const int thr_id = mythr->id;
   const bool bench = opt_benchmark;
-   const __m128i last_byte = m128_const1_32( 0x80000000 );
-   const __m128i four = m128_const1_32( 4 );
+   const __m128i last_byte = _mm_set1_epi32( 0x80000000 );
+   const __m128i four = _mm_set1_epi32( 4 );

   for ( int i = 0; i < 19; i++ )
-       vdata[i] = m128_const1_32( pdata[i] );
+       vdata[i] = _mm_set1_epi32( pdata[i] );

   *noncev = _mm_set_epi32( n+ 3, n+ 2, n+1, n );

   vdata[16+4] = last_byte;
   memset_zero_128( vdata+16 + 5, 10 );
-   vdata[16+15] = m128_const1_32( 80*8 ); // bit count
+   vdata[16+15] = _mm_set1_epi32( 80*8 ); // bit count

   block[ 8] = last_byte;
   memset_zero_128( block + 9, 6 );
-   block[15] = m128_const1_32( 32*8 ); // bit count
+   block[15] = _mm_set1_epi32( 32*8 ); // bit count
   
   // initialize state
-   initstate[0] = m128_const1_64( 0x6A09E6676A09E667 );
-   initstate[1] = m128_const1_64( 0xBB67AE85BB67AE85 );
-   initstate[2] = m128_const1_64( 0x3C6EF3723C6EF372 );
-   initstate[3] = m128_const1_64( 0xA54FF53AA54FF53A );
-   initstate[4] = m128_const1_64( 0x510E527F510E527F );
-   initstate[5] = m128_const1_64( 0x9B05688C9B05688C );
-   initstate[6] = m128_const1_64( 0x1F83D9AB1F83D9AB );
-   initstate[7] = m128_const1_64( 0x5BE0CD195BE0CD19 );
+   istate[0] = _mm_set1_epi64x( 0x6A09E6676A09E667 );
+   istate[1] = _mm_set1_epi64x( 0xBB67AE85BB67AE85 );
+   istate[2] = _mm_set1_epi64x( 0x3C6EF3723C6EF372 );
+   istate[3] = _mm_set1_epi64x( 0xA54FF53AA54FF53A );
+   istate[4] = _mm_set1_epi64x( 0x510E527F510E527F );
+   istate[5] = _mm_set1_epi64x( 0x9B05688C9B05688C );
+   istate[6] = _mm_set1_epi64x( 0x1F83D9AB1F83D9AB );
+   istate[7] = _mm_set1_epi64x( 0x5BE0CD195BE0CD19 );

   // hash first 64 bytes of data
-   sha256_4way_transform_le( midstate, vdata, initstate );
+   sha256_4way_transform_le( mstate, vdata, istate );
+
+//   sha256_4way_prehash_3rounds( mstate2, mexp_pre, vdata + 16, mstate1 );

   do
   {
-      sha256_4way_transform_le( block,  vdata+16, midstate  );
-      sha256_4way_transform_le( block,  block,    initstate );
-      sha256_4way_transform_le( hash32, block,    initstate );
-      mm128_block_bswap_32( hash32, hash32 );
+//      sha256_4way_final_rounds( block, vdata+16, mstate1, mstate2,
+//                                mexp_pre );
+   
+      sha256_4way_transform_le( block,  vdata+16, mstate  );
+      sha256_4way_transform_le( block,  block, istate );
+      sha256_4way_transform_le( hash32, block, istate );

-      for ( int lane = 0; lane < 4; lane++ )
-      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
-      {
-         extr_lane_4x32( lane_hash, hash32, lane, 256 );
-         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+//      if ( unlikely( sha256_4way_transform_le_short(
+//                                  hash32, block, initstate, ptarget ) ))
+//      {
+         mm128_block_bswap_32( hash32, hash32 );
+         for ( int lane = 0; lane < 4; lane++ )
+         if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
         {
-            pdata[19] = n + lane;
-            submit_solution( work, lane_hash, mythr );
+            extr_lane_4x32( lane_hash, hash32, lane, 256 );
+            if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+            {
+               pdata[19] = n + lane;
+               submit_solution( work, lane_hash, mythr );
+            }
         }
-       }
+//       }
       *noncev = _mm_add_epi32( *noncev, four );
       n += 4;
   } while ( (n < last_nonce) && !work_restart[thr_id].restart );
@@ -356,6 +376,5 @@ int scanhash_sha256t_4way( struct work *work, const uint32_t max_nonce,
   return 0;
 }

-
 #endif

--- a/algo/sha/sha256t-gate.c
+++ b/algo/sha/sha256t-gate.c
@@ -5,9 +5,9 @@ bool register_sha256t_algo( algo_gate_t* gate )
    gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
 #if defined(SHA256T_16WAY)
    gate->scanhash   = (void*)&scanhash_sha256t_16way;
-#elif defined(__SHA__)
+#elif defined(SHA256T_SHA)
    gate->optimizations = SHA_OPT;
-    gate->scanhash   = (void*)&scanhash_sha256t;
+    gate->scanhash   = (void*)&scanhash_sha256t_sha;
 #elif defined(SHA256T_8WAY)
    gate->scanhash   = (void*)&scanhash_sha256t_8way;
 #else
@@ -22,7 +22,7 @@ bool register_sha256q_algo( algo_gate_t* gate )
 #if defined(SHA256T_16WAY)
    gate->scanhash   = (void*)&scanhash_sha256q_16way;
    gate->hash       = (void*)&sha256q_16way_hash;
-#elif defined(__SHA__)
+#elif defined(SHA256T_SHA)
    gate->optimizations = SHA_OPT;
    gate->scanhash   = (void*)&scanhash_sha256q;
    gate->hash       = (void*)&sha256q_hash;
--- a/algo/sha/sha256t-gate.h
+++ b/algo/sha/sha256t-gate.h
@@ -6,6 +6,8 @@

 #if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
  #define SHA256T_16WAY 1
+#elif defined(__SHA__)
+  #define SHA256T_SHA 1
 #elif defined(__AVX2__)
  #define SHA256T_8WAY 1
 #else
@@ -42,9 +44,9 @@ int scanhash_sha256q_4way( struct work *work, uint32_t max_nonce,
                           uint64_t *hashes_done, struct thr_info *mythr );
 #endif

-#if defined(__SHA__)
+#if defined(SHA256T_SHA)

-int scanhash_sha256t( struct work *work, uint32_t max_nonce,
+int scanhash_sha256t_sha( struct work *work, uint32_t max_nonce,
                      uint64_t *hashes_done, struct thr_info *mythr );

 #endif
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jay D Dee	be88afc349	v3.23.2	2023-09-21 12:34:06 -04:00
Jay D Dee	d6b5750362	v3.23.1	2023-09-13 11:48:52 -04:00
Jay D Dee	4378d2f841	v3.23.0	2023-08-30 20:15:48 -04:00