v3.10.3

v3.10.2
v3.10.1
2025-09-17 23:44:27 +00:00 · 2019-12-14 01:01:54 -05:00 · 2019-12-09 15:59:02 -05:00 · 2019-12-05 19:09:23 -05:00 · 2019-12-03 12:26:11 -05:00 · 2019-11-26 09:22:03 -05:00
273 changed files with 34189 additions and 12210 deletions
--- a/81
+++ b/81
@@ -1,12 +1,14 @@


-Requirements:
+1. Requirements:
+---------------

 Intel Core2 or newer, or AMD Steamroller or newer CPU. ARM CPUs are not
 supported.
 64 bit Linux operating system. Apple is not supported.

-Building on linux prerequisites:
+2. Building on linux prerequisites:
+-----------------------------------

 It is assumed users know how to install packages on their system and
 be able to compile standard source packages. This is basic Linux and
@@ -20,49 +22,74 @@ http://askubuntu.com/questions/457526/how-to-install-cpuminer-in-ubuntu

 Install any additional dependencies needed by cpuminer-opt. The list below
 are some of the ones that may not be in the default install and need to
-be installed manually. There may be others, read the error messages they
-will give a clue as to the missing package.
+be installed manually. There may be others, read the compiler error messages,
+they will give a clue as to the missing package.

 The following command should install everything you need on Debian based
-distributions such as Ubuntu:
+distributions such as Ubuntu. Fedora and other distributions may have similar
+but different package names. 

-sudo apt-get install build-essential libssl-dev libcurl4-openssl-dev libjansson-dev libgmp-dev automake zlib1g-dev
-
-build-essential  (Development Tools package group on Fedora)
-automake
-libjansson-dev
-libgmp-dev
-libcurl4-openssl-dev
-libssl-dev
-lib-thread
-zlib1g-dev
+$ sudo apt-get install build-essential automake libssl-dev libcurl4-openssl-dev libjansson-dev libgmp-dev zlib1g-dev git

 SHA support on AMD Ryzen CPUs requires gcc version 5 or higher and
-openssl 1.1.0e or higher. Add one of the following, depending on the
-compiler version, to CFLAGS:
-"-march=native" or "-march=znver1" or "-msha".
+openssl 1.1.0e or higher. Add one of the following to CFLAGS for SHA
+support depending on your CPU and compiler version:
+
+"-march=native" is always the best choice
+
+"-march=znver1" for Ryzen 1000 & 2000 series, znver2 for 3000.
+
+"-msha"  Add SHA to other tuning options

 Additional instructions for static compilalation can be found here:
 https://lxadm.com/Static_compilation_of_cpuminer
 Static builds should only considered in a homogeneous HW and SW environment.
 Local builds will always have the best performance and compatibility.

-Extract cpuminer source.
+3. Download cpuminer-opt
+------------------------

-tar xvzf cpuminer-opt-x.y.z.tar.gz
-cd cpuminer-opt-x.y.z
+Download the source code for the latest realease from the official repository.

-Run ./build.sh to build on Linux or execute the following commands.
+https://github.com/JayDDee/cpuminer-opt/releases

-./autogen.sh
-CFLAGS="-O3 -march=native -Wall" ./configure --with-curl
-make
+Extract the source code.

-Start mining.
+$ tar xvzf cpuminer-opt-x.y.z.tar.gz
+
+
+Alternatively it can be cloned from git.
+
+$ git clone https://github.com/JayDDee/cpuminer-opt.git
+ 
+4. Build cpuminer-opt
+---------------------
+
+It is recomended to Build with default options, this will usuallly
+produce the best results.
+
+$ ./build.sh to build on Linux or execute the following commands.
+
+or 
+
+$ ./autogen.sh
+$ CFLAGS="-O3 -march=native -Wall" ./configure --with-curl
+$ make -j n
+
+n is the number of threads.
+
+5. Start mining.
+----------------
+
+$ ./cpuminer -a algo -o url -u username -p password

-./cpuminer -a algo -o url -u username -p password

 Windows
+-------
+
+See also INSTAL_WINDOWS
+
+The following procedure is obsolete and uses an old compiler.

 Precompiled Windows binaries are built on a Linux host using Mingw
 with a more recent compiler than the following Windows hosted procedure.
--- a/5
+++ b/5
@@ -22,14 +22,13 @@ Step by step...

 Refer to Linux compile instructions and install required packages.

-Additionally, install mingw-64.
+Additionally, install mingw-w64.

 sudo apt-get install mingw-w64


 2. Create a local library directory for packages to be compiled in the next
-   step. Recommended location is $HOME/usr/lib/
-
+   step. Suggested location is $HOME/usr/lib/

 3. Download and build other packages for mingw that don't have a mingw64
   version available in the repositories.
--- a/Makefile.am
+++ b/Makefile.am
@@ -18,7 +18,6 @@ dist_man_MANS	= cpuminer.1
 cpuminer_SOURCES = \
  cpu-miner.c \
  util.c \
-  uint256.cpp \
  api.c \
  sysinfos.c \
  algo-gate-api.c\
@@ -51,12 +50,15 @@ cpuminer_SOURCES = \
  algo/blake/blake.c \
  algo/blake/blake-4way.c \
  algo/blake/sph_blake2b.c \
-  algo/blake/blake2b.c \
  algo/blake/sph-blake2s.c \
  algo/blake/blake2s-hash-4way.c \
  algo/blake/blake2s.c \
  algo/blake/blake2s-gate.c \
  algo/blake/blake2s-4way.c \
+  algo/blake/blake2b-hash-4way.c \
+  algo/blake/blake2b.c \
+  algo/blake/blake2b-gate.c \
+  algo/blake/blake2b-4way.c \
  algo/blake/blakecoin-gate.c \
  algo/blake/mod_blakecoin.c \
  algo/blake/blakecoin.c \
@@ -71,6 +73,9 @@ cpuminer_SOURCES = \
  algo/bmw/bmw256-hash-4way.c \
  algo/bmw/bmw512-hash-4way.c \
  algo/bmw/bmw256.c \
+  algo/bmw/bmw512-gate.c \
+  algo/bmw/bmw512.c \
+  algo/bmw/bmw512-4way.c \
  algo/cryptonight/cryptolight.c \
  algo/cryptonight/cryptonight-common.c\
  algo/cryptonight/cryptonight-aesni.c\
@@ -112,12 +117,14 @@ cpuminer_SOURCES = \
  algo/keccak/keccak-4way.c\
  algo/keccak/keccak-gate.c \
  algo/keccak/sse2/keccak.c \
+  algo/lanehash/lane.c \
  algo/luffa/sph_luffa.c \
  algo/luffa/luffa.c \
  algo/luffa/luffa_for_sse2.c \
  algo/luffa/luffa-hash-2way.c \
  algo/lyra2/lyra2.c \
  algo/lyra2/sponge.c \
+  algo/lyra2/sponge-2way.c \
  algo/lyra2/lyra2-gate.c \
  algo/lyra2/lyra2rev2.c \
  algo/lyra2/lyra2rev2-4way.c \
@@ -166,8 +173,8 @@ cpuminer_SOURCES = \
  algo/scryptjane/scrypt-jane.c \
  algo/sha/sph_sha2.c \
  algo/sha/sph_sha2big.c \
-  algo/sha/sha2-hash-4way.c \
-  algo/sha/sha256_hash_11way.c \
+  algo/sha/sha256-hash-4way.c \
+  algo/sha/sha512-hash-4way.c \
  algo/sha/sha2.c \
  algo/sha/sha256t-gate.c \
  algo/sha/sha256t-4way.c \
@@ -191,9 +198,9 @@ cpuminer_SOURCES = \
  algo/skein/skein-gate.c \
  algo/skein/skein2.c \
  algo/skein/skein2-4way.c \
-  algo/skein/skein2-gate.c \
  algo/sm3/sm3.c \
  algo/sm3/sm3-hash-4way.c \
+  algo/swifftx/swifftx.c \
  algo/tiger/sph_tiger.c \
  algo/whirlpool/sph_whirlpool.c \
  algo/whirlpool/whirlpool-hash-4way.c \
@@ -238,6 +245,8 @@ cpuminer_SOURCES = \
  algo/x13/skunk-4way.c \
  algo/x13/skunk.c \
  algo/x13/drop.c \
+  algo/x13/x13bcd-4way.c \
+  algo/x13/x13bcd.c \
  algo/x14/x14-gate.c \
  algo/x14/x14.c \
  algo/x14/x14-4way.c \
@@ -254,6 +263,13 @@ cpuminer_SOURCES = \
  algo/x16/x16r-gate.c \
  algo/x16/x16r.c \
  algo/x16/x16r-4way.c \
+  algo/x16/x16rv2.c \
+  algo/x16/x16rv2-4way.c \
+  algo/x16/x16rt.c \
+  algo/x16/x16rt-4way.c \
+  algo/x16/hex.c \
+  algo/x16/x21s-4way.c \
+  algo/x16/x21s.c \
  algo/x17/x17-gate.c \
  algo/x17/x17.c \
  algo/x17/x17-4way.c \
@@ -264,10 +280,17 @@ cpuminer_SOURCES = \
  algo/x17/sonoa-4way.c \
  algo/x17/sonoa.c \
  algo/x20/x20r.c \
+  algo/x22/x22i-4way.c \
+  algo/x22/x22i.c \
+  algo/x22/x22i-gate.c \
+  algo/x22/x25x.c \
+  algo/x22/x25x-4way.c \
  algo/yescrypt/yescrypt.c \
  algo/yescrypt/sha256_Y.c \
  algo/yescrypt/yescrypt-best.c \
-  algo/yespower/yespower.c \
+  algo/yespower/yespower-gate.c \
+  algo/yespower/yespower-blake2b.c \
+  algo/yespower/crypto/blake2b-yp.c \
  algo/yespower/sha256_p.c \
  algo/yespower/yespower-opt.c

--- a/README.md
+++ b/README.md
@@ -24,7 +24,7 @@ Requirements

 1. A x86_64 architecture CPU with a minimum of SSE2 support. This includes
 Intel Core2 and newer and AMD equivalents. In order to take advantage of AES_NI
-optimizations a CPU with AES_NI is required. This includes Intel Westbridge
+optimizations a CPU with AES_NI is required. This includes Intel Westmere
 and newer and AMD equivalents. Further optimizations are available on some
 algoritms for CPUs with AVX and AVX2, Sandybridge and Haswell respectively.

@@ -55,9 +55,11 @@ Supported Algorithms
                          axiom         Shabal-256 MemoHash
                          bastion
                          blake         Blake-256 (SFR)
-                          blakecoin     blake256r8
+                          blake2b       Blake2b 256
                          blake2s       Blake-2 S
+                          blakecoin     blake256r8
                          bmw           BMW 256
+                          bmw512        BMW 512
                          c11           Chaincoin
                          decred
                          deep          Deepcoin (DCN)
@@ -66,6 +68,7 @@ Supported Algorithms
                          fresh         Fresh
                          groestl       Groestl coin
                          heavy         Heavy
+                          hex           x16r-hex
                          hmq1725       Espers
                          hodl          Hodlcoin
                          jha           Jackpotcoin
@@ -84,10 +87,12 @@ Supported Algorithms
                          neoscrypt     NeoScrypt(128, 2, 1)
                          nist5         Nist5
                          pentablake    Pentablake
-                          phi1612       phi, LUX coin (original algo)
-                          phi2          LUX coin (new algo)
+                          phi1612       phi
+                          phi2          Luxcoin (LUX)
+                          phi2-lux      identical to phi2
                          pluck         Pluck:128 (Supcoin)
                          polytimos     Ninja
+                          power2b       MicroBitcoin (MBC)
                          quark         Quark
                          qubit         Qubit
                          scrypt        scrypt(1024, 1, 1) (default)
@@ -113,12 +118,19 @@ Supported Algorithms
                          x11gost       sib (SibCoin)
                          x12           Galaxie Cash (GCH)
                          x13           X13
+                          x13bcd        bcd
                          x13sm3        hsr (Hshare)
                          x14           X14
                          x15           X15
-                          x16r          Ravencoin (RVN)
-                          x16s          pigeoncoin (PGN)
+                          x16r          
+                          x16rv2        Ravencoin (RVN)
+                          x16rt         Gincoin (GIN)
+                          x16rt-veil    Veil (VEIL)
+                          x16s          
                          x17
+                          x21s          Pigeoncoin (PGN)
+                          x22i          
+                          x25x          Sinovative (SIN)
                          xevan         Bitsend (BSD)
                          yescrypt      Globalboost-Y (BSTY)
                          yescryptr8    BitZeny (ZNY)
@@ -126,11 +138,15 @@ Supported Algorithms
                          yescryptr32   WAVI
                          yespower      Cryply
                          yespowerr16   Yenten (YTN)
+                          yespower-b2b  generic yespower + blake2b
                          zr5           Ziftr

 Errata
 ------

+Old algorithms that are no longer used frequently will not have the latest
+optimizations.
+
 Cryptonight and variants are no longer supported, use another miner.

 Neoscrypt crashes on Windows, use legacy version.
@@ -148,14 +164,17 @@ Benchmark testing does not work for x11evo.
 Bugs
 ----

-Users are encouraged to post their bug reports on the Bitcoin Talk
-forum at:
+Users are encouraged to post their bug reports using git issues or on the
+Bitcoin Talk forum or opening an issue in git:

 https://bitcointalk.org/index.php?topic=1326803.0

-All problem reports must be accompanied by a proper definition.
+https://github.com/JayDDee/cpuminer-opt/issues
+
+All problem reports must be accompanied by a proper problem definition.
 This should include how the problem occurred, the command line and
-output from the miner showing the startup and any errors.
+output from the miner showing the startup messages and any errors.
+A history is also useful, ie did it work before.

 Donations
 ---------
@@ -163,10 +182,6 @@ Donations
 cpuminer-opt has no fees of any kind but donations are accepted.

 BTC: 12tdvfF7KmAsihBXQXynT6E6th2c2pByTT
- ETH: 0x72122edabcae9d3f57eab0729305a425f6fef6d0
- LTC: LdUwoHJnux9r9EKqFWNvAi45kQompHk6e8
- BCH: 1QKYkB6atn4P7RFozyziAXLEnurwnUM1cQ
- BTG: GVUyECtRHeC5D58z9F3nGGfVQndwnsPnHQ

 Happy mining!

--- a/README.txt
+++ b/README.txt
@@ -15,20 +15,29 @@ the features listed at cpuminer startup to ensure you are mining at
 optimum speed using the best available features.

 Architecture names and compile options used are only provided for Intel
-Core series. Even the newest Pentium and Celeron CPUs are often missing
-features.
+Core series. Budget CPUs like Pentium and Celeron are often missing the
+latest features.

 AMD CPUs older than Piledriver, including Athlon x2 and Phenom II x4, are not
 supported by cpuminer-opt due to an incompatible implementation of SSE2 on
 these CPUs. Some algos may crash the miner with an invalid instruction.
 Users are recommended to use an unoptimized miner such as cpuminer-multi.

+More information for Intel and AMD CPU architectures and their features
+can be found on Wikipedia.
+
+https://en.wikipedia.org/wiki/List_of_Intel_CPU_microarchitectures
+
+https://en.wikipedia.org/wiki/List_of_AMD_CPU_microarchitectures
+
+
 Exe name                Compile flags            Arch name

 cpuminer-sse2.exe      "-msse2"                  Core2, Nehalem   
 cpuminer-aes-sse42.exe "-march=westmere"         Westmere
-cpuminer-avx.exe       "-march=corei7-avx"       Sandy-Ivybridge
-cpuminer-avx2.exe      "-march=core-avx2"        Haswell, Sky-Kaby-Coffeelake
+cpuminer-avx.exe       "-march=corei7-avx"       Sandybridge
+cpuminer-avx2.exe      "-march=core-avx2 -maes"  Haswell, Skylake, Coffeelake
+cpuminer-avx512.exe    "-march=skylake-avx512"   Skylake-X, Cascadelake-X
 cpuminer-zen           "-march=znver1"           AMD Ryzen, Threadripper

 If you like this software feel free to donate:
--- a/153
+++ b/153
@@ -1,14 +1,6 @@
 cpuminer-opt is a console program run from the command line using the
 keyboard, not the mouse.

-cpuminer-opt now supports HW SHA acceleration available on AMD Ryzen CPUs.
-This feature requires recent SW including GCC version 5 or higher and
-openssl version 1.1 or higher. It may also require using "-march=znver1"
-compile flag.
-
-cpuminer-opt is a console program, if you're using a mouse you're doing it
-wrong.
-
 Security warning
 ----------------

@@ -33,11 +25,154 @@ Requirements
 Intel Core2 or newer, or AMD Steamroller or newer CPU. ARM CPUs are not
 supported.

-64 bit Linux or Windows operating system. Apple and Android are not supported.
+64 bit Linux or Windows operating system. Apple, Android and Rpi are
+not supported. FreeBSD YMMV.

 Change Log
 ----------

+v3.10.3
+
+AVX512 for x12, x13, x14, x15.
+Fixed x12 AVX2 invalid shares.
+
+v.10.2
+
+AVX512 added for bmw512, c11, phi1612 (phi), qubit, skunk, x11, x11gost (sib).
+Fixed c11 AVX2 invalid shares.
+
+v3.10.1
+
+AVX512 for blake2b, nist5, quark, tribus.
+
+More broken lane fixes, fixed buffer overflow in skein AVX512, fixed
+quark invalid shares AVX2.
+
+Only the highest ranking feature in a class is listed at startup, lower ranking
+features are available but no longer listed.
+
+v3.10.0
+
+AVX512 is now supported on selected algos, Windows binary is now available.
+AVX512 optimizations are available for argon2d, blake2s, keccak, keccakc,
+skein & skein2.
+
+Fixed CPU temperature for some CPU models (Linux only).
+
+Fixed a bug that caused some lanes not to submit shares.
+
+Fixed some previously undetected buffer overflows.
+
+Lyra2rev2 3% faster SSE2 and AVX2.
+
+Added "-fno-asynchronous-unwind-tables" to AVX512 build script for Windows
+to fix known mingw issue.
+
+Changed AVX2 build script to explicitly add AES to address change in
+behaviour in GCC 9. 
+
+v3.9.11
+
+Added x22i & x25x algos.
+Blake2s 2% faster AVX2 with Intel CPU, slower with Ryzen v1, v2 ?
+
+v3.9.10
+
+Faster X* algos with AVX2.
+Small improvements to summary stats report.
+
+v3.9.9.1
+
+Fixed a day1 bug that could cause the miner to idle for up to 2 minutes
+under certain circumstances.
+
+Redesigned summary stats report now includes session statistics.
+
+More robust handling of statistics to reduce corruption.
+
+Removed --hide-diff option.
+
+Better handling of cpu-affinity with more than 64 CPUs.
+
+v3.9.9
+
+Added power2b algo for MicroBitcoin.
+Added generic yespower-b2b (yespower + blake2b) algo to be used with
+the parameters introduced in v3.9.7 for yespower & yescrypt.
+Display additional info when a share is rejected.
+Some low level enhancements and minor tweaking of log output.
+RELEASE_NOTES (this file) and README.md  added to Windows release package.
+
+v3.9.8.1
+
+Summary log report will be generated on stratum diff change or after 5 minutes,
+whichever comes first, to prevent incorrect data in the report.
+
+Removed phi2-lux alias (introduced in v3.9.8) due to Luxcoin's planned fork
+to a new algo. The new Luxcoin algo is not supported by cpuminer-opt.
+Until the fork Luxcoin can be mined using phi2 algo.
+
+--hide-diff option is deprecated and has no effect. It will be removed in a
+future release.
+
+v3.9.8
+
+Changes to log output to provide data more relevant to actual mining
+performance.
+phi2 can now handle pools with a mix of coins that use and don't use roots.
+phi2-lux added as an alias for phi2 as they are identical except for roots.
+Add x16rv2 algo for Ravencoin fork.
+
+v3.9.7
+
+Command line option changes:
+
+"-R" is no longer used as a shortcut for "--retry-pause", users must
+use the long option.
+
+New options:
+
+-N, --param-n: set the N parameter for yescrypt, yespower or scrypt algos
+-R, --param-r: set the R parameter for yescrypt or yespower algos, scrypt is
+     hardcoded with R=1
+-K, --param-key: set the client key/pers parameter for yescrypt/yespower algos.
+
+These options can be used to mine yescrypt or yespower variations using
+the generic yescrypt or yespower algo name and specifying the parameters
+manually. They can even be used to mine variations that aren't formally
+supported by a unique algo name. Existing algos can continue to to be mined
+using their original name without parameters.
+
+v3.9.6.2
+
+New algo blake2b.
+Faster myr-gr on Ryzen using SHA.
+Faster blake2s SSE2.
+Small speedup of around 1% for several other algos.
+
+v3.9.6.1
+
+New algos: x21s, hex (alias x16r-hex).
+
+v3.9.6
+
+New algos: bmw512, x16rt, x16rt-veil (alias veil), x13bcd (alias bcd).
+
+v3.9.5.4
+
+Fixed sha256q AVX2 poor performance.
+Fixed skein2 buffer overflow and restored bswap-interleave optimization.
+More restructuring.
+
+v3.9.5.3
+
+Fix crash mining hodl with aes-sse42.
+More restructuring and share report tweaks.
+
+v3.9.5.2
+
+Revert bswap-interleave optimization for causing crashes on Windows.
+
 v3.9.5.1

 Fixed skein2 crash on Windows.
--- a/algo-gate-api.c
+++ b/algo-gate-api.c
@@ -116,13 +116,10 @@ void init_algo_gate( algo_gate_t* gate )
   gate->get_nonceptr            = (void*)&std_get_nonceptr;
   gate->work_decode             = (void*)&std_le_work_decode;
   gate->decode_extra_data       = (void*)&do_nothing;
-   gate->wait_for_diff           = (void*)&std_wait_for_diff;
-   gate->get_max64               = (void*)&get_max64_0x1fffffLL;
   gate->gen_merkle_root         = (void*)&sha256d_gen_merkle_root;
   gate->stratum_gen_work        = (void*)&std_stratum_gen_work;
   gate->build_stratum_request   = (void*)&std_le_build_stratum_request;
   gate->malloc_txs_request      = (void*)&std_malloc_txs_request;
-   gate->set_target              = (void*)&std_set_target;
   gate->submit_getwork_result   = (void*)&std_le_submit_getwork_result;
   gate->build_block_header      = (void*)&std_build_block_header;
   gate->build_extraheader       = (void*)&std_build_extraheader;
@@ -167,9 +164,10 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
    case ALGO_AXIOM:         register_axiom_algo         ( gate ); break;
    case ALGO_BASTION:       register_bastion_algo       ( gate ); break;
    case ALGO_BLAKE:         register_blake_algo         ( gate ); break;
-    case ALGO_BLAKECOIN:     register_blakecoin_algo     ( gate ); break;
-//    case ALGO_BLAKE2B:      register_blake2b_algo     ( gate ); break;
+    case ALGO_BLAKE2B:       register_blake2b_algo       ( gate ); break;
    case ALGO_BLAKE2S:       register_blake2s_algo       ( gate ); break;
+    case ALGO_BLAKECOIN:     register_blakecoin_algo     ( gate ); break;
+    case ALGO_BMW512:        register_bmw512_algo        ( gate ); break;
    case ALGO_C11:           register_c11_algo           ( gate ); break;
    case ALGO_CRYPTOLIGHT:   register_cryptolight_algo   ( gate ); break;
    case ALGO_CRYPTONIGHT:   register_cryptonight_algo   ( gate ); break;
@@ -181,6 +179,7 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
    case ALGO_FRESH:         register_fresh_algo         ( gate ); break;
    case ALGO_GROESTL:       register_groestl_algo       ( gate ); break;
    case ALGO_HEAVY:         register_heavy_algo         ( gate ); break;
+    case ALGO_HEX:           register_hex_algo           ( gate ); break;
    case ALGO_HMQ1725:       register_hmq1725_algo       ( gate ); break;
    case ALGO_HODL:          register_hodl_algo          ( gate ); break;
    case ALGO_JHA:           register_jha_algo           ( gate ); break;
@@ -203,6 +202,7 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
    case ALGO_PHI2:          register_phi2_algo          ( gate ); break;
    case ALGO_PLUCK:         register_pluck_algo         ( gate ); break;
    case ALGO_POLYTIMOS:     register_polytimos_algo     ( gate ); break;
+    case ALGO_POWER2B:       register_power2b_algo       ( gate ); break;
    case ALGO_QUARK:         register_quark_algo         ( gate ); break;
    case ALGO_QUBIT:         register_qubit_algo         ( gate ); break;
    case ALGO_SCRYPT:        register_scrypt_algo        ( gate ); break;
@@ -227,12 +227,19 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
    case ALGO_X11GOST:       register_x11gost_algo       ( gate ); break;
    case ALGO_X12:           register_x12_algo           ( gate ); break;
    case ALGO_X13:           register_x13_algo           ( gate ); break;
+    case ALGO_X13BCD:        register_x13bcd_algo        ( gate ); break;
    case ALGO_X13SM3:        register_x13sm3_algo        ( gate ); break;
    case ALGO_X14:           register_x14_algo           ( gate ); break;
    case ALGO_X15:           register_x15_algo           ( gate ); break;
    case ALGO_X16R:          register_x16r_algo          ( gate ); break;
+    case ALGO_X16RV2:        register_x16rv2_algo        ( gate ); break;
+    case ALGO_X16RT:         register_x16rt_algo         ( gate ); break;
+    case ALGO_X16RT_VEIL:    register_x16rt_veil_algo    ( gate ); break;
    case ALGO_X16S:          register_x16s_algo          ( gate ); break;
    case ALGO_X17:           register_x17_algo           ( gate ); break;
+    case ALGO_X21S:          register_x21s_algo          ( gate ); break;
+    case ALGO_X22I:          register_x22i_algo          ( gate ); break;
+    case ALGO_X25X:          register_x25x_algo          ( gate ); break;
    case ALGO_XEVAN:         register_xevan_algo         ( gate ); break;
 /*    case ALGO_YESCRYPT:     register_yescrypt_05_algo     ( gate ); break;
     case ALGO_YESCRYPTR8:   register_yescryptr8_05_algo   ( gate ); break;
@@ -245,6 +252,7 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
    case ALGO_YESCRYPTR32:   register_yescryptr32_algo   ( gate ); break;
    case ALGO_YESPOWER:      register_yespower_algo      ( gate ); break;
    case ALGO_YESPOWERR16:   register_yespowerr16_algo   ( gate ); break;
+    case ALGO_YESPOWER_B2B:  register_yespower_b2b_algo  ( gate ); break;
    case ALGO_ZR5:           register_zr5_algo           ( gate ); break;
   default:
      applog(LOG_ERR,"FAIL: algo_gate registration failed, unknown algo %s.\n", algo_names[opt_algo] );
@@ -270,7 +278,7 @@ bool register_json_rpc2( algo_gate_t *gate )
  applog(LOG_WARNING,"supported by cpuminer-opt. Shares submitted will");
  applog(LOG_WARNING,"likely be rejected. Proceed at your own risk.\n");

-  gate->wait_for_diff           = (void*)&do_nothing;
+//  gate->wait_for_diff           = (void*)&do_nothing;
  gate->get_new_work            = (void*)&jr2_get_new_work;
  gate->get_nonceptr            = (void*)&jr2_get_nonceptr;
  gate->stratum_gen_work        = (void*)&jr2_stratum_gen_work;
@@ -327,19 +335,16 @@ const char* const algo_alias_map[][2] =
  { "lyra2",             "lyra2re"      },
  { "lyra2v2",           "lyra2rev2"    },
  { "lyra2v3",           "lyra2rev3"    },
-  { "lyra2zoin",         "lyra2z330"    },
  { "myrgr",             "myr-gr"       },
  { "myriad",            "myr-gr"       },
  { "neo",               "neoscrypt"    },
  { "phi",               "phi1612"      },
-//  { "sia",               "blake2b"      },
  { "sib",               "x11gost"      },
  { "timetravel8",       "timetravel"   },
-  { "ziftr",             "zr5"          },
+  { "veil",              "x16rt-veil"   },
+  { "x16r-hex",          "hex"          },
  { "yenten",            "yescryptr16"  },
-  { "yescryptr8k",       "yescrypt"     },
-  { "zcoin",             "lyra2z"       },
-  { "zoin",              "lyra2z330"    },
+  { "ziftr",             "zr5"          },
  { NULL,                NULL           }   
 };

@@ -361,40 +366,3 @@ void get_algo_alias( char** algo_or_alias )
 #undef ALIAS
 #undef PROPER

-bool submit_solution( struct work *work, void *hash,
-                      struct thr_info *thr )
-{
-     work_set_target_ratio( work, hash );
-     if ( submit_work( thr, work ) )
-     {
-         if ( !opt_quiet )
-            applog( LOG_BLUE, "Share %d submitted by thread %d, job %s.",
-                    accepted_share_count + rejected_share_count + 1,
-                    thr->id, work->job_id );
-         return true;
-     }
-     else
-          applog( LOG_WARNING, "Failed to submit share." );
-     return false;
-}
-
-bool submit_lane_solution( struct work *work, void *hash,
-                           struct thr_info *thr, int lane )
-{
-     work_set_target_ratio( work, hash );
-     if ( submit_work( thr, work ) )
-     {
-         if ( !opt_quiet )
-//            applog( LOG_BLUE, "Share %d submitted by thread %d, lane %d.",
-//                    accepted_share_count + rejected_share_count + 1,
-//                    thr->id, lane );
-            applog( LOG_BLUE, "Share %d submitted by thread %d, lane %d, job %s.",
-                    accepted_share_count + rejected_share_count + 1, thr->id,
-                    lane, work->job_id );
-         return true;
-     }
-     else
-          applog( LOG_WARNING, "Failed to submit share." );
-     return false;
-}
-
--- a/algo-gate-api.h
+++ b/algo-gate-api.h
@@ -35,7 +35,7 @@
 //    6. Determine if other non existant functions are required.
 //    That is determined by the need to add code in cpu-miner.c
 //    that applies only to the new algo. That is forbidden. All
-//    algo specific code must be in theh algo's file.
+//    algo specific code must be in the algo's file.
 //
 //    7. If new functions need to be added to the gate add the type
 //    to the structure, declare a null instance in this file and define
@@ -48,10 +48,10 @@
 //    instances as they are defined by default, or unsafe functions that
 //    are not needed by the algo.
 //
-//    9. Add an case entry to the switch/case in function register_gate
+//    9. Add a case entry to the switch/case in function register_gate
 //    in file algo-gate-api.c for the new algo.
 //
-//    10 If a new function type was defined add an entry to ini talgo_gate
+//    10 If a new function type was defined add an entry to init algo_gate
 //    to initialize the new function to its null instance described in step 7.
 //
 //    11. If the new algo has aliases add them to the alias array in
@@ -85,14 +85,16 @@

 typedef  uint32_t set_t;

-#define EMPTY_SET       0
-#define SSE2_OPT        1
-#define AES_OPT         2  
-#define SSE42_OPT       4
-#define AVX_OPT         8
-#define AVX2_OPT     0x10
-#define SHA_OPT      0x20
-#define AVX512_OPT   0x40
+#define EMPTY_SET        0
+#define SSE2_OPT         1
+#define AES_OPT          2  
+#define SSE42_OPT        4
+#define AVX_OPT          8   // Sandybridge
+#define AVX2_OPT      0x10   // Haswell
+#define SHA_OPT       0x20   // sha256 (Ryzen, Ice Lake)
+#define AVX512_OPT    0x40   // AVX512- F, VL, DQ, BW (Skylake-X)
+#define VAES_OPT      0x80   // VAES (Ice Lake)
+

 // return set containing all elements from sets a & b
 inline set_t set_union ( set_t a, set_t b ) { return a | b; }
@@ -108,14 +110,7 @@ inline bool set_excl ( set_t a, set_t b ) { return (a & b) == 0; }

 typedef struct
 {
-// special case, only one target, provides a callback for scanhash to
-// submit work with less overhead.
-// bool (*submit_work )             ( struct thr_info*, const struct work* );
-
 // mandatory functions, must be overwritten
-// Added a 5th arg for the thread_info structure to replace the int thr id
-// in the first arg. Both will co-exist during the trasition.
-//int ( *scanhash ) ( int, struct work*, uint32_t, uint64_t* );
 int ( *scanhash ) ( struct work*, uint32_t, uint64_t*, struct thr_info* );

 // optional unsafe, must be overwritten if algo uses function
@@ -123,28 +118,55 @@ void ( *hash )     ( void*, const void*, uint32_t ) ;
 void ( *hash_suw ) ( void*, const void* );

 //optional, safe to use default in most cases
+
+// Allocate thread local buffers and other initialization specific to miner
+// threads.
 bool ( *miner_thread_init )      ( int );
+
+// Generate global blockheader from stratum data.
 void ( *stratum_gen_work )       ( struct stratum_ctx*, struct work* );
+
+// Get thread local copy of blockheader with unique nonce.
 void ( *get_new_work )           ( struct work*, struct work*, int, uint32_t*,
                                   bool );
+
+// Return pointer to nonce in blockheader.
 uint32_t *( *get_nonceptr )      ( uint32_t* );
-void ( *decode_extra_data )      ( struct work*, uint64_t* );
-void ( *wait_for_diff )          ( struct stratum_ctx* );
-int64_t ( *get_max64 )           ();
+
+// Decode getwork blockheader
 bool ( *work_decode )            ( const json_t*, struct work* );
-void ( *set_target)              ( struct work*, double );
+
+// Extra getwork data
+void ( *decode_extra_data )      ( struct work*, uint64_t* );
+
 bool ( *submit_getwork_result )  ( CURL*, struct work* );
+
 void ( *gen_merkle_root )        ( char*, struct stratum_ctx* );
+
+// Increment extranonce
 void ( *build_extraheader )      ( struct work*, struct stratum_ctx* );
+
 void ( *build_block_header )     ( struct work*, uint32_t, uint32_t*,
-	                           uint32_t*, uint32_t, uint32_t );
+	                                uint32_t*, uint32_t, uint32_t );
+// Build mining.submit message
 void ( *build_stratum_request )  ( char*, struct work*, struct stratum_ctx* );
+
 char* ( *malloc_txs_request )    ( struct work* );
+
+// Big or little
 void ( *set_work_data_endian )   ( struct work* );
+
 double ( *calc_network_diff )    ( struct work* );
+
+// Wait for first work
 bool ( *ready_to_mine )          ( struct work*, struct stratum_ctx*, int );
-void ( *resync_threads )         ( struct work* );
+
+// Diverge mining threads
 bool ( *do_this_thread )         ( int );
+
+// After do_this_thread
+void ( *resync_threads )         ( struct work* );
+
 json_t* (*longpoll_rpc_call)     ( CURL*, int*, char* );
 bool ( *stratum_handle_response )( json_t* );
 set_t optimizations;
@@ -193,23 +215,12 @@ void four_way_not_tested();
 // allways returns failure
 int null_scanhash();

-// Allow algos to submit from scanhash loop.
-bool submit_solution( struct work *work, void *hash,
-                      struct thr_info *thr );
-bool submit_lane_solution( struct work *work, void *hash,
-                          struct thr_info *thr, int lane );
-
- 
-bool submit_work( struct thr_info *thr, const struct work *work_in );
-
 // displays warning
 void null_hash    ();
 void null_hash_suw();

 // optional safe targets, default listed first unless noted.

-void std_wait_for_diff();
-
 uint32_t *std_get_nonceptr( uint32_t *work_data );
 uint32_t *jr2_get_nonceptr( uint32_t *work_data );

@@ -224,25 +235,13 @@ void jr2_stratum_gen_work( struct stratum_ctx *sctx, struct work *work );
 void sha256d_gen_merkle_root( char *merkle_root, struct stratum_ctx *sctx );
 void SHA256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );

-// pick your favorite or define your own
-int64_t get_max64_0x1fffffLL(); // default
-int64_t get_max64_0x40LL();
-int64_t get_max64_0x3ffff();
-int64_t get_max64_0x3fffffLL();
-int64_t get_max64_0x1ffff();
-int64_t get_max64_0xffffLL();
-
-void std_set_target(    struct work *work, double job_diff );
-void alt_set_target(    struct work* work, double job_diff );
-void scrypt_set_target( struct work *work, double job_diff );
-
 bool std_le_work_decode( const json_t *val, struct work *work );
 bool std_be_work_decode( const json_t *val, struct work *work );
-bool jr2_work_decode( const json_t *val, struct work *work );
+bool jr2_work_decode(    const json_t *val, struct work *work );

 bool std_le_submit_getwork_result( CURL *curl, struct work *work );
 bool std_be_submit_getwork_result( CURL *curl, struct work *work );
-bool jr2_submit_getwork_result( CURL *curl, struct work *work );
+bool jr2_submit_getwork_result(    CURL *curl, struct work *work );

 void std_le_build_stratum_request( char *req, struct work *work );
 void std_be_build_stratum_request( char *req, struct work *work );
@@ -256,8 +255,8 @@ void set_work_data_big_endian( struct work *work );
 double std_calc_network_diff( struct work *work );

 void std_build_block_header( struct work* g_work, uint32_t version,
-	                     uint32_t *prevhash,  uint32_t *merkle_root,
-   	                     uint32_t ntime, uint32_t nbits );
+	                          uint32_t *prevhash,  uint32_t *merkle_root,
+   	                       uint32_t ntime,      uint32_t nbits );

 void std_build_extraheader( struct work *work, struct stratum_ctx *sctx );

@@ -278,8 +277,8 @@ int std_get_work_data_size();
 // by calling the algo's register function.
 bool register_algo_gate( int algo, algo_gate_t *gate );

-// Override any default gate functions that are applicable and do any other
-// algo-specific initialization.
+// Called by algos toverride any default gate functions that are applicable
+// and do any other algo-specific initialization.
 // The register functions for all the algos can be declared here to reduce
 // compiler warnings but that's just more work for devs adding new algos.
 bool register_algo( algo_gate_t *gate );
@@ -292,5 +291,7 @@ bool register_json_rpc2( algo_gate_t *gate );
 // use this to call the hash function of an algo directly, ie util.c test.
 void exec_hash_function( int algo, void *output, const void *pdata );

-void get_algo_alias( char** algo_or_alias );
+// Validate a string as a known algo and alias, updates arg to proper
+// algo name if valid alias, NULL if invalid alias or algo.
+void get_algo_alias( char **algo_or_alias );

--- a/algo/argon2/argon2a/argon2a.c
+++ b/algo/argon2/argon2a/argon2a.c
@@ -74,19 +74,14 @@ int scanhash_argon2( struct work* work, uint32_t max_nonce,
 	return 0;
 }

-int64_t argon2_get_max64 ()
-{
-  return 0x1ffLL;
-}
-
 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->set_target      = (void*)&scrypt_set_target;
-  gate->get_max64       = (void*)&argon2_get_max64;
+  opt_target_factor = 65536.0;
+
  return true;
 };

--- a/algo/argon2/argon2d/argon2d-gate.c
+++ b/algo/argon2/argon2d/argon2d-gate.c
@@ -36,43 +36,39 @@ void argon2d_crds_hash( void *output, const void *input )
 int scanhash_argon2d_crds( struct work *work, uint32_t max_nonce,
                      uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t _ALIGN(64) endiandata[20];
-        uint32_t _ALIGN(64) hash[8];
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
-        int thr_id = mythr->id;  // thr_id arg is deprecated
+   uint32_t _ALIGN(64) endiandata[20];
+   uint32_t _ALIGN(64) hash[8];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t Htarg = ptarget[7];
+   uint32_t nonce = first_nonce;

-        const uint32_t first_nonce = pdata[19];
-        const uint32_t Htarg = ptarget[7];
+   swab32_array( endiandata, pdata, 20 );

-        uint32_t nonce = first_nonce;
+   do {
+      be32enc(&endiandata[19], nonce);
+      argon2d_crds_hash( hash, endiandata );
+      if ( hash[7] <= Htarg && fulltest( hash, ptarget ) && !opt_benchmark )
+      {
+          pdata[19] = nonce;
+          submit_solution( work, hash, mythr );
+      }
+      nonce++;
+   } while (nonce < max_nonce && !work_restart[thr_id].restart);

-        swab32_array( endiandata, pdata, 20 );
-
-        do {
-                be32enc(&endiandata[19], nonce);
-                argon2d_crds_hash( hash, endiandata );
-                if ( hash[7] <= Htarg && fulltest( hash, ptarget ) )
-                {
-                        pdata[19] = nonce;
-                        *hashes_done = pdata[19] - first_nonce;
-                        work_set_target_ratio(work, hash);
-                        return 1;
-                }
-                nonce++;
-        } while (nonce < max_nonce && !work_restart[thr_id].restart);
-
-        pdata[19] = nonce;
-        *hashes_done = pdata[19] - first_nonce + 1;
-        return 0;
+   pdata[19] = nonce;
+   *hashes_done = pdata[19] - first_nonce + 1;
+   return 0;
 }

 bool register_argon2d_crds_algo( algo_gate_t* gate )
 {
        gate->scanhash = (void*)&scanhash_argon2d_crds;
        gate->hash = (void*)&argon2d_crds_hash;
-        gate->set_target = (void*)&scrypt_set_target;
        gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
+        opt_target_factor = 65536.0;
        return true;
 }

@@ -107,43 +103,40 @@ void argon2d_dyn_hash( void *output, const void *input )
 int scanhash_argon2d_dyn( struct work *work, uint32_t max_nonce,
                      uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t _ALIGN(64) endiandata[20];
-        uint32_t _ALIGN(64) hash[8];
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
-        int thr_id = mythr->id;  // thr_id arg is deprecated
+   uint32_t _ALIGN(64) endiandata[20];
+   uint32_t _ALIGN(64) hash[8];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t Htarg = ptarget[7];
+   uint32_t nonce = first_nonce;

-        const uint32_t first_nonce = pdata[19];
-        const uint32_t Htarg = ptarget[7];
+   swab32_array( endiandata, pdata, 20 );

-        uint32_t nonce = first_nonce;
+   do
+   {
+      be32enc(&endiandata[19], nonce);
+      argon2d_dyn_hash( hash, endiandata );
+      if ( hash[7] <= Htarg && fulltest( hash, ptarget ) && !opt_benchmark )
+      {
+          pdata[19] = nonce;
+          submit_solution( work, hash, mythr );
+      }
+      nonce++;
+  } while (nonce < max_nonce && !work_restart[thr_id].restart);

-        swab32_array( endiandata, pdata, 20 );
-
-        do {
-                be32enc(&endiandata[19], nonce);
-                argon2d_dyn_hash( hash, endiandata );
-                if ( hash[7] <= Htarg && fulltest( hash, ptarget ) )
-                {
-                        pdata[19] = nonce;
-                        *hashes_done = pdata[19] - first_nonce;
-                        work_set_target_ratio(work, hash);
-                        return 1;
-                }
-                nonce++;
-        } while (nonce < max_nonce && !work_restart[thr_id].restart);
-
-        pdata[19] = nonce;
-        *hashes_done = pdata[19] - first_nonce + 1;
-        return 0;
+   pdata[19] = nonce;
+   *hashes_done = pdata[19] - first_nonce + 1;
+   return 0;
 }

 bool register_argon2d_dyn_algo( algo_gate_t* gate )
 {
        gate->scanhash = (void*)&scanhash_argon2d_dyn;
        gate->hash = (void*)&argon2d_dyn_hash;
-        gate->set_target = (void*)&scrypt_set_target;
        gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
+        opt_target_factor = 65536.0;
        return true;
 }

@@ -171,11 +164,10 @@ int scanhash_argon2d4096( struct work *work, uint32_t max_nonce,
      be32enc( &endiandata[19], n );
      argon2d_hash_raw( t_cost, m_cost, parallelism, (char*) endiandata, 80,
                 (char*) endiandata, 80, (char*) vhash, 32, ARGON2_VERSION_13 );
-      if ( vhash[7] < Htarg && fulltest( vhash, ptarget ) )
+      if ( vhash[7] < Htarg && fulltest( vhash, ptarget ) && !opt_benchmark )
      {
-         *hashes_done = n - first_nonce + 1;
         pdata[19] = n;
-         return true;
+         submit_solution( work, vhash, mythr );
      }
      n++;

@@ -187,14 +179,11 @@ int scanhash_argon2d4096( struct work *work, uint32_t max_nonce,
   return 0;
 }

-int64_t get_max64_0x1ff() { return 0x1ff; }
-
 bool register_argon2d4096_algo( algo_gate_t* gate )
 {
        gate->scanhash = (void*)&scanhash_argon2d4096;
-        gate->set_target = (void*)&scrypt_set_target;
-        gate->get_max64  = (void*)&get_max64_0x1ff;
        gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
+        opt_target_factor = 65536.0;
        return true;
 }

--- a/algo/argon2/argon2d/argon2d/core.c
+++ b/algo/argon2/argon2d/argon2d/core.c
@@ -28,6 +28,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <mm_malloc.h>

 #include "core.h"
 #include "argon2d_thread.h"
@@ -99,7 +100,8 @@ int allocate_memory(const argon2_context *context, uint8_t **memory,
    if (context->allocate_cbk) {
        (context->allocate_cbk)(memory, memory_size);
    } else {
-        *memory = malloc(memory_size);
+        *memory = _mm_malloc( memory_size, 64 );
+//        *memory = malloc(memory_size);
    }

    if (*memory == NULL) {
@@ -116,7 +118,8 @@ void free_memory(const argon2_context *context, uint8_t *memory,
    if (context->free_cbk) {
        (context->free_cbk)(memory, memory_size);
    } else {
-        free(memory);
+//        free(memory);
+        _mm_free( memory );
    }
 }

--- a/algo/argon2/argon2d/argon2d/opt.c
+++ b/algo/argon2/argon2d/argon2d/opt.c
@@ -21,7 +21,7 @@

 #include "argon2.h"
 #include "core.h"
-
+#include "simd-utils.h"
 #include "../blake2/blake2.h"
 #include "../blake2/blamka-round-opt.h"

@@ -37,24 +37,28 @@

 #if defined(__AVX512F__)

-static void fill_block(__m512i *state, const block *ref_block,
-                       block *next_block, int with_xor) {
+static void fill_block( __m512i *state, const block *ref_block,
+                       block *next_block, int with_xor )
+{
    __m512i block_XY[ARGON2_512BIT_WORDS_IN_BLOCK];
    unsigned int i;

-    if (with_xor) {
-        for (i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++) {
-            state[i] = _mm512_xor_si512(
-                state[i], _mm512_loadu_si512((const __m512i *)ref_block->v + i));
-            block_XY[i] = _mm512_xor_si512(
-                state[i], _mm512_loadu_si512((const __m512i *)next_block->v + i));
-        }
-    } else {
-        for (i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++) {
-            block_XY[i] = state[i] = _mm512_xor_si512(
-                state[i], _mm512_loadu_si512((const __m512i *)ref_block->v + i));
+    if ( with_xor )
+    {
+        for ( i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++ )
+        {
+            state[i] = _mm512_xor_si512( state[i],
+                      _mm512_load_si512( (const __m512i*)ref_block->v + i ) );
+            block_XY[i] = _mm512_xor_si512( state[i],
+                      _mm512_load_si512( (const __m512i*)next_block->v + i ) );
        }
    }
+    else
+    {
+        for ( i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++ )
+            block_XY[i] = state[i] = _mm512_xor_si512( state[i],
+                      _mm512_load_si512( (const __m512i*)ref_block->v + i ) );
+    }

    BLAKE2_ROUND_1( state[ 0], state[ 1], state[ 2], state[ 3],
                    state[ 4], state[ 5], state[ 6], state[ 7] );
@@ -66,23 +70,10 @@ static void fill_block(__m512i *state, const block *ref_block,
    BLAKE2_ROUND_2( state[ 1], state[ 3], state[ 5], state[ 7],
                    state[ 9], state[11], state[13], state[15] );

-/*
-    for (i = 0; i < 2; ++i) {
-        BLAKE2_ROUND_1(
-            state[8 * i + 0], state[8 * i + 1], state[8 * i + 2], state[8 * i + 3],
-            state[8 * i + 4], state[8 * i + 5], state[8 * i + 6], state[8 * i + 7]);
-    }
-
-    for (i = 0; i < 2; ++i) {
-        BLAKE2_ROUND_2(
-            state[2 * 0 + i], state[2 * 1 + i], state[2 * 2 + i], state[2 * 3 + i],
-            state[2 * 4 + i], state[2 * 5 + i], state[2 * 6 + i], state[2 * 7 + i]);
-    }
-*/
-
-    for (i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++) {
-        state[i] = _mm512_xor_si512(state[i], block_XY[i]);
-        _mm512_storeu_si512((__m512i *)next_block->v + i, state[i]);
+    for ( i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++ )
+    {
+        state[i] = _mm512_xor_si512( state[i], block_XY[i] );
+        _mm512_store_si512( (__m512i*)next_block->v + i, state[i] );
    }
 }

@@ -96,14 +87,14 @@ static void fill_block(__m256i *state, const block *ref_block,
    if (with_xor) {
        for (i = 0; i < ARGON2_HWORDS_IN_BLOCK; i++) {
            state[i] = _mm256_xor_si256(
-                state[i], _mm256_loadu_si256((const __m256i *)ref_block->v + i));
+                state[i], _mm256_load_si256((const __m256i *)ref_block->v + i));
            block_XY[i] = _mm256_xor_si256(
-                state[i], _mm256_loadu_si256((const __m256i *)next_block->v + i));
+                state[i], _mm256_load_si256((const __m256i *)next_block->v + i));
        }
    } else {
        for (i = 0; i < ARGON2_HWORDS_IN_BLOCK; i++) {
            block_XY[i] = state[i] = _mm256_xor_si256(
-                state[i], _mm256_loadu_si256((const __m256i *)ref_block->v + i));
+                state[i], _mm256_load_si256((const __m256i *)ref_block->v + i));
        }
    }

@@ -125,21 +116,9 @@ static void fill_block(__m256i *state, const block *ref_block,
    BLAKE2_ROUND_2( state[ 3], state[ 7], state[11], state[15],
                    state[19], state[23], state[27], state[31] );

-/*
-    for (i = 0; i < 4; ++i) {
-        BLAKE2_ROUND_1(state[8 * i + 0], state[8 * i + 4], state[8 * i + 1], state[8 * i + 5],
-                       state[8 * i + 2], state[8 * i + 6], state[8 * i + 3], state[8 * i + 7]);
-    }
-
-    for (i = 0; i < 4; ++i) {
-        BLAKE2_ROUND_2(state[ 0 + i], state[ 4 + i], state[ 8 + i], state[12 + i],
-                       state[16 + i], state[20 + i], state[24 + i], state[28 + i]);
-    }
-*/
-
    for (i = 0; i < ARGON2_HWORDS_IN_BLOCK; i++) {
        state[i] = _mm256_xor_si256(state[i], block_XY[i]);
-        _mm256_storeu_si256((__m256i *)next_block->v + i, state[i]);
+        _mm256_store_si256((__m256i *)next_block->v + i, state[i]);
    }
 }

@@ -153,14 +132,14 @@ static void fill_block(__m128i *state, const block *ref_block,
    if (with_xor) {
        for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
            state[i] = _mm_xor_si128(
-                state[i], _mm_loadu_si128((const __m128i *)ref_block->v + i));
+                state[i], _mm_load_si128((const __m128i *)ref_block->v + i));
            block_XY[i] = _mm_xor_si128(
-                state[i], _mm_loadu_si128((const __m128i *)next_block->v + i));
+                state[i], _mm_load_si128((const __m128i *)next_block->v + i));
        }
    } else {
        for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
            block_XY[i] = state[i] = _mm_xor_si128(
-                state[i], _mm_loadu_si128((const __m128i *)ref_block->v + i));
+                state[i], _mm_load_si128((const __m128i *)ref_block->v + i));
        }
    }

@@ -198,22 +177,9 @@ static void fill_block(__m128i *state, const block *ref_block,
    BLAKE2_ROUND( state[ 7], state[15], state[23], state[31],  
                  state[39], state[47], state[55], state[63] );

-/*
-    for (i = 0; i < 8; ++i) {
-        BLAKE2_ROUND(state[8 * i + 0], state[8 * i + 1], state[8 * i + 2],
-            state[8 * i + 3], state[8 * i + 4], state[8 * i + 5],
-            state[8 * i + 6], state[8 * i + 7]);
-    }
-
-    for (i = 0; i < 8; ++i) {
-        BLAKE2_ROUND(state[8 * 0 + i], state[8 * 1 + i], state[8 * 2 + i],
-            state[8 * 3 + i], state[8 * 4 + i], state[8 * 5 + i],
-            state[8 * 6 + i], state[8 * 7 + i]);
-    }
-*/
    for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
        state[i] = _mm_xor_si128(state[i], block_XY[i]);
-        _mm_storeu_si128((__m128i *)next_block->v + i, state[i]);
+        _mm_store_si128((__m128i *)next_block->v + i, state[i]);
    }
 }

--- a/algo/argon2/argon2d/blake2/blamka-round-opt.h
+++ b/algo/argon2/argon2d/blake2/blamka-round-opt.h
@@ -29,6 +29,8 @@
 #include <x86intrin.h>
 #endif

+#include "simd-utils.h"
+
 #if !defined(__AVX512F__)
 #if !defined(__AVX2__)
 #if !defined(__XOP__)
@@ -182,64 +184,63 @@ static BLAKE2_INLINE __m128i fBlaMka(__m128i x, __m128i y) {

 #include <immintrin.h>

-#define rotr32(x)   _mm256_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1))
-#define rotr24(x)   _mm256_shuffle_epi8(x, _mm256_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10))
-#define rotr16(x)   _mm256_shuffle_epi8(x, _mm256_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9))
-#define rotr63(x)   _mm256_xor_si256(_mm256_srli_epi64((x), 63), _mm256_add_epi64((x), (x)))
+#define  rotr32( x )  mm256_ror_64( x, 32 )
+#define  rotr24( x )  mm256_ror_64( x, 24 )
+#define  rotr16( x )  mm256_ror_64( x, 16 )
+#define  rotr63( x )  mm256_rol_64( x,  1 )
+
+//#define rotr32(x)   _mm256_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1))
+//#define rotr24(x)   _mm256_shuffle_epi8(x, _mm256_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10))
+//#define rotr16(x)   _mm256_shuffle_epi8(x, _mm256_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9))
+//#define rotr63(x)   _mm256_xor_si256(_mm256_srli_epi64((x), 63), _mm256_add_epi64((x), (x)))

 #define G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
    do { \
-        __m256i ml = _mm256_mul_epu32(A0, B0); \
-        ml = _mm256_add_epi64(ml, ml); \
-        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml)); \
+        __m256i ml0, ml1; \
+        ml0 = _mm256_mul_epu32(A0, B0); \
+        ml1 = _mm256_mul_epu32(A1, B1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml0)); \
+        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml1)); \
        D0 = _mm256_xor_si256(D0, A0); \
-        D0 = rotr32(D0); \
-        \
-        ml = _mm256_mul_epu32(C0, D0); \
-        ml = _mm256_add_epi64(ml, ml); \
-        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml)); \
-        \
-        B0 = _mm256_xor_si256(B0, C0); \
-        B0 = rotr24(B0); \
-        \
-        ml = _mm256_mul_epu32(A1, B1); \
-        ml = _mm256_add_epi64(ml, ml); \
-        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml)); \
        D1 = _mm256_xor_si256(D1, A1); \
+        D0 = rotr32(D0); \
        D1 = rotr32(D1); \
-        \
-        ml = _mm256_mul_epu32(C1, D1); \
-        ml = _mm256_add_epi64(ml, ml); \
-        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml)); \
-        \
+        ml0 = _mm256_mul_epu32(C0, D0); \
+        ml1 = _mm256_mul_epu32(C1, D1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml0)); \
+        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml1)); \
+        B0 = _mm256_xor_si256(B0, C0); \
        B1 = _mm256_xor_si256(B1, C1); \
+        B0 = rotr24(B0); \
        B1 = rotr24(B1); \
    } while((void)0, 0);

 #define G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
    do { \
-        __m256i ml = _mm256_mul_epu32(A0, B0); \
-        ml = _mm256_add_epi64(ml, ml); \
-        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml)); \
+        __m256i ml0, ml1; \
+        ml0 = _mm256_mul_epu32(A0, B0); \
+        ml1 = _mm256_mul_epu32(A1, B1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml0)); \
+        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml1)); \
        D0 = _mm256_xor_si256(D0, A0); \
-        D0 = rotr16(D0); \
-        \
-        ml = _mm256_mul_epu32(C0, D0); \
-        ml = _mm256_add_epi64(ml, ml); \
-        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml)); \
-        B0 = _mm256_xor_si256(B0, C0); \
-        B0 = rotr63(B0); \
-        \
-        ml = _mm256_mul_epu32(A1, B1); \
-        ml = _mm256_add_epi64(ml, ml); \
-        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml)); \
        D1 = _mm256_xor_si256(D1, A1); \
+        D0 = rotr16(D0); \
        D1 = rotr16(D1); \
-        \
-        ml = _mm256_mul_epu32(C1, D1); \
-        ml = _mm256_add_epi64(ml, ml); \
-        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml)); \
+        ml0 = _mm256_mul_epu32(C0, D0); \
+        ml1 = _mm256_mul_epu32(C1, D1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml0)); \
+        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml1)); \
+        B0 = _mm256_xor_si256(B0, C0); \
        B1 = _mm256_xor_si256(B1, C1); \
+        B0 = rotr63(B0); \
        B1 = rotr63(B1); \
    } while((void)0, 0);

@@ -259,16 +260,14 @@ static BLAKE2_INLINE __m128i fBlaMka(__m128i x, __m128i y) {
        __m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
        __m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
        B1 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
-        B0 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
-        \
        tmp1 = C0; \
+        B0 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
        C0 = C1; \
-        C1 = tmp1; \
-        \
-        tmp1 = _mm256_blend_epi32(D0, D1, 0xCC); \
        tmp2 = _mm256_blend_epi32(D0, D1, 0x33); \
-        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        C1 = tmp1; \
+        tmp1 = _mm256_blend_epi32(D0, D1, 0xCC); \
        D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
    } while(0);

 #define UNDIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
@@ -287,16 +286,14 @@ static BLAKE2_INLINE __m128i fBlaMka(__m128i x, __m128i y) {
        __m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
        __m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
        B0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
-        B1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
-        \
        tmp1 = C0; \
+        B1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
        C0 = C1; \
-        C1 = tmp1; \
-        \
-        tmp1 = _mm256_blend_epi32(D0, D1, 0x33); \
        tmp2 = _mm256_blend_epi32(D0, D1, 0xCC); \
-        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        C1 = tmp1; \
+        tmp1 = _mm256_blend_epi32(D0, D1, 0x33); \
        D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
    } while((void)0, 0);

 #define BLAKE2_ROUND_1(A0, A1, B0, B1, C0, C1, D0, D1) \
@@ -430,14 +427,14 @@ static __m512i muladd(__m512i x, __m512i y)
 #define SWAP_QUARTERS(A0, A1) \
    do { \
        SWAP_HALVES(A0, A1); \
-        A0 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A0); \
-        A1 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A1); \
+        A0 = _mm512_shuffle_i64x2( A0, A0, 0xd8 ); \
+        A1 = _mm512_shuffle_i64x2( A1, A1, 0xd8 ); \
    } while((void)0, 0)

 #define UNSWAP_QUARTERS(A0, A1) \
    do { \
-        A0 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A0); \
-        A1 = _mm512_permutexvar_epi64(_mm512_setr_epi64(0, 1, 4, 5, 2, 3, 6, 7), A1); \
+        A0 = _mm512_shuffle_i64x2( A0, A0, 0xd8 ); \
+        A1 = _mm512_shuffle_i64x2( A1, A1, 0xd8 ); \
        SWAP_HALVES(A0, A1); \
    } while((void)0, 0)

--- a/algo/blake/blake-4way.c
+++ b/algo/blake/blake-4way.c
@@ -27,25 +27,19 @@ int scanhash_blake_4way( struct work *work, uint32_t max_nonce,
   uint32_t *ptarget = work->target;
   const uint32_t first_nonce = pdata[19];
   uint32_t HTarget = ptarget[7];
-   uint32_t _ALIGN(32) edata[20];
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
   uint32_t n = first_nonce;
   int thr_id = mythr->id;  // thr_id arg is deprecated

   if (opt_benchmark)
      HTarget = 0x7f;

-   // we need big endian data...
-   swab32_array( edata, pdata, 20 );
-   mm128_intrlv_4x32( vdata, edata, edata, edata, edata, 640 );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
   blake256r14_4way_init( &blake_4w_ctx );
   blake256r14_4way( &blake_4w_ctx, vdata, 64 );

-   uint32_t *noncep = vdata + 76;   // 19*4
   do {
-      be32enc( noncep,    n   );
-      be32enc( noncep +1, n+1 );
-      be32enc( noncep +2, n+2 );
-      be32enc( noncep +3, n+3 );
+      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );

      blakehash_4way( hash, vdata );

@@ -76,9 +70,9 @@ void blakehash_8way( void *state, const void *input )
     memcpy( &ctx, &blake_8w_ctx, sizeof ctx );
     blake256r14_8way( &ctx, input + (64<<3), 16 );
     blake256r14_8way_close( &ctx, vhash );
-     mm256_dintrlv_8x32( state,     state+ 32, state+ 64, state+ 96,
-                              state+128, state+160, state+192, state+224,
-                              vhash, 256 );
+     _dintrlv_8x32( state,     state+ 32, state+ 64, state+ 96,
+                    state+128, state+160, state+192, state+224,
+                    vhash, 256 );
 }

 int scanhash_blake_8way( struct work *work, uint32_t max_nonce,
@@ -90,32 +84,21 @@ int scanhash_blake_8way( struct work *work, uint32_t max_nonce,
   uint32_t *ptarget = work->target;
   const uint32_t first_nonce = pdata[19];
   uint32_t HTarget = ptarget[7];
-   uint32_t _ALIGN(32) edata[20];
   uint32_t n = first_nonce;
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
   int thr_id = mythr->id;  // thr_id arg is deprecated

   if (opt_benchmark)
      HTarget = 0x7f;

-   // we need big endian data...
-   swab32_array( edata, pdata, 20 );
-
-   mm256_intrlv_8x32( vdata, edata, edata, edata, edata,
-                                 edata, edata, edata, edata, 640 );
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );

   blake256r14_8way_init( &blake_8w_ctx );
   blake256r14_8way( &blake_8w_ctx, vdata, 64 );

-   uint32_t *noncep = vdata + 152;   // 19*8
   do {
-      be32enc( noncep,    n   );
-      be32enc( noncep +1, n+1 );
-      be32enc( noncep +2, n+2 );
-      be32enc( noncep +3, n+3 );
-      be32enc( noncep +4, n+4 );
-      be32enc( noncep +5, n+5 );
-      be32enc( noncep +6, n+6 );
-      be32enc( noncep +7, n+7 );
+      *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;

      blakehash_8way( hash, vdata );
--- a/algo/blake/blake-gate.c
+++ b/algo/blake/blake-gate.c
@@ -1,18 +1,8 @@
 #include "blake-gate.h"

-int64_t blake_get_max64 ()
-{
-  return 0x7ffffLL;
-}
-
 bool register_blake_algo( algo_gate_t* gate )
 {
  gate->optimizations = AVX2_OPT;
-  gate->get_max64 = (void*)&blake_get_max64;
-//#if defined (__AVX2__) && defined (FOUR_WAY)
-//   gate->optimizations = SSE2_OPT | AVX2_OPT;
-//  gate->scanhash  = (void*)&scanhash_blake_8way;
-//  gate->hash      = (void*)&blakehash_8way;
 #if defined(BLAKE_4WAY)
  four_way_not_tested();
  gate->scanhash  = (void*)&scanhash_blake_4way;
--- a/algo/blake/blake-hash-4way.h
+++ b/algo/blake/blake-hash-4way.h
@@ -59,7 +59,6 @@ extern "C"{
 typedef struct {
   unsigned char buf[64<<2];
   uint32_t H[8<<2];
-   uint32_t S[4<<2];
 //   __m128i buf[16] __attribute__ ((aligned (64)));
 //   __m128i H[8];
 //   __m128i S[4];    
@@ -71,19 +70,22 @@ typedef struct {
 // Default 14 rounds
 typedef blake_4way_small_context blake256_4way_context;
 void blake256_4way_init(void *ctx);
-void blake256_4way(void *ctx, const void *data, size_t len);
+void blake256_4way_update(void *ctx, const void *data, size_t len);
+#define blake256_4way blake256_4way_update
 void blake256_4way_close(void *ctx, void *dst);

 // 14 rounds, blake, decred
 typedef blake_4way_small_context blake256r14_4way_context;
 void blake256r14_4way_init(void *cc);
-void blake256r14_4way(void *cc, const void *data, size_t len);
+void blake256r14_4way_update(void *cc, const void *data, size_t len);
+#define blake256r14_4way blake256r14_4way_update
 void blake256r14_4way_close(void *cc, void *dst);

 // 8 rounds, blakecoin, vanilla
 typedef blake_4way_small_context blake256r8_4way_context;
 void blake256r8_4way_init(void *cc);
-void blake256r8_4way(void *cc, const void *data, size_t len);
+void blake256r8_4way_update(void *cc, const void *data, size_t len);
+#define blake256r8_4way blake256r8_4way_update
 void blake256r8_4way_close(void *cc, void *dst);

 #ifdef __AVX2__
@@ -93,7 +95,6 @@ void blake256r8_4way_close(void *cc, void *dst);
 typedef struct {
   __m256i buf[16] __attribute__ ((aligned (64)));
   __m256i H[8];
-   __m256i S[4];
   size_t ptr;
   sph_u32 T0, T1;
   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
@@ -102,38 +103,93 @@ typedef struct {
 // Default 14 rounds
 typedef blake_8way_small_context blake256_8way_context;
 void blake256_8way_init(void *cc);
-void blake256_8way(void *cc, const void *data, size_t len);
+void blake256_8way_update(void *cc, const void *data, size_t len);
+#define blake256_8way blake256_8way_update
 void blake256_8way_close(void *cc, void *dst);

 // 14 rounds, blake, decred
 typedef blake_8way_small_context blake256r14_8way_context;
 void blake256r14_8way_init(void *cc);
-void blake256r14_8way(void *cc, const void *data, size_t len);
+void blake256r14_8way_update(void *cc, const void *data, size_t len);
 void blake256r14_8way_close(void *cc, void *dst);

 // 8 rounds, blakecoin, vanilla
 typedef blake_8way_small_context blake256r8_8way_context;
 void blake256r8_8way_init(void *cc);
-void blake256r8_8way(void *cc, const void *data, size_t len);
+void blake256r8_8way_update(void *cc, const void *data, size_t len);
+#define blake256r8_8way blake256r8_8way_update
 void blake256r8_8way_close(void *cc, void *dst);

 // Blake-512 4 way

 typedef struct {
-   __m256i buf[16] __attribute__ ((aligned (64)));
+   __m256i buf[16];
   __m256i H[8];
   __m256i S[4];   
   size_t ptr;
   sph_u64 T0, T1;
-} blake_4way_big_context;
+} blake_4way_big_context __attribute__ ((aligned (128)));

 typedef blake_4way_big_context blake512_4way_context;

-void blake512_4way_init(void *cc);
-void blake512_4way(void *cc, const void *data, size_t len);
-void blake512_4way_close(void *cc, void *dst);
-void blake512_4way_addbits_and_close(
-	void *cc, unsigned ub, unsigned n, void *dst);
+void blake512_4way_init( blake_4way_big_context *sc );
+void blake512_4way_update( void *cc, const void *data, size_t len );
+#define blake512_4way blake512_4way_update
+void blake512_4way_close( void *cc, void *dst );
+void blake512_4way_addbits_and_close( void *cc, unsigned ub, unsigned n,
+                                      void *dst );
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//Blake-256 16 way
+
+typedef struct {
+   __m512i buf[16];
+   __m512i H[8];
+   size_t ptr;
+   uint32_t T0, T1;
+   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
+} blake_16way_small_context __attribute__ ((aligned (128)));
+
+// Default 14 rounds
+typedef blake_16way_small_context blake256_16way_context;
+void blake256_16way_init(void *cc);
+void blake256_16way_update(void *cc, const void *data, size_t len);
+void blake256_16way_close(void *cc, void *dst);
+
+// 14 rounds, blake, decred
+typedef blake_16way_small_context blake256r14_16way_context;
+void blake256r14_16way_init(void *cc);
+void blake256r14_16way_update(void *cc, const void *data, size_t len);
+void blake256r14_16way_close(void *cc, void *dst);
+
+// 8 rounds, blakecoin, vanilla
+typedef blake_16way_small_context blake256r8_16way_context;
+void blake256r8_16way_init(void *cc);
+void blake256r8_16way_update(void *cc, const void *data, size_t len);
+void blake256r8_16way_close(void *cc, void *dst);
+
+
+// Blake-512 8 way
+
+typedef struct {
+   __m512i buf[16];
+   __m512i H[8];
+   __m512i S[4];
+   size_t ptr;
+   sph_u64 T0, T1;
+} blake_8way_big_context __attribute__ ((aligned (128)));
+
+typedef blake_8way_big_context blake512_8way_context;
+
+void blake512_8way_init( blake_8way_big_context *sc );
+void blake512_8way_update( void *cc, const void *data, size_t len );
+void blake512_8way_close( void *cc, void *dst );
+void blake512_8way_addbits_and_close( void *cc, unsigned ub, unsigned n,
+                                      void *dst );
+
+#endif  // AVX512
+

 #endif  // AVX2

--- a/algo/blake/blake256-hash-4way.c
+++ b/algo/blake/blake256-hash-4way.c
@@ -304,16 +304,17 @@ static const sph_u32 CS[16] = {

 #endif

+// Blake-256 4 way

 #define GS_4WAY( m0, m1, c0, c1, a, b, c, d ) \
 do { \
-   a = _mm_add_epi32( _mm_add_epi32( _mm_xor_si128( \
-                 _mm_set_epi32( c1, c1, c1, c1 ), m0 ), b ), a ); \
+   a = _mm_add_epi32( _mm_add_epi32( a, b ), \
+                      _mm_xor_si128( _mm_set1_epi32( c1 ), m0 ) ); \
   d = mm128_ror_32( _mm_xor_si128( d, a ), 16 ); \
   c = _mm_add_epi32( c, d ); \
   b = mm128_ror_32( _mm_xor_si128( b, c ), 12 ); \
-   a = _mm_add_epi32( _mm_add_epi32( _mm_xor_si128( \
-                 _mm_set_epi32( c0, c0, c0, c0 ), m1 ), b ), a ); \
+   a = _mm_add_epi32( _mm_add_epi32( a, b ), \
+                      _mm_xor_si128( _mm_set1_epi32( c0 ), m1 ) ); \
   d = mm128_ror_32( _mm_xor_si128( d, a ), 8 ); \
   c = _mm_add_epi32( c, d ); \
   b = mm128_ror_32( _mm_xor_si128( b, c ), 7 ); \
@@ -321,7 +322,8 @@ do { \

 #if SPH_COMPACT_BLAKE_32

-// Blake-256 4 way
+// Not used
+#if 0

 #define ROUND_S_4WAY(r)   do { \
 	GS_4WAY(M[sigma[r][0x0]], M[sigma[r][0x1]], \
@@ -342,6 +344,8 @@ do { \
 		CS[sigma[r][0xE]], CS[sigma[r][0xF]], V3, V4, V9, VE); \
 } while (0)

+#endif
+
 #else

 #define ROUND_S_4WAY(r)   do { \
@@ -359,7 +363,6 @@ do { \

 #define DECL_STATE32_4WAY \
 	__m128i H0, H1, H2, H3, H4, H5, H6, H7; \
-	__m128i S0, S1, S2, S3; \
        uint32_t T0, T1;

 #define READ_STATE32_4WAY(state)   do { \
@@ -371,10 +374,6 @@ do { \
 		H5 = casti_m128i( state->H, 5 ); \
 		H6 = casti_m128i( state->H, 6 ); \
 		H7 = casti_m128i( state->H, 7 ); \
-		S0 = casti_m128i( state->S, 0 ); \
-		S1 = casti_m128i( state->S, 1 ); \
-		S2 = casti_m128i( state->S, 2 ); \
-		S3 = casti_m128i( state->S, 3 ); \
 		T0 = (state)->T0; \
 		T1 = (state)->T1; \
 	} while (0)
@@ -388,17 +387,13 @@ do { \
 		casti_m128i( state->H, 5 ) = H5; \
 		casti_m128i( state->H, 6 ) = H6; \
 		casti_m128i( state->H, 7 ) = H7; \
-		casti_m128i( state->S, 0 ) = S0; \
-		casti_m128i( state->S, 1 ) = S1; \
-		casti_m128i( state->S, 2 ) = S2; \
-		casti_m128i( state->S, 3 ) = S3; \
 		(state)->T0 = T0; \
 		(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; \
@@ -412,34 +407,16 @@ do { \
 	V5 = H5; \
 	V6 = H6; \
 	V7 = H7; \
-        V8 = _mm_xor_si128( S0, _mm_set_epi32( CS0, CS0, CS0, CS0 ) ); \
-        V9 = _mm_xor_si128( S1, _mm_set_epi32( CS1, CS1, CS1, CS1 ) ); \
-        VA = _mm_xor_si128( S2, _mm_set_epi32( CS2, CS2, CS2, CS2 ) ); \
-        VB = _mm_xor_si128( S3, _mm_set_epi32( CS3, CS3, CS3, CS3 ) ); \
-        VC = _mm_xor_si128( _mm_set_epi32( T0, T0, T0, T0 ), \
-                            _mm_set_epi32( CS4, CS4, CS4, CS4 ) ); \
-        VD = _mm_xor_si128( _mm_set_epi32( T0, T0, T0, T0 ), \
-                            _mm_set_epi32( CS5, CS5, CS5, CS5 ) ); \
-        VE = _mm_xor_si128( _mm_set_epi32( T1, T1, T1, T1 ) \
-                          , _mm_set_epi32( CS6, CS6, CS6, CS6 ) ); \
-        VF = _mm_xor_si128( _mm_set_epi32( T1, T1, T1, T1 ), \
-                            _mm_set_epi32( CS7, CS7, CS7, CS7 ) ); \
-	M[0x0] = mm128_bswap_32( *(buf +  0) ); \
-	M[0x1] = mm128_bswap_32( *(buf +  1) ); \
-	M[0x2] = mm128_bswap_32( *(buf +  2) ); \
-	M[0x3] = mm128_bswap_32( *(buf +  3) ); \
-	M[0x4] = mm128_bswap_32( *(buf +  4) ); \
-	M[0x5] = mm128_bswap_32( *(buf +  5) ); \
-	M[0x6] = mm128_bswap_32( *(buf +  6) ); \
-	M[0x7] = mm128_bswap_32( *(buf +  7) ); \
-	M[0x8] = mm128_bswap_32( *(buf +  8) ); \
-	M[0x9] = mm128_bswap_32( *(buf +  9) ); \
-	M[0xA] = mm128_bswap_32( *(buf + 10) ); \
-	M[0xB] = mm128_bswap_32( *(buf + 11) ); \
-	M[0xC] = mm128_bswap_32( *(buf + 12) ); \
-	M[0xD] = mm128_bswap_32( *(buf + 13) ); \
-	M[0xE] = mm128_bswap_32( *(buf + 14) ); \
-	M[0xF] = mm128_bswap_32( *(buf + 15) ); \
+   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( \
@@ -459,11 +436,60 @@ do { \
        H7 = _mm_xor_si128( _mm_xor_si128( \
                                   _mm_xor_si128( S3, V7 ), VF ), H7 ); \
 	} while (0)
+#endif

 #else

 // current impl

+#if defined(__SSSE3__)
+
+#define BLAKE256_4WAY_BLOCK_BSWAP32 do \
+{ \
+   __m128i shuf_bswap32 = _mm_set_epi64x( 0x0c0d0e0f08090a0b, \
+                                          0x0405060700010203 ); \
+   M0 = _mm_shuffle_epi8( buf[ 0], shuf_bswap32 ); \
+   M1 = _mm_shuffle_epi8( buf[ 1], shuf_bswap32 ); \
+   M2 = _mm_shuffle_epi8( buf[ 2], shuf_bswap32 ); \
+   M3 = _mm_shuffle_epi8( buf[ 3], shuf_bswap32 ); \
+   M4 = _mm_shuffle_epi8( buf[ 4], shuf_bswap32 ); \
+   M5 = _mm_shuffle_epi8( buf[ 5], shuf_bswap32 ); \
+   M6 = _mm_shuffle_epi8( buf[ 6], shuf_bswap32 ); \
+   M7 = _mm_shuffle_epi8( buf[ 7], shuf_bswap32 ); \
+   M8 = _mm_shuffle_epi8( buf[ 8], shuf_bswap32 ); \
+   M9 = _mm_shuffle_epi8( buf[ 9], shuf_bswap32 ); \
+   MA = _mm_shuffle_epi8( buf[10], shuf_bswap32 ); \
+   MB = _mm_shuffle_epi8( buf[11], shuf_bswap32 ); \
+   MC = _mm_shuffle_epi8( buf[12], shuf_bswap32 ); \
+   MD = _mm_shuffle_epi8( buf[13], shuf_bswap32 ); \
+   ME = _mm_shuffle_epi8( buf[14], shuf_bswap32 ); \
+   MF = _mm_shuffle_epi8( buf[15], shuf_bswap32 ); \
+} while(0)
+
+#else  // SSE2
+
+#define BLAKE256_4WAY_BLOCK_BSWAP32 do \
+{ \
+   M0 = mm128_bswap_32( buf[0] ); \
+   M1 = mm128_bswap_32( buf[1] ); \
+   M2 = mm128_bswap_32( buf[2] ); \
+   M3 = mm128_bswap_32( buf[3] ); \
+   M4 = mm128_bswap_32( buf[4] ); \
+   M5 = mm128_bswap_32( buf[5] ); \
+   M6 = mm128_bswap_32( buf[6] ); \
+   M7 = mm128_bswap_32( buf[7] ); \
+   M8 = mm128_bswap_32( buf[8] ); \
+   M9 = mm128_bswap_32( buf[9] ); \
+   MA = mm128_bswap_32( buf[10] ); \
+   MB = mm128_bswap_32( buf[11] ); \
+   MC = mm128_bswap_32( buf[12] ); \
+   MD = mm128_bswap_32( buf[13] ); \
+   ME = mm128_bswap_32( buf[14] ); \
+   MF = mm128_bswap_32( buf[15] ); \
+} while(0)
+
+#endif  // SSSE3 else SSE2
+
 #define COMPRESS32_4WAY( rounds ) \
 do { \
   __m128i M0, M1, M2, M3, M4, M5, M6, M7; \
@@ -478,30 +504,19 @@ do { \
   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 ) ); \
-   M0 = mm128_bswap_32( buf[ 0] ); \
-   M1 = mm128_bswap_32( buf[ 1] ); \
-   M2 = mm128_bswap_32( buf[ 2] ); \
-   M3 = mm128_bswap_32( buf[ 3] ); \
-   M4 = mm128_bswap_32( buf[ 4] ); \
-   M5 = mm128_bswap_32( buf[ 5] ); \
-   M6 = mm128_bswap_32( buf[ 6] ); \
-   M7 = mm128_bswap_32( buf[ 7] ); \
-   M8 = mm128_bswap_32( buf[ 8] ); \
-   M9 = mm128_bswap_32( buf[ 9] ); \
-   MA = mm128_bswap_32( buf[10] ); \
-   MB = mm128_bswap_32( buf[11] ); \
-   MC = mm128_bswap_32( buf[12] ); \
-   MD = mm128_bswap_32( buf[13] ); \
-   ME = mm128_bswap_32( buf[14] ); \
-   MF = mm128_bswap_32( buf[15] ); \
+   V8 = m128_const1_64( 0x243F6A88243F6A88 ); \
+   V9 = m128_const1_64( 0x85A308D385A308D3 ); \
+   VA = m128_const1_64( 0x13198A2E13198A2E ); \
+   VB = m128_const1_64( 0x0370734403707344 ); \
+   VC = _mm_xor_si128( _mm_set1_epi32( T0 ), \
+                           m128_const1_64( 0xA4093822A4093822 ) ); \
+   VD = _mm_xor_si128( _mm_set1_epi32( T0 ), \
+                           m128_const1_64( 0x299F31D0299F31D0 ) ); \
+   VE = _mm_xor_si128( _mm_set1_epi32( T1 ), \
+                           m128_const1_64( 0x082EFA98082EFA98 ) ); \
+   VF = _mm_xor_si128( _mm_set1_epi32( T1 ), \
+                           m128_const1_64( 0xEC4E6C89EC4E6C89 ) ); \
+   BLAKE256_4WAY_BLOCK_BSWAP32; \
   ROUND_S_4WAY(0); \
   ROUND_S_4WAY(1); \
   ROUND_S_4WAY(2); \
@@ -519,14 +534,14 @@ do { \
      ROUND_S_4WAY(2); \
      ROUND_S_4WAY(3); \
   } \
-   H0 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( V8, V0 ), S0 ), H0 ); \
-   H1 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( V9, V1 ), S1 ), H1 ); \
-   H2 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( VA, V2 ), S2 ), H2 ); \
-   H3 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( VB, V3 ), S3 ), H3 ); \
-   H4 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( VC, V4 ), S0 ), H4 ); \
-   H5 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( VD, V5 ), S1 ), H5 ); \
-   H6 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( VE, V6 ), S2 ), H6 ); \
-   H7 = _mm_xor_si128( _mm_xor_si128( _mm_xor_si128( VF, V7 ), S3 ), H7 ); \
+   H0 = _mm_xor_si128( _mm_xor_si128( V8, V0 ), H0 ); \
+   H1 = _mm_xor_si128( _mm_xor_si128( V9, V1 ), H1 ); \
+   H2 = _mm_xor_si128( _mm_xor_si128( VA, V2 ), H2 ); \
+   H3 = _mm_xor_si128( _mm_xor_si128( VB, V3 ), H3 ); \
+   H4 = _mm_xor_si128( _mm_xor_si128( VC, V4 ), H4 ); \
+   H5 = _mm_xor_si128( _mm_xor_si128( VD, V5 ), H5 ); \
+   H6 = _mm_xor_si128( _mm_xor_si128( VE, V6 ), H6 ); \
+   H7 = _mm_xor_si128( _mm_xor_si128( VF, V7 ), H7 ); \
 } while (0)

 #endif
@@ -537,13 +552,13 @@ do { \

 #define GS_8WAY( m0, m1, c0, c1, a, b, c, d ) \
 do { \
-   a = _mm256_add_epi32( _mm256_add_epi32( _mm256_xor_si256( \
-                 _mm256_set1_epi32( c1 ), m0 ), b ), a ); \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), \
+                         _mm256_xor_si256( _mm256_set1_epi32( c1 ), m0 ) ); \
   d = mm256_ror_32( _mm256_xor_si256( d, a ), 16 ); \
   c = _mm256_add_epi32( c, d ); \
   b = mm256_ror_32( _mm256_xor_si256( b, c ), 12 ); \
-   a = _mm256_add_epi32( _mm256_add_epi32( _mm256_xor_si256( \
-                 _mm256_set1_epi32( c0 ), m1 ), b ), a ); \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), \
+                         _mm256_xor_si256( _mm256_set1_epi32( c0 ), m1 ) ); \
   d = mm256_ror_32( _mm256_xor_si256( d, a ), 8 ); \
   c = _mm256_add_epi32( c, d ); \
   b = mm256_ror_32( _mm256_xor_si256( b, c ), 7 ); \
@@ -562,7 +577,6 @@ do { \

 #define DECL_STATE32_8WAY \
   __m256i H0, H1, H2, H3, H4, H5, H6, H7; \
-   __m256i S0, S1, S2, S3; \
   sph_u32 T0, T1;

 #define READ_STATE32_8WAY(state) \
@@ -575,10 +589,6 @@ do { \
   H5 = (state)->H[5]; \
   H6 = (state)->H[6]; \
   H7 = (state)->H[7]; \
-   S0 = (state)->S[0]; \
-   S1 = (state)->S[1]; \
-   S2 = (state)->S[2]; \
-   S3 = (state)->S[3]; \
   T0 = (state)->T0; \
   T1 = (state)->T1; \
 } while (0)
@@ -593,10 +603,6 @@ do { \
   (state)->H[5] = H5; \
   (state)->H[6] = H6; \
   (state)->H[7] = H7; \
-   (state)->S[0] = S0; \
-   (state)->S[1] = S1; \
-   (state)->S[2] = S2; \
-   (state)->S[3] = S3; \
   (state)->T0 = T0; \
   (state)->T1 = T1; \
 } while (0)
@@ -607,6 +613,7 @@ do { \
   __m256i M8, M9, MA, MB, MC, MD, ME, MF; \
   __m256i V0, V1, V2, V3, V4, V5, V6, V7; \
   __m256i V8, V9, VA, VB, VC, VD, VE, VF; \
+   __m256i shuf_bswap32; \
   V0 = H0; \
   V1 = H1; \
   V2 = H2; \
@@ -615,30 +622,36 @@ do { \
   V5 = H5; \
   V6 = H6; \
   V7 = H7; \
-   V8 = _mm256_xor_si256( S0, _mm256_set1_epi32( CS0 ) ); \
-   V9 = _mm256_xor_si256( S1, _mm256_set1_epi32( CS1 ) ); \
-   VA = _mm256_xor_si256( S2, _mm256_set1_epi32( CS2 ) ); \
-   VB = _mm256_xor_si256( S3, _mm256_set1_epi32( CS3 ) ); \
-   VC = _mm256_xor_si256( _mm256_set1_epi32( T0 ), _mm256_set1_epi32( CS4 ) ); \
-   VD = _mm256_xor_si256( _mm256_set1_epi32( T0 ), _mm256_set1_epi32( CS5 ) ); \
-   VE = _mm256_xor_si256( _mm256_set1_epi32( T1 ), _mm256_set1_epi32( CS6 ) ); \
-   VF = _mm256_xor_si256( _mm256_set1_epi32( T1 ), _mm256_set1_epi32( CS7 ) ); \
-   M0 = mm256_bswap_32( * buf ); \
-   M1 = mm256_bswap_32( *(buf+1) ); \
-   M2 = mm256_bswap_32( *(buf+2) ); \
-   M3 = mm256_bswap_32( *(buf+3) ); \
-   M4 = mm256_bswap_32( *(buf+4) ); \
-   M5 = mm256_bswap_32( *(buf+5) ); \
-   M6 = mm256_bswap_32( *(buf+6) ); \
-   M7 = mm256_bswap_32( *(buf+7) ); \
-   M8 = mm256_bswap_32( *(buf+8) ); \
-   M9 = mm256_bswap_32( *(buf+9) ); \
-   MA = mm256_bswap_32( *(buf+10) ); \
-   MB = mm256_bswap_32( *(buf+11) ); \
-   MC = mm256_bswap_32( *(buf+12) ); \
-   MD = mm256_bswap_32( *(buf+13) ); \
-   ME = mm256_bswap_32( *(buf+14) ); \
-   MF = mm256_bswap_32( *(buf+15) ); \
+   V8 = m256_const1_64( 0x243F6A88243F6A88 ); \
+   V9 = m256_const1_64( 0x85A308D385A308D3 ); \
+   VA = m256_const1_64( 0x13198A2E13198A2E ); \
+   VB = m256_const1_64( 0x0370734403707344 ); \
+   VC = _mm256_xor_si256( _mm256_set1_epi32( T0 ),\
+                              m256_const1_64( 0xA4093822A4093822 ) ); \
+   VD = _mm256_xor_si256( _mm256_set1_epi32( T0 ),\
+                              m256_const1_64( 0x299F31D0299F31D0 ) ); \
+   VE = _mm256_xor_si256( _mm256_set1_epi32( T1 ), \
+                              m256_const1_64( 0x082EFA98082EFA98 ) ); \
+   VF = _mm256_xor_si256( _mm256_set1_epi32( T1 ), \
+                              m256_const1_64( 0xEC4E6C89EC4E6C89 ) ); \
+   shuf_bswap32 = m256_const_64( 0x1c1d1e1f18191a1b, 0x1415161710111213, \
+                                 0x0c0d0e0f08090a0b, 0x0405060700010203 ); \
+   M0 = _mm256_shuffle_epi8( * buf    , shuf_bswap32 ); \
+   M1 = _mm256_shuffle_epi8( *(buf+ 1), shuf_bswap32 ); \
+   M2 = _mm256_shuffle_epi8( *(buf+ 2), shuf_bswap32 ); \
+   M3 = _mm256_shuffle_epi8( *(buf+ 3), shuf_bswap32 ); \
+   M4 = _mm256_shuffle_epi8( *(buf+ 4), shuf_bswap32 ); \
+   M5 = _mm256_shuffle_epi8( *(buf+ 5), shuf_bswap32 ); \
+   M6 = _mm256_shuffle_epi8( *(buf+ 6), shuf_bswap32 ); \
+   M7 = _mm256_shuffle_epi8( *(buf+ 7), shuf_bswap32 ); \
+   M8 = _mm256_shuffle_epi8( *(buf+ 8), shuf_bswap32 ); \
+   M9 = _mm256_shuffle_epi8( *(buf+ 9), shuf_bswap32 ); \
+   MA = _mm256_shuffle_epi8( *(buf+10), shuf_bswap32 ); \
+   MB = _mm256_shuffle_epi8( *(buf+11), shuf_bswap32 ); \
+   MC = _mm256_shuffle_epi8( *(buf+12), shuf_bswap32 ); \
+   MD = _mm256_shuffle_epi8( *(buf+13), shuf_bswap32 ); \
+   ME = _mm256_shuffle_epi8( *(buf+14), shuf_bswap32 ); \
+   MF = _mm256_shuffle_epi8( *(buf+15), shuf_bswap32 ); \
   ROUND_S_8WAY(0); \
   ROUND_S_8WAY(1); \
   ROUND_S_8WAY(2); \
@@ -656,25 +669,155 @@ do { \
      ROUND_S_8WAY(2); \
      ROUND_S_8WAY(3); \
   } \
-   H0 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( V8, V0 ), \
-                                                              S0 ), H0 ); \
-   H1 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( V9, V1 ), \
-                                                              S1 ), H1 ); \
-   H2 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( VA, V2 ), \
-                                                              S2 ), H2 ); \
-   H3 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( VB, V3 ), \
-                                                              S3 ), H3 ); \
-   H4 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( VC, V4 ), \
-                                                              S0 ), H4 ); \
-   H5 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( VD, V5 ), \
-                                                              S1 ), H5 ); \
-   H6 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( VE, V6 ), \
-                                                              S2 ), H6 ); \
-   H7 = _mm256_xor_si256( _mm256_xor_si256( _mm256_xor_si256( VF, V7 ), \
-                                                              S3 ), H7 ); \
+   H0 = _mm256_xor_si256( _mm256_xor_si256( V8, V0 ), H0 ); \
+   H1 = _mm256_xor_si256( _mm256_xor_si256( V9, V1 ), H1 ); \
+   H2 = _mm256_xor_si256( _mm256_xor_si256( VA, V2 ), H2 ); \
+   H3 = _mm256_xor_si256( _mm256_xor_si256( VB, V3 ), H3 ); \
+   H4 = _mm256_xor_si256( _mm256_xor_si256( VC, V4 ), H4 ); \
+   H5 = _mm256_xor_si256( _mm256_xor_si256( VD, V5 ), H5 ); \
+   H6 = _mm256_xor_si256( _mm256_xor_si256( VE, V6 ), H6 ); \
+   H7 = _mm256_xor_si256( _mm256_xor_si256( VF, V7 ), H7 ); \
 } while (0)


+#endif
+
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// Blaske-256 16 way AVX512
+
+#define GS_16WAY( m0, m1, c0, c1, a, b, c, d ) \
+do { \
+   a = _mm512_add_epi32( _mm512_add_epi32( a, b ), \
+                         _mm512_xor_si512( _mm512_set1_epi32( c1 ), m0 ) ); \
+   d = mm512_ror_32( _mm512_xor_si512( d, a ), 16 ); \
+   c = _mm512_add_epi32( c, d ); \
+   b = mm512_ror_32( _mm512_xor_si512( b, c ), 12 ); \
+   a = _mm512_add_epi32( _mm512_add_epi32( a, b ), \
+                         _mm512_xor_si512( _mm512_set1_epi32( c0 ), m1 ) ); \
+   d = mm512_ror_32( _mm512_xor_si512( d, a ), 8 ); \
+   c = _mm512_add_epi32( c, d ); \
+   b = mm512_ror_32( _mm512_xor_si512( b, c ), 7 ); \
+} while (0)
+
+#define ROUND_S_16WAY(r)   do { \
+        GS_16WAY(Mx(r, 0), Mx(r, 1), CSx(r, 0), CSx(r, 1), V0, V4, V8, VC); \
+        GS_16WAY(Mx(r, 2), Mx(r, 3), CSx(r, 2), CSx(r, 3), V1, V5, V9, VD); \
+        GS_16WAY(Mx(r, 4), Mx(r, 5), CSx(r, 4), CSx(r, 5), V2, V6, VA, VE); \
+        GS_16WAY(Mx(r, 6), Mx(r, 7), CSx(r, 6), CSx(r, 7), V3, V7, VB, VF); \
+        GS_16WAY(Mx(r, 8), Mx(r, 9), CSx(r, 8), CSx(r, 9), V0, V5, VA, VF); \
+        GS_16WAY(Mx(r, A), Mx(r, B), CSx(r, A), CSx(r, B), V1, V6, VB, VC); \
+        GS_16WAY(Mx(r, C), Mx(r, D), CSx(r, C), CSx(r, D), V2, V7, V8, VD); \
+        GS_16WAY(Mx(r, E), Mx(r, F), CSx(r, E), CSx(r, F), V3, V4, V9, VE); \
+} while (0)
+
+#define DECL_STATE32_16WAY \
+   __m512i H0, H1, H2, H3, H4, H5, H6, H7; \
+   sph_u32 T0, T1;
+
+#define READ_STATE32_16WAY(state) \
+do { \
+   H0 = (state)->H[0]; \
+   H1 = (state)->H[1]; \
+   H2 = (state)->H[2]; \
+   H3 = (state)->H[3]; \
+   H4 = (state)->H[4]; \
+   H5 = (state)->H[5]; \
+   H6 = (state)->H[6]; \
+   H7 = (state)->H[7]; \
+   T0 = (state)->T0; \
+   T1 = (state)->T1; \
+} while (0)
+
+#define WRITE_STATE32_16WAY(state) \
+do { \
+   (state)->H[0] = H0; \
+   (state)->H[1] = H1; \
+   (state)->H[2] = H2; \
+   (state)->H[3] = H3; \
+   (state)->H[4] = H4; \
+   (state)->H[5] = H5; \
+   (state)->H[6] = H6; \
+   (state)->H[7] = H7; \
+   (state)->T0 = T0; \
+   (state)->T1 = T1; \
+} while (0)
+
+#define COMPRESS32_16WAY( rounds ) \
+do { \
+   __m512i M0, M1, M2, M3, M4, M5, M6, M7; \
+   __m512i M8, M9, MA, MB, MC, MD, ME, MF; \
+   __m512i V0, V1, V2, V3, V4, V5, V6, V7; \
+   __m512i V8, V9, VA, VB, VC, VD, VE, VF; \
+   __m512i shuf_bswap32; \
+   V0 = H0; \
+   V1 = H1; \
+   V2 = H2; \
+   V3 = H3; \
+   V4 = H4; \
+   V5 = H5; \
+   V6 = H6; \
+   V7 = H7; \
+   V8 = m512_const1_64( 0x243F6A88243F6A88 ); \
+   V9 = m512_const1_64( 0x85A308D385A308D3 ); \
+   VA = m512_const1_64( 0x13198A2E13198A2E ); \
+   VB = m512_const1_64( 0x0370734403707344 ); \
+   VC = _mm512_xor_si512( _mm512_set1_epi32( T0 ),\
+                              m512_const1_64( 0xA4093822A4093822 ) ); \
+   VD = _mm512_xor_si512( _mm512_set1_epi32( T0 ),\
+                              m512_const1_64( 0x299F31D0299F31D0 ) ); \
+   VE = _mm512_xor_si512( _mm512_set1_epi32( T1 ), \
+                              m512_const1_64( 0x082EFA98082EFA98 ) ); \
+   VF = _mm512_xor_si512( _mm512_set1_epi32( T1 ), \
+                              m512_const1_64( 0xEC4E6C89EC4E6C89 ) ); \
+   shuf_bswap32 = m512_const_64( 0x3c3d3e3f38393a3b, 0x3435363730313233, \
+                                 0x2c2d2e2f28292a2b, 0x2425262720212223, \
+                                 0x1c1d1e1f18191a1b, 0x1415161710111213, \
+                                 0x0c0d0e0f08090a0b, 0x0405060700010203 ); \
+   M0 = _mm512_shuffle_epi8( * buf    , shuf_bswap32 ); \
+   M1 = _mm512_shuffle_epi8( *(buf+ 1), shuf_bswap32 ); \
+   M2 = _mm512_shuffle_epi8( *(buf+ 2), shuf_bswap32 ); \
+   M3 = _mm512_shuffle_epi8( *(buf+ 3), shuf_bswap32 ); \
+   M4 = _mm512_shuffle_epi8( *(buf+ 4), shuf_bswap32 ); \
+   M5 = _mm512_shuffle_epi8( *(buf+ 5), shuf_bswap32 ); \
+   M6 = _mm512_shuffle_epi8( *(buf+ 6), shuf_bswap32 ); \
+   M7 = _mm512_shuffle_epi8( *(buf+ 7), shuf_bswap32 ); \
+   M8 = _mm512_shuffle_epi8( *(buf+ 8), shuf_bswap32 ); \
+   M9 = _mm512_shuffle_epi8( *(buf+ 9), shuf_bswap32 ); \
+   MA = _mm512_shuffle_epi8( *(buf+10), shuf_bswap32 ); \
+   MB = _mm512_shuffle_epi8( *(buf+11), shuf_bswap32 ); \
+   MC = _mm512_shuffle_epi8( *(buf+12), shuf_bswap32 ); \
+   MD = _mm512_shuffle_epi8( *(buf+13), shuf_bswap32 ); \
+   ME = _mm512_shuffle_epi8( *(buf+14), shuf_bswap32 ); \
+   MF = _mm512_shuffle_epi8( *(buf+15), shuf_bswap32 ); \
+   ROUND_S_16WAY(0); \
+   ROUND_S_16WAY(1); \
+   ROUND_S_16WAY(2); \
+   ROUND_S_16WAY(3); \
+   ROUND_S_16WAY(4); \
+   ROUND_S_16WAY(5); \
+   ROUND_S_16WAY(6); \
+   ROUND_S_16WAY(7); \
+   if (rounds == 14) \
+   { \
+      ROUND_S_16WAY(8); \
+      ROUND_S_16WAY(9); \
+      ROUND_S_16WAY(0); \
+      ROUND_S_16WAY(1); \
+      ROUND_S_16WAY(2); \
+      ROUND_S_16WAY(3); \
+   } \
+   H0 = _mm512_xor_si512( _mm512_xor_si512( V8, V0 ), H0 ); \
+   H1 = _mm512_xor_si512( _mm512_xor_si512( V9, V1 ), H1 ); \
+   H2 = _mm512_xor_si512( _mm512_xor_si512( VA, V2 ), H2 ); \
+   H3 = _mm512_xor_si512( _mm512_xor_si512( VB, V3 ), H3 ); \
+   H4 = _mm512_xor_si512( _mm512_xor_si512( VC, V4 ), H4 ); \
+   H5 = _mm512_xor_si512( _mm512_xor_si512( VD, V5 ), H5 ); \
+   H6 = _mm512_xor_si512( _mm512_xor_si512( VE, V6 ), H6 ); \
+   H7 = _mm512_xor_si512( _mm512_xor_si512( VF, V7 ), H7 ); \
+} while (0)
+
 #endif

 // Blake-256 4 way
@@ -685,25 +828,14 @@ static void
 blake32_4way_init( blake_4way_small_context *ctx, const uint32_t *iv,
                   const uint32_t *salt, int rounds )
 {
-   casti_m128i( ctx->H, 0 ) = _mm_set1_epi32( iv[0] );
-   casti_m128i( ctx->H, 1 ) = _mm_set1_epi32( iv[1] );
-   casti_m128i( ctx->H, 2 ) = _mm_set1_epi32( iv[2] );
-   casti_m128i( ctx->H, 3 ) = _mm_set1_epi32( iv[3] );
-   casti_m128i( ctx->H, 4 ) = _mm_set1_epi32( iv[4] );
-   casti_m128i( ctx->H, 5 ) = _mm_set1_epi32( iv[5] );
-   casti_m128i( ctx->H, 6 ) = _mm_set1_epi32( iv[6] );
-   casti_m128i( ctx->H, 7 ) = _mm_set1_epi32( iv[7] );
-
-   casti_m128i( ctx->S, 0 ) = m128_zero;
-   casti_m128i( ctx->S, 1 ) = m128_zero;
-   casti_m128i( ctx->S, 2 ) = m128_zero;
-   casti_m128i( ctx->S, 3 ) = m128_zero;
-/*
-   sc->S[0] = _mm_set1_epi32( salt[0] );
-   sc->S[1] = _mm_set1_epi32( salt[1] );
-   sc->S[2] = _mm_set1_epi32( salt[2] );
-   sc->S[3] = _mm_set1_epi32( salt[3] );
-*/
+   casti_m128i( ctx->H, 0 ) = m128_const1_64( 0x6A09E6676A09E667 );
+   casti_m128i( ctx->H, 1 ) = m128_const1_64( 0xBB67AE85BB67AE85 );
+   casti_m128i( ctx->H, 2 ) = m128_const1_64( 0x3C6EF3723C6EF372 );
+   casti_m128i( ctx->H, 3 ) = m128_const1_64( 0xA54FF53AA54FF53A );
+   casti_m128i( ctx->H, 4 ) = m128_const1_64( 0x510E527F510E527F );
+   casti_m128i( ctx->H, 5 ) = m128_const1_64( 0x9B05688C9B05688C );
+   casti_m128i( ctx->H, 6 ) = m128_const1_64( 0x1F83D9AB1F83D9AB );
+   casti_m128i( ctx->H, 7 ) = m128_const1_64( 0x5BE0CD195BE0CD19 );
   ctx->T0 = ctx->T1 = 0;
   ctx->ptr = 0;
   ctx->rounds = rounds;
@@ -773,12 +905,13 @@ blake32_4way_close( blake_4way_small_context *ctx, unsigned ub, unsigned n,
   else
      ctx->T0 -= 512 - bit_len;

-   buf[vptr] = _mm_set1_epi32( 0x80 );
+   buf[vptr] = m128_const1_64( 0x0000008000000080 );

   if ( vptr < 12 )
   {
      memset_zero_128( buf + vptr + 1, 13 - vptr  );
-      buf[ 13 ] = _mm_or_si128( buf[ 13 ], _mm_set1_epi32( 0x01000000UL ) );
+      buf[ 13 ] = _mm_or_si128( buf[ 13 ],
+                                m128_const1_64( 0x0100000001000000ULL ) );
      buf[ 14 ] = mm128_bswap_32( _mm_set1_epi32( th ) );
      buf[ 15 ] = mm128_bswap_32( _mm_set1_epi32( tl ) );
      blake32_4way( ctx, buf + vptr, 64 - ptr );
@@ -790,20 +923,14 @@ blake32_4way_close( blake_4way_small_context *ctx, unsigned ub, unsigned n,
      ctx->T0 = 0xFFFFFE00UL;
      ctx->T1 = 0xFFFFFFFFUL;
      memset_zero_128( buf, 56>>2 );
-      buf[ 13 ] = _mm_or_si128( buf[ 13 ], _mm_set1_epi32( 0x01000000UL ) );
+      buf[ 13 ] = _mm_or_si128( buf[ 13 ],
+                                m128_const1_64( 0x0100000001000000ULL ) );
      buf[ 14 ] = mm128_bswap_32( _mm_set1_epi32( th ) );
      buf[ 15 ] = mm128_bswap_32( _mm_set1_epi32( tl ) );
      blake32_4way( ctx, buf, 64 );
   }

-   casti_m128i( dst, 0 ) = mm128_bswap_32( casti_m128i( ctx->H, 0 ) );
-   casti_m128i( dst, 1 ) = mm128_bswap_32( casti_m128i( ctx->H, 1 ) );
-   casti_m128i( dst, 2 ) = mm128_bswap_32( casti_m128i( ctx->H, 2 ) );
-   casti_m128i( dst, 3 ) = mm128_bswap_32( casti_m128i( ctx->H, 3 ) );
-   casti_m128i( dst, 4 ) = mm128_bswap_32( casti_m128i( ctx->H, 4 ) );
-   casti_m128i( dst, 5 ) = mm128_bswap_32( casti_m128i( ctx->H, 5 ) );
-   casti_m128i( dst, 6 ) = mm128_bswap_32( casti_m128i( ctx->H, 6 ) );
-   casti_m128i( dst, 7 ) = mm128_bswap_32( casti_m128i( ctx->H, 7 ) );
+   mm128_block_bswap_32( (__m128i*)dst, (__m128i*)ctx->H );
 }

 #if defined (__AVX2__)
@@ -816,11 +943,14 @@ static void
 blake32_8way_init( blake_8way_small_context *sc, const sph_u32 *iv,
                   const sph_u32 *salt, int rounds )
 {
-   int i;
-   for ( i = 0; i < 8; i++ )
-      sc->H[i] = _mm256_set1_epi32( iv[i] );
-   for ( i = 0; i < 4; i++ )
-      sc->S[i] = _mm256_set1_epi32( salt[i] );
+   casti_m256i( sc->H, 0 ) = m256_const1_64( 0x6A09E6676A09E667 );
+   casti_m256i( sc->H, 1 ) = m256_const1_64( 0xBB67AE85BB67AE85 );
+   casti_m256i( sc->H, 2 ) = m256_const1_64( 0x3C6EF3723C6EF372 );
+   casti_m256i( sc->H, 3 ) = m256_const1_64( 0xA54FF53AA54FF53A );
+   casti_m256i( sc->H, 4 ) = m256_const1_64( 0x510E527F510E527F );
+   casti_m256i( sc->H, 5 ) = m256_const1_64( 0x9B05688C9B05688C );
+   casti_m256i( sc->H, 6 ) = m256_const1_64( 0x1F83D9AB1F83D9AB );
+   casti_m256i( sc->H, 7 ) = m256_const1_64( 0x5BE0CD195BE0CD19 );
   sc->T0 = sc->T1 = 0;
   sc->ptr = 0;
   sc->rounds = rounds;
@@ -872,18 +1002,14 @@ static void
 blake32_8way_close( blake_8way_small_context *sc, unsigned ub, unsigned n,
                    void *dst, size_t out_size_w32 )
 {
-//   union {
-        __m256i buf[16];
-//        sph_u32 dummy;
-//   } u;
-   size_t ptr, k;
+   __m256i buf[16];
+   size_t ptr;
   unsigned bit_len;
   sph_u32 th, tl;
-   __m256i *out;

   ptr = sc->ptr;
   bit_len = ((unsigned)ptr << 3);
-   buf[ptr>>2] = _mm256_set1_epi32( 0x80 );
+   buf[ptr>>2] = m256_const1_64( 0x0000008000000080ULL );
   tl = sc->T0 + bit_len;
   th = sc->T1;

@@ -905,7 +1031,7 @@ blake32_8way_close( blake_8way_small_context *sc, unsigned ub, unsigned n,
       memset_zero_256( buf + (ptr>>2) + 1, (52 - ptr) >> 2 );
       if ( out_size_w32 == 8 )
           buf[52>>2] = _mm256_or_si256( buf[52>>2],
-                                           _mm256_set1_epi32( 0x01000000UL ) );
+                                m256_const1_64( 0x0100000001000000ULL ) );
       *(buf+(56>>2)) = mm256_bswap_32( _mm256_set1_epi32( th ) );
       *(buf+(60>>2)) = mm256_bswap_32( _mm256_set1_epi32( tl ) );
       blake32_8way( sc, buf + (ptr>>2), 64 - ptr );
@@ -918,18 +1044,189 @@ blake32_8way_close( blake_8way_small_context *sc, unsigned ub, unsigned n,
        sc->T1 = SPH_C32(0xFFFFFFFFUL);
        memset_zero_256( buf, 56>>2 );
       if ( out_size_w32 == 8 )
-           buf[52>>2] = _mm256_set1_epi32( 0x01000000UL );
+           buf[52>>2] = m256_const1_64( 0x0100000001000000ULL );
        *(buf+(56>>2)) = mm256_bswap_32( _mm256_set1_epi32( th ) );
        *(buf+(60>>2)) = mm256_bswap_32( _mm256_set1_epi32( tl ) );
        blake32_8way( sc, buf, 64 );
   }
-   out = (__m256i*)dst;
-   for ( k = 0; k < out_size_w32; k++ )
-        out[k] = mm256_bswap_32( sc->H[k] );
+   mm256_block_bswap_32( (__m256i*)dst, (__m256i*)sc->H );
 }

 #endif

+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//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 )
+{
+   casti_m512i( sc->H, 0 ) = m512_const1_64( 0x6A09E6676A09E667 );
+   casti_m512i( sc->H, 1 ) = m512_const1_64( 0xBB67AE85BB67AE85 );
+   casti_m512i( sc->H, 2 ) = m512_const1_64( 0x3C6EF3723C6EF372 );
+   casti_m512i( sc->H, 3 ) = m512_const1_64( 0xA54FF53AA54FF53A );
+   casti_m512i( sc->H, 4 ) = m512_const1_64( 0x510E527F510E527F );
+   casti_m512i( sc->H, 5 ) = m512_const1_64( 0x9B05688C9B05688C );
+   casti_m512i( sc->H, 6 ) = m512_const1_64( 0x1F83D9AB1F83D9AB );
+   casti_m512i( sc->H, 7 ) = m512_const1_64( 0x5BE0CD195BE0CD19 );
+   sc->T0 = sc->T1 = 0;
+   sc->ptr = 0;
+   sc->rounds = rounds;
+}
+
+static void
+blake32_16way( blake_16way_small_context *sc, const void *data, size_t len )
+{
+   __m512i *vdata = (__m512i*)data;
+   __m512i *buf;
+   size_t ptr;
+   const int buf_size = 64;   // number of elements, sizeof/4
+   DECL_STATE32_16WAY
+   buf = sc->buf;
+   ptr = sc->ptr;
+   if ( len < buf_size - ptr )
+   {
+        memcpy_512( buf + (ptr>>2), vdata, len>>2 );
+        ptr += len;
+        sc->ptr = ptr;
+        return;
+   }
+   READ_STATE32_16WAY(sc);
+   while ( len > 0 )
+   {
+      size_t clen;
+
+      clen = buf_size - ptr;
+      if (clen > len)
+           clen = len;
+      memcpy_512( buf + (ptr>>2), vdata, clen>>2 );
+      ptr += clen;
+      vdata += (clen>>2);
+      len -= clen;
+      if ( ptr == buf_size )
+      {
+          if ( ( T0 = T0 + 512 ) < 512 )
+                T1 = T1 + 1;
+          COMPRESS32_16WAY( sc->rounds );
+          ptr = 0;
+      }
+   }
+   WRITE_STATE32_16WAY(sc);
+   sc->ptr = ptr;
+}
+
+static void
+blake32_16way_close( blake_16way_small_context *sc, unsigned ub, unsigned n,
+                    void *dst, size_t out_size_w32 )
+{
+   __m512i buf[16];
+   size_t ptr;
+   unsigned bit_len;
+   sph_u32 th, tl;
+
+   ptr = sc->ptr;
+   bit_len = ((unsigned)ptr << 3);
+   buf[ptr>>2] = m512_const1_64( 0x0000008000000080ULL );
+   tl = sc->T0 + bit_len;
+   th = sc->T1;
+
+   if ( ptr == 0 )
+   {
+        sc->T0 = 0xFFFFFE00UL;
+        sc->T1 = 0xFFFFFFFFUL;
+   }
+   else if ( sc->T0 == 0 )
+   {
+        sc->T0 = 0xFFFFFE00UL + bit_len;
+        sc->T1 = sc->T1 - 1;
+   }
+   else
+        sc->T0 -= 512 - bit_len;
+
+   if ( ptr <= 52 )
+   {
+       memset_zero_512( buf + (ptr>>2) + 1, (52 - ptr) >> 2 );
+       if ( out_size_w32 == 8 )
+           buf[52>>2] = _mm512_or_si512( buf[52>>2],
+                                m512_const1_64( 0x0100000001000000ULL ) );
+       buf[+56>>2] = mm512_bswap_32( _mm512_set1_epi32( th ) );
+       buf[+60>>2] = mm512_bswap_32( _mm512_set1_epi32( tl ) );
+       blake32_16way( sc, buf + (ptr>>2), 64 - ptr );
+   }
+   else
+   {
+        memset_zero_512( buf + (ptr>>2) + 1, (60-ptr) >> 2 );
+        blake32_16way( sc, buf + (ptr>>2), 64 - ptr );
+        sc->T0 = 0xFFFFFE00UL;
+        sc->T1 = 0xFFFFFFFFUL;
+        memset_zero_512( buf, 56>>2 );
+       if ( out_size_w32 == 8 )
+           buf[52>>2] = m512_const1_64( 0x0100000001000000ULL );
+        buf[56>>2] = mm512_bswap_32( _mm512_set1_epi32( th ) );
+        buf[60>>2] = mm512_bswap_32( _mm512_set1_epi32( tl ) );
+        blake32_16way( sc, buf, 64 );
+   }
+   mm512_block_bswap_32( (__m512i*)dst, (__m512i*)sc->H );
+}
+
+void
+blake256_16way_init(void *cc)
+{
+   blake32_16way_init( cc, IV256, salt_zero_8way_small, 14 );
+}
+
+void
+blake256_16way_update(void *cc, const void *data, size_t len)
+{
+        blake32_16way(cc, data, len);
+}
+
+void
+blake256_16way_close(void *cc, void *dst)
+{
+        blake32_16way_close(cc, 0, 0, dst, 8);
+}
+
+void blake256r14_16way_init(void *cc)
+{
+   blake32_16way_init( cc, IV256, salt_zero_8way_small, 14 );
+}
+
+void
+blake256r14_16way_update(void *cc, const void *data, size_t len)
+{
+   blake32_16way(cc, data, len);
+}
+
+void
+blake256r14_16way_close(void *cc, void *dst)
+{
+   blake32_16way_close(cc, 0, 0, dst, 8);
+}
+
+void blake256r8_16way_init(void *cc)
+{
+   blake32_16way_init( cc, IV256, salt_zero_8way_small, 8 );
+}
+
+void
+blake256r8_16way_update(void *cc, const void *data, size_t len)
+{
+   blake32_16way(cc, data, len);
+}
+
+void
+blake256r8_16way_close(void *cc, void *dst)
+{
+   blake32_16way_close(cc, 0, 0, dst, 8);
+}
+
+#endif // AVX512
+
+
+
 // Blake-256 4 way

 // default 14 rounds, backward copatibility
@@ -962,7 +1259,7 @@ blake256_8way_init(void *cc)
 }

 void
-blake256_8way(void *cc, const void *data, size_t len)
+blake256_8way_update(void *cc, const void *data, size_t len)
 {
        blake32_8way(cc, data, len);
 }
@@ -982,7 +1279,7 @@ void blake256r14_4way_init(void *cc)
 }

 void
-blake256r14_4way(void *cc, const void *data, size_t len)
+blake256r14_4way_update(void *cc, const void *data, size_t len)
 {
   blake32_4way(cc, data, len);
 }
@@ -1001,7 +1298,7 @@ void blake256r14_8way_init(void *cc)
 }

 void
-blake256r14_8way(void *cc, const void *data, size_t len)
+blake256r14_8way_update(void *cc, const void *data, size_t len)
 {
   blake32_8way(cc, data, len);
 }
@@ -1021,7 +1318,7 @@ void blake256r8_4way_init(void *cc)
 }

 void
-blake256r8_4way(void *cc, const void *data, size_t len)
+blake256r8_4way_update(void *cc, const void *data, size_t len)
 {
   blake32_4way(cc, data, len);
 }
@@ -1040,7 +1337,7 @@ void blake256r8_8way_init(void *cc)
 }

 void
-blake256r8_8way(void *cc, const void *data, size_t len)
+blake256r8_8way_update(void *cc, const void *data, size_t len)
 {
   blake32_8way(cc, data, len);
 }
--- a/algo/blake/blake256-hash-4way.c.new
+++ b/algo/blake/blake256-hash-4way.c.new
@@ -1,322 +0,0 @@
-// convert blake256 32 bit to use 64 bit with serial vectoring
-//
-//  cut calls to GS in half
-//
-// combine V
-// v0 = {V0,V1}
-// v1 = {V2,V3}
-// v2 = {V4,V5}
-// v3 = {V6,V7}
-// v4 = {V8,V9}
-// v5 = {VA,VB}
-// v6 = {VC,VD}
-// v7 = {CE,VF}
-//
-// v6x = {VD,VC}      swap(VC,VD)   swap(v6)
-// v7x = {VF,VE}      swap(VE,VF)   swap(v7)
-//
-// V0 = v1v0
-// V1 = v3v2
-// V2 = v5v4
-// V3 = v7v6
-// V4 = v9v8
-// V5 = vbva
-// V6 = vdvc
-// V7 = vfve
-//
-// The rotate in ROUND is to effect straddle and unstraddle for the third
-// and 4th iteration of GS.
-// It concatenates 2 contiguous 256 bit vectors and extracts the middle
-// 256 bits. After the transform they must be restored with only the
-// chosen bits modified in the original 2 vectors.
-// ror1x128 achieves this by putting the chosen bits in arg1, the "low"
-// 256 bit vector and saves the untouched bits temporailly in arg0, the
-// "high" 256 bit vector. Simply reverse the process to restore data back
-// to original positions.
-
-// Use standard 4way when AVX2 is not available use x2 mode with AVX2.
-//
-// Data is organised the same as 32 bit 4 way, in effect serial vectoring
-// on top of parallel vectoring. Same data in the same place just taking
-// two chunks at a time.
-//
-// Transparent to user, x2 mode used when AVX2 detected.
-// Use existing 4way context but revert to scalar types.
-// Same interleave function (128 bit) or x2 with 256 bit?
-// User trsnaparency would have to apply to interleave as well.
-//
-// Use common 4way update and close
-
-/*
-typedef struct {
-   unsigned char buf[64<<2];
-   uint32_t H[8<<2];
-   uint32_t S[4<<2];
-   size_t ptr;
-   uint32_t T0, T1;
-   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
-} blakex2_4way_small_context __attribute__ ((aligned (64)));
-*/
-
-static void
-blake32x2_4way_init( blake_4way_small_context *ctx, const uint32_t *iv,
-                   const uint32_t *salt, int rounds )
-{
-   casti_m128i( ctx->H, 0 ) = _mm_set1_epi32( iv[0] );
-   casti_m128i( ctx->H, 1 ) = _mm_set1_epi32( iv[1] );
-   casti_m128i( ctx->H, 2 ) = _mm_set1_epi32( iv[2] );
-   casti_m128i( ctx->H, 3 ) = _mm_set1_epi32( iv[3] );
-   casti_m128i( ctx->H, 4 ) = _mm_set1_epi32( iv[4] );
-   casti_m128i( ctx->H, 5 ) = _mm_set1_epi32( iv[5] );
-   casti_m128i( ctx->H, 6 ) = _mm_set1_epi32( iv[6] );
-   casti_m128i( ctx->H, 7 ) = _mm_set1_epi32( iv[7] );
-
-   casti_m128i( ctx->S, 0 ) = m128_zero;
-   casti_m128i( ctx->S, 1 ) = m128_zero;
-   casti_m128i( ctx->S, 2 ) = m128_zero;
-   casti_m128i( ctx->S, 3 ) = m128_zero;
-/*
-   sc->S[0] = _mm_set1_epi32( salt[0] );
-   sc->S[1] = _mm_set1_epi32( salt[1] );
-   sc->S[2] = _mm_set1_epi32( salt[2] );
-   sc->S[3] = _mm_set1_epi32( salt[3] );
-*/
-   ctx->T0 = ctx->T1 = 0;
-   ctx->ptr = 0;
-   ctx->rounds = rounds;
-}
-
-static void
-blake32x2( blake_4way_small_context *ctx, const void *data, size_t len )
-{
-   __m128i *buf = (__m256i*)ctx->buf;
-   size_t  bptr = ctx->ptr << 2;
-   size_t  vptr = ctx->ptr >> 3;
-   size_t  blen = len << 2;
-//    unsigned char *buf = ctx->buf;
-//    size_t ptr         = ctx->ptr<<4;  // repurposed
-    DECL_STATE32x2
-
-//    buf = sc->buf;
-//    ptr = sc->ptr;
-
-// adjust len for use with ptr, clen, all absolute bytes.
-//    int blen = len<<2;
-
-    if ( blen < (sizeof ctx->buf) - bptr )
-    {
-        memcpy( buf + vptr, data, blen );
-        ptr += blen;
-        ctx->ptr = bptr >> 2;;
-        return;
-    }
-
-    READ_STATE32( ctx );
-    while ( blen > 0 )
-    {
-        size_t clen;
-
-        clen = ( sizeof sc->buf ) - ptr;
-        if ( clen > blen )
-            clen = blen;
-        memcpy( buf + vptr, data, clen );
-        bptr += clen;
-        vptr = bptr >> 5;
-	data = (const unsigned char *)data + clen;
-        blen -= clen;
-        if ( bptr == sizeof ctx->buf )
-       	{
-           if ( ( T0 = T0 + 512 ) < 512 ) // not needed, will never rollover
-               T1 += 1;
-           COMPRESS32x2_4WAY( ctx->rounds );
-           ptr = 0;
-        }
-    }
-    WRITE_STATE32x2( ctx );
-    ctx->ptr = bptr >> 2;
-}
-
-static void
-blake32x2_4way_close( blake_4way_small_context *ctx, void *dst )
-{
-   __m256i buf[8] __attribute__ ((aligned (64)));
-   size_t   ptr     = ctx->ptr;
-   size_t   vptr    = ctx->ptr>>2;
-   unsigned bit_len = ( (unsigned)ptr << 3 );  // one lane
-   uint32_t th      = ctx->T1;
-   uint32_t tl      = ctx->T0 + bit_len;
-
-   if ( ptr == 0 )
-   {
-        ctx->T0 = 0xFFFFFE00UL;
-        ctx->T1 = 0xFFFFFFFFUL;
-   }
-   else if ( ctx->T0 == 0 )
-   {
-      ctx->T0 = 0xFFFFFE00UL + bit_len;
-      ctx->T1 -= 1;
-   }
-   else
-      ctx->T0 -= 512 - bit_len;
-
-   // memset doesn't do ints
-   buf[ vptr ] = _mm256_set_epi32( 0,0,0,0, 0x80, 0x80, 0x80, 0x80 );
-
-   if ( vptr < 5 )
-   {
-       memset_zero_256( buf + vptr + 1, 6 - vptr  );
-       buf[ 6 ] = _mm256_or_si256( vbuf[ 6 ], _mm256_set_epi32(
-             0x01000000UL,0x01000000UL,0x01000000UL,0x01000000UL, 0,0,0,0 ) ); 
-       buf[ 7 ] = mm256_bswap_32( _mm256_set_epi32( tl,tl,tl,tl,
-			                            th,th,th,th ) );
-       blake32x2_4way( ctx, buf + vptr, 64 - ptr );
-   }
-   else
-   {
-       memset_zero_256( vbuf + vptr + 1, 7 - vptr );
-       blake32x2_4way( ctx,  vbuf + ptr, 64 - ptr );
-       ctx->T0 = 0xFFFFFE00UL;
-       ctx->T1 = 0xFFFFFFFFUL;
-       buf[ 6 ] = mm256_zero;
-       buf[ 6 ] = _mm256_set_epi32( 0,0,0,0,
-		         0x01000000UL,0x01000000UL,0x01000000UL,0x01000000UL );
-       buf[ 7 ] = mm256_bswap_32( _mm256_set_epi32( tl, tl, tl, tl,
-                                                    th, th, th, th );
-       blake32x2_4way( ctx, buf, 64 );
-   }
-
-   casti_m256i( dst, 0 ) = mm256_bswap_32( casti_m256i( ctx->H, 0 ) );
-   casti_m256i( dst, 1 ) = mm256_bswap_32( casti_m256i( ctx->H, 1 ) );
-   casti_m256i( dst, 2 ) = mm256_bswap_32( casti_m256i( ctx->H, 2 ) );
-   casti_m256i( dst, 3 ) = mm256_bswap_32( casti_m256i( ctx->H, 3 ) );
-}
-
-
-
-
-#define DECL_STATE32x2_4WAY \
-   __m256i H0, H1, H2, H3; \
-   __m256i S0, S1; \
-   uint32_t T0, T1;
-
-#define READ_STATE32x2_4WAY(state)  do \
-{ \
-   H0 = casti_m256i( state->H, 0 ); \
-   H1 = casti_m256i( state->H, 1 ); \
-   H2 = casti_m256i( state->H, 2 ); \
-   H3 = casti_m256i( state->H, 3 ); \
-   S0 = casti_m256i( state->S, 0 ); \
-   S1 = casti_m256i( state->S, 1 ); \
-   T0 = state->T0; \
-   T1 = state->T1; \
-
-#define WRITE_STATE32x2_4WAY(state)   do { \
-   casti_m256i( state->H, 0 ) = H0; \
-   casti_m256i( state->H, 1 ) = H1; \
-   casti_m256i( state->H, 2 ) = H2; \
-   casti_m256i( state->H, 3 ) = H3; \
-   casti_m256i( state->S, 0 ) = S0; \
-   casti_m256i( state->S, 1 ) = S1; \
-   state->T0 = T0; \
-   state->T1 = T1; \
-} while (0)
-
-
-#define GSx2_4WAY( m0m2, m1m3, c0c2, c1c3, a, b, c, d ) do \
-{ \
-   a = _mm256_add_epi32( _mm256_add_epi32( _mm256_xor_si256( \
-          _mm256_set_epi32( c1,c3, c1,c3, c1,c3, c1,c3 ), \
-	  _mm256_set_epi32( m0,m2, m0,m2, m0,m2, m0,m2 ) ), b ), a ); \
-   d = mm256_ror_32( _mm_xor_si128( d, a ), 16 ); \
-   c = _mm256_add_epi32( c, d ); \
-   b = mm256_ror_32( _mm256_xor_si256( b, c ), 12 ); \
-   a = _mm256_add_epi32( _mm256_add_epi32( _mm256_xor_si256( \
-          _mm256_set_epi32( c0,c2, c0,c2, c0,c2, c0,c2 ), \
-	  _mm256_set_epi32( m1,m3, m1,m3, m1,m3, m1,m3 ) ), b ), a ); \
-   d = mm256_ror_32( _mm256_xor_si256( d, a ), 8 ); \
-   c = _mm256_add_epi32( c, d ); \
-   b = mm256_ror_32( _mm256_xor_si256( b, c ), 7 ); \
-} while (0)
-
-#define ROUND_Sx2_4WAY(r)   do \
-{ \
-  GS2_4WAY( Mx(r, 0),  Mx(r, 1),  Mx(r, 2),  Mx(r, 3), \
-           CSx(r, 0), CSx(r, 1), CSx(r, 2), CSx(r, 3), V0, V2, V4, V6 ); \
-  GS2_4WAY( Mx(r, 4),  Mx(r, 5),  Mx(r, 6),  Mx(r, 7), \
-           CSx(r, 4), CSx(r, 5), CSx(r, 6), CSx(r, 7), V1, V3, V5, V7 ); \
-  mm256_ror1x128_512( V3, V2 ); \
-  mm256_ror1x128_512( V6, V7 ); \
-  GS2_4WAY( Mx(r, 8),  Mx(r, 9),  Mx(r, A),  Mx(r, B), \
-           CSx(r, 8), CSx(r, 9), CSx(r, A), CSx(r, B), V0, V2, V5, V7 ); \
-  GS2_4WAY( Mx(r, C),  Mx(r, D),  Mx(r, C),  Mx(r, D), \
-           CSx(r, C), CSx(r, D), CSx(r, C), CSx(r, D), V1, V3, V4, V6 ); \
-  mm256_rol1x128_512( V2, V3 ); \
-  mm256_rol1x128_512( V7, V6 ); 
-
-#define COMPRESS32x2_4WAY( rounds ) do \
-{ \
-   __m256i M0, M1, M2, M3, M4, M5, M6, M7; \
-   __m256i V0, V1, V2, V3, V4, V5, V6, V7; \
-   unsigned r; \
-   V0 = H0; \
-   V1 = H1; \
-   V2 = H2; \
-   V3 = H3; \
-   V4 = _mm256_xor_si256( S0, _mm256_set_epi32( CS1, CS1, CS1, CS1, \
-			                        CS0, CS0, CS0, CS0 ) ); \
-   V5 = _mm256_xor_si256( S1, _mm256_set_epi32( CS3, CS3, CS3, CS3, \
-                                                CS2, CS2, CS2, CS2 ) ); \
-   V6 = _mm256_xor_si256( _mm256_set1_epi32( T0 ), \
-                              _mm256_set_epi32( CS5, CS5, CS5, CS5, \
-		                                CS4, CS4, CS4, CS4 ) ); \
-   V7 = _mm256_xor_si256( _mm256_set1_epi32( T1 ), \
-                              _mm256_set_epi32( CS7, CS7, CS7, CS7, \
-                                                CS6, CS6, CS6, CS6 ) ); \
-   M0 = mm256_bswap_32( buf[ 0] ); \
-   M1 = mm256_bswap_32( buf[ 1] ); \
-   M2 = mm256_bswap_32( buf[ 2] ); \
-   M3 = mm256_bswap_32( buf[ 3] ); \
-   M4 = mm256_bswap_32( buf[ 4] ); \
-   M5 = mm256_bswap_32( buf[ 5] ); \
-   M6 = mm256_bswap_32( buf[ 6] ); \
-   M7 = mm256_bswap_32( buf[ 7] ); \
-   ROUND_Sx2_4WAY(0); \
-   ROUND_Sx2_4WAY(1); \
-   ROUND_Sx2_4WAY(2); \
-   ROUND_Sx2_4WAY(3); \
-   ROUND_Sx2_4WAY(4); \
-   ROUND_Sx2_4WAY(5); \
-   ROUND_Sx2_4WAY(6); \
-   ROUND_Sx2_4WAY(7); \
-   if (rounds == 14) \
-   { \
-      ROUND_Sx2_4WAY(8); \
-      ROUND_Sx2_4WAY(9); \
-      ROUND_Sx2_4WAY(0); \
-      ROUND_Sx2_4WAY(1); \
-      ROUND_Sx2_4WAY(2); \
-      ROUND_Sx2_4WAY(3); \
-   } \
-   H0 = _mm256_xor_si256( _mm256_xor_si256( \
-			           _mm256_xor_si256( V8, V0 ), S0 ), H0 ); \
-   H1 = _mm256_xor_si256( _mm256_xor_si256( \
-			           _mm256_xor_si256( V9, V1 ), S1 ), H1 ); \
-   H2 = _mm256_xor_si256( _mm256_xor_si256( \
-			           _mm256_xor_si256( VA, V2 ), S2 ), H2 ); \
-   H3 = _mm256_xor_si256( _mm256_xor_si256( \
-			           _mm256_xor_si256( VB, V3 ), S3 ), H3 ); \
-} while (0)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
--- a/algo/blake/blake2b-4way.c
+++ b/algo/blake/blake2b-4way.c
@@ -0,0 +1,113 @@
+/**
+ * Blake2-B Implementation
+ * tpruvot@github 2015-2016
+ */
+
+#include "blake2b-gate.h"
+#include <string.h>
+#include <stdint.h>
+#include "blake2b-hash-4way.h"
+
+#if defined(BLAKE2B_8WAY)
+
+int scanhash_blake2b_8way( struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[8*8] __attribute__ ((aligned (128)));;
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));;
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   blake2b_8way_ctx ctx __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[49]);   // 3*16+1
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   int thr_id = mythr->id;
+   __m512i  *noncev = (__m512i*)vdata + 9;   // aligned
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+
+   uint32_t n = first_nonce;
+
+   mm512_bswap32_intrlv80_8x64( vdata, pdata );
+
+   do {
+      *noncev = mm512_intrlv_blend_32( mm512_bswap_32(
+                _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
+                                  n+3, 0, n+2, 0, n+1, 0, n  , 0 ) ), *noncev );
+
+      blake2b_8way_init( &ctx );
+      blake2b_8way_update( &ctx, vdata, 80 );
+      blake2b_8way_final( &ctx, hash );
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( hash7[ lane<<1 ] < Htarg )
+      {
+          extr_lane_8x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+          {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+          }
+      }
+      n += 8;
+   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#elif defined(BLAKE2B_4WAY)
+
+// Function not used, code inlined.
+void blake2b_4way_hash(void *output, const void *input)
+{
+    blake2b_4way_ctx ctx;
+    blake2b_4way_init( &ctx );
+    blake2b_4way_update( &ctx, input, 80 );
+    blake2b_4way_final( &ctx, output );
+}
+
+int scanhash_blake2b_4way( struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr )
+{
+	uint32_t hash[8*4] __attribute__ ((aligned (64)));;
+   uint32_t vdata[20*4] __attribute__ ((aligned (32)));;
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   blake2b_4way_ctx ctx __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[25]);   // 3*8+1
+	uint32_t *pdata = work->data;
+	uint32_t *ptarget = work->target;
+   int thr_id = mythr->id;
+   __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+	const uint32_t Htarg = ptarget[7];
+	const uint32_t first_nonce = pdata[19];
+
+	uint32_t n = first_nonce;
+
+   mm256_bswap32_intrlv80_4x64( vdata, pdata );
+
+	do {
+      *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
+
+      blake2b_4way_init( &ctx ); 
+      blake2b_4way_update( &ctx, vdata, 80 );
+      blake2b_4way_final( &ctx, hash );
+
+      for ( int lane = 0; lane < 4; lane++ )
+      if ( hash7[ lane<<1 ] < Htarg )
+      {
+          extr_lane_4x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+          {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+          }
+      }
+      n += 4;
+   } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#endif
--- a/algo/blake/blake2b-gate.c
+++ b/algo/blake/blake2b-gate.c
@@ -0,0 +1,20 @@
+#include "blake2b-gate.h"
+
+
+bool register_blake2b_algo( algo_gate_t* gate )
+{
+#if defined(BLAKE2B_8WAY)
+  gate->scanhash  = (void*)&scanhash_blake2b_8way;
+//  gate->hash      = (void*)&blake2b_8way_hash;
+#elif defined(BLAKE2B_4WAY)
+  gate->scanhash  = (void*)&scanhash_blake2b_4way;
+  gate->hash      = (void*)&blake2b_4way_hash;
+#else
+  gate->scanhash  = (void*)&scanhash_blake2b;
+  gate->hash      = (void*)&blake2b_hash;
+#endif
+  gate->optimizations =  AVX2_OPT | AVX512_OPT;
+  return true;
+};
+
+
--- a/algo/blake/blake2b-gate.h
+++ b/algo/blake/blake2b-gate.h
@@ -0,0 +1,34 @@
+#ifndef __BLAKE2B_GATE_H__
+#define __BLAKE2B_GATE_H__ 1
+
+#include <stdint.h>
+#include "algo-gate-api.h"
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define BLAKE2B_8WAY
+#elif defined(__AVX2__)
+  #define BLAKE2B_4WAY
+#endif
+
+bool register_blake2b_algo( algo_gate_t* gate );
+
+#if defined(BLAKE2B_8WAY)
+
+//void blake2b_8way_hash( void *state, const void *input );
+int scanhash_blake2b_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined(BLAKE2B_4WAY)
+
+void blake2b_4way_hash( void *state, const void *input );
+int scanhash_blake2b_4way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+#else
+
+void blake2b_hash( void *state, const void *input );
+int scanhash_blake2b( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+
+#endif
--- a/algo/blake/blake2b-hash-4way.c
+++ b/algo/blake/blake2b-hash-4way.c
@@ -0,0 +1,372 @@
+/*
+ * Copyright 2009 Colin Percival, 2014 savale
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file was originally written by Colin Percival as part of the Tarsnap
+ * online backup system.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "blake2b-hash-4way.h"
+
+static const uint8_t sigma[12][16] =
+{
+      { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
+      { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
+      { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
+      { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
+      { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
+      { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
+      { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
+      { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
+      { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
+      { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
+      { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
+      { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
+};
+
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define B2B8W_G(a, b, c, d, x, y) \
+{ \
+   v[a] = _mm512_add_epi64( _mm512_add_epi64( v[a], v[b] ), x ); \
+   v[d] = mm512_ror_64( _mm512_xor_si512( v[d], v[a] ), 32 ); \
+   v[c] = _mm512_add_epi64( v[c], v[d] ); \
+   v[b] = mm512_ror_64( _mm512_xor_si512( v[b], v[c] ), 24 ); \
+   v[a] = _mm512_add_epi64( _mm512_add_epi64( v[a], v[b] ), y ); \
+   v[d] = mm512_ror_64( _mm512_xor_si512( v[d], v[a] ), 16 ); \
+   v[c] = _mm512_add_epi64( v[c], v[d] ); \
+   v[b] = mm512_ror_64( _mm512_xor_si512( v[b], v[c] ), 63 ); \
+}
+
+static void blake2b_8way_compress( blake2b_8way_ctx *ctx, int last )
+{  
+   __m512i v[16], m[16];
+
+   v[ 0] = ctx->h[0];
+   v[ 1] = ctx->h[1];
+   v[ 2] = ctx->h[2];
+   v[ 3] = ctx->h[3];
+   v[ 4] = ctx->h[4];
+   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[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] ) );
+
+   if ( last )
+      v[14] = mm512_not( v[14] );
+
+   m[ 0] = ctx->b[ 0];
+   m[ 1] = ctx->b[ 1];
+   m[ 2] = ctx->b[ 2];
+   m[ 3] = ctx->b[ 3];
+   m[ 4] = ctx->b[ 4];
+   m[ 5] = ctx->b[ 5];
+   m[ 6] = ctx->b[ 6];
+   m[ 7] = ctx->b[ 7];
+   m[ 8] = ctx->b[ 8];
+   m[ 9] = ctx->b[ 9];
+   m[10] = ctx->b[10];
+   m[11] = ctx->b[11];
+   m[12] = ctx->b[12];
+   m[13] = ctx->b[13];
+   m[14] = ctx->b[14];
+   m[15] = ctx->b[15];
+
+   for ( int i = 0; i < 12; i++ )
+   {
+      B2B8W_G( 0, 4,  8, 12, m[ sigma[i][ 0] ], m[ sigma[i][ 1] ] );
+      B2B8W_G( 1, 5,  9, 13, m[ sigma[i][ 2] ], m[ sigma[i][ 3] ] );
+      B2B8W_G( 2, 6, 10, 14, m[ sigma[i][ 4] ], m[ sigma[i][ 5] ] );
+      B2B8W_G( 3, 7, 11, 15, m[ sigma[i][ 6] ], m[ sigma[i][ 7] ] );
+      B2B8W_G( 0, 5, 10, 15, m[ sigma[i][ 8] ], m[ sigma[i][ 9] ] );
+      B2B8W_G( 1, 6, 11, 12, m[ sigma[i][10] ], m[ sigma[i][11] ] );
+      B2B8W_G( 2, 7,  8, 13, m[ sigma[i][12] ], m[ sigma[i][13] ] );
+      B2B8W_G( 3, 4,  9, 14, m[ sigma[i][14] ], m[ sigma[i][15] ] );
+   }
+
+   ctx->h[0] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[0], v[0] ), v[ 8] );
+   ctx->h[1] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[1], v[1] ), v[ 9] );
+   ctx->h[2] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[2], v[2] ), v[10] );
+   ctx->h[3] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[3], v[3] ), v[11] );
+   ctx->h[4] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[4], v[4] ), v[12] );
+   ctx->h[5] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[5], v[5] ), v[13] );
+   ctx->h[6] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[6], v[6] ), v[14] );
+   ctx->h[7] = _mm512_xor_si512( _mm512_xor_si512( ctx->h[7], v[7] ), v[15] );
+}
+
+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_xor_si512( ctx->h[0], m512_const1_64( 0x01010020 ) );
+
+   ctx->t[0] = 0;
+   ctx->t[1] = 0;
+   ctx->c = 0;
+   ctx->outlen = 32;
+
+   for ( i = 0; i < 16; i++ )
+     ctx->b[i] = m512_zero;
+
+   return 0;
+}
+
+
+void blake2b_8way_update( blake2b_8way_ctx *ctx, const void *input,
+                          size_t inlen )
+{
+   __m512i* in =(__m512i*)input;
+
+   size_t i, c;
+   c = ctx->c >> 3;
+
+   for ( i = 0; i < (inlen >> 3); i++ )
+   {
+      if ( ctx->c == 128 )
+      {
+         ctx->t[0] += ctx->c;
+         if ( ctx->t[0] < ctx->c )
+            ctx->t[1]++;
+         blake2b_8way_compress( ctx, 0 );
+         ctx->c = 0;
+      }
+      ctx->b[ c++ ] = in[i];
+      ctx->c += 8;
+   }
+}
+
+void blake2b_8way_final( blake2b_8way_ctx *ctx, void *out )
+{
+   size_t c;
+   c = ctx->c >> 3;
+
+   ctx->t[0] += ctx->c;
+   if ( ctx->t[0] < ctx->c )
+      ctx->t[1]++;
+
+   while ( ctx->c < 128 )
+   {
+      ctx->b[c++] = m512_zero;
+      ctx->c += 8;
+   }
+
+   blake2b_8way_compress( ctx, 1 );           // final block flag = 1
+
+   casti_m512i( out, 0 ) = ctx->h[0];
+   casti_m512i( out, 1 ) = ctx->h[1];
+   casti_m512i( out, 2 ) = ctx->h[2];
+   casti_m512i( out, 3 ) = ctx->h[3];
+}
+
+#endif
+
+#if defined(__AVX2__)
+
+// G Mixing function.
+
+#define B2B_G(a, b, c, d, x, y) \
+{ \
+   v[a] = _mm256_add_epi64( _mm256_add_epi64( v[a], v[b] ), x ); \
+	v[d] = mm256_ror_64( _mm256_xor_si256( v[d], v[a] ), 32 ); \
+	v[c] = _mm256_add_epi64( v[c], v[d] ); \
+	v[b] = mm256_ror_64( _mm256_xor_si256( v[b], v[c] ), 24 ); \
+	v[a] = _mm256_add_epi64( _mm256_add_epi64( v[a], v[b] ), y ); \
+	v[d] = mm256_ror_64( _mm256_xor_si256( v[d], v[a] ), 16 ); \
+	v[c] = _mm256_add_epi64( v[c], v[d] ); \
+	v[b] = mm256_ror_64( _mm256_xor_si256( v[b], v[c] ), 63 ); \
+}
+
+// Initialization Vector.
+/*
+static const uint64_t blake2b_iv[8] = {
+	0x6A09E667F3BCC908, 0xBB67AE8584CAA73B,
+	0x3C6EF372FE94F82B, 0xA54FF53A5F1D36F1,
+	0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
+	0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179
+};
+*/
+
+static void blake2b_4way_compress( blake2b_4way_ctx *ctx, int last )
+{
+	__m256i v[16], m[16];
+
+   v[ 0] = ctx->h[0];
+   v[ 1] = ctx->h[1];
+   v[ 2] = ctx->h[2];
+   v[ 3] = ctx->h[3];
+   v[ 4] = ctx->h[4];
+   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[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] ) );
+
+   if ( last )   
+		v[14] = mm256_not( v[14] );
+
+   m[ 0] = ctx->b[ 0];
+   m[ 1] = ctx->b[ 1];
+   m[ 2] = ctx->b[ 2];
+   m[ 3] = ctx->b[ 3];
+   m[ 4] = ctx->b[ 4];
+   m[ 5] = ctx->b[ 5];
+   m[ 6] = ctx->b[ 6];
+   m[ 7] = ctx->b[ 7];
+   m[ 8] = ctx->b[ 8];
+   m[ 9] = ctx->b[ 9];
+   m[10] = ctx->b[10];
+   m[11] = ctx->b[11];
+   m[12] = ctx->b[12];
+   m[13] = ctx->b[13];
+   m[14] = ctx->b[14];
+   m[15] = ctx->b[15];
+   
+	for ( int i = 0; i < 12; i++ )
+   { 
+		B2B_G( 0, 4,  8, 12, m[ sigma[i][ 0] ], m[ sigma[i][ 1] ] );
+		B2B_G( 1, 5,  9, 13, m[ sigma[i][ 2] ], m[ sigma[i][ 3] ] );
+		B2B_G( 2, 6, 10, 14, m[ sigma[i][ 4] ], m[ sigma[i][ 5] ] );
+		B2B_G( 3, 7, 11, 15, m[ sigma[i][ 6] ], m[ sigma[i][ 7] ] );
+		B2B_G( 0, 5, 10, 15, m[ sigma[i][ 8] ], m[ sigma[i][ 9] ] );
+		B2B_G( 1, 6, 11, 12, m[ sigma[i][10] ], m[ sigma[i][11] ] );
+		B2B_G( 2, 7,  8, 13, m[ sigma[i][12] ], m[ sigma[i][13] ] );
+		B2B_G( 3, 4,  9, 14, m[ sigma[i][14] ], m[ sigma[i][15] ] );
+	}
+
+   ctx->h[0] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[0], v[0] ), v[ 8] );
+   ctx->h[1] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[1], v[1] ), v[ 9] );
+   ctx->h[2] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[2], v[2] ), v[10] );
+   ctx->h[3] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[3], v[3] ), v[11] );
+   ctx->h[4] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[4], v[4] ), v[12] );
+   ctx->h[5] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[5], v[5] ), v[13] );
+   ctx->h[6] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[6], v[6] ), v[14] );
+   ctx->h[7] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[7], v[7] ), v[15] );
+}
+
+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_xor_si256( ctx->h[0], m256_const1_64( 0x01010020 ) );
+
+	ctx->t[0] = 0;
+	ctx->t[1] = 0;
+	ctx->c = 0;
+	ctx->outlen = 32;
+
+   for ( i = 0; i < 16; i++ )
+     ctx->b[i] = m256_zero;
+
+	return 0;
+}
+
+void blake2b_4way_update( blake2b_4way_ctx *ctx, const void *input,
+                          size_t inlen ) 
+{
+   __m256i* in =(__m256i*)input;
+
+	size_t i, c;
+   c = ctx->c >> 3; 
+
+	for ( i = 0; i < (inlen >> 3); i++ )
+   {
+		if ( ctx->c == 128 )
+      { 
+			ctx->t[0] += ctx->c;
+			if ( ctx->t[0] < ctx->c )
+				ctx->t[1]++;
+			blake2b_4way_compress( ctx, 0 );
+			ctx->c = 0;
+		}
+      ctx->b[ c++ ] = in[i];
+      ctx->c += 8;
+   }
+}
+
+void blake2b_4way_final( blake2b_4way_ctx *ctx, void *out )
+{
+	size_t c;
+   c = ctx->c >> 3;
+
+	ctx->t[0] += ctx->c;
+	if ( ctx->t[0] < ctx->c )
+		ctx->t[1]++;
+
+	while ( ctx->c < 128 )
+   {
+      ctx->b[c++] = m256_zero;
+      ctx->c += 8;
+   }
+
+   blake2b_4way_compress( ctx, 1 );           // final block flag = 1
+
+   casti_m256i( out, 0 ) = ctx->h[0];
+   casti_m256i( out, 1 ) = ctx->h[1];
+   casti_m256i( out, 2 ) = ctx->h[2];
+   casti_m256i( out, 3 ) = ctx->h[3];
+}
+
+#endif
--- a/algo/blake/blake2b-hash-4way.h
+++ b/algo/blake/blake2b-hash-4way.h
@@ -0,0 +1,53 @@
+#pragma once
+#ifndef __BLAKE2B_HASH_4WAY_H__
+#define __BLAKE2B_HASH_4WAY_H__
+
+#include "simd-utils.h"
+#include <stddef.h>
+#include <stdint.h>
+
+#if defined(_MSC_VER)
+#include <inttypes.h>
+#define inline __inline
+#define ALIGN(x) __declspec(align(x))
+#else
+#define ALIGN(x) __attribute__((aligned(x)))
+#endif
+
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+ALIGN(128) typedef struct {
+   __m512i b[16]; // input buffer
+   __m512i h[8];  // chained state
+   uint64_t t[2];  // total number of bytes
+   size_t c;       // pointer for b[]
+   size_t outlen;  // digest size
+} blake2b_8way_ctx;
+
+int blake2b_8way_init( blake2b_8way_ctx *ctx );
+void blake2b_8way_update( blake2b_8way_ctx *ctx, const void *input,
+                          size_t inlen );
+void blake2b_8way_final( blake2b_8way_ctx *ctx, void *out );
+
+#endif
+
+#if defined(__AVX2__)
+
+// state context
+ALIGN(128) typedef struct {
+	__m256i b[16]; // input buffer
+	__m256i h[8];  // chained state
+	uint64_t t[2];  // total number of bytes
+	size_t c;       // pointer for b[]
+	size_t outlen;  // digest size
+} blake2b_4way_ctx;
+
+int blake2b_4way_init( blake2b_4way_ctx *ctx );
+void blake2b_4way_update( blake2b_4way_ctx *ctx, const void *input,
+                          size_t inlen );
+void blake2b_4way_final( blake2b_4way_ctx *ctx, void *out );
+
+#endif
+
+#endif
--- a/algo/blake/blake2b.c
+++ b/algo/blake/blake2b.c
@@ -3,13 +3,11 @@
 * tpruvot@github 2015-2016
 */

-#include "algo-gate-api.h"
+#include "blake2b-gate.h"
 #include <string.h>
 #include <stdint.h>
 #include "algo/blake/sph_blake2b.h"

-//static __thread sph_blake2b_ctx s_midstate;
-//static __thread sph_blake2b_ctx s_ctx;
 #define MIDLEN 76
 #define A 64

@@ -25,16 +23,6 @@ void blake2b_hash(void *output, const void *input)
 	memcpy(output, hash, 32);
 }

-/*
-static void blake2b_hash_end(uint32_t *output, const uint32_t *input)
-{
-	s_ctx.outlen = MIDLEN;
-	memcpy(&s_ctx, &s_midstate, 32 + 16 + MIDLEN);
-	sph_blake2b_update(&s_ctx, (uint8_t*) &input[MIDLEN/4], 80 - MIDLEN);
-	sph_blake2b_final(&s_ctx, (uint8_t*) output);
-}
-*/
-
 int scanhash_blake2b( struct work *work, uint32_t max_nonce,
                      uint64_t *hashes_done, struct thr_info *mythr )
 {
@@ -45,7 +33,7 @@ int scanhash_blake2b( struct work *work, uint32_t max_nonce,
   int thr_id = mythr->id;  // thr_id arg is deprecated

 	const uint32_t Htarg = ptarget[7];
-	const uint32_t first_nonce = pdata[8];
+	const uint32_t first_nonce = pdata[19];

 	uint32_t n = first_nonce;

@@ -53,179 +41,23 @@ int scanhash_blake2b( struct work *work, uint32_t max_nonce,
 		be32enc(&endiandata[i], pdata[i]);
 	}

-	// midstate (untested yet)
-	//blake2b_init(&s_midstate, 32, NULL, 0);
-	//blake2b_update(&s_midstate, (uint8_t*) endiandata, MIDLEN);
-	//memcpy(&s_ctx, &s_midstate, sizeof(blake2b_ctx));
-
 	do {
-		be32enc(&endiandata[8], n);
+		be32enc(&endiandata[19], n);
 		//blake2b_hash_end(vhashcpu, endiandata);
 		blake2b_hash(vhashcpu, endiandata);

 		if (vhashcpu[7] < Htarg && fulltest(vhashcpu, ptarget)) {
 			work_set_target_ratio(work, vhashcpu);
 			*hashes_done = n - first_nonce + 1;
-			pdata[8] = n;
+			pdata[19] = n;
 			return 1;
 		}
 		n++;

 	} while (n < max_nonce && !work_restart[thr_id].restart);
 	*hashes_done = n - first_nonce + 1;
-	pdata[8] = n;
+	pdata[19] = n;

 	return 0;
 }

-static inline void swab256(void *dest_p, const void *src_p)
-{
-	uint32_t *dest = (uint32_t *)dest_p;
-	const uint32_t *src = (uint32_t *)src_p;
-
-	dest[0] = swab32(src[7]);
-	dest[1] = swab32(src[6]);
-	dest[2] = swab32(src[5]);
-	dest[3] = swab32(src[4]);
-	dest[4] = swab32(src[3]);
-	dest[5] = swab32(src[2]);
-	dest[6] = swab32(src[1]);
-	dest[7] = swab32(src[0]);
-}
-
-/* compute nbits to get the network diff */
-void blake2b_calc_network_diff(struct work *work)
-{
-        // sample for diff 43.281 : 1c05ea29
-        uint32_t nbits = work->data[11]; // unsure if correct
-        uint32_t bits = (nbits & 0xffffff);
-        int16_t shift = (swab32(nbits) & 0xff); // 0x1c = 28
-
-        double d = (double)0x0000ffff / (double)bits;
-        for (int m=shift; m < 29; m++) d *= 256.0;
-        for (int m=29; m < shift; m++) d /= 256.0;
-        if (opt_debug_diff)
-                applog(LOG_DEBUG, "net diff: %f -> shift %u, bits %08x", d, shift, bits);
-        net_diff = d;
-}
-
-void blake2b_be_build_stratum_request( char *req, struct work *work )
-{
-   unsigned char *xnonce2str;
-   uint32_t ntime,       nonce;
-   char     ntimestr[9], noncestr[9];
-   be32enc( &ntime, work->data[ algo_gate.ntime_index ] );
-   be32enc( &nonce, work->data[ algo_gate.nonce_index ] );
-   bin2hex( ntimestr, (char*)(&ntime), sizeof(uint32_t) );
-   bin2hex( noncestr, (char*)(&nonce), sizeof(uint32_t) );
-   uint16_t high_nonce = swab32(work->data[9]) >> 16;
-   xnonce2str = abin2hex((unsigned char*)(&high_nonce), 2);
-   snprintf( req, JSON_BUF_LEN,
-        "{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}",
-         rpc_user, work->job_id, xnonce2str, ntimestr, noncestr );
-   free( xnonce2str );
-}
-
-#define min(a,b) (a>b ? (b) :(a))
-
-// merkle root handled here, no need for gen_merkle_root gate target
-void blake2b_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
-{
-    uchar merkle_root[64] = { 0 };
-    uint32_t extraheader[32] = { 0 };
-    int headersize = 0;
-    size_t t;
-    int i;
-
-    // merkle root
-    memcpy( merkle_root, sctx->job.coinbase, 32 );
-    headersize = min( (int)sctx->job.coinbase_size - 32, sizeof(extraheader) );
-    memcpy( extraheader, &sctx->job.coinbase[32], headersize );
-    // Increment extranonce2 
-    for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-    // Assemble block header 
-    memset( g_work->data, 0, sizeof(g_work->data) );
-//    g_work->data[0] = le32dec( sctx->job.version );
-//    for ( i = 0; i < 8; i++ )
-//       g_work->data[1 + i] = le32dec( (uint32_t *) sctx->job.prevhash + i );
-    for ( i = 0; i < 8; i++ )
-       g_work->data[i] = ((uint32_t*)sctx->job.prevhash)[7-i];
-//    for ( i = 0; i < 8; i++ )
-//       g_work->data[9 + i] = be32dec( (uint32_t *) merkle_root + i );
-    g_work->data[8]  = 0; // nonce
-    g_work->data[9]  = swab32( extraheader[0] ) | ( rand() & 0xf0 );
-    g_work->data[10] = be32dec( sctx->job.ntime );
-    g_work->data[11] = be32dec( sctx->job.nbits );
-    for ( i = 0; i < 8; i++ )
-       g_work->data[12+i] = ( (uint32_t*)merkle_root )[i];
-}
-
-#undef min
-
-void blake2b_get_new_work( struct work* work, struct work* g_work, int thr_id,
-                           uint32_t* end_nonce_ptr, bool clean_job )
-{
-   const int wkcmp_sz = 32;  // bytes
-   const int wkcmp_off = 32 + 16; 
-   uint32_t *nonceptr = algo_gate.get_nonceptr( work->data );
-
-   if ( memcmp( &work->data[ wkcmp_off ], &g_work->data[ wkcmp_off ], wkcmp_sz )
-      && ( clean_job || ( *nonceptr >= *end_nonce_ptr ) 
-      || strcmp( work->job_id, g_work->job_id ) ) )
-   {
-      work_free( work );
-      work_copy( work, g_work );
-      *nonceptr = ( 0xffffffffU / opt_n_threads ) * thr_id;
-      if ( opt_randomize )
-         *nonceptr += ( (rand() *4 ) & UINT32_MAX ) / opt_n_threads;
-      *end_nonce_ptr = ( 0xffffffffU / opt_n_threads ) * (thr_id+1) - 0x20;
-   }
-   else
-       ++(*nonceptr);
-
-   // suprnova job_id check without data/target/height change...
-   // we just may have copied new g_wwork to work so why this test here?
-//   if (  have_stratum && strcmp( work->job_id, g_work->job_id ) )
-      // exit thread loop
-//      continue;
-//   else
-//   {
-//      nonceptr[1] += 0x10;
-//      nonceptr[1] |= thr_id;
-//   }
-}
-
-bool blake2b_ready_to_mine( struct work* work, struct stratum_ctx* stratum,
-                           int thr_id )
-{
-   if ( have_stratum && strcmp( stratum->job.job_id, work->job_id ) )
-      // need to regen g_work..
-      return false;
-   // extradata: prevent duplicates
-   work->data[ 8     ] += 0x10;
-   work->data[ 8 + 1 ] |= thr_id;
-   return true;
-}
-
-double blake2b_get_max64() { return 0x1fffffLL; }
-
-bool register_blake2b_algo( algo_gate_t* gate )
-{
-  algo_not_tested();
-  gate->ntime_index   = 10;
-  gate->nbits_index   = 11;
-  gate->nonce_index   =  8;
-  gate->work_cmp_size = 32;
-  gate->scanhash              = (void*)&scanhash_blake2b;
-  gate->hash                  = (void*)&blake2b_hash;
-  gate->calc_network_diff     = (void*)&blake2b_calc_network_diff;
-  gate->build_stratum_request = (void*)&blake2b_be_build_stratum_request;
-  gate->work_decode           = (void*)&std_be_work_decode;
-  gate->submit_getwork_result = (void*)&std_be_submit_getwork_result;
-  gate->build_extraheader     = (void*)&blake2b_build_extraheader;
-  gate->get_new_work          = (void*)&blake2b_get_new_work;
-  gate->get_max64             = (void*)&blake2b_get_max64;
-  gate->ready_to_mine         = (void*)&blake2b_ready_to_mine;
-  have_gbt = false;
-  return true;
-}
--- a/algo/blake/blake2s-4way.c
+++ b/algo/blake/blake2s-4way.c
@@ -3,22 +3,72 @@
 #include <string.h>
 #include <stdint.h>

-#if defined(BLAKE2S_8WAY)
+#if defined(BLAKE2S_16WAY)
+
+static __thread blake2s_16way_state blake2s_16w_ctx;
+
+void blake2s_16way_hash( void *output, const void *input )
+{
+   blake2s_16way_state ctx;
+   memcpy( &ctx, &blake2s_16w_ctx, sizeof ctx );
+   blake2s_16way_update( &ctx, input + (64<<4), 16 );
+   blake2s_16way_final( &ctx, output, BLAKE2S_OUTBYTES );
+}
+
+int scanhash_blake2s_16way( struct work *work, uint32_t max_nonce,
+                            uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[20*16] __attribute__ ((aligned (128)));
+   uint32_t hash[8*16] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[7<<4]);
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   __m512i  *noncev = (__m512i*)vdata + 19;   // aligned
+   uint32_t n = first_nonce;
+   int thr_id = mythr->id;  
+
+   mm512_bswap32_intrlv80_16x32( vdata, pdata );
+   blake2s_16way_init( &blake2s_16w_ctx, BLAKE2S_OUTBYTES );
+   blake2s_16way_update( &blake2s_16w_ctx, vdata, 64 );
+
+   do {
+      *noncev = mm512_bswap_32( _mm512_set_epi32(
+	                  n+15, n+14, n+13, n+12, n+11, n+10, n+ 9, n+ 8,
+	                  n+ 7, n+ 6, n+ 5, n+ 4, n+ 3, n+ 2, n+ 1, n ) );
+      pdata[19] = n;
+
+      blake2s_16way_hash( hash, vdata );
+
+      for ( int lane = 0; lane < 16; lane++ )
+      if ( unlikely( hash7[lane] <= Htarg ) )
+      {
+         extr_lane_16x32( lane_hash, hash, lane, 256 );
+         if ( likely( fulltest( lane_hash, ptarget ) && !opt_benchmark ) )
+         {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+         }
+      }
+      n += 16;
+   } while ( (n < max_nonce-16) && !work_restart[thr_id].restart );
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#elif defined(BLAKE2S_8WAY)

 static __thread blake2s_8way_state blake2s_8w_ctx;

 void blake2s_8way_hash( void *output, const void *input )
 {
-   uint32_t vhash[8*8] __attribute__ ((aligned (64)));
   blake2s_8way_state ctx;
   memcpy( &ctx, &blake2s_8w_ctx, sizeof ctx );
-
   blake2s_8way_update( &ctx, input + (64<<3), 16 );
-   blake2s_8way_final( &ctx, vhash, BLAKE2S_OUTBYTES );
-
-   mm256_dintrlv_8x32( output,     output+ 32, output+ 64, output+ 96,
-                            output+128, output+160, output+192, output+224,
-                            vhash, 256 );
+   blake2s_8way_final( &ctx, output, BLAKE2S_OUTBYTES );
 }

 int scanhash_blake2s_8way( struct work *work, uint32_t max_nonce,
@@ -26,44 +76,38 @@ int scanhash_blake2s_8way( struct work *work, uint32_t max_nonce,
 {
   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
   uint32_t hash[8*8] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[7<<3]);
   uint32_t *pdata = work->data;
   uint32_t *ptarget = work->target;
-   uint32_t _ALIGN(64) edata[20];
   const uint32_t Htarg = ptarget[7];
   const uint32_t first_nonce = pdata[19];
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
   uint32_t n = first_nonce;
-   uint32_t *noncep = vdata + 152;   // 19*8
-   int thr_id = mythr->id;  // thr_id arg is deprecated
+   int thr_id = mythr->id; 

-   swab32_array( edata, pdata, 20 );
-   mm256_intrlv_8x32( vdata, edata, edata, edata, edata,
-                                 edata, edata, edata, edata, 640 );
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
   blake2s_8way_init( &blake2s_8w_ctx, BLAKE2S_OUTBYTES );
   blake2s_8way_update( &blake2s_8w_ctx, vdata, 64 );

   do {
-      be32enc( noncep,    n   );
-      be32enc( noncep +1, n+1 );
-      be32enc( noncep +2, n+2 );
-      be32enc( noncep +3, n+3 );
-      be32enc( noncep +4, n+4 );
-      be32enc( noncep +5, n+5 );
-      be32enc( noncep +6, n+6 );
-      be32enc( noncep +7, n+7 );
+      *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;

      blake2s_8way_hash( hash, vdata );

-
-      for ( int i = 0; i < 8; i++ )
-      if (  (hash+(i<<3))[7] <= Htarg )
-      if ( fulltest( hash+(i<<3), ptarget ) && !opt_benchmark )
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( hash7[lane] <= Htarg ) )
      {
-          pdata[19] = n+i;
-          submit_lane_solution( work, hash+(i<<3), mythr, i );
+         extr_lane_8x32( lane_hash, hash, lane, 256 );
+         if ( likely( fulltest( lane_hash, ptarget ) && !opt_benchmark ) )
+         {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+         }
      }
      n += 8;
-
   } while ( (n < max_nonce) && !work_restart[thr_id].restart );

   *hashes_done = n - first_nonce + 1;
@@ -76,15 +120,10 @@ static __thread blake2s_4way_state blake2s_4w_ctx;

 void blake2s_4way_hash( void *output, const void *input )
 {
-   uint32_t vhash[8*4] __attribute__ ((aligned (64)));
   blake2s_4way_state ctx;
   memcpy( &ctx, &blake2s_4w_ctx, sizeof ctx );
-
   blake2s_4way_update( &ctx, input + (64<<2), 16 );
-   blake2s_4way_final( &ctx, vhash, BLAKE2S_OUTBYTES );
-
-   dintrlv_4x32( output, output+32, output+64, output+96,
-		            vhash, 256 );
+   blake2s_4way_final( &ctx, output, BLAKE2S_OUTBYTES );
 }

 int scanhash_blake2s_4way( struct work *work, uint32_t max_nonce,
@@ -92,38 +131,36 @@ int scanhash_blake2s_4way( struct work *work, uint32_t max_nonce,
 {
   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
   uint32_t hash[8*4] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[7<<2]);
   uint32_t *pdata = work->data;
   uint32_t *ptarget = work->target;
-   uint32_t _ALIGN(64) edata[20];
   const uint32_t Htarg = ptarget[7];
   const uint32_t first_nonce = pdata[19];
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
   uint32_t n = first_nonce;
-   uint32_t *noncep = vdata + 76;   // 19*4
-   int thr_id = mythr->id;  // thr_id arg is deprecated
+   int thr_id = mythr->id; 

-   swab32_array( edata, pdata, 20 );
-   mm128_intrlv_4x32( vdata, edata, edata, edata, edata, 640 );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
   blake2s_4way_init( &blake2s_4w_ctx, BLAKE2S_OUTBYTES );
   blake2s_4way_update( &blake2s_4w_ctx, vdata, 64 );

   do {
-      be32enc( noncep,    n   );
-      be32enc( noncep +1, n+1 );
-      be32enc( noncep +2, n+2 );
-      be32enc( noncep +3, n+3 );
+      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
      pdata[19] = n;

      blake2s_4way_hash( hash, vdata );

-      for ( int i = 0; i < 4; i++ )
-      if ( (hash+(i<<3))[7] <= Htarg )
-      if ( fulltest( hash+(i<<3), ptarget ) && !opt_benchmark )
+      for ( int lane = 0; lane < 4; lane++ ) if ( hash7[lane] <= Htarg )
      {
-          pdata[19] = n+i;
-          submit_lane_solution( work, hash+(i<<3), mythr, i );
+         extr_lane_4x32( lane_hash, hash, lane, 256 );
+         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+         {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+              }
      }
      n += 4;
-
   } while ( (n < max_nonce) && !work_restart[thr_id].restart );

   *hashes_done = n - first_nonce + 1;
--- a/algo/blake/blake2s-gate.c
+++ b/algo/blake/blake2s-gate.c
@@ -1,15 +1,12 @@
 #include "blake2s-gate.h"

-
-// changed to get_max64_0x3fffffLL in cpuminer-multi-decred
-int64_t blake2s_get_max64 ()
-{
-   return 0x7ffffLL;
-}
-
 bool register_blake2s_algo( algo_gate_t* gate )
 {
-#if defined(BLAKE2S_8WAY)
+#if defined(BLAKE2S_16WAY)
+  gate->scanhash  = (void*)&scanhash_blake2s_16way;
+  gate->hash      = (void*)&blake2s_16way_hash;
+#elif defined(BLAKE2S_8WAY)
+//#if defined(BLAKE2S_8WAY)
  gate->scanhash  = (void*)&scanhash_blake2s_8way;
  gate->hash      = (void*)&blake2s_8way_hash;
 #elif defined(BLAKE2S_4WAY)
@@ -19,8 +16,7 @@ bool register_blake2s_algo( algo_gate_t* gate )
  gate->scanhash  = (void*)&scanhash_blake2s;
  gate->hash      = (void*)&blake2s_hash;
 #endif
-  gate->get_max64 = (void*)&blake2s_get_max64;
-  gate->optimizations = SSE42_OPT | AVX2_OPT;
+  gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
  return true;
 };

--- a/algo/blake/blake2s-gate.h
+++ b/algo/blake/blake2s-gate.h
@@ -4,16 +4,30 @@
 #include <stdint.h>
 #include "algo-gate-api.h"

-#if defined(__SSE4_2__)
+//#if defined(__SSE4_2__)
+#if defined(__SSE2__)
  #define BLAKE2S_4WAY
 #endif
+
 #if defined(__AVX2__)
  #define BLAKE2S_8WAY
 #endif

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define BLAKE2S_16WAY
+#endif
+
 bool register_blake2s_algo( algo_gate_t* gate );

-#if defined(BLAKE2S_8WAY)
+#if defined(BLAKE2S_16WAY)
+
+void blake2s_16way_hash( void *state, const void *input );
+int scanhash_blake2s_16way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined (BLAKE2S_8WAY)
+
+//#if defined(BLAKE2S_8WAY)

 void blake2s_8way_hash( void *state, const void *input );
 int scanhash_blake2s_8way( struct work *work, uint32_t max_nonce,
--- a/algo/blake/blake2s-hash-4way.c
+++ b/algo/blake/blake2s-hash-4way.c
@@ -17,13 +17,16 @@
 #include <string.h>
 #include <stdio.h>

-#if defined(__SSE4_2__)
+//#if defined(__SSE4_2__)
+#if defined(__SSE2__)

+/*
 static const uint32_t blake2s_IV[8] =
 {
 	0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
 	0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
 };
+*/

 static const uint8_t blake2s_sigma[10][16] =
 {
@@ -39,6 +42,7 @@ static const uint8_t blake2s_sigma[10][16] =
 	{ 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 } ,
 };

+
 // define a constant for initial param.

 int blake2s_4way_init( blake2s_4way_state *S, const uint8_t outlen )
@@ -57,8 +61,18 @@ int blake2s_4way_init( blake2s_4way_state *S, const uint8_t outlen )
   memset( P->personal, 0, sizeof( P->personal ) );

   memset( S, 0, sizeof( blake2s_4way_state ) );
-   for( int i = 0; i < 8; ++i )
-      S->h[i] = _mm_set1_epi32( blake2s_IV[i] );
+
+   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 );
+   
+//   for( int i = 0; i < 8; ++i )
+//      S->h[i] = _mm_set1_epi32( blake2s_IV[i] );

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

@@ -76,41 +90,45 @@ int blake2s_4way_compress( blake2s_4way_state *S, const __m128i* block )
   memcpy_128( m, block, 16 );
   memcpy_128( v, S->h, 8 );

-   v[ 8] = _mm_set1_epi32( blake2s_IV[0] );
-   v[ 9] = _mm_set1_epi32( blake2s_IV[1] );
-   v[10] = _mm_set1_epi32( blake2s_IV[2] );
-   v[11] = _mm_set1_epi32( blake2s_IV[3] );
+   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[12] = _mm_xor_si128( _mm_set1_epi32( S->t[0] ),
-                          _mm_set1_epi32( blake2s_IV[4] ) );
+                          m128_const1_64( 0x510E527F510E527FULL ) );
   v[13] = _mm_xor_si128( _mm_set1_epi32( S->t[1] ),
-                          _mm_set1_epi32( blake2s_IV[5] ) );
+                          m128_const1_64( 0x9B05688C9B05688CULL ) );
   v[14] = _mm_xor_si128( _mm_set1_epi32( S->f[0] ),
-                          _mm_set1_epi32( blake2s_IV[6] ) );
+                          m128_const1_64( 0x1F83D9AB1F83D9ABULL ) );
   v[15] = _mm_xor_si128( _mm_set1_epi32( S->f[1] ),
-                          _mm_set1_epi32( blake2s_IV[7] ) );
+                          m128_const1_64( 0x5BE0CD195BE0CD19ULL ) );

-#define G4W(r,i,a,b,c,d) \
+#define G4W( sigma0, sigma1, a, b, c, d ) \
 do { \
-   a = _mm_add_epi32( _mm_add_epi32( a, b ), m[ blake2s_sigma[r][2*i+0] ] ); \
+   uint8_t s0 = sigma0; \
+   uint8_t s1 = sigma1; \
+   a = _mm_add_epi32( _mm_add_epi32( a, b ), m[ s0 ] ); \
   d = mm128_ror_32( _mm_xor_si128( d, a ), 16 ); \
   c = _mm_add_epi32( c, d ); \
   b = mm128_ror_32( _mm_xor_si128( b, c ), 12 ); \
-   a = _mm_add_epi32( _mm_add_epi32( a, b ), m[ blake2s_sigma[r][2*i+1] ] ); \
+   a = _mm_add_epi32( _mm_add_epi32( a, b ), m[ s1 ] ); \
   d = mm128_ror_32( _mm_xor_si128( d, a ),  8 ); \
   c = _mm_add_epi32( c, d ); \
   b = mm128_ror_32( _mm_xor_si128( b, c ),  7 ); \
 } while(0)

+
 #define ROUND4W(r)  \
 do { \
-   G4W( r, 0, v[ 0], v[ 4], v[ 8], v[12] ); \
-   G4W( r, 1, v[ 1], v[ 5], v[ 9], v[13] ); \
-   G4W( r, 2, v[ 2], v[ 6], v[10], v[14] ); \
-   G4W( r, 3, v[ 3], v[ 7], v[11], v[15] ); \
-   G4W( r, 4, v[ 0], v[ 5], v[10], v[15] ); \
-   G4W( r, 5, v[ 1], v[ 6], v[11], v[12] ); \
-   G4W( r, 6, v[ 2], v[ 7], v[ 8], v[13] ); \
-   G4W( r, 7, v[ 3], v[ 4], v[ 9], v[14] ); \
+   uint8_t *sigma = (uint8_t*)&blake2s_sigma[r]; \
+   G4W( sigma[ 0], sigma[ 1], v[ 0], v[ 4], v[ 8], v[12] ); \
+   G4W( sigma[ 2], sigma[ 3], v[ 1], v[ 5], v[ 9], v[13] ); \
+   G4W( sigma[ 4], sigma[ 5], v[ 2], v[ 6], v[10], v[14] ); \
+   G4W( sigma[ 6], sigma[ 7], v[ 3], v[ 7], v[11], v[15] ); \
+   G4W( sigma[ 8], sigma[ 9], v[ 0], v[ 5], v[10], v[15] ); \
+   G4W( sigma[10], sigma[11], v[ 1], v[ 6], v[11], v[12] ); \
+   G4W( sigma[12], sigma[13], v[ 2], v[ 7], v[ 8], v[13] ); \
+   G4W( sigma[14], sigma[15], v[ 3], v[ 4], v[ 9], v[14] ); \
 } while(0)

   ROUND4W( 0 );
@@ -132,26 +150,47 @@ do { \
   return 0;
 }

+// There is a problem that can't be resolved internally.
+// If the last block is a full 64 bytes it should not be compressed in
+// update but left for final. However, when streaming, it isn't known
+// which block is last. There may be a subsequent call to update to add
+// more data.
+//
+// The reference code handled this by juggling 2 blocks at a time at
+// a significant performance penalty.
+//
+// Instead a new function is introduced called full_blocks which combines
+// update and final and is to be used in non-streaming mode where the data
+// is a multiple of 64 bytes.
+// 
+// Supported:
+//    64 + 16 bytes  (blake2s with midstate optimization)
+//    80 bytes       (blake2s without midstate optimization)
+//    Any multiple of 64 bytes in one shot (x25x)
+//
+// Unsupported:
+//    Stream of full 64 byte blocks one at a time.   
+
+// use only when streaming more data or final block not full.
 int blake2s_4way_update( blake2s_4way_state *S, const void *in,
                         uint64_t inlen )
 {
-  __m128i *input = (__m128i*)in;
-  __m128i *buf = (__m128i*)S->buf;
-  const int bsize = BLAKE2S_BLOCKBYTES;
+   __m128i *input = (__m128i*)in;
+   __m128i *buf = (__m128i*)S->buf;

   while( inlen > 0 )
   {
      size_t left = S->buflen;
-      if( inlen >= bsize - left )
+      if( inlen >= BLAKE2S_BLOCKBYTES - left )
      {
-         memcpy_128( buf + (left>>2), input, (bsize - left) >> 2 );
-         S->buflen += bsize - left;
+         memcpy_128( buf + (left>>2), input, (BLAKE2S_BLOCKBYTES - left) >> 2 );
+         S->buflen += BLAKE2S_BLOCKBYTES - left;
         S->t[0] += BLAKE2S_BLOCKBYTES;
         S->t[1] += ( S->t[0] < BLAKE2S_BLOCKBYTES );
         blake2s_4way_compress( S, buf ); 
         S->buflen = 0;
-         input += ( bsize >> 2 );
-         inlen -= bsize;
+         input += ( BLAKE2S_BLOCKBYTES >> 2 );
+         inlen -= BLAKE2S_BLOCKBYTES;
      }
      else
      {
@@ -183,8 +222,45 @@ int blake2s_4way_final( blake2s_4way_state *S, void *out, uint8_t outlen )
   return 0;
 }

+// Update and final when inlen is a multiple of 64 bytes
+int blake2s_4way_full_blocks( blake2s_4way_state *S, void *out,
+                              const void *input, uint64_t inlen )
+{
+    __m128i *in = (__m128i*)input;
+    __m128i *buf = (__m128i*)S->buf;
+
+    while( inlen > BLAKE2S_BLOCKBYTES )
+    {
+       memcpy_128( buf, in, BLAKE2S_BLOCKBYTES >> 2 );
+       S->buflen = BLAKE2S_BLOCKBYTES;
+       inlen -= BLAKE2S_BLOCKBYTES;
+       S->t[0] += BLAKE2S_BLOCKBYTES;
+       S->t[1] += ( S->t[0] < BLAKE2S_BLOCKBYTES );
+       blake2s_4way_compress( S, buf );
+       S->buflen = 0;
+       in += ( BLAKE2S_BLOCKBYTES >> 2 );
+    }
+
+    // last block
+    memcpy_128( buf, in, BLAKE2S_BLOCKBYTES >> 2 );
+    S->buflen = BLAKE2S_BLOCKBYTES;
+    S->t[0] += S->buflen;
+    S->t[1] += ( S->t[0] < S->buflen );
+    if ( S->last_node )  S->f[1] = ~0U;
+    S->f[0] = ~0U;
+    blake2s_4way_compress( S, buf );
+
+    for ( int i = 0; i < 8; ++i )
+      casti_m128i( out, i ) = S->h[ i ];
+    return 0;
+}
+
 #if defined(__AVX2__)

+// The commented code below is slower on Intel but faster on
+// Zen1 AVX2. It's also faster than Zen1 AVX.
+// Ryzen gen2 is unknown at this time.
+ 
 int blake2s_8way_compress( blake2s_8way_state *S, const __m256i *block )
 {
   __m256i m[16];
@@ -193,6 +269,23 @@ 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[12] = _mm256_xor_si256( _mm256_set1_epi32( S->t[0] ),
+                          m256_const1_64( 0x510E527F510E527FULL ) );
+
+   v[13] = _mm256_xor_si256( _mm256_set1_epi32( S->t[1] ),
+                          m256_const1_64( 0x9B05688C9B05688CULL ) );
+
+   v[14] = _mm256_xor_si256( _mm256_set1_epi32( S->f[0] ),
+                          m256_const1_64( 0x1F83D9AB1F83D9ABULL ) );
+
+   v[15] = _mm256_xor_si256( _mm256_set1_epi32( S->f[1] ),
+                          m256_const1_64( 0x5BE0CD195BE0CD19ULL ) );
+
+/*
   v[ 8] = _mm256_set1_epi32( blake2s_IV[0] );
   v[ 9] = _mm256_set1_epi32( blake2s_IV[1] );
   v[10] = _mm256_set1_epi32( blake2s_IV[2] );
@@ -206,6 +299,7 @@ int blake2s_8way_compress( blake2s_8way_state *S, const __m256i *block )
   v[15] = _mm256_xor_si256( _mm256_set1_epi32( S->f[1] ),
                             _mm256_set1_epi32( blake2s_IV[7] ) );

+
 #define G8W(r,i,a,b,c,d) \
 do { \
   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), \
@@ -219,7 +313,36 @@ do { \
   c = _mm256_add_epi32( c, d ); \
   b = mm256_ror_32( _mm256_xor_si256( b, c ),  7 ); \
 } while(0)
+*/

+#define G8W( sigma0, sigma1, a, b, c, d) \
+do { \
+   uint8_t s0 = sigma0; \
+   uint8_t s1 = sigma1; \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), m[ s0 ] ); \
+   d = mm256_ror_32( _mm256_xor_si256( d, a ), 16 ); \
+   c = _mm256_add_epi32( c, d ); \
+   b = mm256_ror_32( _mm256_xor_si256( b, c ), 12 ); \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), m[ s1 ] ); \
+   d = mm256_ror_32( _mm256_xor_si256( d, a ),  8 ); \
+   c = _mm256_add_epi32( c, d ); \
+   b = mm256_ror_32( _mm256_xor_si256( b, c ),  7 ); \
+} while(0)
+
+#define ROUND8W(r)  \
+do { \
+   uint8_t *sigma = (uint8_t*)&blake2s_sigma[r]; \
+   G8W( sigma[ 0], sigma[ 1], v[ 0], v[ 4], v[ 8], v[12] ); \
+   G8W( sigma[ 2], sigma[ 3], v[ 1], v[ 5], v[ 9], v[13] ); \
+   G8W( sigma[ 4], sigma[ 5], v[ 2], v[ 6], v[10], v[14] ); \
+   G8W( sigma[ 6], sigma[ 7], v[ 3], v[ 7], v[11], v[15] ); \
+   G8W( sigma[ 8], sigma[ 9], v[ 0], v[ 5], v[10], v[15] ); \
+   G8W( sigma[10], sigma[11], v[ 1], v[ 6], v[11], v[12] ); \
+   G8W( sigma[12], sigma[13], v[ 2], v[ 7], v[ 8], v[13] ); \
+   G8W( sigma[14], sigma[15], v[ 3], v[ 4], v[ 9], v[14] ); \
+} while(0)
+
+/*
 #define ROUND8W(r)  \
 do { \
   G8W( r, 0, v[ 0], v[ 4], v[ 8], v[12] ); \
@@ -231,6 +354,7 @@ do { \
   G8W( r, 6, v[ 2], v[ 7], v[ 8], v[13] ); \
   G8W( r, 7, v[ 3], v[ 4], v[ 9], v[14] ); \
 } while(0)
+*/

   ROUND8W( 0 );
   ROUND8W( 1 );
@@ -267,8 +391,18 @@ 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 ) );
-   for( int i = 0; i < 8; ++i )
-      S->h[i] = _mm256_set1_epi32( blake2s_IV[i] );
+   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 );
+
+
+//   for( int i = 0; i < 8; ++i )
+//      S->h[i] = _mm256_set1_epi32( blake2s_IV[i] );

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

@@ -332,6 +466,168 @@ int blake2s_8way_final( blake2s_8way_state *S, void *out, uint8_t outlen )

 #endif // __AVX2__

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// Blake2s-256 16 way
+
+int blake2s_16way_compress( blake2s_16way_state *S, const __m512i *block )
+{
+   __m512i m[16];
+   __m512i v[16];
+
+   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[12] = _mm512_xor_si512( _mm512_set1_epi32( S->t[0] ),
+                          m512_const1_64( 0x510E527F510E527FULL ) );
+
+   v[13] = _mm512_xor_si512( _mm512_set1_epi32( S->t[1] ),
+                          m512_const1_64( 0x9B05688C9B05688CULL ) );
+
+   v[14] = _mm512_xor_si512( _mm512_set1_epi32( S->f[0] ),
+                          m512_const1_64( 0x1F83D9AB1F83D9ABULL ) );
+
+   v[15] = _mm512_xor_si512( _mm512_set1_epi32( S->f[1] ),
+                          m512_const1_64( 0x5BE0CD195BE0CD19ULL ) );
+
+
+#define G16W( sigma0, sigma1, a, b, c, d) \
+do { \
+   uint8_t s0 = sigma0; \
+   uint8_t s1 = sigma1; \
+   a = _mm512_add_epi32( _mm512_add_epi32( a, b ), m[ s0 ] ); \
+   d = mm512_ror_32( _mm512_xor_si512( d, a ), 16 ); \
+   c = _mm512_add_epi32( c, d ); \
+   b = mm512_ror_32( _mm512_xor_si512( b, c ), 12 ); \
+   a = _mm512_add_epi32( _mm512_add_epi32( a, b ), m[ s1 ] ); \
+   d = mm512_ror_32( _mm512_xor_si512( d, a ),  8 ); \
+   c = _mm512_add_epi32( c, d ); \
+   b = mm512_ror_32( _mm512_xor_si512( b, c ),  7 ); \
+} while(0)
+
+#define ROUND16W(r)  \
+do { \
+   uint8_t *sigma = (uint8_t*)&blake2s_sigma[r]; \
+   G16W( sigma[ 0], sigma[ 1], v[ 0], v[ 4], v[ 8], v[12] ); \
+   G16W( sigma[ 2], sigma[ 3], v[ 1], v[ 5], v[ 9], v[13] ); \
+   G16W( sigma[ 4], sigma[ 5], v[ 2], v[ 6], v[10], v[14] ); \
+   G16W( sigma[ 6], sigma[ 7], v[ 3], v[ 7], v[11], v[15] ); \
+   G16W( sigma[ 8], sigma[ 9], v[ 0], v[ 5], v[10], v[15] ); \
+   G16W( sigma[10], sigma[11], v[ 1], v[ 6], v[11], v[12] ); \
+   G16W( sigma[12], sigma[13], v[ 2], v[ 7], v[ 8], v[13] ); \
+   G16W( sigma[14], sigma[15], v[ 3], v[ 4], v[ 9], v[14] ); \
+} while(0)
+
+   ROUND16W( 0 );
+   ROUND16W( 1 );
+   ROUND16W( 2 );
+   ROUND16W( 3 );
+   ROUND16W( 4 );
+   ROUND16W( 5 );
+   ROUND16W( 6 );
+   ROUND16W( 7 );
+   ROUND16W( 8 );
+   ROUND16W( 9 );
+
+   for( size_t i = 0; i < 8; ++i )
+      S->h[i] = _mm512_xor_si512( _mm512_xor_si512( S->h[i], v[i] ), v[i + 8] );
+
+#undef G16W
+#undef ROUND16W
+   return 0;
+}
+
+int blake2s_16way_init( blake2s_16way_state *S, const uint8_t outlen )
+{
+   blake2s_nway_param P[1];
+
+   P->digest_length = outlen;
+   P->key_length    = 0;
+   P->fanout        = 1;
+   P->depth         = 1;
+   P->leaf_length   = 0;
+   *((uint64_t*)(P->node_offset)) = 0;
+   P->node_depth    = 0;
+   P->inner_length  = 0;
+   memset( P->salt,     0, sizeof( P->salt ) );
+   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 );
+
+   uint32_t *p = ( uint32_t * )( P );
+
+   /* IV XOR ParamBlock */
+   for ( size_t i = 0; i < 8; ++i )
+      S->h[i] = _mm512_xor_si512( S->h[i], _mm512_set1_epi32( p[i] ) );
+   return 0;
+}
+
+int blake2s_16way_update( blake2s_16way_state *S, const void *in,
+                         uint64_t inlen )
+{
+  __m512i *input = (__m512i*)in;
+  __m512i *buf = (__m512i*)S->buf;
+  const int bsize = BLAKE2S_BLOCKBYTES;
+
+   while( inlen > 0 )
+   {
+      size_t left = S->buflen;
+      if( inlen >= bsize - left )
+      {
+         memcpy_512( buf + (left>>2), input, (bsize - left) >> 2 );
+         S->buflen += bsize - left;
+         S->t[0] += BLAKE2S_BLOCKBYTES;
+         S->t[1] += ( S->t[0] < BLAKE2S_BLOCKBYTES );
+         blake2s_16way_compress( S, buf );
+         S->buflen = 0;
+         input += ( bsize >> 2 );
+         inlen -= bsize;
+      }
+      else
+      {
+          memcpy_512( buf + ( left>>2 ), input, inlen>>2 );
+          S->buflen += (size_t) inlen;
+          input += ( inlen>>2 );
+          inlen -= inlen;
+      }
+   }
+   return 0;
+}
+
+int blake2s_16way_final( blake2s_16way_state *S, void *out, uint8_t outlen )
+{
+   __m512i *buf = (__m512i*)S->buf;
+
+   S->t[0] += S->buflen;
+   S->t[1] += ( S->t[0] < S->buflen );
+   if ( S->last_node )
+      S->f[1] = ~0U;
+   S->f[0] = ~0U;
+
+   memset_zero_512( buf + ( S->buflen>>2 ),
+                    ( BLAKE2S_BLOCKBYTES - S->buflen ) >> 2 );
+   blake2s_16way_compress( S, buf );
+
+   for ( int i = 0; i < 8; ++i )
+      casti_m512i( out, i ) = S->h[ i ];
+   return 0;
+}
+
+#endif   // AVX512
+
+
 #if 0
 int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
 {
--- a/algo/blake/blake2s-hash-4way.h
+++ b/algo/blake/blake2s-hash-4way.h
@@ -14,7 +14,8 @@
 #ifndef __BLAKE2S_HASH_4WAY_H__
 #define __BLAKE2S_HASH_4WAY_H__ 1

-#if defined(__SSE4_2__)
+//#if defined(__SSE4_2__)
+#if defined(__SSE2__)

 #include "simd-utils.h"

@@ -74,6 +75,9 @@ int blake2s_4way_init( blake2s_4way_state *S, const uint8_t outlen );
 int blake2s_4way_update( blake2s_4way_state *S, const void *in,
                         uint64_t inlen );
 int blake2s_4way_final( blake2s_4way_state *S, void *out, uint8_t outlen );
+int blake2s_4way_full_blocks( blake2s_4way_state *S, void *out,
+                              const void *input, uint64_t inlen );
+

 #if defined(__AVX2__)

@@ -91,6 +95,27 @@ int blake2s_8way_init( blake2s_8way_state *S, const uint8_t outlen );
 int blake2s_8way_update( blake2s_8way_state *S, const void *in,
                         uint64_t inlen );
 int blake2s_8way_final( blake2s_8way_state *S, void *out, uint8_t outlen );
+//int blake2s_8way_full_blocks( blake2s_8way_state *S, void *out,
+//                              const void *input, uint64_t inlen );
+
+#endif
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+ALIGN( 128 ) typedef struct __blake2s_16way_state
+{
+   __m512i h[8];
+   uint8_t  buf[ BLAKE2S_BLOCKBYTES * 16 ];
+   uint32_t t[2];
+   uint32_t f[2];
+   size_t   buflen;
+   uint8_t  last_node;
+} blake2s_16way_state ;
+
+int blake2s_16way_init( blake2s_16way_state *S, const uint8_t outlen );
+int blake2s_16way_update( blake2s_16way_state *S, const void *in,
+                         uint64_t inlen );
+int blake2s_16way_final( blake2s_16way_state *S, void *out, uint8_t outlen );

 #endif

--- a/algo/blake/blake2s.c
+++ b/algo/blake/blake2s.c
@@ -70,18 +70,3 @@ int scanhash_blake2s( struct work *work,

 	return 0;
 }
-/*
-// changed to get_max64_0x3fffffLL in cpuminer-multi-decred
-int64_t blake2s_get_max64 ()
-{
-   return 0x7ffffLL;
-}
-
-bool register_blake2s_algo( algo_gate_t* gate )
-{
-  gate->scanhash  = (void*)&scanhash_blake2s;
-  gate->hash      = (void*)&blake2s_hash;
-  gate->get_max64 = (void*)&blake2s_get_max64;
-  return true;
-};
-*/
--- a/algo/blake/blake512-hash-4way.c
+++ b/algo/blake/blake512-hash-4way.c
@@ -42,21 +42,13 @@
 extern "C"{
 #endif

-#if SPH_SMALL_FOOTPRINT && !defined SPH_SMALL_FOOTPRINT_BLAKE
-#define SPH_SMALL_FOOTPRINT_BLAKE   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-512
-
+// Blake-512 common
+   
+/*
 static const sph_u64 IV512[8] = {
 	SPH_C64(0x6A09E667F3BCC908), SPH_C64(0xBB67AE8584CAA73B),
 	SPH_C64(0x3C6EF372FE94F82B), SPH_C64(0xA54FF53A5F1D36F1),
@@ -64,10 +56,7 @@ static const sph_u64 IV512[8] = {
 	SPH_C64(0x1F83D9ABFB41BD6B), SPH_C64(0x5BE0CD19137E2179)
 };

-
-#if SPH_COMPACT_BLAKE_32 || SPH_COMPACT_BLAKE_64
-
-// Blake-256 4 & 8 way, Blake-512 4 way
+static const sph_u64 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 },
@@ -88,7 +77,17 @@ static const unsigned sigma[16][16] = {
 	{  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 }
 };

-#endif
+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)
+
+*/

 #define Z00   0
 #define Z01   1
@@ -264,8 +263,6 @@ static const unsigned sigma[16][16] = {
 #define Mx_(n)      Mx__(n)
 #define Mx__(n)     M ## n

-// Blake-512 4 way
-
 #define CBx(r, i)   CBx_(Z ## r ## i)
 #define CBx_(n)     CBx__(n)
 #define CBx__(n)    CB ## n
@@ -287,60 +284,304 @@ static const unsigned sigma[16][16] = {
 #define CBE   SPH_C64(0x0801F2E2858EFC16)
 #define CBF   SPH_C64(0x636920D871574E69)

-#if SPH_COMPACT_BLAKE_64
-// not used
-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)
-};
+#define READ_STATE64(state)   do { \
+      H0 = (state)->H[0]; \
+      H1 = (state)->H[1]; \
+      H2 = (state)->H[2]; \
+      H3 = (state)->H[3]; \
+      H4 = (state)->H[4]; \
+      H5 = (state)->H[5]; \
+      H6 = (state)->H[6]; \
+      H7 = (state)->H[7]; \
+      S0 = (state)->S[0]; \
+      S1 = (state)->S[1]; \
+      S2 = (state)->S[2]; \
+      S3 = (state)->S[3]; \
+      T0 = (state)->T0; \
+      T1 = (state)->T1; \
+   } while (0)

-#endif
+#define WRITE_STATE64(state)   do { \
+      (state)->H[0] = H0; \
+      (state)->H[1] = H1; \
+      (state)->H[2] = H2; \
+      (state)->H[3] = H3; \
+      (state)->H[4] = H4; \
+      (state)->H[5] = H5; \
+      (state)->H[6] = H6; \
+      (state)->H[7] = H7; \
+      (state)->S[0] = S0; \
+      (state)->S[1] = S1; \
+      (state)->S[2] = S2; \
+      (state)->S[3] = S3; \
+      (state)->T0 = T0; \
+      (state)->T1 = T1; \
+   } while (0)

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// Blake-512 8 way AVX512
+
+#define GB_8WAY(m0, m1, c0, c1, a, b, c, d)   do { \
+   a = _mm512_add_epi64( _mm512_add_epi64( _mm512_xor_si512( \
+                 _mm512_set1_epi64( c1 ), m0 ), b ), a ); \
+   d = mm512_ror_64( _mm512_xor_si512( d, a ), 32 ); \
+   c = _mm512_add_epi64( c, d ); \
+   b = mm512_ror_64( _mm512_xor_si512( b, c ), 25 ); \
+   a = _mm512_add_epi64( _mm512_add_epi64( _mm512_xor_si512( \
+                 _mm512_set1_epi64( c0 ), m1 ), b ), a ); \
+   d = mm512_ror_64( _mm512_xor_si512( d, a ), 16 ); \
+   c = _mm512_add_epi64( c, d ); \
+   b = mm512_ror_64( _mm512_xor_si512( b, c ), 11 ); \
+} while (0)
+
+#define ROUND_B_8WAY(r)   do { \
+   GB_8WAY(Mx(r, 0), Mx(r, 1), CBx(r, 0), CBx(r, 1), V0, V4, V8, VC); \
+   GB_8WAY(Mx(r, 2), Mx(r, 3), CBx(r, 2), CBx(r, 3), V1, V5, V9, VD); \
+   GB_8WAY(Mx(r, 4), Mx(r, 5), CBx(r, 4), CBx(r, 5), V2, V6, VA, VE); \
+   GB_8WAY(Mx(r, 6), Mx(r, 7), CBx(r, 6), CBx(r, 7), V3, V7, VB, VF); \
+   GB_8WAY(Mx(r, 8), Mx(r, 9), CBx(r, 8), CBx(r, 9), V0, V5, VA, VF); \
+   GB_8WAY(Mx(r, A), Mx(r, B), CBx(r, A), CBx(r, B), V1, V6, VB, VC); \
+   GB_8WAY(Mx(r, C), Mx(r, D), CBx(r, C), CBx(r, D), V2, V7, V8, VD); \
+   GB_8WAY(Mx(r, E), Mx(r, F), CBx(r, E), CBx(r, F), V3, V4, V9, VE); \
+   } while (0)
+
+#define DECL_STATE64_8WAY \
+   __m512i H0, H1, H2, H3, H4, H5, H6, H7; \
+        __m512i S0, S1, S2, S3; \
+   sph_u64 T0, T1;
+
+#define COMPRESS64_8WAY   do \
+{ \
+  __m512i M0, M1, M2, M3, M4, M5, M6, M7; \
+  __m512i M8, M9, MA, MB, MC, MD, ME, MF; \
+  __m512i V0, V1, V2, V3, V4, V5, V6, V7; \
+  __m512i V8, V9, VA, VB, VC, VD, VE, VF; \
+  __m512i shuf_bswap64; \
+  V0 = H0; \
+  V1 = H1; \
+  V2 = H2; \
+  V3 = H3; \
+  V4 = H4; \
+  V5 = H5; \
+  V6 = H6; \
+  V7 = H7; \
+  V8 = _mm512_xor_si512( S0, m512_const1_64( CB0 ) );  \
+  V9 = _mm512_xor_si512( S1, m512_const1_64( CB1 ) );  \
+  VA = _mm512_xor_si512( S2, m512_const1_64( CB2 ) );  \
+  VB = _mm512_xor_si512( S3, m512_const1_64( CB3 ) );  \
+  VC = _mm512_xor_si512( _mm512_set1_epi64( T0 ), \
+                         m512_const1_64( CB4 ) );  \
+  VD = _mm512_xor_si512( _mm512_set1_epi64( T0 ), \
+                         m512_const1_64( CB5 ) );  \
+  VE = _mm512_xor_si512( _mm512_set1_epi64( T1 ), \
+                         m512_const1_64( CB6 ) );  \
+  VF = _mm512_xor_si512( _mm512_set1_epi64( T1 ), \
+                         m512_const1_64( CB7 ) );  \
+  shuf_bswap64 = m512_const_64( 0x38393a3b3c3d3e3f, 0x3031323334353637, \
+                                0x28292a2b2c2d2e2f, 0x2021222324252627, \
+                                0x18191a1b1c1d1e1f, 0x1011121314151617, \
+                                0x08090a0b0c0d0e0f, 0x0001020304050607 ); \
+  M0 = _mm512_shuffle_epi8( *(buf+ 0), shuf_bswap64 ); \
+  M1 = _mm512_shuffle_epi8( *(buf+ 1), shuf_bswap64 ); \
+  M2 = _mm512_shuffle_epi8( *(buf+ 2), shuf_bswap64 ); \
+  M3 = _mm512_shuffle_epi8( *(buf+ 3), shuf_bswap64 ); \
+  M4 = _mm512_shuffle_epi8( *(buf+ 4), shuf_bswap64 ); \
+  M5 = _mm512_shuffle_epi8( *(buf+ 5), shuf_bswap64 ); \
+  M6 = _mm512_shuffle_epi8( *(buf+ 6), shuf_bswap64 ); \
+  M7 = _mm512_shuffle_epi8( *(buf+ 7), shuf_bswap64 ); \
+  M8 = _mm512_shuffle_epi8( *(buf+ 8), shuf_bswap64 ); \
+  M9 = _mm512_shuffle_epi8( *(buf+ 9), shuf_bswap64 ); \
+  MA = _mm512_shuffle_epi8( *(buf+10), shuf_bswap64 ); \
+  MB = _mm512_shuffle_epi8( *(buf+11), shuf_bswap64 ); \
+  MC = _mm512_shuffle_epi8( *(buf+12), shuf_bswap64 ); \
+  MD = _mm512_shuffle_epi8( *(buf+13), shuf_bswap64 ); \
+  ME = _mm512_shuffle_epi8( *(buf+14), shuf_bswap64 ); \
+  MF = _mm512_shuffle_epi8( *(buf+15), shuf_bswap64 ); \
+  ROUND_B_8WAY(0); \
+  ROUND_B_8WAY(1); \
+  ROUND_B_8WAY(2); \
+  ROUND_B_8WAY(3); \
+  ROUND_B_8WAY(4); \
+  ROUND_B_8WAY(5); \
+  ROUND_B_8WAY(6); \
+  ROUND_B_8WAY(7); \
+  ROUND_B_8WAY(8); \
+  ROUND_B_8WAY(9); \
+  ROUND_B_8WAY(0); \
+  ROUND_B_8WAY(1); \
+  ROUND_B_8WAY(2); \
+  ROUND_B_8WAY(3); \
+  ROUND_B_8WAY(4); \
+  ROUND_B_8WAY(5); \
+  H0 = mm512_xor4( V8, V0, S0, H0 ); \
+  H1 = mm512_xor4( V9, V1, S1, H1 ); \
+  H2 = mm512_xor4( VA, V2, S2, H2 ); \
+  H3 = mm512_xor4( VB, V3, S3, H3 ); \
+  H4 = mm512_xor4( VC, V4, S0, H4 ); \
+  H5 = mm512_xor4( VD, V5, S1, H5 ); \
+  H6 = mm512_xor4( VE, V6, S2, H6 ); \
+  H7 = mm512_xor4( VF, V7, S3, H7 ); \
+} while (0)
+
+void blake512_8way_init( blake_8way_big_context *sc )
+{
+   __m512i zero = m512_zero;
+   casti_m512i( sc->H, 0 ) = m512_const1_64( 0x6A09E667F3BCC908 );
+   casti_m512i( sc->H, 1 ) = m512_const1_64( 0xBB67AE8584CAA73B );
+   casti_m512i( sc->H, 2 ) = m512_const1_64( 0x3C6EF372FE94F82B );
+   casti_m512i( sc->H, 3 ) = m512_const1_64( 0xA54FF53A5F1D36F1 );
+   casti_m512i( sc->H, 4 ) = m512_const1_64( 0x510E527FADE682D1 );
+   casti_m512i( sc->H, 5 ) = m512_const1_64( 0x9B05688C2B3E6C1F );
+   casti_m512i( sc->H, 6 ) = m512_const1_64( 0x1F83D9ABFB41BD6B );
+   casti_m512i( sc->H, 7 ) = m512_const1_64( 0x5BE0CD19137E2179 );
+
+   casti_m512i( sc->S, 0 ) = zero;
+   casti_m512i( sc->S, 1 ) = zero;
+   casti_m512i( sc->S, 2 ) = zero;
+   casti_m512i( sc->S, 3 ) = zero;
+
+   sc->T0 = sc->T1 = 0;
+   sc->ptr = 0;
+}
+
+static void
+blake64_8way( blake_8way_big_context *sc, const void *data, size_t len )
+{
+   __m512i *vdata = (__m512i*)data;
+   __m512i *buf;
+   size_t ptr;
+   DECL_STATE64_8WAY
+
+   const int buf_size = 128;  //  sizeof/8
+
+   buf = sc->buf;
+   ptr = sc->ptr;
+   if ( len < (buf_size - ptr) )
+   {
+   memcpy_512( buf + (ptr>>3), vdata, len>>3 );
+   ptr += len;
+   sc->ptr = ptr;
+   return;
+   }
+
+   READ_STATE64(sc);
+   while ( len > 0 )
+   {
+   size_t clen;
+
+   clen = buf_size - ptr;
+   if ( clen > len )
+      clen = len;
+   memcpy_512( buf + (ptr>>3), vdata, clen>>3 );
+   ptr += clen;
+   vdata = vdata + (clen>>3);
+   len -= clen;
+   if ( ptr == buf_size )
+        {
+      if ( ( T0 = SPH_T64(T0 + 1024) ) < 1024 )
+         T1 = SPH_T64(T1 + 1);
+      COMPRESS64_8WAY;
+      ptr = 0;
+   }
+   }
+   WRITE_STATE64(sc);
+   sc->ptr = ptr;
+}
+
+static void
+blake64_8way_close( blake_8way_big_context *sc, void *dst )
+{
+   __m512i buf[16];
+   size_t ptr;
+   unsigned bit_len;
+//   uint64_t z, zz;
+   sph_u64 th, tl;
+
+   ptr = sc->ptr;
+   bit_len = ((unsigned)ptr << 3);
+//   z = 0x80 >> n;
+//   zz = ((ub & -z) | z) & 0xFF;
+//   buf[ptr>>3] = _mm512_set1_epi64( zz );
+   buf[ptr>>3] = m512_const1_64( 0x80 );
+   tl = sc->T0 + bit_len;
+   th = sc->T1;
+   if (ptr == 0 )
+   {
+   sc->T0 = SPH_C64(0xFFFFFFFFFFFFFC00ULL);
+   sc->T1 = SPH_C64(0xFFFFFFFFFFFFFFFFULL);
+   }
+   else if ( sc->T0 == 0 )
+   {
+   sc->T0 = SPH_C64(0xFFFFFFFFFFFFFC00ULL) + bit_len;
+   sc->T1 = SPH_T64(sc->T1 - 1);
+   }
+   else
+   {
+        sc->T0 -= 1024 - bit_len;
+   }
+   if ( ptr <= 104 )
+   {
+       memset_zero_512( buf + (ptr>>3) + 1, (104-ptr) >> 3 );
+       buf[104>>3] = _mm512_or_si512( buf[104>>3],
+                                 m512_const1_64( 0x0100000000000000ULL ) );
+       buf[112>>3] = m512_const1_64( bswap_64( th ) );
+       buf[120>>3] = m512_const1_64( bswap_64( tl ) );
+
+       blake64_8way( sc, buf + (ptr>>3), 128 - ptr );
+   }
+   else
+  {
+       memset_zero_512( buf + (ptr>>3) + 1, (120 - ptr) >> 3 );
+
+       blake64_8way( sc, buf + (ptr>>3), 128 - ptr );
+       sc->T0 = SPH_C64(0xFFFFFFFFFFFFFC00ULL);
+       sc->T1 = SPH_C64(0xFFFFFFFFFFFFFFFFULL);
+       memset_zero_512( buf, 112>>3 );
+       buf[104>>3] = m512_const1_64( 0x0100000000000000ULL );
+       buf[112>>3] = m512_const1_64( bswap_64( th ) );
+       buf[120>>3] = m512_const1_64( bswap_64( tl ) );
+
+       blake64_8way( sc, buf, 128 );
+   }
+   mm512_block_bswap_64( (__m512i*)dst, sc->H );
+}
+
+void
+blake512_8way_update(void *cc, const void *data, size_t len)
+{
+   blake64_8way(cc, data, len);
+}
+
+void
+blake512_8way_close(void *cc, void *dst)
+{
+   blake512_8way_addbits_and_close(cc, 0, 0, dst);
+}
+
+void
+blake512_8way_addbits_and_close(void *cc, unsigned ub, unsigned n, void *dst)
+{
+   blake64_8way_close(cc, dst);
+}
+
+#endif  // AVX512

 // Blake-512 4 way

 #define GB_4WAY(m0, m1, c0, c1, a, b, c, d)   do { \
   a = _mm256_add_epi64( _mm256_add_epi64( _mm256_xor_si256( \
-                 _mm256_set_epi64x( c1, c1, c1, c1 ), m0 ), b ), a ); \
+                 _mm256_set1_epi64x( c1 ), m0 ), b ), a ); \
   d = mm256_ror_64( _mm256_xor_si256( d, a ), 32 ); \
   c = _mm256_add_epi64( c, d ); \
   b = mm256_ror_64( _mm256_xor_si256( b, c ), 25 ); \
   a = _mm256_add_epi64( _mm256_add_epi64( _mm256_xor_si256( \
-                 _mm256_set_epi64x( c0, c0, c0, c0 ), m1 ), b ), a ); \
+                 _mm256_set1_epi64x( c0 ), m1 ), b ), a ); \
   d = mm256_ror_64( _mm256_xor_si256( d, a ), 16 ); \
   c = _mm256_add_epi64( c, d ); \
   b = mm256_ror_64( _mm256_xor_si256( b, c ), 11 ); \
 } while (0)

-#if SPH_COMPACT_BLAKE_64
-// not used
-#define ROUND_B_4WAY(r)   do { \
-	GB_4WAY(M[sigma[r][0x0]], M[sigma[r][0x1]], \
-		CB[sigma[r][0x0]], CB[sigma[r][0x1]], V0, V4, V8, VC); \
-	GB_4WAY(M[sigma[r][0x2]], M[sigma[r][0x3]], \
-		CB[sigma[r][0x2]], CB[sigma[r][0x3]], V1, V5, V9, VD); \
-	GB_4WAY(M[sigma[r][0x4]], M[sigma[r][0x5]], \
-		CB[sigma[r][0x4]], CB[sigma[r][0x5]], V2, V6, VA, VE); \
-	GB_4WAY(M[sigma[r][0x6]], M[sigma[r][0x7]], \
-		CB[sigma[r][0x6]], CB[sigma[r][0x7]], V3, V7, VB, VF); \
-	GB_4WAY(M[sigma[r][0x8]], M[sigma[r][0x9]], \
-		CB[sigma[r][0x8]], CB[sigma[r][0x9]], V0, V5, VA, VF); \
-	GB_4WAY(M[sigma[r][0xA]], M[sigma[r][0xB]], \
-		CB[sigma[r][0xA]], CB[sigma[r][0xB]], V1, V6, VB, VC); \
-	GB_4WAY(M[sigma[r][0xC]], M[sigma[r][0xD]], \
-		CB[sigma[r][0xC]], CB[sigma[r][0xD]], V2, V7, V8, VD); \
-	GB_4WAY(M[sigma[r][0xE]], M[sigma[r][0xF]], \
-		CB[sigma[r][0xE]], CB[sigma[r][0xF]], V3, V4, V9, VE); \
-} while (0)
-
-#else
-//current_impl
 #define ROUND_B_4WAY(r)   do { \
 	GB_4WAY(Mx(r, 0), Mx(r, 1), CBx(r, 0), CBx(r, 1), V0, V4, V8, VC); \
 	GB_4WAY(Mx(r, 2), Mx(r, 3), CBx(r, 2), CBx(r, 3), V1, V5, V9, VD); \
@@ -352,208 +593,100 @@ static const sph_u64 CB[16] = {
 	GB_4WAY(Mx(r, E), Mx(r, F), CBx(r, E), CBx(r, F), V3, V4, V9, VE); \
 	} while (0)

-#endif
-
-
-// Blake-512 4 way
-
 #define DECL_STATE64_4WAY \
 	__m256i H0, H1, H2, H3, H4, H5, H6, H7; \
        __m256i S0, S1, S2, S3; \
 	sph_u64 T0, T1;

-#define READ_STATE64_4WAY(state)   do { \
-		H0 = (state)->H[0]; \
-		H1 = (state)->H[1]; \
-		H2 = (state)->H[2]; \
-		H3 = (state)->H[3]; \
-		H4 = (state)->H[4]; \
-		H5 = (state)->H[5]; \
-		H6 = (state)->H[6]; \
-		H7 = (state)->H[7]; \
-		S0 = (state)->S[0]; \
-		S1 = (state)->S[1]; \
-		S2 = (state)->S[2]; \
-		S3 = (state)->S[3]; \
-		T0 = (state)->T0; \
-		T1 = (state)->T1; \
-	} while (0)
+#define COMPRESS64_4WAY   do \
+{ \
+  __m256i M0, M1, M2, M3, M4, M5, M6, M7; \
+  __m256i M8, M9, MA, MB, MC, MD, ME, MF; \
+  __m256i V0, V1, V2, V3, V4, V5, V6, V7; \
+  __m256i V8, V9, VA, VB, VC, VD, VE, VF; \
+  __m256i shuf_bswap64; \
+  V0 = H0; \
+  V1 = H1; \
+  V2 = H2; \
+  V3 = H3; \
+  V4 = H4; \
+  V5 = H5; \
+  V6 = H6; \
+  V7 = H7; \
+  V8 = _mm256_xor_si256( S0, m256_const1_64( CB0 ) );  \
+  V9 = _mm256_xor_si256( S1, m256_const1_64( CB1 ) );  \
+  VA = _mm256_xor_si256( S2, m256_const1_64( CB2 ) );  \
+  VB = _mm256_xor_si256( S3, m256_const1_64( CB3 ) );  \
+  VC = _mm256_xor_si256( _mm256_set1_epi64x( T0 ), \
+                         m256_const1_64( CB4 ) );  \
+  VD = _mm256_xor_si256( _mm256_set1_epi64x( T0 ), \
+                         m256_const1_64( CB5 ) );  \
+  VE = _mm256_xor_si256( _mm256_set1_epi64x( T1 ), \
+                         m256_const1_64( CB6 ) );  \
+  VF = _mm256_xor_si256( _mm256_set1_epi64x( T1 ), \
+                         m256_const1_64( CB7 ) );  \
+  shuf_bswap64 = m256_const_64( 0x18191a1b1c1d1e1f, 0x1011121314151617, \
+                                0x08090a0b0c0d0e0f, 0x0001020304050607 ); \
+  M0 = _mm256_shuffle_epi8( *(buf+ 0), shuf_bswap64 ); \
+  M1 = _mm256_shuffle_epi8( *(buf+ 1), shuf_bswap64 ); \
+  M2 = _mm256_shuffle_epi8( *(buf+ 2), shuf_bswap64 ); \
+  M3 = _mm256_shuffle_epi8( *(buf+ 3), shuf_bswap64 ); \
+  M4 = _mm256_shuffle_epi8( *(buf+ 4), shuf_bswap64 ); \
+  M5 = _mm256_shuffle_epi8( *(buf+ 5), shuf_bswap64 ); \
+  M6 = _mm256_shuffle_epi8( *(buf+ 6), shuf_bswap64 ); \
+  M7 = _mm256_shuffle_epi8( *(buf+ 7), shuf_bswap64 ); \
+  M8 = _mm256_shuffle_epi8( *(buf+ 8), shuf_bswap64 ); \
+  M9 = _mm256_shuffle_epi8( *(buf+ 9), shuf_bswap64 ); \
+  MA = _mm256_shuffle_epi8( *(buf+10), shuf_bswap64 ); \
+  MB = _mm256_shuffle_epi8( *(buf+11), shuf_bswap64 ); \
+  MC = _mm256_shuffle_epi8( *(buf+12), shuf_bswap64 ); \
+  MD = _mm256_shuffle_epi8( *(buf+13), shuf_bswap64 ); \
+  ME = _mm256_shuffle_epi8( *(buf+14), shuf_bswap64 ); \
+  MF = _mm256_shuffle_epi8( *(buf+15), shuf_bswap64 ); \
+  ROUND_B_4WAY(0); \
+  ROUND_B_4WAY(1); \
+  ROUND_B_4WAY(2); \
+  ROUND_B_4WAY(3); \
+  ROUND_B_4WAY(4); \
+  ROUND_B_4WAY(5); \
+  ROUND_B_4WAY(6); \
+  ROUND_B_4WAY(7); \
+  ROUND_B_4WAY(8); \
+  ROUND_B_4WAY(9); \
+  ROUND_B_4WAY(0); \
+  ROUND_B_4WAY(1); \
+  ROUND_B_4WAY(2); \
+  ROUND_B_4WAY(3); \
+  ROUND_B_4WAY(4); \
+  ROUND_B_4WAY(5); \
+  H0 = mm256_xor4( V8, V0, S0, H0 ); \
+  H1 = mm256_xor4( V9, V1, S1, H1 ); \
+  H2 = mm256_xor4( VA, V2, S2, H2 ); \
+  H3 = mm256_xor4( VB, V3, S3, H3 ); \
+  H4 = mm256_xor4( VC, V4, S0, H4 ); \
+  H5 = mm256_xor4( VD, V5, S1, H5 ); \
+  H6 = mm256_xor4( VE, V6, S2, H6 ); \
+  H7 = mm256_xor4( VF, V7, S3, H7 ); \
+} while (0)

-#define WRITE_STATE64_4WAY(state)   do { \
-		(state)->H[0] = H0; \
-		(state)->H[1] = H1; \
-		(state)->H[2] = H2; \
-		(state)->H[3] = H3; \
-		(state)->H[4] = H4; \
-		(state)->H[5] = H5; \
-		(state)->H[6] = H6; \
-		(state)->H[7] = H7; \
-		(state)->S[0] = S0; \
-		(state)->S[1] = S1; \
-		(state)->S[2] = S2; \
-		(state)->S[3] = S3; \
-		(state)->T0 = T0; \
-		(state)->T1 = T1; \
-	} while (0)

-#if SPH_COMPACT_BLAKE_64
-
-// not used
-#define COMPRESS64_4WAY   do { \
-	__m256i M[16]; \
-	__m256i V0, V1, V2, V3, V4, V5, V6, V7; \
-	__m256i 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 = _mm256_xor_si256( S0, _mm256_set_epi64x( CB0, CB0, CB0, CB0 ) ); \
-        V9 = _mm256_xor_si256( S1, _mm256_set_epi64x( CB1, CB1, CB1, CB1 ) ); \
-        VA = _mm256_xor_si256( S2, _mm256_set_epi64x( CB2, CB2, CB2, CB2 ) ); \
-        VB = _mm256_xor_si256( S3, _mm256_set_epi64x( CB3, CB3, CB3, CB3 ) ); \
-        VC = _mm256_xor_si256( _mm256_set_epi64x( T0, T0, T0, T0 ), \
-                               _mm256_set_epi64x( CB4, CB4, CB4, CB4 ) ); \
-        VD = _mm256_xor_si256( _mm256_set_epi64x( T0, T0, T0, T0 ), \
-                               _mm256_set_epi64x( CB5, CB5, CB5, CB5 ) ); \
-        VE = _mm256_xor_si256( _mm256_set_epi64x( T1, T1, T1, T1 ), \
-                               _mm256_set_epi64x( CB6, CB6, CB6, CB6 ) ); \
-        VF = _mm256_xor_si256( _mm256_set_epi64x( T1, T1, T1, T1 ), \
-                               _mm256_set_epi64x( CB7, CB7, CB7, CB7 ) ); \
-	M[0x0] = mm256_bswap_64( *(buf+0) ); \
-	M[0x1] = mm256_bswap_64( *(buf+1) ); \
-	M[0x2] = mm256_bswap_64( *(buf+2) ); \
-	M[0x3] = mm256_bswap_64( *(buf+3) ); \
-	M[0x4] = mm256_bswap_64( *(buf+4) ); \
-	M[0x5] = mm256_bswap_64( *(buf+5) ); \
-	M[0x6] = mm256_bswap_64( *(buf+6) ); \
-	M[0x7] = mm256_bswap_64( *(buf+7) ); \
-	M[0x8] = mm256_bswap_64( *(buf+8) ); \
-	M[0x9] = mm256_bswap_64( *(buf+9) ); \
-	M[0xA] = mm256_bswap_64( *(buf+10) ); \
-	M[0xB] = mm256_bswap_64( *(buf+11) ); \
-	M[0xC] = mm256_bswap_64( *(buf+12) ); \
-	M[0xD] = mm256_bswap_64( *(buf+13) ); \
-	M[0xE] = mm256_bswap_64( *(buf+14) ); \
-	M[0xF] = mm256_bswap_64( *(buf+15) ); \
-	for (r = 0; r < 16; r ++) \
-		ROUND_B_4WAY(r); \
-        H0 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S0, V0 ), V8 ), H0 ); \
-        H1 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S1, V1 ), V9 ), H1 ); \
-        H2 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S2, V2 ), VA ), H2 ); \
-        H3 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S3, V3 ), VB ), H3 ); \
-        H4 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S0, V4 ), VC ), H4 ); \
-        H5 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S1, V5 ), VD ), H5 ); \
-        H6 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S2, V6 ), VE ), H6 ); \
-        H7 = _mm256_xor_si256( _mm256_xor_si256( \
-                    _mm256_xor_si256( S3, V7 ), VF ), H7 ); \
-	} while (0)
-
-#else
-
-//current impl
-
-#define COMPRESS64_4WAY   do { \
-     __m256i M0, M1, M2, M3, M4, M5, M6, M7; \
-     __m256i M8, M9, MA, MB, MC, MD, ME, MF; \
-     __m256i V0, V1, V2, V3, V4, V5, V6, V7; \
-     __m256i V8, V9, VA, VB, VC, VD, VE, VF; \
-     V0 = H0; \
-     V1 = H1; \
-     V2 = H2; \
-     V3 = H3; \
-     V4 = H4; \
-     V5 = H5; \
-     V6 = H6; \
-     V7 = H7; \
-     V8 = _mm256_xor_si256( S0, _mm256_set_epi64x( CB0, CB0, CB0, CB0 ) );  \
-     V9 = _mm256_xor_si256( S1, _mm256_set_epi64x( CB1, CB1, CB1, CB1 ) );  \
-     VA = _mm256_xor_si256( S2, _mm256_set_epi64x( CB2, CB2, CB2, CB2 ) );  \
-     VB = _mm256_xor_si256( S3, _mm256_set_epi64x( CB3, CB3, CB3, CB3 ) );  \
-     VC = _mm256_xor_si256( _mm256_set_epi64x( T0, T0, T0, T0 ), \
-                            _mm256_set_epi64x( CB4, CB4, CB4, CB4 ) );  \
-     VD = _mm256_xor_si256( _mm256_set_epi64x( T0, T0, T0, T0 ), \
-                            _mm256_set_epi64x( CB5, CB5, CB5, CB5 ) );  \
-     VE = _mm256_xor_si256( _mm256_set_epi64x( T1, T1, T1, T1 ), \
-                            _mm256_set_epi64x( CB6, CB6, CB6, CB6 ) );  \
-     VF = _mm256_xor_si256( _mm256_set_epi64x( T1, T1, T1, T1 ), \
-                            _mm256_set_epi64x( CB7, CB7, CB7, CB7 ) );  \
-     M0 = mm256_bswap_64( *(buf + 0) ); \
-     M1 = mm256_bswap_64( *(buf + 1) ); \
-     M2 = mm256_bswap_64( *(buf + 2) ); \
-     M3 = mm256_bswap_64( *(buf + 3) ); \
-     M4 = mm256_bswap_64( *(buf + 4) ); \
-     M5 = mm256_bswap_64( *(buf + 5) ); \
-     M6 = mm256_bswap_64( *(buf + 6) ); \
-     M7 = mm256_bswap_64( *(buf + 7) ); \
-     M8 = mm256_bswap_64( *(buf + 8) ); \
-     M9 = mm256_bswap_64( *(buf + 9) ); \
-     MA = mm256_bswap_64( *(buf + 10) ); \
-     MB = mm256_bswap_64( *(buf + 11) ); \
-     MC = mm256_bswap_64( *(buf + 12) ); \
-     MD = mm256_bswap_64( *(buf + 13) ); \
-     ME = mm256_bswap_64( *(buf + 14) ); \
-     MF = mm256_bswap_64( *(buf + 15) ); \
-     ROUND_B_4WAY(0); \
-     ROUND_B_4WAY(1); \
-     ROUND_B_4WAY(2); \
-     ROUND_B_4WAY(3); \
-     ROUND_B_4WAY(4); \
-     ROUND_B_4WAY(5); \
-     ROUND_B_4WAY(6); \
-     ROUND_B_4WAY(7); \
-     ROUND_B_4WAY(8); \
-     ROUND_B_4WAY(9); \
-     ROUND_B_4WAY(0); \
-     ROUND_B_4WAY(1); \
-     ROUND_B_4WAY(2); \
-     ROUND_B_4WAY(3); \
-     ROUND_B_4WAY(4); \
-     ROUND_B_4WAY(5); \
-     H0 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S0, V0 ), V8 ), H0 ); \
-     H1 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S1, V1 ), V9 ), H1 ); \
-     H2 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S2, V2 ), VA ), H2 ); \
-     H3 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S3, V3 ), VB ), H3 ); \
-     H4 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S0, V4 ), VC ), H4 ); \
-     H5 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S1, V5 ), VD ), H5 ); \
-     H6 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S2, V6 ), VE ), H6 ); \
-     H7 = _mm256_xor_si256( _mm256_xor_si256( \
-                            _mm256_xor_si256( S3, V7 ), VF ), H7 ); \
-	} while (0)
-
-#endif
-
-static const sph_u64 salt_zero_big[4] = { 0, 0, 0, 0 };
-
-static void
-blake64_4way_init( blake_4way_big_context *sc, const sph_u64 *iv,
-              const sph_u64 *salt )
+void blake512_4way_init( blake_4way_big_context *sc )
 {
-        int i;
-        for ( i = 0; i < 8; i++ )
-           sc->H[i] = _mm256_set1_epi64x( iv[i] );
-        for ( i = 0; i < 4; i++ )
-           sc->S[i] = _mm256_set1_epi64x( salt[i] );
-        sc->T0 = sc->T1 = 0;
-        sc->ptr = 0;
+   __m256i zero = m256_zero;
+   casti_m256i( sc->H, 0 ) = m256_const1_64( 0x6A09E667F3BCC908 );
+   casti_m256i( sc->H, 1 ) = m256_const1_64( 0xBB67AE8584CAA73B );
+   casti_m256i( sc->H, 2 ) = m256_const1_64( 0x3C6EF372FE94F82B );
+   casti_m256i( sc->H, 3 ) = m256_const1_64( 0xA54FF53A5F1D36F1 );
+   casti_m256i( sc->H, 4 ) = m256_const1_64( 0x510E527FADE682D1 );
+   casti_m256i( sc->H, 5 ) = m256_const1_64( 0x9B05688C2B3E6C1F );
+   casti_m256i( sc->H, 6 ) = m256_const1_64( 0x1F83D9ABFB41BD6B );
+   casti_m256i( sc->H, 7 ) = m256_const1_64( 0x5BE0CD19137E2179 );
+   casti_m256i( sc->S, 0 ) = zero;
+   casti_m256i( sc->S, 1 ) = zero;
+   casti_m256i( sc->S, 2 ) = zero;
+   casti_m256i( sc->S, 3 ) = zero;
+   sc->T0 = sc->T1 = 0;
+   sc->ptr = 0;
 }

 static void
@@ -576,7 +709,7 @@ blake64_4way( blake_4way_big_context *sc, const void *data, size_t len)
 	return;
   }

-   READ_STATE64_4WAY(sc);
+   READ_STATE64(sc);
   while ( len > 0 )
   {
 	size_t clen;
@@ -596,29 +729,21 @@ blake64_4way( blake_4way_big_context *sc, const void *data, size_t len)
 		ptr = 0;
 	}
   }
-   WRITE_STATE64_4WAY(sc);
+   WRITE_STATE64(sc);
   sc->ptr = ptr;
 }

 static void
-blake64_4way_close( blake_4way_big_context *sc,
-	unsigned ub, unsigned n, void *dst, size_t out_size_w64)
+blake64_4way_close( blake_4way_big_context *sc, void *dst )
 {
-//   union {
-      __m256i buf[16];
-//      sph_u64 dummy;
-//   } u;
-   size_t ptr, k;
+   __m256i buf[16];
+   size_t ptr;
   unsigned bit_len;
-   uint64_t z, zz;
   sph_u64 th, tl;
-   __m256i *out;

   ptr = sc->ptr;
   bit_len = ((unsigned)ptr << 3);
-   z = 0x80 >> n;
-   zz = ((ub & -z) | z) & 0xFF;
-   buf[ptr>>3] = _mm256_set_epi64x( zz, zz, zz, zz );
+   buf[ptr>>3] = m256_const1_64( 0x80 );
   tl = sc->T0 + bit_len;
   th = sc->T1;
   if (ptr == 0 )
@@ -635,49 +760,44 @@ blake64_4way_close( blake_4way_big_context *sc,
   {
        sc->T0 -= 1024 - bit_len;
   }
+
   if ( ptr <= 104 )
   {
       memset_zero_256( buf + (ptr>>3) + 1, (104-ptr) >> 3 );
-       if ( out_size_w64 == 8 )
-          buf[(104>>3)] = _mm256_or_si256( buf[(104>>3)],
-                                 _mm256_set1_epi64x( 0x0100000000000000ULL ) );
-       *(buf+(112>>3)) = mm256_bswap_64(
-                                    _mm256_set_epi64x( th, th, th, th ) );
-       *(buf+(120>>3)) = mm256_bswap_64(
-                                    _mm256_set_epi64x( tl, tl, tl, tl ) );
+       buf[104>>3] = _mm256_or_si256( buf[104>>3],
+                                 m256_const1_64( 0x0100000000000000ULL ) );
+       buf[112>>3] = m256_const1_64( bswap_64( th ) );
+       buf[120>>3] = m256_const1_64( bswap_64( tl ) );

       blake64_4way( sc, buf + (ptr>>3), 128 - ptr );
   }
   else
-  {
+   {
       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);
       memset_zero_256( buf, 112>>3 ); 
-       if ( out_size_w64 == 8 )
-           buf[104>>3] = _mm256_set1_epi64x( 0x0100000000000000ULL );
-       *(buf+(112>>3)) = mm256_bswap_64(
-                                    _mm256_set_epi64x( th, th, th, th ) );
-       *(buf+(120>>3)) = mm256_bswap_64(
-                                    _mm256_set_epi64x( tl, tl, tl, tl ) );
+       buf[104>>3] = m256_const1_64( 0x0100000000000000ULL );
+       buf[112>>3] = m256_const1_64( bswap_64( th ) );
+       buf[120>>3] = m256_const1_64( bswap_64( tl ) );

       blake64_4way( sc, buf, 128 );
   }
-   out = (__m256i*)dst;
-   for ( k = 0; k < out_size_w64; k++ )
-       out[k] = mm256_bswap_64( sc->H[k] );
+   mm256_block_bswap_64( (__m256i*)dst, sc->H );
 }

+/*
 void
 blake512_4way_init(void *cc)
 {
 	blake64_4way_init(cc, IV512, salt_zero_big);
 }
+*/

 void
-blake512_4way(void *cc, const void *data, size_t len)
+blake512_4way_update(void *cc, const void *data, size_t len)
 {
 	blake64_4way(cc, data, len);
 }
@@ -685,15 +805,18 @@ blake512_4way(void *cc, const void *data, size_t len)
 void
 blake512_4way_close(void *cc, void *dst)
 {
-	blake512_4way_addbits_and_close(cc, 0, 0, dst);
+   blake64_4way_close( cc, dst );
+
+//   blake512_4way_addbits_and_close(cc, dst);
 }

+/*
 void
 blake512_4way_addbits_and_close(void *cc, unsigned ub, unsigned n, void *dst)
 {
 	blake64_4way_close(cc, ub, n, dst, 8);
 }
-
+*/
 #ifdef __cplusplus
 }
 #endif
--- a/algo/blake/blakecoin-4way.c
+++ b/algo/blake/blakecoin-4way.c
@@ -29,23 +29,18 @@ int scanhash_blakecoin_4way( struct work *work, uint32_t max_nonce,
   uint32_t *ptarget = work->target;
   const uint32_t first_nonce = pdata[19];
   uint32_t HTarget = ptarget[7];
-   uint32_t _ALIGN(32) edata[20];
   uint32_t n = first_nonce;
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
   int thr_id = mythr->id;  // thr_id arg is deprecated
   if ( opt_benchmark )
      HTarget = 0x7f;

-   swab32_array( edata, pdata, 20 );
-   mm128_intrlv_4x32( vdata, edata, edata, edata, edata, 640 );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
   blake256r8_4way_init( &blakecoin_4w_ctx );
   blake256r8_4way( &blakecoin_4w_ctx, vdata, 64 );

-   uint32_t *noncep = vdata + 76;   // 19*4
   do {
-      be32enc( noncep,    n   );
-      be32enc( noncep +1, n+1 );
-      be32enc( noncep +2, n+2 );
-      be32enc( noncep +3, n+3 );
+      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
      pdata[19] = n;
      blakecoin_4way_hash( hash, vdata );

@@ -79,9 +74,8 @@ void blakecoin_8way_hash( void *state, const void *input )
     blake256r8_8way( &ctx, input + (64<<3), 16 );
     blake256r8_8way_close( &ctx, vhash );

-     mm256_dintrlv_8x32( state,     state+ 32, state+ 64, state+ 96,
-                              state+128, state+160, state+192, state+224,
-                              vhash, 256 );
+     dintrlv_8x32( state,     state+ 32, state+ 64, state+ 96, state+128,
+                   state+160, state+192, state+224, vhash, 256 );
 }

 int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
@@ -93,29 +87,19 @@ int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
   uint32_t *ptarget = work->target;
   const uint32_t first_nonce = pdata[19];
   uint32_t HTarget = ptarget[7];
-   uint32_t _ALIGN(32) edata[20];
   uint32_t n = first_nonce;
-   uint32_t *noncep = vdata + 152;   // 19*8
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
   int thr_id = mythr->id;  // thr_id arg is deprecated
   if ( opt_benchmark )
      HTarget = 0x7f;

-   // we need big endian data...
-   swab32_array( edata, pdata, 20 );
-   mm256_intrlv_8x32( vdata, edata, edata, edata, edata,
-                                 edata, edata, edata, edata, 640 );
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
   blake256r8_8way_init( &blakecoin_8w_ctx );
   blake256r8_8way( &blakecoin_8w_ctx, vdata, 64 );

   do {
-      be32enc( noncep,    n   );
-      be32enc( noncep +1, n+1 );
-      be32enc( noncep +2, n+2 );
-      be32enc( noncep +3, n+3 );
-      be32enc( noncep +4, n+4 );
-      be32enc( noncep +5, n+5 );
-      be32enc( noncep +6, n+6 );
-      be32enc( noncep +7, n+7 );
+      *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 );

--- a/algo/blake/blakecoin-gate.c
+++ b/algo/blake/blakecoin-gate.c
@@ -1,13 +1,6 @@
 #include "blakecoin-gate.h"
 #include <memory.h>

-// changed to get_max64_0x3fffffLL in cpuminer-multi-decred
-int64_t blakecoin_get_max64 ()
-{
-  return 0x7ffffLL;
-//  return 0x3fffffLL;
-}
-
 // vanilla uses default gen merkle root, otherwise identical to blakecoin
 bool register_vanilla_algo( algo_gate_t* gate )
 {
@@ -23,7 +16,6 @@ bool register_vanilla_algo( algo_gate_t* gate )
  gate->hash     = (void*)&blakecoinhash;
 #endif
  gate->optimizations = SSE42_OPT | AVX2_OPT;
-  gate->get_max64 = (void*)&blakecoin_get_max64;
  return true;
 }

--- a/algo/blake/blakecoin.c
+++ b/algo/blake/blakecoin.c
@@ -93,33 +93,3 @@ int scanhash_blakecoin( struct work *work, uint32_t max_nonce,
 	return 0;
 }

-/*
-void blakecoin_gen_merkle_root ( char* merkle_root, struct stratum_ctx* sctx )
-{
- SHA256( sctx->job.coinbase, (int)sctx->job.coinbase_size, merkle_root );
-}
-*/
-/*
-// changed to get_max64_0x3fffffLL in cpuminer-multi-decred
-int64_t blakecoin_get_max64 ()
-{
-  return 0x7ffffLL;
-}
-
-// vanilla uses default gen merkle root, otherwise identical to blakecoin
-bool register_vanilla_algo( algo_gate_t* gate )
-{
-    gate->scanhash = (void*)&scanhash_blakecoin;
-    gate->hash     = (void*)&blakecoinhash;
-    gate->get_max64 = (void*)&blakecoin_get_max64;
-    blakecoin_init( &blake_init_ctx );
-    return true;
-}
-
-bool register_blakecoin_algo( algo_gate_t* gate )
-{
-  register_vanilla_algo( gate );
-  gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
-  return true;
-}
-*/
--- a/algo/blake/decred-gate.c
+++ b/algo/blake/decred-gate.c
@@ -38,7 +38,7 @@ void decred_decode_extradata( struct work* work, uint64_t* net_blocks )
   if (!have_longpoll && work->height > *net_blocks + 1)
   {
      char netinfo[64] = { 0 };
-      if (opt_showdiff && net_diff > 0.)
+      if ( net_diff > 0. )
      {
         if (net_diff != work->targetdiff)
            sprintf(netinfo, ", diff %.3f, target %.1f", net_diff,
@@ -116,7 +116,7 @@ void decred_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
   // block header suffix from coinb2 (stake version)
   memcpy( &g_work->data[44],
           &sctx->job.coinbase[ sctx->job.coinbase_size-4 ], 4 );
-   sctx->bloc_height = g_work->data[32];
+   sctx->block_height = g_work->data[32];
   //applog_hex(work->data, 180);
   //applog_hex(&work->data[36], 36);
 }
@@ -154,7 +154,6 @@ bool register_decred_algo( algo_gate_t* gate )
 #endif
  gate->optimizations = AVX2_OPT;
  gate->get_nonceptr          = (void*)&decred_get_nonceptr;
-  gate->get_max64             = (void*)&get_max64_0x3fffffLL;
  gate->decode_extra_data     = (void*)&decred_decode_extradata;
  gate->build_stratum_request = (void*)&decred_be_build_stratum_request;
  gate->work_decode           = (void*)&std_be_work_decode;
--- a/algo/blake/decred.c
+++ b/algo/blake/decred.c
@@ -143,7 +143,7 @@ void decred_decode_extradata( struct work* work, uint64_t* net_blocks )
   if (!have_longpoll && work->height > *net_blocks + 1)
   {
      char netinfo[64] = { 0 };
-      if (opt_showdiff && net_diff > 0.)
+      if (net_diff > 0.)
      {
         if (net_diff != work->targetdiff)
 	    sprintf(netinfo, ", diff %.3f, target %.1f", net_diff,
@@ -269,7 +269,6 @@ bool register_decred_algo( algo_gate_t* gate )
  gate->scanhash              = (void*)&scanhash_decred;
  gate->hash                  = (void*)&decred_hash;
  gate->get_nonceptr          = (void*)&decred_get_nonceptr;
-  gate->get_max64             = (void*)&get_max64_0x3fffffLL;
  gate->decode_extra_data     = (void*)&decred_decode_extradata;
  gate->build_stratum_request = (void*)&decred_be_build_stratum_request;
  gate->work_decode           = (void*)&std_be_work_decode;
--- a/algo/blake/pentablake-4way.c
+++ b/algo/blake/pentablake-4way.c
@@ -10,13 +10,8 @@
 #include "blake-hash-4way.h"
 #include "sph_blake.h"

-//#define DEBUG_ALGO
-
 extern void pentablakehash_4way( void *output, const void *input )
 {
-//	unsigned char _ALIGN(32) hash[128];
-//	// same as uint32_t hashA[16], hashB[16];
-//	#define hashB hash+64

     uint64_t hash0[8] __attribute__ ((aligned (64)));
     uint64_t hash1[8] __attribute__ ((aligned (64)));
@@ -29,22 +24,7 @@ extern void pentablakehash_4way( void *output, const void *input )
     blake512_4way_init( &ctx );
     blake512_4way( &ctx, input, 80 );
     blake512_4way_close( &ctx, vhash );
-/*
-uint64_t sin0[10], sin1[10], sin2[10], sin3[10];
-mm256_deinterleave_4x64( sin0, sin1, sin2, sin3, input, 640 );
-sph_blake512_context ctx2_blake;
-sph_blake512_init(&ctx2_blake);
-sph_blake512(&ctx2_blake, sin0, 80);
-sph_blake512_close(&ctx2_blake, (void*) hash);

-mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
-uint64_t* hash64 = (uint64_t*)hash;
-for( int i = 0; i < 8; i++ )
-{
-   if ( hash0[i] != hash64[i] )
-      printf("hash mismatch %u\n",i);
-}
-*/
     blake512_4way_init( &ctx );
     blake512_4way( &ctx, vhash, 64 );
     blake512_4way_close( &ctx, vhash );
@@ -61,42 +41,10 @@ for( int i = 0; i < 8; i++ )
     blake512_4way( &ctx, vhash, 64 );
     blake512_4way_close( &ctx, vhash );

-     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
     memcpy( output,    hash0, 32 );
     memcpy( output+32, hash1, 32 );
     memcpy( output+64, hash2, 32 );
     memcpy( output+96, hash3, 32 );
-
-/*
-     uint64_t sin0[10] __attribute__ ((aligned (64)));
-     uint64_t sin1[10] __attribute__ ((aligned (64)));
-     uint64_t sin2[10] __attribute__ ((aligned (64)));
-     uint64_t sin3[10] __attribute__ ((aligned (64)));
-
-	sph_blake512_context     ctx_blake;
-
-	sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, input, 80);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-	memcpy(output, hash, 32);
-*/
 }

 int scanhash_pentablake_4way( struct work *work,
@@ -137,7 +85,7 @@ int scanhash_pentablake_4way( struct work *work,
    swab32_array( endiandata, pdata, 20 );

    uint64_t *edata = (uint64_t*)endiandata;
-    mm256_intrlv_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+    intrlv_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );

    for ( int m=0; m < 6; m++ )
    {
--- a/algo/blake/pentablake-gate.c
+++ b/algo/blake/pentablake-gate.c
@@ -10,7 +10,6 @@ bool register_pentablake_algo( algo_gate_t* gate )
    gate->hash      = (void*)&pentablakehash;
 #endif
    gate->optimizations = AVX2_OPT;
-    gate->get_max64 = (void*)&get_max64_0x3ffff;
    return true;
 };

--- a/algo/blake/sph_blake2b.c
+++ b/algo/blake/sph_blake2b.c
@@ -103,7 +103,6 @@ static void blake2b_compress( sph_blake2b_ctx *ctx, int last )
 	v[13] ^= ctx->t[1];                 // high 64 bits
 	if (last)                           // last block flag set ?
 		v[14] = ~v[14];
-
 	for (i = 0; i < 16; i++)            // get little-endian words
 		m[i] = B2B_GET64(&ctx->b[8 * i]);

@@ -184,7 +183,8 @@ void sph_blake2b_final( sph_blake2b_ctx *ctx, void *out )

 	while (ctx->c < 128)                // fill up with zeros
 		ctx->b[ctx->c++] = 0;
-	blake2b_compress(ctx, 1);           // final block flag = 1
+
+   blake2b_compress(ctx, 1);           // final block flag = 1

 	// little endian convert and store
 	for (i = 0; i < ctx->outlen; i++) {
--- a/algo/bmw/bmw-hash-4way.h
+++ b/algo/bmw/bmw-hash-4way.h
@@ -62,9 +62,10 @@ typedef struct {

 typedef bmw_4way_small_context bmw256_4way_context;

-void bmw256_4way_init(void *cc);
+void bmw256_4way_init( bmw256_4way_context *ctx );

-void bmw256_4way(void *cc, const void *data, size_t len);
+void bmw256_4way_update(void *cc, const void *data, size_t len);
+#define bmw256_4way bmw256_4way_update

 void bmw256_4way_close(void *cc, void *dst);

@@ -78,7 +79,7 @@ void bmw256_4way_addbits_and_close(
 // BMW-256 8 way 32

 typedef struct {
-   __m256i buf[64];
+   __m256i buf[16];
   __m256i H[16];
   size_t ptr;
   uint32_t bit_count;  // assume bit_count fits in 32 bits
@@ -87,11 +88,33 @@ typedef struct {
 typedef bmw_8way_small_context bmw256_8way_context;

 void bmw256_8way_init( bmw256_8way_context *ctx );
-void bmw256_8way( bmw256_8way_context *ctx, const void *data, size_t len );
+void bmw256_8way_update( bmw256_8way_context *ctx, const void *data,
+                         size_t len );
+#define bmw256_8way bmw256_8way_update
 void bmw256_8way_close( bmw256_8way_context *ctx, void *dst );

 #endif

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// BMW-256 16 way 32
+
+typedef struct {
+   __m512i buf[16];
+   __m512i H[16];
+   size_t ptr;
+   uint32_t bit_count;  // assume bit_count fits in 32 bits
+} bmw_16way_small_context __attribute__ ((aligned (128)));
+
+typedef bmw_16way_small_context bmw256_16way_context;
+
+void bmw256_16way_init( bmw256_16way_context *ctx );
+void bmw256_16way_update( bmw256_16way_context *ctx, const void *data,
+                          size_t len );
+void bmw256_16way_close( bmw256_16way_context *ctx, void *dst );
+
+#endif
+

 #if defined(__SSE2__)

@@ -107,7 +130,8 @@ typedef struct {
 typedef bmw_2way_big_context bmw512_2way_context;

 void bmw512_2way_init( bmw512_2way_context *ctx );
-void bmw512_2way( bmw512_2way_context *ctx, const void *data, size_t len );
+void bmw512_2way_update( bmw512_2way_context *ctx, const void *data,
+                         size_t len );
 void bmw512_2way_close( bmw512_2way_context *ctx, void *dst );

 #endif // __SSE2__
@@ -121,14 +145,15 @@ typedef struct {
   __m256i H[16];
   size_t ptr;
   sph_u64 bit_count;
-} bmw_4way_big_context;
+} bmw_4way_big_context __attribute__((aligned(128)));

 typedef bmw_4way_big_context bmw512_4way_context;


 void bmw512_4way_init(void *cc);

-void bmw512_4way(void *cc, const void *data, size_t len);
+void bmw512_4way_update(void *cc, const void *data, size_t len);
+#define bmw512_4way bmw512_4way_update

 void bmw512_4way_close(void *cc, void *dst);

@@ -137,6 +162,22 @@ void bmw512_4way_addbits_and_close(

 #endif  // __AVX2__

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+typedef struct {
+   __m512i buf[16];
+   __m512i H[16];
+   size_t ptr;
+   uint64_t bit_count;
+} bmw512_8way_context __attribute__((aligned(128)));
+
+void bmw512_8way_init( bmw512_8way_context *ctx );
+void bmw512_8way_update( bmw512_8way_context *ctx, const void *data,
+                         size_t len );
+void bmw512_8way_close( bmw512_8way_context *ctx, void *dst );
+
+#endif // AVX512
+
 #ifdef __cplusplus
 }
 #endif
--- a/algo/bmw/bmw256-hash-4way.c
+++ b/algo/bmw/bmw256-hash-4way.c
--- a/algo/bmw/bmw512-4way.c
+++ b/algo/bmw/bmw512-4way.c
@@ -0,0 +1,115 @@
+#include "bmw512-gate.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+//#include "sph_keccak.h"
+#include "bmw-hash-4way.h"
+
+#if defined(BMW512_8WAY)
+
+void bmw512hash_8way(void *state, const void *input)
+{
+    bmw512_8way_context ctx;
+    bmw512_8way_init( &ctx );
+    bmw512_8way_update( &ctx, input, 80 );
+    bmw512_8way_close( &ctx, state );
+}
+
+int scanhash_bmw512_8way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[24*8] __attribute__ ((aligned (128)));
+   uint32_t hash[16*8] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[49]);   // 3*16+1
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   uint32_t n = pdata[19];
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 8;
+   __m512i  *noncev = (__m512i*)vdata + 9;   // aligned
+   const uint32_t Htarg = ptarget[7];
+   int thr_id = mythr->id;
+
+   mm512_bswap32_intrlv80_8x64( vdata, pdata );
+   do {
+       *noncev = mm512_intrlv_blend_32( mm512_bswap_32(
+                _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0 ,
+                                  n+3, 0, n+2, 0, n+1, 0, n  , 0 ) ), *noncev );
+
+      bmw512hash_8way( hash, vdata );
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( hash7[ lane<<1 ] < Htarg ) )
+//      if ( ( ( hash7[ lane<<1 ] & 0xFFFFFF00 ) == 0 ) )
+      {
+          extr_lane_8x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) )
+          {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+          }
+      }
+      n += 8;
+
+   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart) );
+
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+   
+#elif defined(BMW512_4WAY)
+
+//#ifdef BMW512_4WAY
+
+void bmw512hash_4way(void *state, const void *input)
+{
+    bmw512_4way_context ctx;
+    bmw512_4way_init( &ctx );
+    bmw512_4way( &ctx, input, 80 );
+    bmw512_4way_close( &ctx, state );
+}
+
+int scanhash_bmw512_4way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[24*4] __attribute__ ((aligned (128)));
+   uint32_t hash[16*4] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[25]);   // 3*8+1
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   uint32_t n = pdata[19];
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce -  4;
+   __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+   const uint32_t Htarg = ptarget[7];
+    int thr_id = mythr->id;  // thr_id arg is deprecated
+
+   mm256_bswap32_intrlv80_4x64( vdata, pdata );
+   do {
+       *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
+	
+      bmw512hash_4way( hash, vdata );
+
+      for ( int lane = 0; lane < 4; lane++ )
+      if ( unlikely( hash7[ lane<<1 ] < Htarg ) )
+//      if ( ( ( hash7[ lane<<1 ] & 0xFFFFFF00 ) == 0 ) )
+      {
+          extr_lane_4x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) )
+          {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+          }
+      }
+      n += 4;
+
+   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart ) );
+
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+#endif
--- a/algo/bmw/bmw512-gate.c
+++ b/algo/bmw/bmw512-gate.c
@@ -0,0 +1,20 @@
+#include "bmw512-gate.h"
+
+bool register_bmw512_algo( algo_gate_t* gate )
+{
+  gate->optimizations = AVX2_OPT | AVX512_OPT;
+  opt_target_factor = 256.0;
+#if defined (BMW512_8WAY)
+  gate->scanhash  = (void*)&scanhash_bmw512_8way;
+  gate->hash      = (void*)&bmw512hash_8way;
+#elif defined (BMW512_4WAY)
+  gate->scanhash  = (void*)&scanhash_bmw512_4way;
+  gate->hash      = (void*)&bmw512hash_4way;
+#else
+  gate->scanhash        = (void*)&scanhash_bmw512;
+  gate->hash            = (void*)&bmw512hash;
+#endif
+  return true;
+};
+
+
--- a/algo/bmw/bmw512-gate.h
+++ b/algo/bmw/bmw512-gate.h
@@ -0,0 +1,33 @@
+#ifndef BMW512_GATE_H__
+#define BMW512_GATE_H__ 1
+
+#include "algo-gate-api.h"
+#include <stdint.h>
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define BMW512_8WAY 1
+#elif defined(__AVX2__)
+  #define BMW512_4WAY 1
+#endif
+
+#if defined(BMW512_8WAY)
+
+void bmw512hash_8way( void *state, const void *input );
+int scanhash_bmw512_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined(BMW512_4WAY)
+
+void bmw512hash_4way( void *state, const void *input );
+int scanhash_bmw512_4way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#else
+
+void bmw512hash( void *state, const void *input );
+int scanhash_bmw512( struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+
+#endif
--- a/algo/bmw/bmw512-hash-4way.c
+++ b/algo/bmw/bmw512-hash-4way.c
--- a/algo/bmw/bmw512.c
+++ b/algo/bmw/bmw512.c
@@ -0,0 +1,53 @@
+#include "algo-gate-api.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "sph_bmw.h"
+
+void bmw512hash(void *state, const void *input)
+{
+    sph_bmw512_context ctx;
+    uint32_t hash[32];	
+   
+    sph_bmw512_init( &ctx );
+    sph_bmw512( &ctx,input, 80 );
+    sph_bmw512_close( &ctx, hash );
+
+    memcpy( state, hash, 32 );
+}
+
+int scanhash_bmw512( 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 n = pdata[19] - 1;
+	const uint32_t first_nonce = pdata[19];
+	//const uint32_t Htarg = ptarget[7];
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+
+	uint32_t _ALIGN(32) hash64[8];
+	uint32_t endiandata[32];
+
+   for (int i=0; i < 19; i++) 
+           be32enc(&endiandata[i], pdata[i]);
+
+	do {
+	
+		pdata[19] = ++n;
+		be32enc(&endiandata[19], n); 
+		bmw512hash(hash64, endiandata);
+        if (((hash64[7]&0xFFFFFF00)==0) && 
+				fulltest(hash64, ptarget)) {
+            *hashes_done = n - first_nonce + 1;
+			return true;
+		}
+	} while (n < max_nonce && !work_restart[thr_id].restart);
+	
+	*hashes_done = n - first_nonce + 1;
+	pdata[19] = n;
+	return 0;
+}
+
--- a/algo/cryptonight/cryptolight.c
+++ b/algo/cryptonight/cryptolight.c
@@ -242,6 +242,8 @@ void cryptolight_hash(void* output, const void* input, int len) {
 	free(ctx);
 }

+#if defined(__AES__)
+
 static void cryptolight_hash_ctx_aes_ni(void* output, const void* input,
                       int len, struct cryptonight_ctx* ctx)
 {
@@ -312,6 +314,8 @@ static void cryptolight_hash_ctx_aes_ni(void* output, const void* input,
 	oaes_free((OAES_CTX **) &ctx->aes_ctx);
 }

+#endif
+
 int scanhash_cryptolight( struct work *work,
 		uint32_t max_nonce, uint64_t *hashes_done, struct thr_info *mythr)
 {
@@ -359,7 +363,6 @@ bool register_cryptolight_algo( algo_gate_t* gate )
  gate->scanhash  = (void*)&scanhash_cryptolight;
  gate->hash      = (void*)&cryptolight_hash;
  gate->hash_suw  = (void*)&cryptolight_hash; 
-  gate->get_max64 = (void*)&get_max64_0x40LL;
  return true;
 };

--- a/algo/cryptonight/cryptonight-common.c
+++ b/algo/cryptonight/cryptonight-common.c
@@ -111,7 +111,6 @@ bool register_cryptonight_algo( algo_gate_t* gate )
  gate->scanhash         = (void*)&scanhash_cryptonight;
  gate->hash             = (void*)&cryptonight_hash;
  gate->hash_suw         = (void*)&cryptonight_hash_suw;  
-  gate->get_max64        = (void*)&get_max64_0x40LL;
  return true;
 };

@@ -123,7 +122,6 @@ bool register_cryptonightv7_algo( algo_gate_t* gate )
  gate->scanhash      = (void*)&scanhash_cryptonight;
  gate->hash          = (void*)&cryptonight_hash;
  gate->hash_suw      = (void*)&cryptonight_hash_suw;
-  gate->get_max64     = (void*)&get_max64_0x40LL;
  return true;
 };

--- a/algo/cubehash/cube-hash-2way.c
+++ b/algo/cubehash/cube-hash-2way.c
@@ -7,6 +7,7 @@

 // 2x128

+
 // The result of hashing 10 rounds of initial data which consists of params
 // zero padded.
 static const uint64_t IV256[] =
@@ -25,12 +26,193 @@ static const uint64_t IV512[] =
 0xA5A70E75D65C8A2B, 0xBC796576B1C62456, 0xE7989AF11921C8F7, 0xD43E3B447795D246
 };

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// 4 way 128 is handy to avoid reinterleaving in many algos.
+// If reinterleaving is necessary it may be more efficient to use
+// 2 way 256. The same transform code should work for both.
+
+static void transform_4way( cube_4way_context *sp )
+{
+    int r;
+    const int rounds = sp->rounds;
+
+    __m512i x0, x1, x2, x3, x4, x5, x6, x7, y0, y1;
+
+    x0 = _mm512_load_si512( (__m512i*)sp->h     );
+    x1 = _mm512_load_si512( (__m512i*)sp->h + 1 );
+    x2 = _mm512_load_si512( (__m512i*)sp->h + 2 );
+    x3 = _mm512_load_si512( (__m512i*)sp->h + 3 );
+    x4 = _mm512_load_si512( (__m512i*)sp->h + 4 );
+    x5 = _mm512_load_si512( (__m512i*)sp->h + 5 );
+    x6 = _mm512_load_si512( (__m512i*)sp->h + 6 );
+    x7 = _mm512_load_si512( (__m512i*)sp->h + 7 );
+
+    for ( r = 0; r < rounds; ++r )
+    {
+        x4 = _mm512_add_epi32( x0, x4 );
+        x5 = _mm512_add_epi32( x1, x5 );
+        x6 = _mm512_add_epi32( x2, x6 );
+        x7 = _mm512_add_epi32( x3, x7 );
+        y0 = x0;
+        y1 = x1;
+        x0 = mm512_rol_32( x2, 7 );
+        x1 = mm512_rol_32( x3, 7 );
+        x2 = mm512_rol_32( y0, 7 );
+        x3 = mm512_rol_32( y1, 7 );
+        x0 = _mm512_xor_si512( x0, x4 );
+        x1 = _mm512_xor_si512( x1, x5 );
+        x2 = _mm512_xor_si512( x2, x6 );
+        x3 = _mm512_xor_si512( x3, x7 );
+        x4 = mm512_swap128_64( x4 );
+        x5 = mm512_swap128_64( x5 );
+        x6 = mm512_swap128_64( x6 );
+        x7 = mm512_swap128_64( x7 );
+        x4 = _mm512_add_epi32( x0, x4 );
+        x5 = _mm512_add_epi32( x1, x5 );
+        x6 = _mm512_add_epi32( x2, x6 );
+        x7 = _mm512_add_epi32( x3, x7 );
+        y0 = x0;
+        y1 = x2;
+        x0 = mm512_rol_32( x1, 11 );
+        x1 = mm512_rol_32( y0, 11 );
+        x2 = mm512_rol_32( x3, 11 );
+        x3 = mm512_rol_32( y1, 11 );
+        x0 = _mm512_xor_si512( x0, x4 );
+        x1 = _mm512_xor_si512( x1, x5 );
+        x2 = _mm512_xor_si512( x2, x6 );
+        x3 = _mm512_xor_si512( x3, x7 );
+        x4 = mm512_swap64_32( x4 );
+        x5 = mm512_swap64_32( x5 );
+        x6 = mm512_swap64_32( x6 );
+        x7 = mm512_swap64_32( x7 );
+    }
+
+    _mm512_store_si512( (__m512i*)sp->h,     x0 );
+    _mm512_store_si512( (__m512i*)sp->h + 1, x1 );
+    _mm512_store_si512( (__m512i*)sp->h + 2, x2 );
+    _mm512_store_si512( (__m512i*)sp->h + 3, x3 );
+    _mm512_store_si512( (__m512i*)sp->h + 4, x4 );
+    _mm512_store_si512( (__m512i*)sp->h + 5, x5 );
+    _mm512_store_si512( (__m512i*)sp->h + 6, x6 );
+    _mm512_store_si512( (__m512i*)sp->h + 7, x7 );
+}
+
+int cube_4way_init( cube_4way_context *sp, int hashbitlen, int rounds,
+                    int blockbytes )
+{
+    __m512i *h = (__m512i*)sp->h;
+    __m128i *iv = (__m128i*)( hashbitlen == 512 ? (__m128i*)IV512
+                                                : (__m128i*)IV256 );
+    sp->hashlen   = hashbitlen/128;
+    sp->blocksize = blockbytes/16;
+    sp->rounds    = rounds;
+    sp->pos       = 0;
+
+    h[ 0] = m512_const1_128( iv[0] );
+    h[ 1] = m512_const1_128( iv[1] );
+    h[ 2] = m512_const1_128( iv[2] );
+    h[ 3] = m512_const1_128( iv[3] );
+    h[ 4] = m512_const1_128( iv[4] );
+    h[ 5] = m512_const1_128( iv[5] );
+    h[ 6] = m512_const1_128( iv[6] );
+    h[ 7] = m512_const1_128( iv[7] );
+    h[ 0] = m512_const1_128( iv[0] );
+    h[ 1] = m512_const1_128( iv[1] );
+    h[ 2] = m512_const1_128( iv[2] );
+    h[ 3] = m512_const1_128( iv[3] );
+    h[ 4] = m512_const1_128( iv[4] );
+    h[ 5] = m512_const1_128( iv[5] );
+    h[ 6] = m512_const1_128( iv[6] );
+    h[ 7] = m512_const1_128( iv[7] );
+
+    return 0;
+}
+
+int cube_4way_update( cube_4way_context *sp, const void *data, size_t size )
+{
+    const int len = size >> 4;
+    const __m512i *in = (__m512i*)data;
+    int i;
+
+    for ( i = 0; i < len; i++ )
+    {
+        sp->h[ sp->pos ] = _mm512_xor_si512( sp->h[ sp->pos ], in[i] );
+        sp->pos++;
+        if ( sp->pos == sp->blocksize )
+        {
+           transform_4way( sp );
+           sp->pos = 0;
+        }
+    }
+    return 0;
+}
+
+int cube_4way_close( cube_4way_context *sp, void *output )
+{
+    __m512i *hash = (__m512i*)output;
+    int i;
+
+    // pos is zero for 64 byte data, 1 for 80 byte data.
+    sp->h[ sp->pos ] = _mm512_xor_si512( sp->h[ sp->pos ],
+                                 m512_const2_64( 0, 0x0000000000000080 ) );
+    transform_4way( sp );
+
+    sp->h[7] = _mm512_xor_si512( sp->h[7],
+                                 m512_const2_64( 0x0000000100000000, 0 ) );
+
+    for ( i = 0; i < 10; ++i ) 
+       transform_4way( sp );
+
+    memcpy( hash, sp->h, sp->hashlen<<6 );
+    return 0;
+}
+
+int cube_4way_update_close( cube_4way_context *sp, void *output,
+                               const void *data, size_t size )
+{
+    const int len = size >> 4;
+    const __m512i *in = (__m512i*)data;
+    __m512i *hash = (__m512i*)output;
+    int i;
+
+    for ( i = 0; i < len; i++ )
+    {
+        sp->h[ sp->pos ] = _mm512_xor_si512( sp->h[ sp->pos ], in[i] );
+        sp->pos++;
+        if ( sp->pos == sp->blocksize )
+        {
+           transform_4way( sp );
+           sp->pos = 0;
+        }
+    }
+
+    // pos is zero for 64 byte data, 1 for 80 byte data.
+    sp->h[ sp->pos ] = _mm512_xor_si512( sp->h[ sp->pos ],
+                                    m512_const2_64( 0, 0x0000000000000080 ) );
+    transform_4way( sp );
+
+    sp->h[7] = _mm512_xor_si512( sp->h[7],
+                                    m512_const2_64( 0x0000000100000000, 0 ) );
+
+    for ( i = 0; i < 10; ++i )
+       transform_4way( sp );
+
+    memcpy( hash, sp->h, sp->hashlen<<6);
+    return 0;
+}
+
+
+#endif // AVX512
+
+// 2 way 128 
+
 static void transform_2way( cube_2way_context *sp )
 {
    int r;
    const int rounds = sp->rounds;

-    __m256i x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3;
+    __m256i x0, x1, x2, x3, x4, x5, x6, x7, y0, y1;

    x0 = _mm256_load_si256( (__m256i*)sp->h     );
    x1 = _mm256_load_si256( (__m256i*)sp->h + 1 );
@@ -47,50 +229,38 @@ 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 );
-        y0 = x2;
-        y1 = x3;
-        y2 = x0;
-        y3 = x1;
-        x0 = _mm256_xor_si256( _mm256_slli_epi32( y0,  7 ),
-                               _mm256_srli_epi32( y0, 25 ) );
-        x1 = _mm256_xor_si256( _mm256_slli_epi32( y1,  7 ),
-                               _mm256_srli_epi32( y1, 25 ) );
-        x2 = _mm256_xor_si256( _mm256_slli_epi32( y2,  7 ),
-                               _mm256_srli_epi32( y2, 25 ) );
-        x3 = _mm256_xor_si256( _mm256_slli_epi32( y3,  7 ),
-                               _mm256_srli_epi32( y3, 25 ) );
+        y0 = x0;
+        y1 = x1;
+        x0 = mm256_rol_32( x2, 7 );
+        x1 = mm256_rol_32( x3, 7 );
+        x2 = mm256_rol_32( y0, 7 );
+        x3 = mm256_rol_32( y1, 7 );
        x0 = _mm256_xor_si256( x0, x4 );
        x1 = _mm256_xor_si256( x1, x5 );
        x2 = _mm256_xor_si256( x2, x6 );
        x3 = _mm256_xor_si256( x3, x7 );
-        x4 = mm256_swap64_128( x4 );
-        x5 = mm256_swap64_128( x5 );
-        x6 = mm256_swap64_128( x6 );
-        x7 = mm256_swap64_128( x7 );
+        x4 = mm256_swap128_64( x4 );
+        x5 = mm256_swap128_64( x5 );
+        x6 = mm256_swap128_64( x6 );
+        x7 = mm256_swap128_64( x7 );
        x4 = _mm256_add_epi32( x0, x4 );
        x5 = _mm256_add_epi32( x1, x5 );
        x6 = _mm256_add_epi32( x2, x6 );
        x7 = _mm256_add_epi32( x3, x7 );
-        y0 = x1;
-        y1 = x0;
-        y2 = x3;
-        y3 = x2;
-        x0 = _mm256_xor_si256( _mm256_slli_epi32( y0, 11 ),
-                               _mm256_srli_epi32( y0, 21 ) );
-        x1 = _mm256_xor_si256( _mm256_slli_epi32( y1, 11 ),
-                               _mm256_srli_epi32( y1, 21 ) );
-        x2 = _mm256_xor_si256( _mm256_slli_epi32( y2, 11 ),
-                               _mm256_srli_epi32( y2, 21 ) );
-        x3 = _mm256_xor_si256( _mm256_slli_epi32( y3, 11 ),
-                               _mm256_srli_epi32( y3, 21 ) );
+        y0 = x0;
+        y1 = x2;
+        x0 = mm256_rol_32( x1, 11 );
+        x1 = mm256_rol_32( y0, 11 );
+        x2 = mm256_rol_32( x3, 11 );
+        x3 = mm256_rol_32( y1, 11 );
        x0 = _mm256_xor_si256( x0, x4 );
        x1 = _mm256_xor_si256( x1, x5 );
        x2 = _mm256_xor_si256( x2, x6 );
        x3 = _mm256_xor_si256( x3, x7 );
-        x4 = mm256_swap32_64( x4 );
-        x5 = mm256_swap32_64( x5 );
-        x6 = mm256_swap32_64( x6 );
-        x7 = mm256_swap32_64( x7 );
+        x4 = mm256_swap64_32( x4 );
+        x5 = mm256_swap64_32( x5 );
+        x6 = mm256_swap64_32( x6 );
+        x7 = mm256_swap64_32( x7 );
    }

    _mm256_store_si256( (__m256i*)sp->h,     x0 );
@@ -101,29 +271,36 @@ static void transform_2way( cube_2way_context *sp )
    _mm256_store_si256( (__m256i*)sp->h + 5, x5 );
    _mm256_store_si256( (__m256i*)sp->h + 6, x6 );
    _mm256_store_si256( (__m256i*)sp->h + 7, x7 );
-
 }

 int cube_2way_init( cube_2way_context *sp, int hashbitlen, int rounds,
                    int blockbytes )
 {
-    const uint64_t* iv = hashbitlen == 512 ? IV512 : IV256;
+    __m256i *h = (__m256i*)sp->h;
+    __m128i *iv = (__m128i*)( hashbitlen == 512 ? (__m128i*)IV512
+                                                : (__m128i*)IV256 );
    sp->hashlen   = hashbitlen/128;
    sp->blocksize = blockbytes/16;
    sp->rounds    = rounds;
    sp->pos       = 0;

-    __m256i* h = (__m256i*)sp->h;
-
-    h[0] = _mm256_set_epi64x( iv[ 1], iv[ 0], iv[ 1], iv[ 0] );
-    h[1] = _mm256_set_epi64x( iv[ 3], iv[ 2], iv[ 3], iv[ 2] );
-    h[2] = _mm256_set_epi64x( iv[ 5], iv[ 4], iv[ 5], iv[ 4] );
-    h[3] = _mm256_set_epi64x( iv[ 7], iv[ 6], iv[ 7], iv[ 6] );
-    h[4] = _mm256_set_epi64x( iv[ 9], iv[ 8], iv[ 9], iv[ 8] );
-    h[5] = _mm256_set_epi64x( iv[11], iv[10], iv[11], iv[10] );
-    h[6] = _mm256_set_epi64x( iv[13], iv[12], iv[13], iv[12] );
-    h[7] = _mm256_set_epi64x( iv[15], iv[14], iv[15], iv[14] );
-
+    h[ 0] = m256_const1_128( iv[0] );
+    h[ 1] = m256_const1_128( iv[1] );
+    h[ 2] = m256_const1_128( iv[2] );
+    h[ 3] = m256_const1_128( iv[3] );
+    h[ 4] = m256_const1_128( iv[4] );
+    h[ 5] = m256_const1_128( iv[5] );
+    h[ 6] = m256_const1_128( iv[6] );
+    h[ 7] = m256_const1_128( iv[7] );
+    h[ 0] = m256_const1_128( iv[0] );
+    h[ 1] = m256_const1_128( iv[1] );
+    h[ 2] = m256_const1_128( iv[2] );
+    h[ 3] = m256_const1_128( iv[3] );
+    h[ 4] = m256_const1_128( iv[4] );
+    h[ 5] = m256_const1_128( iv[5] );
+    h[ 6] = m256_const1_128( iv[6] );
+    h[ 7] = m256_const1_128( iv[7] );
+    
    return 0;
 }

@@ -134,9 +311,6 @@ int cube_2way_update( cube_2way_context *sp, const void *data, size_t size )
    const __m256i *in = (__m256i*)data;
    int i;

-    // It is assumed data is aligned to 256 bits and is a multiple of 128 bits.
-    // Current usage sata is either 64 or 80 bytes.
-
    for ( i = 0; i < len; i++ )
    {
        sp->h[ sp->pos ] = _mm256_xor_si256( sp->h[ sp->pos ], in[i] );
@@ -157,15 +331,15 @@ int cube_2way_close( cube_2way_context *sp, void *output )

    // pos is zero for 64 byte data, 1 for 80 byte data.
    sp->h[ sp->pos ] = _mm256_xor_si256( sp->h[ sp->pos ],
-                                _mm256_set_epi32( 0,0,0,0x80,  0,0,0,0x80 ) );
+                                   m256_const2_64( 0, 0x0000000000000080 ) );
    transform_2way( sp );

    sp->h[7] = _mm256_xor_si256( sp->h[7],
-		                 _mm256_set_epi32( 1,0,0,0,  1,0,0,0 ) );
+                                   m256_const2_64( 0x0000000100000000, 0 ) );

    for ( i = 0; i < 10; ++i )           transform_2way( sp );

-    for ( i = 0; i < sp->hashlen; i++ )  hash[i] = sp->h[i];
+    memcpy( hash, sp->h, sp->hashlen<<5 );
    return 0;
 }

@@ -190,15 +364,15 @@ int cube_2way_update_close( cube_2way_context *sp, void *output,

    // pos is zero for 64 byte data, 1 for 80 byte data.
    sp->h[ sp->pos ] = _mm256_xor_si256( sp->h[ sp->pos ],
-                    _mm256_set_epi32( 0,0,0,0x80,  0,0,0,0x80 ) );
+                                    m256_const2_64( 0, 0x0000000000000080 ) );
    transform_2way( sp );

-    sp->h[7] = _mm256_xor_si256( sp->h[7], _mm256_set_epi32( 1,0,0,0,
-                                                             1,0,0,0 ) );
+    sp->h[7] = _mm256_xor_si256( sp->h[7],
+                                    m256_const2_64( 0x0000000100000000, 0 ) );

-    for ( i = 0; i < 10; ++i )            transform_2way( sp );
+    for ( i = 0; i < 10; ++i )    transform_2way( sp );

-    for ( i = 0; i < sp->hashlen; i++ )   hash[i] = sp->h[i];
+    memcpy( hash, sp->h, sp->hashlen<<5 );
    return 0;
 }

--- a/algo/cubehash/cube-hash-2way.h
+++ b/algo/cubehash/cube-hash-2way.h
@@ -1,11 +1,38 @@
 #ifndef CUBE_HASH_2WAY_H__
-#define CUBE_HASH_2WAY_H__
-
-#if defined(__AVX2__)
+#define CUBE_HASH_2WAY_H__ 1

 #include <stdint.h>
 #include "simd-utils.h"

+#if defined(__AVX2__)
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+struct _cube_4way_context
+{
+    __m512i h[8];
+    int hashlen;
+    int rounds;
+    int blocksize;
+    int pos; 
+} __attribute__ ((aligned (128)));
+
+typedef struct _cube_4way_context cube_4way_context;
+
+int cube_4way_init( cube_4way_context* sp, int hashbitlen, int rounds,
+                       int blockbytes );
+// reinitialize context with same parameters, much faster.
+int cube_4way_reinit( cube_4way_context *sp );
+
+int cube_4way_update( cube_4way_context *sp, const void *data, size_t size );
+
+int cube_4way_close( cube_4way_context *sp, void *output );
+
+int cube_4way_update_close( cube_4way_context *sp, void *output,
+                            const void *data, size_t size );
+
+#endif
+
 // 2x128, 2 way parallel SSE2

 struct _cube_2way_context
@@ -15,7 +42,7 @@ struct _cube_2way_context
    int rounds;
    int blocksize;         // __m128i
    int pos;               // number of __m128i read into x from current block
-} __attribute__ ((aligned (64)));
+} __attribute__ ((aligned (128)));

 typedef struct _cube_2way_context cube_2way_context;

--- a/algo/cubehash/cubehash_sse2.c
+++ b/algo/cubehash/cubehash_sse2.c
@@ -16,24 +16,6 @@
 #include "simd-utils.h"
 #include <stdio.h>

-// The result of hashing 10 rounds of initial data which is params and 
-// mostly zeros.
-static const uint64_t IV256[] =
-{
-0xCCD6F29FEA2BD4B4, 0x35481EAE63117E71, 0xE5D94E6322512D5B, 0xF4CC12BE7E624131,
-0x42AF2070C2D0B696, 0x3361DA8CD0720C35, 0x8EF8AD8328CCECA4, 0x40E5FBAB4680AC00,
-0x6107FBD5D89041C3, 0xF0B266796C859D41, 0x5FA2560309392549, 0x93CB628565C892FD,
-0x9E4B4E602AF2B5AE, 0x85254725774ABFDD, 0x4AB6AAD615815AEB, 0xD6032C0A9CDAF8AF
-};
-
-static const uint64_t IV512[] =
-{
-0x50F494D42AEA2A61, 0x4167D83E2D538B8B, 0xC701CF8C3FEE2313, 0x50AC5695CC39968E,
-0xA647A8B34D42C787, 0x825B453797CF0BEF, 0xF22090C4EEF864D2, 0xA23911AED0E5CD33,
-0x148FE485FCD398D9, 0xB64445321B017BEF, 0x2FF5781C6A536159, 0x0DBADEA991FA7934,
-0xA5A70E75D65C8A2B, 0xBC796576B1C62456, 0xE7989AF11921C8F7, 0xD43E3B447795D246
-};
-
 static void transform( cubehashParam *sp )
 {
    int r;
@@ -53,26 +35,22 @@ static void transform( cubehashParam *sp )
        x2 = _mm256_add_epi32( x0, x2 );
        x3 = _mm256_add_epi32( x1, x3 );
        y0 = x0;
-        x0 = _mm256_xor_si256( _mm256_slli_epi32( x1, 7 ),
-                               _mm256_srli_epi32( x1, 25 ) );
-        x1 = _mm256_xor_si256( _mm256_slli_epi32( y0, 7 ),
-                               _mm256_srli_epi32( y0, 25 ) );
+        x0 = mm256_rol_32( x1, 7 );
+        x1 = mm256_rol_32( y0, 7 );
        x0 = _mm256_xor_si256( x0, x2 );
        x1 = _mm256_xor_si256( x1, x3 );
-        x2 = _mm256_shuffle_epi32( x2, 0x4e );
-        x3 = _mm256_shuffle_epi32( x3, 0x4e );
+        x2 = mm256_swap128_64( x2 );
+        x3 = mm256_swap128_64( x3 );
        x2 = _mm256_add_epi32( x0, x2 );
        x3 = _mm256_add_epi32( x1, x3 );
-        y0 = _mm256_permute4x64_epi64( x0, 0x4e );
-        y1 = _mm256_permute4x64_epi64( x1, 0x4e );
-        x0 = _mm256_xor_si256( _mm256_slli_epi32( y0, 11 ),
-                               _mm256_srli_epi32( y0, 21 ) );
-        x1 = _mm256_xor_si256( _mm256_slli_epi32( y1, 11 ), 
-                               _mm256_srli_epi32( y1, 21 ) );
+        y0 = mm256_swap_128( x0 );
+        y1 = mm256_swap_128( x1 );
+        x0 = mm256_rol_32( y0, 11 );
+        x1 = mm256_rol_32( y1, 11 );
        x0 = _mm256_xor_si256( x0, x2 );
        x1 = _mm256_xor_si256( x1, x3 );
-        x2 = _mm256_shuffle_epi32( x2, 0xb1 );
-        x3 = _mm256_shuffle_epi32( x3, 0xb1 );
+        x2 = mm256_swap64_32( x2 );
+        x3 = mm256_swap64_32( x3 );
    }

    _mm256_store_si256( (__m256i*)sp->x,     x0 );
@@ -147,37 +125,58 @@ static void transform( cubehashParam *sp )
 #endif
 }  // transform

+/*
+// The result of hashing 10 rounds of initial data which is params and
+// mostly zeros.
+static const uint64_t IV256[] =
+{
+0xCCD6F29FEA2BD4B4, 0x35481EAE63117E71, 0xE5D94E6322512D5B, 0xF4CC12BE7E624131,
+0x42AF2070C2D0B696, 0x3361DA8CD0720C35, 0x8EF8AD8328CCECA4, 0x40E5FBAB4680AC00,
+0x6107FBD5D89041C3, 0xF0B266796C859D41, 0x5FA2560309392549, 0x93CB628565C892FD,
+0x9E4B4E602AF2B5AE, 0x85254725774ABFDD, 0x4AB6AAD615815AEB, 0xD6032C0A9CDAF8AF
+};
+
+static const uint64_t IV512[] =
+{
+0x50F494D42AEA2A61, 0x4167D83E2D538B8B, 0xC701CF8C3FEE2313, 0x50AC5695CC39968E,
+0xA647A8B34D42C787, 0x825B453797CF0BEF, 0xF22090C4EEF864D2, 0xA23911AED0E5CD33,
+0x148FE485FCD398D9, 0xB64445321B017BEF, 0x2FF5781C6A536159, 0x0DBADEA991FA7934,
+0xA5A70E75D65C8A2B, 0xBC796576B1C62456, 0xE7989AF11921C8F7, 0xD43E3B447795D246
+};
+*/
+
 int cubehashInit(cubehashParam *sp, int hashbitlen, int rounds, int blockbytes)
 {
-    const uint64_t* iv = hashbitlen == 512 ? IV512 : IV256;
+    __m128i *x = (__m128i*)sp->x;
    sp->hashlen   = hashbitlen/128;
    sp->blocksize = blockbytes/16;
    sp->rounds    = rounds;
    sp->pos       = 0;
-    
-#if defined(__AVX2__)

-    __m256i* x = (__m256i*)sp->x;
+    if ( hashbitlen == 512 )
+    {

-    x[0] = _mm256_set_epi64x( iv[ 3], iv[ 2], iv[ 1], iv[ 0] );
-    x[1] = _mm256_set_epi64x( iv[ 7], iv[ 6], iv[ 5], iv[ 4] );
-    x[2] = _mm256_set_epi64x( iv[11], iv[10], iv[ 9], iv[ 8] );
-    x[3] = _mm256_set_epi64x( iv[15], iv[14], iv[13], iv[12] );
+       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 );
+    }
+    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 );
+    }   

-#else
-
-    __m128i* x = (__m128i*)sp->x;
-
-     x[0] = _mm_set_epi64x( iv[ 1], iv[ 0] );
-     x[1] = _mm_set_epi64x( iv[ 3], iv[ 2] );
-     x[2] = _mm_set_epi64x( iv[ 5], iv[ 4] );
-     x[3] = _mm_set_epi64x( iv[ 7], iv[ 6] );
-     x[4] = _mm_set_epi64x( iv[ 9], iv[ 8] );
-     x[5] = _mm_set_epi64x( iv[11], iv[10] );
-     x[6] = _mm_set_epi64x( iv[13], iv[12] );
-     x[7] = _mm_set_epi64x( iv[15], iv[14] );
-
-#endif
    return SUCCESS;
 }

--- a/algo/groestl/groestl.c
+++ b/algo/groestl/groestl.c
@@ -94,19 +94,13 @@ int scanhash_groestl( struct work *work, uint32_t max_nonce,
 	return 0;
 }

-void groestl_set_target( struct work* work, double job_diff )
-{
- work_set_target( work, job_diff / (256.0 * opt_diff_factor) );
-}
-
 bool register_dmd_gr_algo( algo_gate_t* gate )
 {
    init_groestl_ctx();
    gate->optimizations   = SSE2_OPT | AES_OPT;
    gate->scanhash        = (void*)&scanhash_groestl;
    gate->hash            = (void*)&groestlhash;
-    gate->set_target      = (void*)&groestl_set_target;
-    gate->get_max64       = (void*)&get_max64_0x3ffff;
+    opt_target_factor = 256.0;
    return true;
 };

--- a/algo/groestl/myr-groestl.c
+++ b/algo/groestl/myr-groestl.c
@@ -10,7 +10,7 @@
 #else
  #include "aes_ni/hash-groestl.h"
 #endif
-#include "algo/sha/sph_sha2.h"
+#include <openssl/sha.h>

 typedef struct {
 #ifdef NO_AES_NI
@@ -18,7 +18,7 @@ typedef struct {
 #else
    hashState_groestl       groestl;
 #endif
-    sph_sha256_context sha;
+    SHA256_CTX              sha;
 } myrgr_ctx_holder;

 myrgr_ctx_holder myrgr_ctx;
@@ -28,15 +28,15 @@ void init_myrgr_ctx()
 #ifdef NO_AES_NI
     sph_groestl512_init( &myrgr_ctx.groestl );
 #else
-     init_groestl (&myrgr_ctx.groestl, 64 );
+     init_groestl ( &myrgr_ctx.groestl, 64 );
 #endif
-     sph_sha256_init(&myrgr_ctx.sha);
+     SHA256_Init( &myrgr_ctx.sha );
 }

 void myriad_hash(void *output, const void *input)
 {
-        myrgr_ctx_holder ctx;
-        memcpy( &ctx, &myrgr_ctx, sizeof(myrgr_ctx) );
+   myrgr_ctx_holder ctx;
+   memcpy( &ctx, &myrgr_ctx, sizeof(myrgr_ctx) );

 	uint32_t _ALIGN(32) hash[16];

@@ -44,23 +44,22 @@ void myriad_hash(void *output, const void *input)
 	sph_groestl512(&ctx.groestl, input, 80);
 	sph_groestl512_close(&ctx.groestl, hash);
 #else
-        update_groestl( &ctx.groestl, (char*)input, 640 );
-        final_groestl( &ctx.groestl, (char*)hash);
+   update_groestl( &ctx.groestl, (char*)input, 640 );
+   final_groestl( &ctx.groestl, (char*)hash);
 #endif

-	sph_sha256(&ctx.sha, hash, 64);
-	sph_sha256_close(&ctx.sha, hash);
+   SHA256_Update( &ctx.sha, (unsigned char*)hash, 64 );
+   SHA256_Final( (unsigned char*)hash, &ctx.sha );

 	memcpy(output, hash, 32);
 }

-int scanhash_myriad( struct work *work,
-	uint32_t max_nonce, uint64_t *hashes_done, struct thr_info *mythr)
+int scanhash_myriad( 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 _ALIGN(64) endiandata[20];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
 	const uint32_t first_nonce = pdata[19];
 	uint32_t nonce = first_nonce;
   int thr_id = mythr->id;  // thr_id arg is deprecated
@@ -89,15 +88,3 @@ int scanhash_myriad( struct work *work,
 	*hashes_done = pdata[19] - first_nonce + 1;
 	return 0;
 }
-/*
-bool register_myriad_algo( algo_gate_t* gate )
-{
-    gate->optimizations = SSE2_OPT | AES_OPT;
-    init_myrgr_ctx();
-    gate->scanhash = (void*)&scanhash_myriad;
-    gate->hash     = (void*)&myriadhash;
-//    gate->hash_alt = (void*)&myriadhash;
-    gate->get_max64 = (void*)&get_max64_0x3ffff;
-    return true;
-};
-*/
--- a/algo/groestl/myrgr-4way.c
+++ b/algo/groestl/myrgr-4way.c
@@ -8,7 +8,7 @@
 #include <string.h>

 #include "aes_ni/hash-groestl.h"
-#include "algo/sha/sha2-hash-4way.h"
+#include "algo/sha/sha-hash-4way.h"

 typedef struct {
    hashState_groestl       groestl;
@@ -47,10 +47,6 @@ void myriad_4way_hash( void *output, const void *input )

     sha256_4way( &ctx.sha, vhash, 64 );
     sha256_4way_close( &ctx.sha, output );
-
-//     sha256_4way_close( &ctx.sha, vhash );
-//     mm128_dintrlv_4x32( output, output+32, output+64, output+96,
-//                           vhash, 256 );
 }

 int scanhash_myriad_4way( struct work *work, uint32_t max_nonce,
@@ -68,18 +64,10 @@ int scanhash_myriad_4way( struct work *work, uint32_t max_nonce,
   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
   int thr_id = mythr->id;  // thr_id arg is deprecated

-/*
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
-
-	uint32_t _ALIGN(64) endiandata[20];
-	const uint32_t first_nonce = pdata[19];
-	uint32_t nonce = first_nonce;
-*/
   if ( opt_benchmark )
      ( (uint32_t*)ptarget )[7] = 0x0000ff;

-   mm128_bswap_intrlv80_4x32( vdata, pdata );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
   do {
      *noncev = mm128_bswap_32( _mm_set_epi32( n+3,n+2,n+1,n ) );

--- a/algo/groestl/myrgr-gate.c
+++ b/algo/groestl/myrgr-gate.c
@@ -12,7 +12,6 @@ bool register_myriad_algo( algo_gate_t* gate )
  gate->hash      = (void*)&myriad_hash;
 #endif
  gate->optimizations = AES_OPT | AVX2_OPT;
-  gate->get_max64 = (void*)&get_max64_0x3ffff;
  return true;
 };

--- a/algo/groestl/myrgr-gate.h
+++ b/algo/groestl/myrgr-gate.h
@@ -4,7 +4,7 @@
 #include "algo-gate-api.h"
 #include <stdint.h>

-#if defined(__AVX2__) && defined(__AES__)
+#if defined(__AVX2__) && defined(__AES__) && !defined(__SHA__)
  #define MYRGR_4WAY
 #endif

--- a/algo/hamsi/hamsi-hash-4way.c
+++ b/algo/hamsi/hamsi-hash-4way.c
@@ -32,8 +32,6 @@

 #include <stddef.h>
 #include <string.h>
-
-//#include "miner.h"
 #include "hamsi-hash-4way.h"

 #if defined(__AVX2__)
@@ -100,7 +98,7 @@ extern "C"{
 #endif

 //#include "hamsi-helper-4way.c"
-
+/*
 static const sph_u32 IV512[] = {
 	SPH_C32(0x73746565), SPH_C32(0x6c706172), SPH_C32(0x6b204172),
 	SPH_C32(0x656e6265), SPH_C32(0x72672031), SPH_C32(0x302c2062),
@@ -109,7 +107,7 @@ static const sph_u32 IV512[] = {
 	SPH_C32(0x65766572), SPH_C32(0x6c65652c), SPH_C32(0x2042656c),
 	SPH_C32(0x6769756d)
 };
-
+*/
 static const sph_u32 alpha_n[] = {
 	SPH_C32(0xff00f0f0), SPH_C32(0xccccaaaa), SPH_C32(0xf0f0cccc),
 	SPH_C32(0xff00aaaa), SPH_C32(0xccccaaaa), SPH_C32(0xf0f0ff00),
@@ -138,6 +136,7 @@ static const sph_u32 alpha_f[] = {
 	SPH_C32(0xcaf9f9c0), SPH_C32(0x0ff0639c)
 };

+
 // imported from hamsi helper

 /* Note: this table lists bits within each byte from least
@@ -529,48 +528,374 @@ static const sph_u32 T512[64][16] = {
 	  SPH_C32(0xe7e00a94) }
 };

+#define s0   m0
+#define s1   c0
+#define s2   m1
+#define s3   c1
+#define s4   c2
+#define s5   m2
+#define s6   c3
+#define s7   m3
+#define s8   m4
+#define s9   c4
+#define sA   m5
+#define sB   c5
+#define sC   c6
+#define sD   m6
+#define sE   c7
+#define sF   m7
+
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// Hamsi 8 way 
+
+#define INPUT_BIG8 \
+do { \
+  __m512i db = *buf; \
+  const uint64_t *tp = (uint64_t*)&T512[0][0];  \
+  m0 = m1 = m2 = m3 = m4 = m5 = m6 = m7 = m512_zero; \
+  for ( int u = 0; u < 64; u++ ) \
+  { \
+     __m512i dm = _mm512_and_si512( db, m512_one_64 ) ; \
+     dm = mm512_negate_32( _mm512_or_si512( dm, \
+                                          _mm512_slli_epi64( dm, 32 ) ) ); \
+     m0 = _mm512_xor_si512( m0, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[0] ) ) ); \
+     m1 = _mm512_xor_si512( m1, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[1] ) ) ); \
+     m2 = _mm512_xor_si512( m2, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[2] ) ) ); \
+     m3 = _mm512_xor_si512( m3, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[3] ) ) ); \
+     m4 = _mm512_xor_si512( m4, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[4] ) ) ); \
+     m5 = _mm512_xor_si512( m5, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[5] ) ) ); \
+     m6 = _mm512_xor_si512( m6, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[6] ) ) ); \
+     m7 = _mm512_xor_si512( m7, _mm512_and_si512( dm, \
+                                          m512_const1_64( tp[7] ) ) ); \
+     tp += 8; \
+     db = _mm512_srli_epi64( db, 1 ); \
+  } \
+} while (0)
+
+#define SBOX8( a, b, c, d ) \
+do { \
+  __m512i t; \
+  t = a; \
+  a = _mm512_and_si512( a, c ); \
+  a = _mm512_xor_si512( a, d ); \
+  c = _mm512_xor_si512( c, b ); \
+  c = _mm512_xor_si512( c, a ); \
+  d = _mm512_or_si512( d, t ); \
+  d = _mm512_xor_si512( d, b ); \
+  t = _mm512_xor_si512( t, c ); \
+  b = d; \
+  d = _mm512_or_si512( d, t ); \
+  d = _mm512_xor_si512( d, a ); \
+  a = _mm512_and_si512( a, b ); \
+  t = _mm512_xor_si512( t, a ); \
+  b = _mm512_xor_si512( b, d ); \
+  b = _mm512_xor_si512( b, t ); \
+  a = c; \
+  c = b; \
+  b = d; \
+  d = mm512_not( t ); \
+} while (0)
+
+#define L8( a, b, c, d ) \
+do { \
+   a = mm512_rol_32( a, 13 ); \
+   c = mm512_rol_32( c,  3 ); \
+   b = _mm512_xor_si512( b, _mm512_xor_si512( a, c ) ); \
+   d = _mm512_xor_si512( d, _mm512_xor_si512( c, \
+                                              _mm512_slli_epi32( a, 3 ) ) ); \
+   b = mm512_rol_32( b, 1 ); \
+   d = mm512_rol_32( d, 7 ); \
+   a = _mm512_xor_si512( a, _mm512_xor_si512( b, d ) ); \
+   c = _mm512_xor_si512( c, _mm512_xor_si512( d, \
+                                              _mm512_slli_epi32( b, 7 ) ) ); \
+   a = mm512_rol_32( a,  5 ); \
+   c = mm512_rol_32( c, 22 ); \
+} while (0)
+
+#define DECL_STATE_BIG8 \
+   __m512i c0, c1, c2, c3, c4, c5, c6, c7; \
+
+#define READ_STATE_BIG8(sc) \
+do { \
+   c0 = sc->h[0x0]; \
+   c1 = sc->h[0x1]; \
+   c2 = sc->h[0x2]; \
+   c3 = sc->h[0x3]; \
+   c4 = sc->h[0x4]; \
+   c5 = sc->h[0x5]; \
+   c6 = sc->h[0x6]; \
+   c7 = sc->h[0x7]; \
+} while (0)
+
+#define WRITE_STATE_BIG8(sc) \
+do { \
+   sc->h[0x0] = c0; \
+   sc->h[0x1] = c1; \
+   sc->h[0x2] = c2; \
+   sc->h[0x3] = c3; \
+   sc->h[0x4] = c4; \
+   sc->h[0x5] = c5; \
+   sc->h[0x6] = c6; \
+   sc->h[0x7] = c7; \
+} while (0)
+
+
+#define ROUND_BIG8(rc, alpha) \
+do { \
+   __m512i t0, t1, t2, t3; \
+   s0 = _mm512_xor_si512( s0, m512_const1_64( \
+                   ( (uint64_t)(rc) << 32 ) ^ ( (uint64_t*)(alpha) )[ 0] ) ); \
+   s1 = _mm512_xor_si512( s1, m512_const1_64( ( (uint64_t*)(alpha) )[ 1] ) ); \
+   s2 = _mm512_xor_si512( s2, m512_const1_64( ( (uint64_t*)(alpha) )[ 2] ) ); \
+   s3 = _mm512_xor_si512( s3, m512_const1_64( ( (uint64_t*)(alpha) )[ 3] ) ); \
+   s4 = _mm512_xor_si512( s4, m512_const1_64( ( (uint64_t*)(alpha) )[ 4] ) ); \
+   s5 = _mm512_xor_si512( s5, m512_const1_64( ( (uint64_t*)(alpha) )[ 5] ) ); \
+   s6 = _mm512_xor_si512( s6, m512_const1_64( ( (uint64_t*)(alpha) )[ 6] ) ); \
+   s7 = _mm512_xor_si512( s7, m512_const1_64( ( (uint64_t*)(alpha) )[ 7] ) ); \
+   s8 = _mm512_xor_si512( s8, m512_const1_64( ( (uint64_t*)(alpha) )[ 8] ) ); \
+   s9 = _mm512_xor_si512( s9, m512_const1_64( ( (uint64_t*)(alpha) )[ 9] ) ); \
+   sA = _mm512_xor_si512( sA, m512_const1_64( ( (uint64_t*)(alpha) )[10] ) ); \
+   sB = _mm512_xor_si512( sB, m512_const1_64( ( (uint64_t*)(alpha) )[11] ) ); \
+   sC = _mm512_xor_si512( sC, m512_const1_64( ( (uint64_t*)(alpha) )[12] ) ); \
+   sD = _mm512_xor_si512( sD, m512_const1_64( ( (uint64_t*)(alpha) )[13] ) ); \
+   sE = _mm512_xor_si512( sE, m512_const1_64( ( (uint64_t*)(alpha) )[14] ) ); \
+   sF = _mm512_xor_si512( sF, m512_const1_64( ( (uint64_t*)(alpha) )[15] ) ); \
+\
+  SBOX8( s0, s4, s8, sC ); \
+  SBOX8( s1, s5, s9, sD ); \
+  SBOX8( s2, s6, sA, sE ); \
+  SBOX8( s3, s7, sB, sF ); \
+\
+  t1 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s4, 4 ), \
+                                        _mm512_bslli_epi128( s5, 4 ) ); \
+  t3 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( sD, 4 ), \
+                                        _mm512_bslli_epi128( sE, 4 ) ); \
+  L8( s0, t1, s9, t3 ); \
+  s4 = _mm512_mask_blend_epi32( 0xaaaa, s4, _mm512_bslli_epi128( t1, 4 ) ); \
+  s5 = _mm512_mask_blend_epi32( 0x5555, s5, _mm512_bsrli_epi128( t1, 4 ) ); \
+  sD = _mm512_mask_blend_epi32( 0xaaaa, sD, _mm512_bslli_epi128( t3, 4 ) ); \
+  sE = _mm512_mask_blend_epi32( 0x5555, sE, _mm512_bsrli_epi128( t3, 4 ) ); \
+\
+  t1 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s5, 4 ), \
+                                        _mm512_bslli_epi128( s6, 4 ) ); \
+  t3 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( sE, 4 ), \
+                                        _mm512_bslli_epi128( sF, 4 ) ); \
+  L8( s1, t1, sA, t3 ); \
+  s5 = _mm512_mask_blend_epi32( 0xaaaa, s5, _mm512_bslli_epi128( t1, 4 ) ); \
+  s6 = _mm512_mask_blend_epi32( 0x5555, s6, _mm512_bsrli_epi128( t1, 4 ) ); \
+  sE = _mm512_mask_blend_epi32( 0xaaaa, sE, _mm512_bslli_epi128( t3, 4 ) ); \
+  sF = _mm512_mask_blend_epi32( 0x5555, sF, _mm512_bsrli_epi128( t3, 4 ) ); \
+\
+  t1 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s6, 4 ), \
+                                        _mm512_bslli_epi128( s7, 4 ) ); \
+  t3 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( sF, 4 ), \
+                                        _mm512_bslli_epi128( sC, 4 ) ); \
+  L8( s2, t1, sB, t3 ); \
+  s6 = _mm512_mask_blend_epi32( 0xaaaa, s6, _mm512_bslli_epi128( t1, 4 ) ); \
+  s7 = _mm512_mask_blend_epi32( 0x5555, s7, _mm512_bsrli_epi128( t1, 4 ) ); \
+  sF = _mm512_mask_blend_epi32( 0xaaaa, sF, _mm512_bslli_epi128( t3, 4 ) ); \
+  sC = _mm512_mask_blend_epi32( 0x5555, sC, _mm512_bsrli_epi128( t3, 4 ) ); \
+\
+  t1 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s7, 4 ), \
+                                        _mm512_bslli_epi128( s4, 4 ) ); \
+  t3 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( sC, 4 ), \
+                                        _mm512_bslli_epi128( sD, 4 ) ); \
+  L8( s3, t1, s8, t3 ); \
+  s7 = _mm512_mask_blend_epi32( 0xaaaa, s7, _mm512_bslli_epi128( t1, 4 ) ); \
+  s4 = _mm512_mask_blend_epi32( 0x5555, s4, _mm512_bsrli_epi128( t1, 4 ) ); \
+  sC = _mm512_mask_blend_epi32( 0xaaaa, sC, _mm512_bslli_epi128( t3, 4 ) ); \
+  sD = _mm512_mask_blend_epi32( 0x5555, sD, _mm512_bsrli_epi128( t3, 4 ) ); \
+\
+  t0 = _mm512_mask_blend_epi32( 0xaaaa, s0, _mm512_bslli_epi128( s8, 4 ) ); \
+  t1 = _mm512_mask_blend_epi32( 0xaaaa, s1, s9 ); \
+  t2 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s2, 4 ), sA ); \
+  t3 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s3, 4 ), \
+                                        _mm512_bslli_epi128( sB, 4 ) ); \
+  L8( t0, t1, t2, t3 ); \
+  s0 = _mm512_mask_blend_epi32( 0x5555, s0, t0 ); \
+  s8 = _mm512_mask_blend_epi32( 0x5555, s8, _mm512_bsrli_epi128( t0, 4 ) ); \
+  s1 = _mm512_mask_blend_epi32( 0x5555, s1, t1 ); \
+  s9 = _mm512_mask_blend_epi32( 0xaaaa, s9, t1 ); \
+  s2 = _mm512_mask_blend_epi32( 0xaaaa, s2, _mm512_bslli_epi128( t2, 4 ) ); \
+  sA = _mm512_mask_blend_epi32( 0xaaaa, sA, t2 ); \
+  s3 = _mm512_mask_blend_epi32( 0xaaaa, s3, _mm512_bslli_epi128( t3, 4 ) ); \
+  sB = _mm512_mask_blend_epi32( 0x5555, sB, _mm512_bsrli_epi128( t3, 4 ) ); \
+\
+  t0 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s4, 4 ), sC ); \
+  t1 = _mm512_mask_blend_epi32( 0xaaaa, _mm512_bsrli_epi128( s5, 4 ), \
+                                        _mm512_bslli_epi128( sD, 4 ) ); \
+  t2 = _mm512_mask_blend_epi32( 0xaaaa, s6, _mm512_bslli_epi128( sE, 4 ) ); \
+  t3 = _mm512_mask_blend_epi32( 0xaaaa, s7, sF ); \
+  L8( t0, t1, t2, t3 ); \
+  s4 = _mm512_mask_blend_epi32( 0xaaaa, s4, _mm512_bslli_epi128( t0, 4 ) ); \
+  sC = _mm512_mask_blend_epi32( 0xaaaa, sC, t0 ); \
+  s5 = _mm512_mask_blend_epi32( 0xaaaa, s5, _mm512_bslli_epi128( t1, 4 ) ); \
+  sD = _mm512_mask_blend_epi32( 0x5555, sD, _mm512_bsrli_epi128( t1, 4 ) ); \
+  s6 = _mm512_mask_blend_epi32( 0x5555, s6, t2 ); \
+  sE = _mm512_mask_blend_epi32( 0x5555, sE, _mm512_bsrli_epi128( t2, 4 ) ); \
+  s7 = _mm512_mask_blend_epi32( 0x5555, s7, t3 ); \
+  sF = _mm512_mask_blend_epi32( 0xaaaa, sF, t3 ); \
+} while (0)
+
+#define P_BIG8 \
+do { \
+   ROUND_BIG8(0, alpha_n); \
+   ROUND_BIG8(1, alpha_n); \
+   ROUND_BIG8(2, alpha_n); \
+   ROUND_BIG8(3, alpha_n); \
+   ROUND_BIG8(4, alpha_n); \
+   ROUND_BIG8(5, alpha_n); \
+} while (0)
+
+#define PF_BIG8 \
+do { \
+   ROUND_BIG8( 0, alpha_f); \
+   ROUND_BIG8( 1, alpha_f); \
+   ROUND_BIG8( 2, alpha_f); \
+   ROUND_BIG8( 3, alpha_f); \
+   ROUND_BIG8( 4, alpha_f); \
+   ROUND_BIG8( 5, alpha_f); \
+   ROUND_BIG8( 6, alpha_f); \
+   ROUND_BIG8( 7, alpha_f); \
+   ROUND_BIG8( 8, alpha_f); \
+   ROUND_BIG8( 9, alpha_f); \
+   ROUND_BIG8(10, alpha_f); \
+   ROUND_BIG8(11, alpha_f); \
+} while (0)
+
+#define T_BIG8 \
+do { /* order is important */ \
+   c7 = sc->h[ 0x7 ] = _mm512_xor_si512( sc->h[ 0x7 ], sB ); \
+   c6 = sc->h[ 0x6 ] = _mm512_xor_si512( sc->h[ 0x6 ], sA ); \
+   c5 = sc->h[ 0x5 ] = _mm512_xor_si512( sc->h[ 0x5 ], s9 ); \
+   c4 = sc->h[ 0x4 ] = _mm512_xor_si512( sc->h[ 0x4 ], s8 ); \
+   c3 = sc->h[ 0x3 ] = _mm512_xor_si512( sc->h[ 0x3 ], s3 ); \
+   c2 = sc->h[ 0x2 ] = _mm512_xor_si512( sc->h[ 0x2 ], s2 ); \
+   c1 = sc->h[ 0x1 ] = _mm512_xor_si512( sc->h[ 0x1 ], s1 ); \
+   c0 = sc->h[ 0x0 ] = _mm512_xor_si512( sc->h[ 0x0 ], s0 ); \
+} while (0)
+
+void hamsi_8way_big( hamsi_8way_big_context *sc, __m512i *buf, size_t num )
+{
+   DECL_STATE_BIG8
+   uint32_t tmp = num << 6;
+
+   sc->count_low = SPH_T32( sc->count_low + tmp );
+   sc->count_high += (sph_u32)( (num >> 13) >> 13 );
+   if ( sc->count_low < tmp )
+      sc->count_high++;
+
+   READ_STATE_BIG8( sc );
+   while ( num-- > 0 )
+   {
+      __m512i m0, m1, m2, m3, m4, m5, m6, m7;
+
+      INPUT_BIG8;
+      P_BIG8;
+      T_BIG8;
+      buf++;
+   }
+   WRITE_STATE_BIG8( sc );
+}
+
+void hamsi_8way_big_final( hamsi_8way_big_context *sc, __m512i *buf )
+{
+   __m512i m0, m1, m2, m3, m4, m5, m6, m7;
+   DECL_STATE_BIG8
+   READ_STATE_BIG8( sc );
+   INPUT_BIG8;
+   PF_BIG8;
+   T_BIG8;
+   WRITE_STATE_BIG8( sc );
+}
+
+
+void hamsi512_8way_init( hamsi_8way_big_context *sc )
+{
+   sc->partial_len = 0;
+   sc->count_high = sc->count_low = 0;
+
+   sc->h[0] = m512_const1_64( 0x6c70617273746565 );
+   sc->h[1] = m512_const1_64( 0x656e62656b204172 );
+   sc->h[2] = m512_const1_64( 0x302c206272672031 );
+   sc->h[3] = m512_const1_64( 0x3434362c75732032 );
+   sc->h[4] = m512_const1_64( 0x3030312020422d33 );
+   sc->h[5] = m512_const1_64( 0x656e2d484c657576 );
+   sc->h[6] = m512_const1_64( 0x6c65652c65766572 );
+   sc->h[7] = m512_const1_64( 0x6769756d2042656c );
+}
+
+void hamsi512_8way_update( hamsi_8way_big_context *sc, const void *data,
+                           size_t len )
+{
+   __m512i *vdata = (__m512i*)data;
+
+   hamsi_8way_big( sc, vdata, len>>3 );
+   vdata += ( (len& ~(size_t)7) >> 3 );
+   len &= (size_t)7;
+   memcpy_512( sc->buf, vdata, len>>3 );
+   sc->partial_len = len;
+}
+
+void hamsi512_8way_close( hamsi_8way_big_context *sc, void *dst )
+{
+   __m512i pad[1];
+   int ch, cl;
+
+   sph_enc32be( &ch, sc->count_high );
+   sph_enc32be( &cl, sc->count_low + ( sc->partial_len << 3 ) );
+   pad[0] =  _mm512_set_epi32( cl, ch, cl, ch, cl, ch, cl, ch,
+                               cl, ch, cl, ch, cl, ch, cl, ch );
+//   pad[0] =  m512_const2_32( cl, ch );
+   sc->buf[0] = m512_const1_64( 0x80 );
+   hamsi_8way_big( sc, sc->buf, 1 );
+   hamsi_8way_big_final( sc, pad );
+
+   mm512_block_bswap_32( (__m512i*)dst, sc->h );
+}
+
+
+#endif // AVX512
+
+
+// Hamsi 4 way
+
 #define INPUT_BIG \
 do { \
  __m256i db = *buf; \
-  const sph_u32 *tp = &T512[0][0]; \
-  m0 = m256_zero; \
-  m1 = m256_zero; \
-  m2 = m256_zero; \
-  m3 = m256_zero; \
-  m4 = m256_zero; \
-  m5 = m256_zero; \
-  m6 = m256_zero; \
-  m7 = m256_zero; \
+  const uint64_t *tp = (uint64_t*)&T512[0][0];  \
+  m0 = m1 = m2 = m3 = m4 = m5 = m6 = m7 = m256_zero; \
  for ( int u = 0; u < 64; u++ ) \
  { \
     __m256i dm = _mm256_and_si256( db, m256_one_64 ) ; \
     dm = mm256_negate_32( _mm256_or_si256( dm, \
                         _mm256_slli_epi64( dm, 32 ) ) ); \
     m0 = _mm256_xor_si256( m0, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0x1], tp[0x0], tp[0x1], tp[0x0], \
-                                    tp[0x1], tp[0x0], tp[0x1], tp[0x0] ) ) ); \
+                                          m256_const1_64( tp[0] ) ) ); \
     m1 = _mm256_xor_si256( m1, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0x3], tp[0x2], tp[0x3], tp[0x2], \
-                                    tp[0x3], tp[0x2], tp[0x3], tp[0x2] ) ) ); \
+                                          m256_const1_64( tp[1] ) ) ); \
     m2 = _mm256_xor_si256( m2, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0x5], tp[0x4], tp[0x5], tp[0x4], \
-                                    tp[0x5], tp[0x4], tp[0x5], tp[0x4] ) ) ); \
+                                          m256_const1_64( tp[2] ) ) ); \
     m3 = _mm256_xor_si256( m3, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0x7], tp[0x6], tp[0x7], tp[0x6], \
-                                    tp[0x7], tp[0x6], tp[0x7], tp[0x6] ) ) ); \
+                                          m256_const1_64( tp[3] ) ) ); \
     m4 = _mm256_xor_si256( m4, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0x9], tp[0x8], tp[0x9], tp[0x8], \
-                                    tp[0x9], tp[0x8], tp[0x9], tp[0x8] ) ) ); \
+                                          m256_const1_64( tp[4] ) ) ); \
     m5 = _mm256_xor_si256( m5, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0xB], tp[0xA], tp[0xB], tp[0xA], \
-                                    tp[0xB], tp[0xA], tp[0xB], tp[0xA] ) ) ); \
+                                          m256_const1_64( tp[5] ) ) ); \
     m6 = _mm256_xor_si256( m6, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0xD], tp[0xC], tp[0xD], tp[0xC], \
-                                    tp[0xD], tp[0xC], tp[0xD], tp[0xC] ) ) ); \
+                                          m256_const1_64( tp[6] ) ) ); \
     m7 = _mm256_xor_si256( m7, _mm256_and_si256( dm, \
-                  _mm256_set_epi32( tp[0xF], tp[0xE], tp[0xF], tp[0xE], \
-                                    tp[0xF], tp[0xE], tp[0xF], tp[0xE] ) ) ); \
-     tp += 0x10; \
+                                          m256_const1_64( tp[7] ) ) ); \
+     tp += 8; \
     db = _mm256_srli_epi64( db, 1 ); \
  } \
 } while (0)
@@ -642,6 +967,7 @@ do { \
   sc->h[0x7] = c7; \
 } while (0)

+/*
 #define s0   m0
 #define s1   c0
 #define s2   m1
@@ -658,58 +984,28 @@ do { \
 #define sD   m6
 #define sE   c7
 #define sF   m7
+*/

 #define ROUND_BIG(rc, alpha) \
 do { \
-  __m256i t0, t1, t2, t3; \
-  s0 = _mm256_xor_si256( s0, _mm256_set_epi32( \
-        alpha[0x01] ^ (rc), alpha[0x00], alpha[0x01] ^ (rc), alpha[0x00], \
-        alpha[0x01] ^ (rc), alpha[0x00], alpha[0x01] ^ (rc), alpha[0x00] ) ); \
-  s1 = _mm256_xor_si256( s1, _mm256_set_epi32( \
-                     alpha[0x03], alpha[0x02], alpha[0x03], alpha[0x02], \
-                     alpha[0x03], alpha[0x02], alpha[0x03], alpha[0x02] ) ); \
-  s2 = _mm256_xor_si256( s2, _mm256_set_epi32( \
-                     alpha[0x05], alpha[0x04], alpha[0x05], alpha[0x04], \
-                     alpha[0x05], alpha[0x04], alpha[0x05], alpha[0x04] ) ); \
-  s3 = _mm256_xor_si256( s3, _mm256_set_epi32( \
-                     alpha[0x07], alpha[0x06], alpha[0x07], alpha[0x06], \
-                     alpha[0x07], alpha[0x06], alpha[0x07], alpha[0x06] ) ); \
-  s4 = _mm256_xor_si256( s4, _mm256_set_epi32( \
-                     alpha[0x09], alpha[0x08], alpha[0x09], alpha[0x08], \
-                     alpha[0x09], alpha[0x08], alpha[0x09], alpha[0x08] ) ); \
-  s5 = _mm256_xor_si256( s5, _mm256_set_epi32( \
-                     alpha[0x0B], alpha[0x0A], alpha[0x0B], alpha[0x0A], \
-                     alpha[0x0B], alpha[0x0A], alpha[0x0B], alpha[0x0A] ) ); \
-  s6 = _mm256_xor_si256( s6, _mm256_set_epi32( \
-                     alpha[0x0D], alpha[0x0C], alpha[0x0D], alpha[0x0C], \
-                     alpha[0x0D], alpha[0x0C], alpha[0x0D], alpha[0x0C] ) ); \
-  s7 = _mm256_xor_si256( s7, _mm256_set_epi32( \
-                     alpha[0x0F], alpha[0x0E], alpha[0x0F], alpha[0x0E], \
-                     alpha[0x0F], alpha[0x0E], alpha[0x0F], alpha[0x0E] ) ); \
-  s8 = _mm256_xor_si256( s8, _mm256_set_epi32( \
-                     alpha[0x11], alpha[0x10], alpha[0x11], alpha[0x10], \
-                     alpha[0x11], alpha[0x10], alpha[0x11], alpha[0x10] ) ); \
-  s9 = _mm256_xor_si256( s9, _mm256_set_epi32( \
-                     alpha[0x13], alpha[0x12], alpha[0x13], alpha[0x12], \
-                     alpha[0x13], alpha[0x12], alpha[0x13], alpha[0x12] ) ); \
-  sA = _mm256_xor_si256( sA, _mm256_set_epi32( \
-                     alpha[0x15], alpha[0x14], alpha[0x15], alpha[0x14], \
-                     alpha[0x15], alpha[0x14], alpha[0x15], alpha[0x14] ) ); \
-  sB = _mm256_xor_si256( sB, _mm256_set_epi32( \
-                     alpha[0x17], alpha[0x16], alpha[0x17], alpha[0x16], \
-                     alpha[0x17], alpha[0x16], alpha[0x17], alpha[0x16] ) ); \
-  sC = _mm256_xor_si256( sC, _mm256_set_epi32( \
-                     alpha[0x19], alpha[0x18], alpha[0x19], alpha[0x18], \
-                     alpha[0x19], alpha[0x18], alpha[0x19], alpha[0x18] ) ); \
-  sD = _mm256_xor_si256( sD, _mm256_set_epi32( \
-                     alpha[0x1B], alpha[0x1A], alpha[0x1B], alpha[0x1A], \
-                     alpha[0x1B], alpha[0x1A], alpha[0x1B], alpha[0x1A] ) ); \
-  sE = _mm256_xor_si256( sE, _mm256_set_epi32( \
-                     alpha[0x1D], alpha[0x1C], alpha[0x1D], alpha[0x1C], \
-                     alpha[0x1D], alpha[0x1C], alpha[0x1D], alpha[0x1C] ) ); \
-  sF = _mm256_xor_si256( sF, _mm256_set_epi32( \
-                     alpha[0x1F], alpha[0x1E], alpha[0x1F], alpha[0x1E], \
-                     alpha[0x1F], alpha[0x1E], alpha[0x1F], alpha[0x1E] ) ); \
+   __m256i t0, t1, t2, t3; \
+   s0 = _mm256_xor_si256( s0, m256_const1_64( \
+                   ( (uint64_t)(rc) << 32 ) ^ ( (uint64_t*)(alpha) )[ 0] ) ); \
+   s1 = _mm256_xor_si256( s1, m256_const1_64( ( (uint64_t*)(alpha) )[ 1] ) ); \
+   s2 = _mm256_xor_si256( s2, m256_const1_64( ( (uint64_t*)(alpha) )[ 2] ) ); \
+   s3 = _mm256_xor_si256( s3, m256_const1_64( ( (uint64_t*)(alpha) )[ 3] ) ); \
+   s4 = _mm256_xor_si256( s4, m256_const1_64( ( (uint64_t*)(alpha) )[ 4] ) ); \
+   s5 = _mm256_xor_si256( s5, m256_const1_64( ( (uint64_t*)(alpha) )[ 5] ) ); \
+   s6 = _mm256_xor_si256( s6, m256_const1_64( ( (uint64_t*)(alpha) )[ 6] ) ); \
+   s7 = _mm256_xor_si256( s7, m256_const1_64( ( (uint64_t*)(alpha) )[ 7] ) ); \
+   s8 = _mm256_xor_si256( s8, m256_const1_64( ( (uint64_t*)(alpha) )[ 8] ) ); \
+   s9 = _mm256_xor_si256( s9, m256_const1_64( ( (uint64_t*)(alpha) )[ 9] ) ); \
+   sA = _mm256_xor_si256( sA, m256_const1_64( ( (uint64_t*)(alpha) )[10] ) ); \
+   sB = _mm256_xor_si256( sB, m256_const1_64( ( (uint64_t*)(alpha) )[11] ) ); \
+   sC = _mm256_xor_si256( sC, m256_const1_64( ( (uint64_t*)(alpha) )[12] ) ); \
+   sD = _mm256_xor_si256( sD, m256_const1_64( ( (uint64_t*)(alpha) )[13] ) ); \
+   sE = _mm256_xor_si256( sE, m256_const1_64( ( (uint64_t*)(alpha) )[14] ) ); \
+   sF = _mm256_xor_si256( sF, m256_const1_64( ( (uint64_t*)(alpha) )[15] ) ); \
 \
  SBOX( s0, s4, s8, sC ); \
  SBOX( s1, s5, s9, sD ); \
@@ -863,47 +1159,22 @@ void hamsi_big_final( hamsi_4way_big_context *sc, __m256i *buf )
 void hamsi512_4way_init( hamsi_4way_big_context *sc )
 {
   sc->partial_len = 0;
-   sph_u32 lo, hi;
   sc->count_high = sc->count_low = 0;
-   for ( int i = 0; i < 8; i++ )
-   {
-      lo = 2*i;
-      hi = 2*i + 1;
-      sc->h[i] = _mm256_set_epi32( IV512[hi], IV512[lo], IV512[hi], IV512[lo],
-                                   IV512[hi], IV512[lo], IV512[hi], IV512[lo] );
-   }
+
+   sc->h[0] = m256_const1_64( 0x6c70617273746565 );
+   sc->h[1] = m256_const1_64( 0x656e62656b204172 );
+   sc->h[2] = m256_const1_64( 0x302c206272672031 );
+   sc->h[3] = m256_const1_64( 0x3434362c75732032 );
+   sc->h[4] = m256_const1_64( 0x3030312020422d33 );
+   sc->h[5] = m256_const1_64( 0x656e2d484c657576 );
+   sc->h[6] = m256_const1_64( 0x6c65652c65766572 );
+   sc->h[7] = m256_const1_64( 0x6769756d2042656c );
 }

 void hamsi512_4way( hamsi_4way_big_context *sc, const void *data, size_t len )
 {
   __m256i *vdata = (__m256i*)data;

-// It looks like the only way to get in here is if core was previously called
-// with a very small len
-// That's not likely even with 80 byte input so deprecate partial len
-/*
-   if ( sc->partial_len != 0 )
-   {
-      size_t mlen;
-
-      mlen = 8 - sc->partial_len;
-      if ( len < mlen )
-      {
-         memcpy_256( sc->partial + (sc->partial_len >> 3), data, len>>3 );
-         sc->partial_len += len;
-         return;
-      }
-      else
-      {
-         memcpy_256( sc->partial + (sc->partial_len >> 3), data, mlen>>3 );
-         len -= mlen;
-         vdata += mlen>>3;
-         hamsi_big( sc, sc->partial, 1 );
-         sc->partial_len = 0;
-      }
-   }
-*/
-
   hamsi_big( sc, vdata, len>>3 );
   vdata += ( (len& ~(size_t)7) >> 3 );
   len &= (size_t)7;
@@ -913,20 +1184,19 @@ void hamsi512_4way( hamsi_4way_big_context *sc, const void *data, size_t len )

 void hamsi512_4way_close( hamsi_4way_big_context *sc, void *dst )
 {
-   __m256i *out = (__m256i*)dst;
   __m256i pad[1];
-   size_t u;
   int ch, cl;

   sph_enc32be( &ch, sc->count_high );
   sph_enc32be( &cl, sc->count_low + ( sc->partial_len << 3 ) );
   pad[0] =  _mm256_set_epi32( cl, ch, cl, ch, cl, ch, cl, ch );
-   sc->buf[0] = _mm256_set_epi32( 0UL, 0x80UL, 0UL, 0x80UL,
-                                  0UL, 0x80UL, 0UL, 0x80UL );
+   sc->buf[0] = m256_const1_64( 0x80 );
+//      sc->buf[0] = _mm256_set_epi32( 0UL, 0x80UL, 0UL, 0x80UL,
+//                                  0UL, 0x80UL, 0UL, 0x80UL );
   hamsi_big( sc, sc->buf, 1 );
   hamsi_big_final( sc, pad );
-   for ( u = 0; u < 8; u ++ )
-      out[u] = mm256_bswap_32( sc->h[u] );
+
+   mm256_block_bswap_32( (__m256i*)dst, sc->h );
 }

 #ifdef __cplusplus
--- a/algo/hamsi/hamsi-hash-4way.h
+++ b/algo/hamsi/hamsi-hash-4way.h
@@ -60,9 +60,32 @@ typedef struct {
 typedef hamsi_4way_big_context hamsi512_4way_context;

 void hamsi512_4way_init( hamsi512_4way_context *sc );
-void hamsi512_4way( hamsi512_4way_context *sc, const void *data, size_t len );
+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 );

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+typedef struct {
+   __m512i h[8];
+   __m512i buf[1];
+   size_t partial_len;
+   sph_u32 count_high, count_low;
+} hamsi_8way_big_context;
+
+typedef hamsi_8way_big_context hamsi512_8way_context;
+
+void hamsi512_8way_init( hamsi512_8way_context *sc );
+void hamsi512_8way_update( hamsi512_8way_context *sc, const void *data,
+                           size_t len );
+void hamsi512_8way_close( hamsi512_8way_context *sc, void *dst );
+
+
+
+#endif
+
+
 #ifdef __cplusplus
 }
 #endif
--- a/algo/hodl/aes.c
+++ b/algo/hodl/aes.c
@@ -83,7 +83,7 @@ void ExpandAESKey256(__m128i *keys, const __m128i *KeyBuf)
    keys[14] = tmp1;
 }

-#ifdef __SSE4_2__
+#if defined(__SSE4_2__)
 //#ifdef __AVX__

 #define AESENC(i,j) \
@@ -151,7 +151,7 @@ void AES256CBC(__m128i** data, const __m128i** next, __m128i ExpandedKey[][16],
    }
 }

-#else    // NO SSE4.2
+#else    // NO AVX

 static inline __m128i AES256Core(__m128i State, const __m128i *ExpandedKey)
 {
--- a/algo/hodl/hodl-gate.c
+++ b/algo/hodl/hodl-gate.c
@@ -15,11 +15,6 @@ pthread_barrier_t hodl_barrier;
 // need to be passed.
 unsigned char *hodl_scratchbuf = NULL;

-void hodl_set_target( struct work* work, double diff )
-{
-     diff_to_target(work->target, diff / 8388608.0 );
-}
-
 void hodl_le_build_stratum_request( char* req, struct work* work,
                                    struct stratum_ctx *sctx ) 
 {
@@ -166,11 +161,10 @@ bool register_hodl_algo( algo_gate_t* gate )
 //     return false;
 //  }
  pthread_barrier_init( &hodl_barrier, NULL, opt_n_threads );
-  gate->optimizations         = AES_OPT | SSE42_OPT | AVX2_OPT;
+  gate->optimizations         = AES_OPT | AVX_OPT | AVX2_OPT;
  gate->scanhash              = (void*)&hodl_scanhash;
  gate->get_new_work          = (void*)&hodl_get_new_work;
  gate->longpoll_rpc_call     = (void*)&hodl_longpoll_rpc_call;
-  gate->set_target            = (void*)&hodl_set_target;
  gate->build_stratum_request = (void*)&hodl_le_build_stratum_request;
  gate->malloc_txs_request    = (void*)&hodl_malloc_txs_request;
  gate->build_block_header    = (void*)&hodl_build_block_header;
@@ -179,6 +173,7 @@ bool register_hodl_algo( algo_gate_t* gate )
  gate->work_cmp_size         = 76;
  hodl_scratchbuf = (unsigned char*)malloc( 1 << 30 );
  allow_getwork = false;
+  opt_target_factor = 8388608.0;
  return ( hodl_scratchbuf != NULL );
 }

--- a/algo/hodl/hodl-wolf.c
+++ b/algo/hodl/hodl-wolf.c
@@ -17,7 +17,7 @@ void GenerateGarbageCore( CacheEntry *Garbage, int ThreadID, int ThreadCount,
    const uint32_t StartChunk = ThreadID * Chunk;
    const uint32_t EndChunk   = StartChunk + Chunk;

-#ifdef __SSE4_2__
+#if defined(__SSE4_2__)
 //#ifdef __AVX__
    uint64_t* TempBufs[ SHA512_PARALLEL_N ] ;
    uint64_t* desination[ SHA512_PARALLEL_N ];
@@ -64,7 +64,7 @@ void Rev256(uint32_t *Dest, const uint32_t *Src)
 int scanhash_hodl_wolf( struct work* work, uint32_t max_nonce,
                        uint64_t *hashes_done, struct thr_info *mythr )
 {
-#ifdef __SSE4_2__
+#if defined(__SSE4_2__)
 //#ifdef __AVX__
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
@@ -140,7 +140,7 @@ int scanhash_hodl_wolf( struct work* work, uint32_t max_nonce,
    return(0);


-#else  // no SSE4.2
+#else  // no AVX

    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
@@ -148,6 +148,7 @@ int scanhash_hodl_wolf( struct work* work, uint32_t max_nonce,
    CacheEntry *Garbage = (CacheEntry*)hodl_scratchbuf;
    CacheEntry Cache;
    uint32_t CollisionCount = 0;
+    int threadNumber = mythr->id;

    swab32_array( BlockHdr, pdata, 20 );
        // Search for pattern in psuedorandom data      
@@ -205,7 +206,7 @@ int scanhash_hodl_wolf( struct work* work, uint32_t max_nonce,
    *hashes_done = CollisionCount;
    return(0);

-#endif  // SSE4.2 else
+#endif  // AVX else

 }

--- a/algo/hodl/sha512-avx.h
+++ b/algo/hodl/sha512-avx.h
@@ -23,6 +23,7 @@ typedef struct
   __m256i h[8];
   __m256i w[80];
 #elif defined(__SSE4_2__)
+//#elif defined(__AVX__)
   __m128i h[8];
   __m128i w[80];
 #else
@@ -32,7 +33,8 @@ typedef struct

 #ifdef __AVX2__
 #define SHA512_PARALLEL_N 8
-#elif defined(__SSE$_2__)
+#elif defined(__SSE4_2__)
+//#elif defined(__AVX__)
 #define SHA512_PARALLEL_N 4
 #else
 #define SHA512_PARALLEL_N 1   // dummy value
--- a/algo/hodl/sha512_avx.c
+++ b/algo/hodl/sha512_avx.c
@@ -1,6 +1,6 @@
 #ifndef __AVX2__

-#ifdef __SSE4_2__
+#if defined(__SSE4_2__)
 //#ifdef __AVX__

 //Dependencies
--- a/algo/hodl/wolf-aes.h
+++ b/algo/hodl/wolf-aes.h
@@ -6,7 +6,7 @@

 void ExpandAESKey256(__m128i *keys, const __m128i *KeyBuf);

-#ifdef __SSE4_2__
+#if defined(__SSE4_2__)
 //#ifdef __AVX__

 #define AES_PARALLEL_N 8
--- a/algo/jh/jh-hash-4way.c
+++ b/algo/jh/jh-hash-4way.c
@@ -92,9 +92,41 @@ extern "C"{

 #endif

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define Sb_8W(x0, x1, x2, x3, c) \
+do { \
+   __m512i cc = _mm512_set1_epi64( c ); \
+    x3 = mm512_not( x3 ); \
+    x0 = _mm512_xor_si512( x0, _mm512_andnot_si512( x2, cc ) ); \
+    tmp = _mm512_xor_si512( cc, _mm512_and_si512( x0, x1 ) ); \
+    x0 = _mm512_xor_si512( x0, _mm512_and_si512( x2, x3 ) ); \
+    x3 = _mm512_xor_si512( x3, _mm512_andnot_si512( x1, x2 ) ); \
+    x1 = _mm512_xor_si512( x1, _mm512_and_si512( x0, x2 ) ); \
+    x2 = _mm512_xor_si512( x2, _mm512_andnot_si512( x3, x0 ) ); \
+    x0 = _mm512_xor_si512( x0, _mm512_or_si512( x1, x3 ) ); \
+    x3 = _mm512_xor_si512( x3, _mm512_and_si512( x1, x2 ) ); \
+    x1 = _mm512_xor_si512( x1, _mm512_and_si512( tmp, x0 ) ); \
+    x2 = _mm512_xor_si512( x2, tmp ); \
+} while (0)
+
+#define Lb_8W(x0, x1, x2, x3, x4, x5, x6, x7) \
+do { \
+    x4 = _mm512_xor_si512( x4, x1 ); \
+    x5 = _mm512_xor_si512( x5, x2 ); \
+    x6 = _mm512_xor_si512( x6, _mm512_xor_si512( x3, x0 ) ); \
+    x7 = _mm512_xor_si512( x7, x0 ); \
+    x0 = _mm512_xor_si512( x0, x5 ); \
+    x1 = _mm512_xor_si512( x1, x6 ); \
+    x2 = _mm512_xor_si512( x2, _mm512_xor_si512( x7, x4 ) ); \
+    x3 = _mm512_xor_si512( x3, x4 ); \
+} while (0)
+
+#endif
+
 #define Sb(x0, x1, x2, x3, c) \
 do { \
-   __m256i cc = _mm256_set_epi64x( c, c, c, c ); \
+   __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 ) ); \
@@ -226,6 +258,48 @@ static const sph_u64 C[] = {
 			x4 ## l, x5 ## l, x6 ## l, x7 ## l); \
 	} while (0)

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define S_8W(x0, x1, x2, x3, cb, r)   do { \
+      Sb_8W(x0 ## h, x1 ## h, x2 ## h, x3 ## h, cb ## hi(r)); \
+      Sb_8W(x0 ## l, x1 ## l, x2 ## l, x3 ## l, cb ## lo(r)); \
+   } while (0)
+
+#define L_8W(x0, x1, x2, x3, x4, x5, x6, x7)   do { \
+      Lb_8W(x0 ## h, x1 ## h, x2 ## h, x3 ## h, \
+         x4 ## h, x5 ## h, x6 ## h, x7 ## h); \
+      Lb_8W(x0 ## l, x1 ## l, x2 ## l, x3 ## l, \
+         x4 ## l, x5 ## l, x6 ## l, x7 ## l); \
+   } while (0)
+
+#define Wz_8W(x, c, n) \
+do { \
+   __m512i t = _mm512_slli_epi64( _mm512_and_si512(x ## h, (c)), (n) ); \
+   x ## h = _mm512_or_si512( _mm512_and_si512( \
+                                _mm512_srli_epi64(x ## h, (n)), (c)), t ); \
+   t = _mm512_slli_epi64( _mm512_and_si512(x ## l, (c)), (n) ); \
+   x ## l = _mm512_or_si512( _mm512_and_si512((x ## l >> (n)), (c)), t ); \
+} 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 W86(x) \
+do { \
+   __m512i t = x ## h; \
+   x ## h = x ## l; \
+   x ## l = t; \
+} while (0)
+
+#define DECL_STATE_8W \
+   __m512i h0h, h1h, h2h, h3h, h4h, h5h, h6h, h7h; \
+   __m512i h0l, h1l, h2l, h3l, h4l, h5l, h6l, h7l; \
+   __m512i tmp;
+
+#endif

 #define Wz(x, c, n) \
 do { \
@@ -236,28 +310,12 @@ do { \
   x ## l = _mm256_or_si256( _mm256_and_si256((x ## l >> (n)), (c)), t ); \
 } while (0)

-
-/*
-#define Wz(x, c, n)   do { \
-		sph_u64 t = (x ## h & (c)) << (n); \
-		x ## h = ((x ## h >> (n)) & (c)) | t; \
-		t = (x ## l & (c)) << (n); \
-		x ## l = ((x ## l >> (n)) & (c)) | t; \
-	} while (0)
-*/
-
-#define W0(x)   Wz(x, _mm256_set_epi64x( 0x5555555555555555, \
-       0x5555555555555555, 0x5555555555555555, 0x5555555555555555 ), 1 )
-#define W1(x)   Wz(x, _mm256_set_epi64x( 0x3333333333333333, \
-       0x3333333333333333, 0x3333333333333333, 0x3333333333333333 ), 2 )
-#define W2(x)   Wz(x, _mm256_set_epi64x( 0x0F0F0F0F0F0F0F0F, \
-       0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F ), 4 )
-#define W3(x)   Wz(x, _mm256_set_epi64x( 0x00FF00FF00FF00FF, \
-       0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF ), 8 ) 
-#define W4(x)   Wz(x, _mm256_set_epi64x( 0x0000FFFF0000FFFF, \
-       0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF, 0x0000FFFF0000FFFF ), 16 )
-#define W5(x)   Wz(x, _mm256_set_epi64x( 0x00000000FFFFFFFF, \
-       0x00000000FFFFFFFF, 0x00000000FFFFFFFF, 0x00000000FFFFFFFF ), 32 )
+#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 W6(x) \
 do { \
   __m256i t = x ## h; \
@@ -265,25 +323,12 @@ do { \
   x ## l = t; \
 } while (0)

-/*
-#define W0(x)   Wz(x, SPH_C64(0x5555555555555555),  1)
-#define W1(x)   Wz(x, SPH_C64(0x3333333333333333),  2)
-#define W2(x)   Wz(x, SPH_C64(0x0F0F0F0F0F0F0F0F),  4)
-#define W3(x)   Wz(x, SPH_C64(0x00FF00FF00FF00FF),  8)
-#define W4(x)   Wz(x, SPH_C64(0x0000FFFF0000FFFF), 16)
-#define W5(x)   Wz(x, SPH_C64(0x00000000FFFFFFFF), 32)
-#define W6(x)   do { \
-		sph_u64 t = x ## h; \
-		x ## h = x ## l; \
-		x ## l = t; \
-	} while (0)
-*/
-
 #define DECL_STATE \
 	__m256i h0h, h1h, h2h, h3h, h4h, h5h, h6h, h7h; \
 	__m256i h0l, h1l, h2l, h3l, h4l, h5l, h6l, h7l; \
 	__m256i tmp;

+
 #define READ_STATE(state)   do { \
 		h0h = (state)->H[ 0]; \
 		h0l = (state)->H[ 1]; \
@@ -322,6 +367,38 @@ do { \
 		(state)->H[15] = h7l; \
 	} while (0)

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define INPUT_BUF1_8W \
+   __m512i m0h = buf[0]; \
+   __m512i m0l = buf[1]; \
+   __m512i m1h = buf[2]; \
+   __m512i m1l = buf[3]; \
+   __m512i m2h = buf[4]; \
+   __m512i m2l = buf[5]; \
+   __m512i m3h = buf[6]; \
+   __m512i m3l = buf[7]; \
+   h0h = _mm512_xor_si512( h0h, m0h ); \
+   h0l = _mm512_xor_si512( h0l, m0l ); \
+   h1h = _mm512_xor_si512( h1h, m1h ); \
+   h1l = _mm512_xor_si512( h1l, m1l ); \
+   h2h = _mm512_xor_si512( h2h, m2h ); \
+   h2l = _mm512_xor_si512( h2l, m2l ); \
+   h3h = _mm512_xor_si512( h3h, m3h ); \
+   h3l = _mm512_xor_si512( h3l, m3l ); \
+
+#define INPUT_BUF2_8W \
+   h4h = _mm512_xor_si512( h4h, m0h ); \
+   h4l = _mm512_xor_si512( h4l, m0l ); \
+   h5h = _mm512_xor_si512( h5h, m1h ); \
+   h5l = _mm512_xor_si512( h5l, m1l ); \
+   h6h = _mm512_xor_si512( h6h, m2h ); \
+   h6l = _mm512_xor_si512( h6l, m2l ); \
+   h7h = _mm512_xor_si512( h7h, m3h ); \
+   h7l = _mm512_xor_si512( h7l, m3l ); \
+
+#endif
+
 #define INPUT_BUF1 \
 	__m256i m0h = buf[0]; \
 	__m256i m0l = buf[1]; \
@@ -331,14 +408,14 @@ do { \
 	__m256i m2l = buf[5]; \
 	__m256i m3h = buf[6]; \
 	__m256i m3l = buf[7]; \
-        h0h = _mm256_xor_si256( h0h, m0h ); \
-        h0l = _mm256_xor_si256( h0l, m0l ); \
-        h1h = _mm256_xor_si256( h1h, m1h ); \
-        h1l = _mm256_xor_si256( h1l, m1l ); \
-        h2h = _mm256_xor_si256( h2h, m2h ); \
-        h2l = _mm256_xor_si256( h2l, m2l ); \
-        h3h = _mm256_xor_si256( h3h, m3h ); \
-        h3l = _mm256_xor_si256( h3l, m3l ); \
+   h0h = _mm256_xor_si256( h0h, m0h ); \
+   h0l = _mm256_xor_si256( h0l, m0l ); \
+   h1h = _mm256_xor_si256( h1h, m1h ); \
+   h1l = _mm256_xor_si256( h1l, m1l ); \
+   h2h = _mm256_xor_si256( h2h, m2h ); \
+   h2l = _mm256_xor_si256( h2l, m2l ); \
+   h3h = _mm256_xor_si256( h3h, m3h ); \
+   h3l = _mm256_xor_si256( h3l, m3l ); \

 #define INPUT_BUF2 \
   h4h = _mm256_xor_si256( h4h, m0h ); \
@@ -350,6 +427,7 @@ do { \
   h7h = _mm256_xor_si256( h7h, m3h ); \
   h7l = _mm256_xor_si256( h7l, m3l ); \

+
 static const sph_u64 IV256[] = {
 	C64e(0xeb98a3412c20d3eb), C64e(0x92cdbe7b9cb245c1),
 	C64e(0x1c93519160d4c7fa), C64e(0x260082d67e508a03),
@@ -376,6 +454,22 @@ static const sph_u64 IV512[] = {
 #else


+#endif
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define SL_8W(ro)   SLu_8W(r + ro, ro)
+
+#define SLu_8W(r, ro)   do { \
+      S_8W(h0, h2, h4, h6, Ceven_, r); \
+      S_8W(h1, h3, h5, h7, Codd_, r); \
+      L_8W(h0, h2, h4, h6, h1, h3, h5, h7); \
+      W8 ## ro(h1); \
+      W8 ## ro(h3); \
+      W8 ## ro(h5); \
+      W8 ## ro(h7); \
+   } while (0)
+
 #endif

 #define SL(ro)   SLu(r + ro, ro)
@@ -399,6 +493,23 @@ static const sph_u64 IV512[] = {
 * loop.
 */

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define E8_8W   do { \
+      unsigned r; \
+      for (r = 0; r < 42; r += 7) { \
+         SL_8W(0); \
+         SL_8W(1); \
+         SL_8W(2); \
+         SL_8W(3); \
+         SL_8W(4); \
+         SL_8W(5); \
+         SL_8W(6); \
+      } \
+   } while (0)
+
+#endif
+
 #define E8   do { \
 		unsigned r; \
 		for (r = 0; r < 42; r += 7) { \
@@ -425,51 +536,100 @@ static const sph_u64 IV512[] = {
 * On a "true 64-bit" architecture, we can unroll at will.
 */

-#define E8   do { \
-		SLu( 0, 0); \
-		SLu( 1, 1); \
-		SLu( 2, 2); \
-		SLu( 3, 3); \
-		SLu( 4, 4); \
-		SLu( 5, 5); \
-		SLu( 6, 6); \
-		SLu( 7, 0); \
-		SLu( 8, 1); \
-		SLu( 9, 2); \
-		SLu(10, 3); \
-		SLu(11, 4); \
-		SLu(12, 5); \
-		SLu(13, 6); \
-		SLu(14, 0); \
-		SLu(15, 1); \
-		SLu(16, 2); \
-		SLu(17, 3); \
-		SLu(18, 4); \
-		SLu(19, 5); \
-		SLu(20, 6); \
-		SLu(21, 0); \
-		SLu(22, 1); \
-		SLu(23, 2); \
-		SLu(24, 3); \
-		SLu(25, 4); \
-		SLu(26, 5); \
-		SLu(27, 6); \
-		SLu(28, 0); \
-		SLu(29, 1); \
-		SLu(30, 2); \
-		SLu(31, 3); \
-		SLu(32, 4); \
-		SLu(33, 5); \
-		SLu(34, 6); \
-		SLu(35, 0); \
-		SLu(36, 1); \
-		SLu(37, 2); \
-		SLu(38, 3); \
-		SLu(39, 4); \
-		SLu(40, 5); \
-		SLu(41, 6); \
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define E8_8W   do { \
+		SLu_8W( 0, 0); \
+		SLu_8W( 1, 1); \
+		SLu_8W( 2, 2); \
+		SLu_8W( 3, 3); \
+		SLu_8W( 4, 4); \
+		SLu_8W( 5, 5); \
+		SLu_8W( 6, 6); \
+		SLu_8W( 7, 0); \
+		SLu_8W( 8, 1); \
+		SLu_8W( 9, 2); \
+		SLu_8W(10, 3); \
+		SLu_8W(11, 4); \
+		SLu_8W(12, 5); \
+		SLu_8W(13, 6); \
+		SLu_8W(14, 0); \
+		SLu_8W(15, 1); \
+		SLu_8W(16, 2); \
+		SLu_8W(17, 3); \
+		SLu_8W(18, 4); \
+		SLu_8W(19, 5); \
+		SLu_8W(20, 6); \
+		SLu_8W(21, 0); \
+		SLu_8W(22, 1); \
+		SLu_8W(23, 2); \
+		SLu_8W(24, 3); \
+		SLu_8W(25, 4); \
+		SLu_8W(26, 5); \
+		SLu_8W(27, 6); \
+		SLu_8W(28, 0); \
+		SLu_8W(29, 1); \
+		SLu_8W(30, 2); \
+		SLu_8W(31, 3); \
+		SLu_8W(32, 4); \
+		SLu_8W(33, 5); \
+		SLu_8W(34, 6); \
+		SLu_8W(35, 0); \
+		SLu_8W(36, 1); \
+		SLu_8W(37, 2); \
+		SLu_8W(38, 3); \
+		SLu_8W(39, 4); \
+		SLu_8W(40, 5); \
+		SLu_8W(41, 6); \
 	} while (0)

+#endif  // AVX512
+
+#define E8   do { \
+      SLu( 0, 0); \
+      SLu( 1, 1); \
+      SLu( 2, 2); \
+      SLu( 3, 3); \
+      SLu( 4, 4); \
+      SLu( 5, 5); \
+      SLu( 6, 6); \
+      SLu( 7, 0); \
+      SLu( 8, 1); \
+      SLu( 9, 2); \
+      SLu(10, 3); \
+      SLu(11, 4); \
+      SLu(12, 5); \
+      SLu(13, 6); \
+      SLu(14, 0); \
+      SLu(15, 1); \
+      SLu(16, 2); \
+      SLu(17, 3); \
+      SLu(18, 4); \
+      SLu(19, 5); \
+      SLu(20, 6); \
+      SLu(21, 0); \
+      SLu(22, 1); \
+      SLu(23, 2); \
+      SLu(24, 3); \
+      SLu(25, 4); \
+      SLu(26, 5); \
+      SLu(27, 6); \
+      SLu(28, 0); \
+      SLu(29, 1); \
+      SLu(30, 2); \
+      SLu(31, 3); \
+      SLu(32, 4); \
+      SLu(33, 5); \
+      SLu(34, 6); \
+      SLu(35, 0); \
+      SLu(36, 1); \
+      SLu(37, 2); \
+      SLu(38, 3); \
+      SLu(39, 4); \
+      SLu(40, 5); \
+      SLu(41, 6); \
+   } while (0)
+
 #else


@@ -477,13 +637,200 @@ static const sph_u64 IV512[] = {

 #endif

-static void
-jh_4way_init( jh_4way_context *sc, const void *iv )
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+void jh256_8way_init( jh_8way_context *sc )
 {
-    uint64_t *v = (uint64_t*)iv;
-    
-    for ( int i = 0; i < 16; i++ )
-        sc->H[i] = _mm256_set_epi64x( v[i], v[i], v[i], v[i] );
+    // 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->ptr = 0;
+    sc->block_count = 0;
+}
+
+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->ptr = 0;
+    sc->block_count = 0;
+}
+
+static void
+jh_8way_core( jh_8way_context *sc, const void *data, size_t len )
+{
+    __m512i *buf;
+    __m512i *vdata = (__m512i*)data;
+   const int buf_size = 64;   // 64 * _m512i
+   size_t ptr;
+   DECL_STATE_8W
+
+   buf = sc->buf;
+   ptr = sc->ptr;
+
+   if ( len < (buf_size - ptr) )
+   {
+       memcpy_512( buf + (ptr>>3), vdata, len>>3 );
+       ptr += len;
+       sc->ptr = ptr;
+       return;
+   }
+
+   READ_STATE(sc);
+   while ( len > 0 )
+   {
+       size_t clen;
+       clen = buf_size - ptr;
+       if ( clen > len )
+          clen = len;
+
+       memcpy_512( buf + (ptr>>3), vdata, clen>>3 );
+       ptr += clen;
+       vdata += (clen>>3);
+       len -= clen;
+       if ( ptr == buf_size )
+       {
+          INPUT_BUF1_8W;
+          E8_8W;
+          INPUT_BUF2_8W;
+          sc->block_count ++;
+          ptr = 0;
+       }
+   }
+   WRITE_STATE(sc);
+   sc->ptr = ptr;
+}
+
+static void
+jh_8way_close( jh_8way_context *sc, unsigned ub, unsigned n, void *dst,
+               size_t out_size_w32, const void *iv )
+{
+   __m512i buf[16*4];
+   __m512i *dst512 = (__m512i*)dst;
+   size_t numz, u;
+   sph_u64 l0, l1, l0e, l1e;
+
+   buf[0] = m512_const1_64( 0x80ULL );
+
+   if ( sc->ptr == 0 )
+       numz = 48;
+   else
+       numz = 112 - sc->ptr;
+
+   memset_zero_512( buf+1, (numz>>3) - 1 );
+
+   l0 = SPH_T64(sc->block_count << 9) + (sc->ptr << 3);
+   l1 = SPH_T64(sc->block_count >> 55);
+   sph_enc64be( &l0e, l0 );
+   sph_enc64be( &l1e, l1 );
+   *(buf + (numz>>3)    ) = _mm512_set1_epi64( l1e );
+   *(buf + (numz>>3) + 1) = _mm512_set1_epi64( l0e );
+
+   jh_8way_core( sc, buf, numz + 16 );
+
+   for ( u=0; u < 8; u++ )
+       buf[u] = sc->H[u+8];
+
+    memcpy_512( dst512, buf, 8 );
+}
+
+void
+jh256_8way_update(void *cc, const void *data, size_t len)
+{
+   jh_8way_core(cc, data, len);
+}
+
+void
+jh256_8way_close(void *cc, void *dst)
+{
+   jh_8way_close(cc, 0, 0, dst, 8, IV256);
+}
+
+void
+jh512_8way_update(void *cc, const void *data, size_t len)
+{
+   jh_8way_core(cc, data, len);
+}
+
+void
+jh512_8way_close(void *cc, void *dst)
+{
+   jh_8way_close(cc, 0, 0, dst, 16, IV512);
+}
+
+#endif
+
+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->ptr = 0;
+    sc->block_count = 0;
+}
+
+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->ptr = 0;
    sc->block_count = 0;
 }
@@ -542,7 +889,7 @@ jh_4way_close( jh_4way_context *sc, unsigned ub, unsigned n, void *dst,
   size_t numz, u;
   sph_u64 l0, l1, l0e, l1e;

-   buf[0] = _mm256_set_epi64x( 0x80, 0x80, 0x80, 0x80 );
+   buf[0] = m256_const1_64( 0x80ULL );

   if ( sc->ptr == 0 )
       numz = 48;
@@ -555,8 +902,8 @@ jh_4way_close( jh_4way_context *sc, unsigned ub, unsigned n, void *dst,
   l1 = SPH_T64(sc->block_count >> 55);
   sph_enc64be( &l0e, l0 );
   sph_enc64be( &l1e, l1 );
-   *(buf + (numz>>3)    ) = _mm256_set_epi64x( l1e, l1e, l1e, l1e );
-   *(buf + (numz>>3) + 1) = _mm256_set_epi64x( l0e, l0e, l0e, l0e ); 
+   *(buf + (numz>>3)    ) = _mm256_set1_epi64x( l1e );
+   *(buf + (numz>>3) + 1) = _mm256_set1_epi64x( l0e ); 

   jh_4way_core( sc, buf, numz + 16 );

@@ -567,13 +914,7 @@ jh_4way_close( jh_4way_context *sc, unsigned ub, unsigned n, void *dst,
 }

 void
-jh256_4way_init(void *cc)
-{
-	jh_4way_init(cc, IV256);
-}
-
-void
-jh256_4way(void *cc, const void *data, size_t len)
+jh256_4way_update(void *cc, const void *data, size_t len)
 {
 	jh_4way_core(cc, data, len);
 }
@@ -585,13 +926,7 @@ jh256_4way_close(void *cc, void *dst)
 }

 void
-jh512_4way_init(void *cc)
-{
-	jh_4way_init(cc, IV512);
-}
-
-void
-jh512_4way(void *cc, const void *data, size_t len)
+jh512_4way_update(void *cc, const void *data, size_t len)
 {
 	jh_4way_core(cc, data, len);
 }
@@ -602,6 +937,7 @@ jh512_4way_close(void *cc, void *dst)
 	jh_4way_close(cc, 0, 0, dst, 16, IV512);
 }

+
 #ifdef __cplusplus
 }
 #endif
--- a/algo/jh/jh-hash-4way.h
+++ b/algo/jh/jh-hash-4way.h
@@ -60,34 +60,57 @@ extern "C"{
 * can be cloned by copying the context (e.g. with a simple
 * <code>memcpy()</code>).
 */
+
+ 
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
 typedef struct {
-    __m256i buf[8] __attribute__ ((aligned (64)));
+    __m512i buf[8];
+    __m512i H[16];
+    size_t ptr;
+    uint64_t block_count;
+} jh_8way_context __attribute__ ((aligned (128)));
+
+typedef jh_8way_context jh256_8way_context;
+
+typedef jh_8way_context jh512_8way_context;
+
+void jh256_8way_init( jh_8way_context *sc);
+
+void jh256_8way_update(void *cc, const void *data, size_t len);
+
+void jh256_8way_close(void *cc, void *dst);
+
+void jh512_8way_init( jh_8way_context *sc );
+
+void jh512_8way_update(void *cc, const void *data, size_t len);
+
+void jh512_8way_close(void *cc, void *dst);
+
+#endif
+
+typedef struct {
+    __m256i buf[8];
    __m256i H[16];
    size_t ptr;
    uint64_t block_count;
-/*
-	unsigned char buf[64]; 
-	size_t ptr;
-	union {
-		sph_u64 wide[16];
-	} H;
-	sph_u64 block_count;
-*/
-} jh_4way_context;
+} jh_4way_context __attribute__ ((aligned (128)));

 typedef jh_4way_context jh256_4way_context;

 typedef jh_4way_context jh512_4way_context;

-void jh256_4way_init(void *cc);
+void jh256_4way_init( jh_4way_context *sc);

-void jh256_4way(void *cc, const void *data, size_t len);
+void jh256_4way_update(void *cc, const void *data, size_t len);
+#define jh256_4way jh256_4way_update

 void jh256_4way_close(void *cc, void *dst);

-void jh512_4way_init(void *cc);
+void jh512_4way_init( jh_4way_context *sc );

-void jh512_4way(void *cc, const void *data, size_t len);
+void jh512_4way_update(void *cc, const void *data, size_t len);
+#define jh512_4way jh512_4way_update

 void jh512_4way_close(void *cc, void *dst);

@@ -95,6 +118,6 @@ void jh512_4way_close(void *cc, void *dst);
 }
 #endif

-#endif
+#endif // AVX2

 #endif
--- a/algo/jh/jha-4way.c
+++ b/algo/jh/jha-4way.c
@@ -3,7 +3,6 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-//#include "avxdefs.h"

 #if defined(JHA_4WAY)

@@ -13,9 +12,6 @@
 #include "algo/keccak/keccak-hash-4way.h"
 #include "algo/groestl/aes_ni/hash-groestl.h"

-//static __thread keccak512_4way_context jha_kec_mid
-//                                   __attribute__ ((aligned (64)));
-
 void jha_hash_4way( void *out, const void *input )
 {
    uint64_t hash0[8] __attribute__ ((aligned (64)));
@@ -46,7 +42,7 @@ void jha_hash_4way( void *out, const void *input )
       vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256(
               vh[0], _mm256_set1_epi64x( 1 ) ), m256_zero );

-       mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+       dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
       init_groestl( &ctx_groestl, 64 );
       update_and_final_groestl( &ctx_groestl, (char*)hash0,
                                               (char*)hash0, 512 );
@@ -59,7 +55,7 @@ void jha_hash_4way( void *out, const void *input )
       init_groestl( &ctx_groestl, 64 );
       update_and_final_groestl( &ctx_groestl, (char*)hash3,
                                               (char*)hash3, 512 );
-       mm256_intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+       intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );

       skein512_4way_init( &ctx_skein );
       skein512_4way( &ctx_skein, vhash, 64 );
@@ -79,8 +75,6 @@ void jha_hash_4way( void *out, const void *input )
       for ( int i = 0; i < 8; i++ )
          casti_m256i( out, i ) = _mm256_blendv_epi8( vhA[i], vhB[i], vh_mask );
    }
-
-//    mm256_dintrlv_4x64( out, out+32, out+64, out+96, vhash, 256 );
 }

 int scanhash_jha_4way( struct work *work, uint32_t max_nonce,
@@ -115,12 +109,7 @@ int scanhash_jha_4way( struct work *work, uint32_t max_nonce,
 		0
 	};

-//   for ( int i=0; i < 19; i++ )
-//      be32enc( &endiandata[i], pdata[i] );
-
-//   uint64_t *edata = (uint64_t*)endiandata;
-//   mm256_intrlv_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
-   mm256_bswap_intrlv80_4x64( vdata, pdata );
+   mm256_bswap32_intrlv80_4x64( vdata, pdata );

   for ( int m = 0; m < 6; m++ )
   {
@@ -130,26 +119,17 @@ int scanhash_jha_4way( struct work *work, uint32_t max_nonce,
         do {
              *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
-//              be32enc( noncep,   n   );
-//              be32enc( noncep+2, n+1 );
-//              be32enc( noncep+4, n+2 );
-//              be32enc( noncep+6, n+3 );

              jha_hash_4way( hash, vdata );
              pdata[19] = n;

-//              for ( int i = 0; i < 4; i++ )
-//              if ( ( !( (hash+(i<<3))[7] & mask ) == 0 )
-//                  && fulltest( hash+(i<<3), ptarget ) )
              for ( int i = 0; i < 4; i++ ) if ( !( (hash7[i] & mask ) == 0 ) )
              {
-                 mm256_extr_lane_4x64( lane_hash, hash, i, 256 );
+                 extr_lane_4x64( lane_hash, hash, i, 256 );
                 if ( fulltest( hash+(i<<3), ptarget ) && !opt_benchmark )
                 {
                    pdata[19] = n+i;
                    submit_lane_solution( work, lane_hash, mythr, i );
-//                 nonces[ num_found++ ] = n+i;
-//                 work_set_target_ratio( work, hash+(i<<3) );
                 }
              }
              n += 4;
--- a/algo/jh/jha-gate.c
+++ b/algo/jh/jha-gate.c
@@ -12,7 +12,7 @@ bool register_jha_algo( algo_gate_t* gate )
  gate->hash             = (void*)&jha_hash;
 #endif
  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT;
-  gate->set_target       = (void*)&scrypt_set_target;
+  opt_target_factor = 65536.0;
  return true;
 };

--- a/algo/keccak/keccak-4way.c
+++ b/algo/keccak/keccak-4way.c
@@ -1,18 +1,68 @@
 #include "keccak-gate.h"
-
-#ifdef KECCAK_4WAY
-
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
 #include "sph_keccak.h"
 #include "keccak-hash-4way.h"

+#if defined(KECCAK_8WAY)
+
+void keccakhash_8way(void *state, const void *input)
+{
+    keccak256_8way_context ctx;
+    keccak256_8way_init( &ctx );
+    keccak256_8way_update( &ctx, input, 80 );
+    keccak256_8way_close( &ctx, state );
+}
+
+int scanhash_keccak_8way( struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[24*8] __attribute__ ((aligned (128)));
+   uint32_t hash[16*8] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[49]);   // 3*16+1
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   uint32_t n = pdata[19];
+   const uint32_t first_nonce = pdata[19];
+   __m512i  *noncev = (__m512i*)vdata + 9;   // aligned
+   const uint32_t Htarg = ptarget[7];
+   int thr_id = mythr->id;  
+
+   mm512_bswap32_intrlv80_8x64( vdata, pdata );
+   do {
+       *noncev = mm512_intrlv_blend_32( mm512_bswap_32(
+                _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
+                                  n+3, 0, n+2, 0, n+1, 0, n  , 0 ) ), *noncev );
+
+      keccakhash_8way( hash, vdata );
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( hash7[ lane<<1 ] < Htarg ) 
+      {
+          extr_lane_8x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+          {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+          }
+      }
+      n += 8;
+
+   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#elif defined(KECCAK_4WAY)
+
 void keccakhash_4way(void *state, const void *input)
 {
    keccak256_4way_context ctx;
    keccak256_4way_init( &ctx );
-    keccak256_4way( &ctx, input, 80 );
+    keccak256_4way_update( &ctx, input, 80 );
    keccak256_4way_close( &ctx, state );
 }

@@ -20,7 +70,7 @@ int scanhash_keccak_4way( struct work *work, uint32_t max_nonce,
                          uint64_t *hashes_done, struct thr_info *mythr )
 {
   uint32_t vdata[24*4] __attribute__ ((aligned (64)));
-   uint32_t hash[8*4] __attribute__ ((aligned (32)));
+   uint32_t hash[16*4] __attribute__ ((aligned (32)));
   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
   uint32_t *hash7 = &(hash[25]);   // 3*8+1
   uint32_t *pdata = work->data;
@@ -28,10 +78,10 @@ int scanhash_keccak_4way( struct work *work, uint32_t max_nonce,
   uint32_t n = pdata[19];
   const uint32_t first_nonce = pdata[19];
   __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
-//   const uint32_t Htarg = ptarget[7];
-    int thr_id = mythr->id;  // thr_id arg is deprecated
+   const uint32_t Htarg = ptarget[7];
+   int thr_id = mythr->id;

-   mm256_bswap_intrlv80_4x64( vdata, pdata );
+   mm256_bswap32_intrlv80_4x64( vdata, pdata );
   do {
       *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
@@ -39,10 +89,10 @@ int scanhash_keccak_4way( struct work *work, uint32_t max_nonce,
      keccakhash_4way( hash, vdata );

      for ( int lane = 0; lane < 4; lane++ )
-      if ( ( ( hash7[ lane<<1 ] & 0xFFFFFF00 ) == 0 ) )
+      if ( hash7[ lane<<1 ] < Htarg )
      {
-          mm256_extr_lane_4x64( lane_hash, hash, lane, 256 );
-          if ( fulltest( lane_hash, ptarget ) )
+          extr_lane_4x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
          {
              pdata[19] = n + lane;
              submit_lane_solution( work, lane_hash, mythr, lane );
--- a/algo/keccak/keccak-gate.c
+++ b/algo/keccak/keccak-gate.c
@@ -1,45 +1,38 @@
 #include "keccak-gate.h"

-void keccak_set_target( struct work* work, double job_diff )
-{
-  work_set_target( work, job_diff / (128.0 * opt_diff_factor) );
-}
-
-int64_t keccak_get_max64() { return 0x7ffffLL; }

 bool register_keccak_algo( algo_gate_t* gate )
 {
-  gate->optimizations = AVX2_OPT;
+  gate->optimizations = AVX2_OPT | AVX512_OPT;
  gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
-  gate->set_target      = (void*)&keccak_set_target;
-  gate->get_max64       = (void*)&keccak_get_max64;
-#if defined (KECCAK_4WAY)
+  opt_target_factor = 128.0;
+#if defined (KECCAK_8WAY)
+  gate->scanhash  = (void*)&scanhash_keccak_8way;
+  gate->hash      = (void*)&keccakhash_8way;
+#elif defined (KECCAK_4WAY)
  gate->scanhash  = (void*)&scanhash_keccak_4way;
  gate->hash      = (void*)&keccakhash_4way;
 #else
-  gate->scanhash        = (void*)&scanhash_keccak;
-  gate->hash            = (void*)&keccakhash;
+  gate->scanhash  = (void*)&scanhash_keccak;
+  gate->hash      = (void*)&keccakhash;
 #endif
  return true;
 };

-void keccakc_set_target( struct work* work, double job_diff )
-{
-  work_set_target( work, job_diff / (256.0 * opt_diff_factor) );
-}
-
 bool register_keccakc_algo( algo_gate_t* gate )
 {
-  gate->optimizations = AVX2_OPT;
+  gate->optimizations = AVX2_OPT | AVX512_OPT;
  gate->gen_merkle_root = (void*)&sha256d_gen_merkle_root;
-  gate->set_target      = (void*)&keccakc_set_target;
-  gate->get_max64       = (void*)&keccak_get_max64;
-#if defined (KECCAK_4WAY)
+  opt_target_factor = 256.0;
+#if defined (KECCAK_8WAY)
+  gate->scanhash  = (void*)&scanhash_keccak_8way;
+  gate->hash      = (void*)&keccakhash_8way;
+#elif defined (KECCAK_4WAY)
  gate->scanhash  = (void*)&scanhash_keccak_4way;
  gate->hash      = (void*)&keccakhash_4way;
 #else
-  gate->scanhash        = (void*)&scanhash_keccak;
-  gate->hash            = (void*)&keccakhash;
+  gate->scanhash  = (void*)&scanhash_keccak;
+  gate->hash      = (void*)&keccakhash;
 #endif
  return true;
 };
--- a/algo/keccak/keccak-gate.h
+++ b/algo/keccak/keccak-gate.h
@@ -1,23 +1,33 @@
 #ifndef KECCAK_GATE_H__
-#define KECCAK_GATE_H__
+#define KECCAK_GATE_H__ 1

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

-#if defined(__AVX2__)
-  #define KECCAK_4WAY
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define KECCAK_8WAY 1
+#elif defined(__AVX2__)
+  #define KECCAK_4WAY 1
 #endif

-#if defined(KECCAK_4WAY)
+#if defined(KECCAK_8WAY)
+
+void keccakhash_8way( void *state, const void *input );
+int scanhash_keccak_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined(KECCAK_4WAY)

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

-#endif
+#else

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

 #endif
+
+#endif
--- a/algo/keccak/keccak-hash-4way.c
+++ b/algo/keccak/keccak-hash-4way.c
@@ -1,23 +1,24 @@
 #include <stddef.h>
+#include <stdint.h>
 #include "keccak-hash-4way.h"

-#if defined(__AVX2__)
-
-static const sph_u64 RC[] = {
-        SPH_C64(0x0000000000000001), SPH_C64(0x0000000000008082),
-        SPH_C64(0x800000000000808A), SPH_C64(0x8000000080008000),
-        SPH_C64(0x000000000000808B), SPH_C64(0x0000000080000001),
-        SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008009),
-        SPH_C64(0x000000000000008A), SPH_C64(0x0000000000000088),
-        SPH_C64(0x0000000080008009), SPH_C64(0x000000008000000A),
-        SPH_C64(0x000000008000808B), SPH_C64(0x800000000000008B),
-        SPH_C64(0x8000000000008089), SPH_C64(0x8000000000008003),
-        SPH_C64(0x8000000000008002), SPH_C64(0x8000000000000080),
-        SPH_C64(0x000000000000800A), SPH_C64(0x800000008000000A),
-        SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008080),
-        SPH_C64(0x0000000080000001), SPH_C64(0x8000000080008008)
+static const uint64_t RC[] = {
+        0x0000000000000001, 0x0000000000008082,
+        0x800000000000808A, 0x8000000080008000,
+        0x000000000000808B, 0x0000000080000001,
+        0x8000000080008081, 0x8000000000008009,
+        0x000000000000008A, 0x0000000000000088,
+        0x0000000080008009, 0x000000008000000A,
+        0x000000008000808B, 0x800000000000008B,
+        0x8000000000008089, 0x8000000000008003,
+        0x8000000000008002, 0x8000000000000080,
+        0x000000000000800A, 0x800000008000000A,
+        0x8000000080008081, 0x8000000000008080,
+        0x0000000080000001, 0x8000000080008008
 };

+// generic macros
+
 #define a00   (kc->w[ 0])
 #define a10   (kc->w[ 1])
 #define a20   (kc->w[ 2])
@@ -48,6 +49,197 @@ static const sph_u64 RC[] = {
 #define READ_STATE(sc)
 #define WRITE_STATE(sc)

+#define MOV64(d, s)      (d = s)
+#define XOR64_IOTA       XOR64
+
+#define LPAR   (
+#define RPAR   )
+
+#define DO(x)   x
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define INPUT_BUF(size)   do { \
+    size_t j; \
+    for (j = 0; j < (size>>3); j++ ) \
+        kc->w[j ] = _mm512_xor_si512( kc->w[j], buf[j] ); \
+} while (0)
+
+// Targetted macros, keccak-macros.h is included for each target.
+
+#define DECL64(x)        __m512i x
+#define XOR64(d, a, b)   (d = _mm512_xor_si512(a,b))
+#define AND64(d, a, b)   (d = _mm512_and_si512(a,b))
+#define OR64(d, a, b)    (d = _mm512_or_si512(a,b))
+#define NOT64(d, s)      (d = _mm512_xor_si512(s,m512_neg1))
+#define ROL64(d, v, n)   (d = mm512_rol_64(v, n))
+
+#include "keccak-macros.c"
+
+#define KECCAK_F_1600   DO(KECCAK_F_1600_512)
+
+#define KECCAK_F_1600_512   do { \
+    int j; \
+    for (j = 0; j < 24; j += 8) \
+    { \
+       KF_ELT( 0,  1, _mm512_set1_epi64( RC[j + 0] ) ); \
+       KF_ELT( 1,  2, _mm512_set1_epi64( RC[j + 1] ) ); \
+       KF_ELT( 2,  3, _mm512_set1_epi64( RC[j + 2] ) ); \
+       KF_ELT( 3,  4, _mm512_set1_epi64( RC[j + 3] ) ); \
+       KF_ELT( 4,  5, _mm512_set1_epi64( RC[j + 4] ) ); \
+       KF_ELT( 5,  6, _mm512_set1_epi64( RC[j + 5] ) ); \
+       KF_ELT( 6,  7, _mm512_set1_epi64( RC[j + 6] ) ); \
+       KF_ELT( 7,  8, _mm512_set1_epi64( RC[j + 7] ) ); \
+       P8_TO_P0; \
+    } \
+} while (0)
+
+static void keccak64_8way_init( keccak64_ctx_m512i *kc, unsigned out_size )
+{
+   __m512i zero = m512_zero;
+   __m512i neg1 = m512_neg1;
+
+   // Initialization for the "lane complement".
+   kc->w[ 0] = zero;   kc->w[ 1] = neg1;
+   kc->w[ 2] = neg1;   kc->w[ 3] = zero;
+   kc->w[ 4] = zero;   kc->w[ 5] = zero;
+   kc->w[ 6] = zero;   kc->w[ 7] = zero;
+   kc->w[ 8] = neg1;   kc->w[ 9] = zero;
+   kc->w[10] = zero;   kc->w[11] = zero;
+   kc->w[12] = neg1;   kc->w[13] = zero;
+   kc->w[14] = zero;   kc->w[15] = zero;
+   kc->w[16] = zero;   kc->w[17] = neg1;
+   kc->w[18] = zero;   kc->w[19] = zero;
+   kc->w[20] = neg1;   kc->w[21] = zero;
+   kc->w[22] = zero;   kc->w[23] = zero;
+   kc->w[24] = zero;   kc->ptr = 0;
+   kc->lim = 200 - (out_size >> 2);
+}
+
+static void
+keccak64_8way_core( keccak64_ctx_m512i *kc, const void *data, size_t len,
+               size_t lim )
+{
+    __m512i *buf;
+    __m512i *vdata = (__m512i*)data;
+    size_t ptr;
+    DECL_STATE
+
+    buf = kc->buf;
+    ptr = kc->ptr;
+
+    if ( len < (lim - ptr) )
+    {
+        memcpy_512( buf + (ptr>>3), vdata, len>>3 );
+        kc->ptr = ptr + len;
+        return;
+    }
+    READ_STATE( kc );
+    while ( len > 0 )
+    {
+        size_t clen;
+
+        clen = (lim - ptr);
+        if ( clen > len )
+             clen = len;
+        memcpy_512( buf + (ptr>>3), vdata, clen>>3 );
+        ptr += clen;
+        vdata = vdata + (clen>>3);
+        len -= clen;
+        if ( ptr == lim )
+        {
+            INPUT_BUF( lim );
+            KECCAK_F_1600;
+            ptr = 0;
+        }
+    }
+    WRITE_STATE( kc );
+    kc->ptr = ptr;
+}
+
+static void keccak64_8way_close( keccak64_ctx_m512i *kc, void *dst,
+                                 size_t byte_len, size_t lim )
+{
+    unsigned eb;
+    union {
+       __m512i tmp[lim + 1];
+       sph_u64 dummy;   /* for alignment */
+    } u;
+    size_t j;
+    size_t m512_len = byte_len >> 3;
+
+    eb = 0x100  >> 8;
+    if ( kc->ptr == (lim - 8) )
+    {
+        const uint64_t t = eb | 0x8000000000000000;
+        u.tmp[0] = m512_const1_64( t );
+        j = 8;
+    }
+    else
+    {
+        j = lim - kc->ptr;
+        u.tmp[0] = m512_const1_64( eb );
+        memset_zero_512( u.tmp + 1, (j>>3) - 2 );
+        u.tmp[ (j>>3) - 1] = m512_const1_64( 0x8000000000000000 );
+    }
+    keccak64_8way_core( kc, u.tmp, j, lim );
+    /* Finalize the "lane complement" */
+    NOT64( kc->w[ 1], kc->w[ 1] );
+    NOT64( kc->w[ 2], kc->w[ 2] );
+    NOT64( kc->w[ 8], kc->w[ 8] );
+    NOT64( kc->w[12], kc->w[12] );
+    NOT64( kc->w[17], kc->w[17] );
+    NOT64( kc->w[20], kc->w[20] );
+    memcpy_512( dst, kc->w, m512_len );
+}
+
+void keccak256_8way_init( void *kc )
+{
+   keccak64_8way_init( kc, 256 );
+}
+
+void
+keccak256_8way_update(void *cc, const void *data, size_t len)
+{
+    keccak64_8way_core(cc, data, len, 136);
+}
+
+void
+keccak256_8way_close(void *cc, void *dst)
+{
+    keccak64_8way_close(cc, dst, 32, 136);
+}
+
+void keccak512_8way_init( void *kc )
+{
+   keccak64_8way_init( kc, 512 );
+}
+
+void
+keccak512_8way_update(void *cc, const void *data, size_t len)
+{
+        keccak64_8way_core(cc, data, len, 72);
+}
+
+void
+keccak512_8way_close(void *cc, void *dst)
+{
+        keccak64_8way_close(cc, dst, 64, 72);
+}
+
+#undef INPUT_BUF
+#undef DECL64
+#undef XOR64
+#undef AND64
+#undef OR64
+#undef NOT64
+#undef ROL64
+#undef KECCAK_F_1600
+
+#endif  // AVX512
+
+#if defined(__AVX2__)
+
 #define INPUT_BUF(size)   do { \
    size_t j; \
    for (j = 0; j < (size>>3); j++ ) \
@@ -55,314 +247,28 @@ static const sph_u64 RC[] = {
 } while (0)

 #define DECL64(x)        __m256i x
-#define MOV64(d, s)      (d = s)
 #define XOR64(d, a, b)   (d = _mm256_xor_si256(a,b))
 #define AND64(d, a, b)   (d = _mm256_and_si256(a,b))
 #define OR64(d, a, b)    (d = _mm256_or_si256(a,b))
 #define NOT64(d, s)      (d = _mm256_xor_si256(s,m256_neg1))
 #define ROL64(d, v, n)   (d = mm256_rol_64(v, n))
-#define XOR64_IOTA       XOR64

-#define TH_ELT(t, c0, c1, c2, c3, c4, d0, d1, d2, d3, d4)   do { \
-                DECL64(tt0); \
-                DECL64(tt1); \
-                DECL64(tt2); \
-                DECL64(tt3); \
-                XOR64(tt0, d0, d1); \
-                XOR64(tt1, d2, d3); \
-                XOR64(tt0, tt0, d4); \
-                XOR64(tt0, tt0, tt1); \
-                ROL64(tt0, tt0, 1); \
-                XOR64(tt2, c0, c1); \
-                XOR64(tt3, c2, c3); \
-                XOR64(tt0, tt0, c4); \
-                XOR64(tt2, tt2, tt3); \
-                XOR64(t, tt0, tt2); \
-        } while (0)
+#include "keccak-macros.c"

-#define THETA(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
-        b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
-        b40, b41, b42, b43, b44) \
-        do { \
-                DECL64(t0); \
-                DECL64(t1); \
-                DECL64(t2); \
-                DECL64(t3); \
-                DECL64(t4); \
-                TH_ELT(t0, b40, b41, b42, b43, b44, b10, b11, b12, b13, b14); \
-                TH_ELT(t1, b00, b01, b02, b03, b04, b20, b21, b22, b23, b24); \
-                TH_ELT(t2, b10, b11, b12, b13, b14, b30, b31, b32, b33, b34); \
-                TH_ELT(t3, b20, b21, b22, b23, b24, b40, b41, b42, b43, b44); \
-                TH_ELT(t4, b30, b31, b32, b33, b34, b00, b01, b02, b03, b04); \
-                XOR64(b00, b00, t0); \
-                XOR64(b01, b01, t0); \
-                XOR64(b02, b02, t0); \
-                XOR64(b03, b03, t0); \
-                XOR64(b04, b04, t0); \
-                XOR64(b10, b10, t1); \
-                XOR64(b11, b11, t1); \
-                XOR64(b12, b12, t1); \
-                XOR64(b13, b13, t1); \
-                XOR64(b14, b14, t1); \
-                XOR64(b20, b20, t2); \
-                XOR64(b21, b21, t2); \
-                XOR64(b22, b22, t2); \
-                XOR64(b23, b23, t2); \
-                XOR64(b24, b24, t2); \
-                XOR64(b30, b30, t3); \
-                XOR64(b31, b31, t3); \
-                XOR64(b32, b32, t3); \
-                XOR64(b33, b33, t3); \
-                XOR64(b34, b34, t3); \
-                XOR64(b40, b40, t4); \
-                XOR64(b41, b41, t4); \
-                XOR64(b42, b42, t4); \
-                XOR64(b43, b43, t4); \
-                XOR64(b44, b44, t4); \
-        } while (0)
+#define KECCAK_F_1600   DO(KECCAK_F_1600_256)

-#define RHO(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
-        b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
-        b40, b41, b42, b43, b44) \
-        do { \
-                /* ROL64(b00, b00,  0); */ \
-                ROL64(b01, b01, 36); \
-                ROL64(b02, b02,  3); \
-                ROL64(b03, b03, 41); \
-                ROL64(b04, b04, 18); \
-                ROL64(b10, b10,  1); \
-                ROL64(b11, b11, 44); \
-                ROL64(b12, b12, 10); \
-                ROL64(b13, b13, 45); \
-                ROL64(b14, b14,  2); \
-                ROL64(b20, b20, 62); \
-                ROL64(b21, b21,  6); \
-                ROL64(b22, b22, 43); \
-                ROL64(b23, b23, 15); \
-                ROL64(b24, b24, 61); \
-                ROL64(b30, b30, 28); \
-                ROL64(b31, b31, 55); \
-                ROL64(b32, b32, 25); \
-                ROL64(b33, b33, 21); \
-                ROL64(b34, b34, 56); \
-                ROL64(b40, b40, 27); \
-                ROL64(b41, b41, 20); \
-                ROL64(b42, b42, 39); \
-                ROL64(b43, b43,  8); \
-                ROL64(b44, b44, 14); \
-        } while (0)
-
-/*
- * The KHI macro integrates the "lane complement" optimization. On input,
- * some words are complemented:
- *    a00 a01 a02 a04 a13 a20 a21 a22 a30 a33 a34 a43
- * On output, the following words are complemented:
- *    a04 a10 a20 a22 a23 a31
- *
- * The (implicit) permutation and the theta expansion will bring back
- * the input mask for the next round.
- */
-
-#define KHI_XO(d, a, b, c)   do { \
-                DECL64(kt); \
-                OR64(kt, b, c); \
-                XOR64(d, a, kt); \
-        } while (0)
-
-#define KHI_XA(d, a, b, c)   do { \
-                DECL64(kt); \
-                AND64(kt, b, c); \
-                XOR64(d, a, kt); \
-        } while (0)
-
-#define KHI(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
-        b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
-        b40, b41, b42, b43, b44) \
-        do { \
-                DECL64(c0); \
-                DECL64(c1); \
-                DECL64(c2); \
-                DECL64(c3); \
-                DECL64(c4); \
-                DECL64(bnn); \
-                NOT64(bnn, b20); \
-                KHI_XO(c0, b00, b10, b20); \
-                KHI_XO(c1, b10, bnn, b30); \
-                KHI_XA(c2, b20, b30, b40); \
-                KHI_XO(c3, b30, b40, b00); \
-                KHI_XA(c4, b40, b00, b10); \
-                MOV64(b00, c0); \
-                MOV64(b10, c1); \
-                MOV64(b20, c2); \
-                MOV64(b30, c3); \
-                MOV64(b40, c4); \
-                NOT64(bnn, b41); \
-                KHI_XO(c0, b01, b11, b21); \
-                KHI_XA(c1, b11, b21, b31); \
-                KHI_XO(c2, b21, b31, bnn); \
-                KHI_XO(c3, b31, b41, b01); \
-                KHI_XA(c4, b41, b01, b11); \
-                MOV64(b01, c0); \
-                MOV64(b11, c1); \
-                MOV64(b21, c2); \
-                MOV64(b31, c3); \
-                MOV64(b41, c4); \
-                NOT64(bnn, b32); \
-                KHI_XO(c0, b02, b12, b22); \
-                KHI_XA(c1, b12, b22, b32); \
-                KHI_XA(c2, b22, bnn, b42); \
-                KHI_XO(c3, bnn, b42, b02); \
-                KHI_XA(c4, b42, b02, b12); \
-                MOV64(b02, c0); \
-                MOV64(b12, c1); \
-                MOV64(b22, c2); \
-                MOV64(b32, c3); \
-                MOV64(b42, c4); \
-                NOT64(bnn, b33); \
-                KHI_XA(c0, b03, b13, b23); \
-                KHI_XO(c1, b13, b23, b33); \
-                KHI_XO(c2, b23, bnn, b43); \
-                KHI_XA(c3, bnn, b43, b03); \
-                KHI_XO(c4, b43, b03, b13); \
-                MOV64(b03, c0); \
-                MOV64(b13, c1); \
-                MOV64(b23, c2); \
-                MOV64(b33, c3); \
-                MOV64(b43, c4); \
-                NOT64(bnn, b14); \
-                KHI_XA(c0, b04, bnn, b24); \
-                KHI_XO(c1, bnn, b24, b34); \
-                KHI_XA(c2, b24, b34, b44); \
-                KHI_XO(c3, b34, b44, b04); \
-                KHI_XA(c4, b44, b04, b14); \
-                MOV64(b04, c0); \
-                MOV64(b14, c1); \
-                MOV64(b24, c2); \
-                MOV64(b34, c3); \
-                MOV64(b44, c4); \
-        } while (0)
-
-#define IOTA(r)   XOR64_IOTA(a00, a00, r)
-
-#define P0    a00, a01, a02, a03, a04, a10, a11, a12, a13, a14, a20, a21, \
-              a22, a23, a24, a30, a31, a32, a33, a34, a40, a41, a42, a43, a44
-#define P1    a00, a30, a10, a40, a20, a11, a41, a21, a01, a31, a22, a02, \
-              a32, a12, a42, a33, a13, a43, a23, a03, a44, a24, a04, a34, a14
-#define P2    a00, a33, a11, a44, a22, a41, a24, a02, a30, a13, a32, a10, \
-              a43, a21, a04, a23, a01, a34, a12, a40, a14, a42, a20, a03, a31
-#define P3    a00, a23, a41, a14, a32, a24, a42, a10, a33, a01, a43, a11, \
-              a34, a02, a20, a12, a30, a03, a21, a44, a31, a04, a22, a40, a13
-#define P4    a00, a12, a24, a31, a43, a42, a04, a11, a23, a30, a34, a41, \
-              a03, a10, a22, a21, a33, a40, a02, a14, a13, a20, a32, a44, a01
-#define P5    a00, a21, a42, a13, a34, a04, a20, a41, a12, a33, a03, a24, \
-              a40, a11, a32, a02, a23, a44, a10, a31, a01, a22, a43, a14, a30
-#define P6    a00, a02, a04, a01, a03, a20, a22, a24, a21, a23, a40, a42, \
-              a44, a41, a43, a10, a12, a14, a11, a13, a30, a32, a34, a31, a33
-#define P7    a00, a10, a20, a30, a40, a22, a32, a42, a02, a12, a44, a04, \
-              a14, a24, a34, a11, a21, a31, a41, a01, a33, a43, a03, a13, a23
-#define P8    a00, a11, a22, a33, a44, a32, a43, a04, a10, a21, a14, a20, \
-              a31, a42, a03, a41, a02, a13, a24, a30, a23, a34, a40, a01, a12
-#define P9    a00, a41, a32, a23, a14, a43, a34, a20, a11, a02, a31, a22, \
-              a13, a04, a40, a24, a10, a01, a42, a33, a12, a03, a44, a30, a21
-#define P10   a00, a24, a43, a12, a31, a34, a03, a22, a41, a10, a13, a32, \
-              a01, a20, a44, a42, a11, a30, a04, a23, a21, a40, a14, a33, a02
-#define P11   a00, a42, a34, a21, a13, a03, a40, a32, a24, a11, a01, a43, \
-              a30, a22, a14, a04, a41, a33, a20, a12, a02, a44, a31, a23, a10
-#define P12   a00, a04, a03, a02, a01, a40, a44, a43, a42, a41, a30, a34, \
-              a33, a32, a31, a20, a24, a23, a22, a21, a10, a14, a13, a12, a11
-#define P13   a00, a20, a40, a10, a30, a44, a14, a34, a04, a24, a33, a03, \
-              a23, a43, a13, a22, a42, a12, a32, a02, a11, a31, a01, a21, a41
-#define P14   a00, a22, a44, a11, a33, a14, a31, a03, a20, a42, a23, a40, \
-              a12, a34, a01, a32, a04, a21, a43, a10, a41, a13, a30, a02, a24
-#define P15   a00, a32, a14, a41, a23, a31, a13, a40, a22, a04, a12, a44, \
-              a21, a03, a30, a43, a20, a02, a34, a11, a24, a01, a33, a10, a42
-#define P16   a00, a43, a31, a24, a12, a13, a01, a44, a32, a20, a21, a14, \
-              a02, a40, a33, a34, a22, a10, a03, a41, a42, a30, a23, a11, a04
-#define P17   a00, a34, a13, a42, a21, a01, a30, a14, a43, a22, a02, a31, \
-              a10, a44, a23, a03, a32, a11, a40, a24, a04, a33, a12, a41, a20
-#define P18   a00, a03, a01, a04, a02, a30, a33, a31, a34, a32, a10, a13, \
-              a11, a14, a12, a40, a43, a41, a44, a42, a20, a23, a21, a24, a22
-#define P19   a00, a40, a30, a20, a10, a33, a23, a13, a03, a43, a11, a01, \
-              a41, a31, a21, a44, a34, a24, a14, a04, a22, a12, a02, a42, a32
-#define P20   a00, a44, a33, a22, a11, a23, a12, a01, a40, a34, a41, a30, \
-              a24, a13, a02, a14, a03, a42, a31, a20, a32, a21, a10, a04, a43
-#define P21   a00, a14, a23, a32, a41, a12, a21, a30, a44, a03, a24, a33, \
-              a42, a01, a10, a31, a40, a04, a13, a22, a43, a02, a11, a20, a34
-#define P22   a00, a31, a12, a43, a24, a21, a02, a33, a14, a40, a42, a23, \
-              a04, a30, a11, a13, a44, a20, a01, a32, a34, a10, a41, a22, a03
-#define P23   a00, a13, a21, a34, a42, a02, a10, a23, a31, a44, a04, a12, \
-              a20, a33, a41, a01, a14, a22, a30, a43, a03, a11, a24, a32, a40
-
-#define P8_TO_P0   do { \
-                DECL64(t); \
-                MOV64(t, a01); \
-                MOV64(a01, a11); \
-                MOV64(a11, a43); \
-                MOV64(a43, t); \
-                MOV64(t, a02); \
-                MOV64(a02, a22); \
-                MOV64(a22, a31); \
-                MOV64(a31, t); \
-                MOV64(t, a03); \
-                MOV64(a03, a33); \
-                MOV64(a33, a24); \
-                MOV64(a24, t); \
-                MOV64(t, a04); \
-                MOV64(a04, a44); \
-                MOV64(a44, a12); \
-                MOV64(a12, t); \
-                MOV64(t, a10); \
-                MOV64(a10, a32); \
-                MOV64(a32, a13); \
-                MOV64(a13, t); \
-                MOV64(t, a14); \
-                MOV64(a14, a21); \
-                MOV64(a21, a20); \
-                MOV64(a20, t); \
-                MOV64(t, a23); \
-                MOV64(a23, a42); \
-                MOV64(a42, a40); \
-                MOV64(a40, t); \
-                MOV64(t, a30); \
-                MOV64(a30, a41); \
-                MOV64(a41, a34); \
-                MOV64(a34, t); \
-        } while (0)
-
-#define LPAR   (
-#define RPAR   )
-
-#define KF_ELT(r, s, k)   do { \
-                THETA LPAR P ## r RPAR; \
-                RHO LPAR P ## r RPAR; \
-                KHI LPAR P ## s RPAR; \
-                IOTA(k); \
-        } while (0)
-
-#define DO(x)   x
-
-#define KECCAK_F_1600   DO(KECCAK_F_1600_)
-
-#define KECCAK_F_1600_   do { \
+#define KECCAK_F_1600_256   do { \
    int j; \
    for (j = 0; j < 24; j += 8) \
    { \
-       KF_ELT( 0,  1, (_mm256_set_epi64x( RC[j + 0], RC[j + 0], \
-                                       RC[j + 0], RC[j + 0])) ); \
-       KF_ELT( 1,  2, (_mm256_set_epi64x( RC[j + 1], RC[j + 1], \
-                                       RC[j + 1], RC[j + 1])) ); \
-       KF_ELT( 2,  3, (_mm256_set_epi64x( RC[j + 2], RC[j + 2], \
-                                       RC[j + 2], RC[j + 2])) ); \
-       KF_ELT( 3,  4, (_mm256_set_epi64x( RC[j + 3], RC[j + 3], \
-                                       RC[j + 3], RC[j + 3])) ); \
-       KF_ELT( 4,  5, (_mm256_set_epi64x( RC[j + 4], RC[j + 4], \
-                                       RC[j + 4], RC[j + 4])) ); \
-       KF_ELT( 5,  6, (_mm256_set_epi64x( RC[j + 5], RC[j + 5], \
-                                       RC[j + 5], RC[j + 5])) ); \
-       KF_ELT( 6,  7, (_mm256_set_epi64x( RC[j + 6], RC[j + 6], \
-                                       RC[j + 6], RC[j + 6])) ); \
-       KF_ELT( 7,  8, (_mm256_set_epi64x( RC[j + 7], RC[j + 7], \
-                                       RC[j + 7], RC[j + 7])) ); \
+       KF_ELT( 0,  1, _mm256_set1_epi64x( RC[j + 0] ) ); \
+       KF_ELT( 1,  2, _mm256_set1_epi64x( RC[j + 1] ) ); \
+       KF_ELT( 2,  3, _mm256_set1_epi64x( RC[j + 2] ) ); \
+       KF_ELT( 3,  4, _mm256_set1_epi64x( RC[j + 3] ) ); \
+       KF_ELT( 4,  5, _mm256_set1_epi64x( RC[j + 4] ) ); \
+       KF_ELT( 5,  6, _mm256_set1_epi64x( RC[j + 5] ) ); \
+       KF_ELT( 6,  7, _mm256_set1_epi64x( RC[j + 6] ) ); \
+       KF_ELT( 7,  8, _mm256_set1_epi64x( RC[j + 7] ) ); \
       P8_TO_P0; \
    } \
 } while (0)
@@ -370,18 +276,23 @@ static const sph_u64 RC[] = {

 static void keccak64_init( keccak64_ctx_m256i *kc, unsigned out_size )
 {
-   int i;
-   for (i = 0; i < 25; i ++)
-          kc->w[i] = _mm256_setzero_si256();
+   __m256i zero = m256_zero;
+   __m256i neg1 = m256_neg1;

   // Initialization for the "lane complement".
-   kc->w[ 1] = m256_neg1;
-   kc->w[ 2] = m256_neg1;
-   kc->w[ 8] = m256_neg1;
-   kc->w[12] = m256_neg1;
-   kc->w[17] = m256_neg1;
-   kc->w[20] = m256_neg1;
-   kc->ptr = 0;
+   kc->w[ 0] = zero;   kc->w[ 1] = neg1;
+   kc->w[ 2] = neg1;   kc->w[ 3] = zero;
+   kc->w[ 4] = zero;   kc->w[ 5] = zero;
+   kc->w[ 6] = zero;   kc->w[ 7] = zero;
+   kc->w[ 8] = neg1;   kc->w[ 9] = zero;
+   kc->w[10] = zero;   kc->w[11] = zero;
+   kc->w[12] = neg1;   kc->w[13] = zero;
+   kc->w[14] = zero;   kc->w[15] = zero;
+   kc->w[16] = zero;   kc->w[17] = neg1;
+   kc->w[18] = zero;   kc->w[19] = zero;
+   kc->w[20] = neg1;   kc->w[21] = zero;
+   kc->w[22] = zero;   kc->w[23] = zero;
+   kc->w[24] = zero;   kc->ptr = 0;
   kc->lim = 200 - (out_size >> 2);
 }

@@ -441,17 +352,16 @@ static void keccak64_close( keccak64_ctx_m256i *kc, void *dst, size_t byte_len,
    eb = 0x100  >> 8;
    if ( kc->ptr == (lim - 8) )
    {
-        uint64_t t = eb | 0x8000000000000000;
-        u.tmp[0] = _mm256_set_epi64x( t, t, t, t );
+        const uint64_t t = eb | 0x8000000000000000;
+        u.tmp[0] = m256_const1_64( t );
        j = 8;
    }
    else
    {
        j = lim - kc->ptr;
-        u.tmp[0] = _mm256_set_epi64x( eb, eb, eb, eb );
+        u.tmp[0] = m256_const1_64( eb );
        memset_zero_256( u.tmp + 1, (j>>3) - 2 );
-        u.tmp[ (j>>3) - 1] = _mm256_set_epi64x( 0x8000000000000000,
-                0x8000000000000000, 0x8000000000000000, 0x8000000000000000);
+        u.tmp[ (j>>3) - 1] = m256_const1_64( 0x8000000000000000 );
    }
    keccak64_core( kc, u.tmp, j, lim );
    /* Finalize the "lane complement" */
@@ -461,9 +371,7 @@ static void keccak64_close( keccak64_ctx_m256i *kc, void *dst, size_t byte_len,
    NOT64( kc->w[12], kc->w[12] );
    NOT64( kc->w[17], kc->w[17] );
    NOT64( kc->w[20], kc->w[20] );
-    for ( j = 0; j < m256_len; j++ )
-         u.tmp[j] =  kc->w[j]; 
-    memcpy_256( dst, u.tmp, m256_len );
+    memcpy_256( dst, kc->w, m256_len );
 }

 void keccak256_4way_init( void *kc )
@@ -472,7 +380,7 @@ void keccak256_4way_init( void *kc )
 }

 void
-keccak256_4way(void *cc, const void *data, size_t len)
+keccak256_4way_update(void *cc, const void *data, size_t len)
 {
    keccak64_core(cc, data, len, 136);
 }
@@ -489,15 +397,24 @@ void keccak512_4way_init( void *kc )
 }

 void
-keccak512_4way(void *cc, const void *data, size_t len)
+keccak512_4way_update(void *cc, const void *data, size_t len)
 {
-        keccak64_core(cc, data, len, 72);
+   keccak64_core(cc, data, len, 72);
 }

 void
 keccak512_4way_close(void *cc, void *dst)
 {
-        keccak64_close(cc, dst, 64, 72);
+   keccak64_close(cc, dst, 64, 72);
 }

-#endif
+#undef INPUT_BUF
+#undef DECL64
+#undef XOR64
+#undef AND64
+#undef OR64
+#undef NOT64
+#undef ROL64
+#undef KECCAK_F_1600
+
+#endif  // AVX2
--- a/algo/keccak/keccak-hash-4way.h
+++ b/algo/keccak/keccak-hash-4way.h
@@ -64,26 +64,49 @@ extern "C"{
 * <code>memcpy()</code>).
 */

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
 typedef struct {
-        __m256i buf[144*8];    /* first field, for alignment */
+        __m512i buf[144*8];
+        __m512i w[25];
+        size_t ptr, lim;
+} keccak64_ctx_m512i __attribute__((aligned(128)));
+
+typedef keccak64_ctx_m512i keccak256_8way_context;
+typedef keccak64_ctx_m512i keccak512_8way_context;
+
+void keccak256_8way_init(void *cc);
+void keccak256_8way_update(void *cc, const void *data, size_t len);
+void keccak256_8way_close(void *cc, void *dst);
+
+void keccak512_8way_init(void *cc);
+void keccak512_8way_update(void *cc, const void *data, size_t len);
+void keccak512_8way_close(void *cc, void *dst);
+void keccak512_8way_addbits_and_close(
+        void *cc, unsigned ub, unsigned n, void *dst);
+
+#endif   
+
+typedef struct {
+        __m256i buf[144*8];  
        __m256i w[25];
        size_t ptr, lim;
-//        sph_u64 wide[25];
-} keccak64_ctx_m256i;
+} keccak64_ctx_m256i __attribute__((aligned(128)));

 typedef keccak64_ctx_m256i keccak256_4way_context;
 typedef keccak64_ctx_m256i keccak512_4way_context;

 void keccak256_4way_init(void *cc);
-void keccak256_4way(void *cc, const void *data, size_t len);
+void keccak256_4way_update(void *cc, const void *data, size_t len);
 void keccak256_4way_close(void *cc, void *dst);
-
+#define keccak256_4way keccak256_4way_update

 void keccak512_4way_init(void *cc);
-void keccak512_4way(void *cc, const void *data, size_t len);
+void keccak512_4way_update(void *cc, const void *data, size_t len);
 void keccak512_4way_close(void *cc, void *dst);
 void keccak512_4way_addbits_and_close(
        void *cc, unsigned ub, unsigned n, void *dst);
+#define keccak512_4way keccak512_4way_update

 #endif

--- a/algo/keccak/keccak-macros.c
+++ b/algo/keccak/keccak-macros.c
@@ -0,0 +1,324 @@
+#ifdef TH_ELT
+#undef TH_ELT
+#endif
+#define TH_ELT(t, c0, c1, c2, c3, c4, d0, d1, d2, d3, d4)   do { \
+                DECL64(tt0); \
+                DECL64(tt1); \
+                DECL64(tt2); \
+                DECL64(tt3); \
+                XOR64(tt0, d0, d1); \
+                XOR64(tt1, d2, d3); \
+                XOR64(tt0, tt0, d4); \
+                XOR64(tt0, tt0, tt1); \
+                ROL64(tt0, tt0, 1); \
+                XOR64(tt2, c0, c1); \
+                XOR64(tt3, c2, c3); \
+                XOR64(tt0, tt0, c4); \
+                XOR64(tt2, tt2, tt3); \
+                XOR64(t, tt0, tt2); \
+        } while (0)
+
+#ifdef THETA
+#undef THETA
+#endif
+#define THETA(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
+        b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
+        b40, b41, b42, b43, b44) \
+        do { \
+                DECL64(t0); \
+                DECL64(t1); \
+                DECL64(t2); \
+                DECL64(t3); \
+                DECL64(t4); \
+                TH_ELT(t0, b40, b41, b42, b43, b44, b10, b11, b12, b13, b14); \
+                TH_ELT(t1, b00, b01, b02, b03, b04, b20, b21, b22, b23, b24); \
+                TH_ELT(t2, b10, b11, b12, b13, b14, b30, b31, b32, b33, b34); \
+                TH_ELT(t3, b20, b21, b22, b23, b24, b40, b41, b42, b43, b44); \
+                TH_ELT(t4, b30, b31, b32, b33, b34, b00, b01, b02, b03, b04); \
+                XOR64(b00, b00, t0); \
+                XOR64(b01, b01, t0); \
+                XOR64(b02, b02, t0); \
+                XOR64(b03, b03, t0); \
+                XOR64(b04, b04, t0); \
+                XOR64(b10, b10, t1); \
+                XOR64(b11, b11, t1); \
+                XOR64(b12, b12, t1); \
+                XOR64(b13, b13, t1); \
+                XOR64(b14, b14, t1); \
+                XOR64(b20, b20, t2); \
+                XOR64(b21, b21, t2); \
+                XOR64(b22, b22, t2); \
+                XOR64(b23, b23, t2); \
+                XOR64(b24, b24, t2); \
+                XOR64(b30, b30, t3); \
+                XOR64(b31, b31, t3); \
+                XOR64(b32, b32, t3); \
+                XOR64(b33, b33, t3); \
+                XOR64(b34, b34, t3); \
+                XOR64(b40, b40, t4); \
+                XOR64(b41, b41, t4); \
+                XOR64(b42, b42, t4); \
+                XOR64(b43, b43, t4); \
+                XOR64(b44, b44, t4); \
+        } while (0)
+
+#ifdef RHO
+#undef RHO
+#endif
+#define RHO(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
+        b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
+        b40, b41, b42, b43, b44) \
+        do { \
+                /* ROL64(b00, b00,  0); */ \
+                ROL64(b01, b01, 36); \
+                ROL64(b02, b02,  3); \
+                ROL64(b03, b03, 41); \
+                ROL64(b04, b04, 18); \
+                ROL64(b10, b10,  1); \
+                ROL64(b11, b11, 44); \
+                ROL64(b12, b12, 10); \
+                ROL64(b13, b13, 45); \
+                ROL64(b14, b14,  2); \
+                ROL64(b20, b20, 62); \
+                ROL64(b21, b21,  6); \
+                ROL64(b22, b22, 43); \
+                ROL64(b23, b23, 15); \
+                ROL64(b24, b24, 61); \
+                ROL64(b30, b30, 28); \
+                ROL64(b31, b31, 55); \
+                ROL64(b32, b32, 25); \
+                ROL64(b33, b33, 21); \
+                ROL64(b34, b34, 56); \
+                ROL64(b40, b40, 27); \
+                ROL64(b41, b41, 20); \
+                ROL64(b42, b42, 39); \
+                ROL64(b43, b43,  8); \
+                ROL64(b44, b44, 14); \
+        } while (0)
+
+/*
+ * The KHI macro integrates the "lane complement" optimization. On input,
+ * some words are complemented:
+ *    a00 a01 a02 a04 a13 a20 a21 a22 a30 a33 a34 a43
+ * On output, the following words are complemented:
+ *    a04 a10 a20 a22 a23 a31
+ *
+ * The (implicit) permutation and the theta expansion will bring back
+ * the input mask for the next round.
+ */
+
+#ifdef KHI_XO
+#undef KHI_XO
+#endif
+#define KHI_XO(d, a, b, c)   do { \
+                DECL64(kt); \
+                OR64(kt, b, c); \
+                XOR64(d, a, kt); \
+        } while (0)
+
+#ifdef KHI_XA
+#undef KHI_XA
+#endif
+#define KHI_XA(d, a, b, c)   do { \
+                DECL64(kt); \
+                AND64(kt, b, c); \
+                XOR64(d, a, kt); \
+        } while (0)
+
+#ifdef KHI
+#undef KHI
+#endif
+#define KHI(b00, b01, b02, b03, b04, b10, b11, b12, b13, b14, \
+        b20, b21, b22, b23, b24, b30, b31, b32, b33, b34, \
+        b40, b41, b42, b43, b44) \
+        do { \
+                DECL64(c0); \
+                DECL64(c1); \
+                DECL64(c2); \
+                DECL64(c3); \
+                DECL64(c4); \
+                DECL64(bnn); \
+                NOT64(bnn, b20); \
+                KHI_XO(c0, b00, b10, b20); \
+                KHI_XO(c1, b10, bnn, b30); \
+                KHI_XA(c2, b20, b30, b40); \
+                KHI_XO(c3, b30, b40, b00); \
+                KHI_XA(c4, b40, b00, b10); \
+                MOV64(b00, c0); \
+                MOV64(b10, c1); \
+                MOV64(b20, c2); \
+                MOV64(b30, c3); \
+                MOV64(b40, c4); \
+                NOT64(bnn, b41); \
+                KHI_XO(c0, b01, b11, b21); \
+                KHI_XA(c1, b11, b21, b31); \
+                KHI_XO(c2, b21, b31, bnn); \
+                KHI_XO(c3, b31, b41, b01); \
+                KHI_XA(c4, b41, b01, b11); \
+                MOV64(b01, c0); \
+                MOV64(b11, c1); \
+                MOV64(b21, c2); \
+                MOV64(b31, c3); \
+                MOV64(b41, c4); \
+                NOT64(bnn, b32); \
+                KHI_XO(c0, b02, b12, b22); \
+                KHI_XA(c1, b12, b22, b32); \
+                KHI_XA(c2, b22, bnn, b42); \
+                KHI_XO(c3, bnn, b42, b02); \
+                KHI_XA(c4, b42, b02, b12); \
+                MOV64(b02, c0); \
+                MOV64(b12, c1); \
+                MOV64(b22, c2); \
+                MOV64(b32, c3); \
+                MOV64(b42, c4); \
+                NOT64(bnn, b33); \
+                KHI_XA(c0, b03, b13, b23); \
+                KHI_XO(c1, b13, b23, b33); \
+                KHI_XO(c2, b23, bnn, b43); \
+                KHI_XA(c3, bnn, b43, b03); \
+                KHI_XO(c4, b43, b03, b13); \
+                MOV64(b03, c0); \
+                MOV64(b13, c1); \
+                MOV64(b23, c2); \
+                MOV64(b33, c3); \
+                MOV64(b43, c4); \
+                NOT64(bnn, b14); \
+                KHI_XA(c0, b04, bnn, b24); \
+                KHI_XO(c1, bnn, b24, b34); \
+                KHI_XA(c2, b24, b34, b44); \
+                KHI_XO(c3, b34, b44, b04); \
+                KHI_XA(c4, b44, b04, b14); \
+                MOV64(b04, c0); \
+                MOV64(b14, c1); \
+                MOV64(b24, c2); \
+                MOV64(b34, c3); \
+                MOV64(b44, c4); \
+        } while (0)
+
+#ifdef IOTA
+#undef IOTA
+#endif
+#define IOTA(r)   XOR64_IOTA(a00, a00, r)
+
+#ifdef P0
+#undef P1
+#undef P2
+#undef P3
+#undef P4
+#undef P5
+#undef P6
+#undef P7
+#undef P8
+#undef P9
+#undef P10
+#undef p11
+#undef P12
+#undef P13
+#undef P14
+#undef P15
+#undef P16
+#undef P17
+#undef P18
+#undef P19
+#undef P20
+#undef P21
+#undef P22
+#undef P23
+#endif
+
+#define P0    a00, a01, a02, a03, a04, a10, a11, a12, a13, a14, a20, a21, \
+              a22, a23, a24, a30, a31, a32, a33, a34, a40, a41, a42, a43, a44
+#define P1    a00, a30, a10, a40, a20, a11, a41, a21, a01, a31, a22, a02, \
+              a32, a12, a42, a33, a13, a43, a23, a03, a44, a24, a04, a34, a14
+#define P2    a00, a33, a11, a44, a22, a41, a24, a02, a30, a13, a32, a10, \
+              a43, a21, a04, a23, a01, a34, a12, a40, a14, a42, a20, a03, a31
+#define P3    a00, a23, a41, a14, a32, a24, a42, a10, a33, a01, a43, a11, \
+              a34, a02, a20, a12, a30, a03, a21, a44, a31, a04, a22, a40, a13
+#define P4    a00, a12, a24, a31, a43, a42, a04, a11, a23, a30, a34, a41, \
+              a03, a10, a22, a21, a33, a40, a02, a14, a13, a20, a32, a44, a01
+#define P5    a00, a21, a42, a13, a34, a04, a20, a41, a12, a33, a03, a24, \
+              a40, a11, a32, a02, a23, a44, a10, a31, a01, a22, a43, a14, a30
+#define P6    a00, a02, a04, a01, a03, a20, a22, a24, a21, a23, a40, a42, \
+              a44, a41, a43, a10, a12, a14, a11, a13, a30, a32, a34, a31, a33
+#define P7    a00, a10, a20, a30, a40, a22, a32, a42, a02, a12, a44, a04, \
+              a14, a24, a34, a11, a21, a31, a41, a01, a33, a43, a03, a13, a23
+#define P8    a00, a11, a22, a33, a44, a32, a43, a04, a10, a21, a14, a20, \
+              a31, a42, a03, a41, a02, a13, a24, a30, a23, a34, a40, a01, a12
+#define P9    a00, a41, a32, a23, a14, a43, a34, a20, a11, a02, a31, a22, \
+              a13, a04, a40, a24, a10, a01, a42, a33, a12, a03, a44, a30, a21
+#define P10   a00, a24, a43, a12, a31, a34, a03, a22, a41, a10, a13, a32, \
+              a01, a20, a44, a42, a11, a30, a04, a23, a21, a40, a14, a33, a02
+#define P11   a00, a42, a34, a21, a13, a03, a40, a32, a24, a11, a01, a43, \
+              a30, a22, a14, a04, a41, a33, a20, a12, a02, a44, a31, a23, a10
+#define P12   a00, a04, a03, a02, a01, a40, a44, a43, a42, a41, a30, a34, \
+              a33, a32, a31, a20, a24, a23, a22, a21, a10, a14, a13, a12, a11
+#define P13   a00, a20, a40, a10, a30, a44, a14, a34, a04, a24, a33, a03, \
+              a23, a43, a13, a22, a42, a12, a32, a02, a11, a31, a01, a21, a41
+#define P14   a00, a22, a44, a11, a33, a14, a31, a03, a20, a42, a23, a40, \
+              a12, a34, a01, a32, a04, a21, a43, a10, a41, a13, a30, a02, a24
+#define P15   a00, a32, a14, a41, a23, a31, a13, a40, a22, a04, a12, a44, \
+              a21, a03, a30, a43, a20, a02, a34, a11, a24, a01, a33, a10, a42
+#define P16   a00, a43, a31, a24, a12, a13, a01, a44, a32, a20, a21, a14, \
+              a02, a40, a33, a34, a22, a10, a03, a41, a42, a30, a23, a11, a04
+#define P17   a00, a34, a13, a42, a21, a01, a30, a14, a43, a22, a02, a31, \
+              a10, a44, a23, a03, a32, a11, a40, a24, a04, a33, a12, a41, a20
+#define P18   a00, a03, a01, a04, a02, a30, a33, a31, a34, a32, a10, a13, \
+              a11, a14, a12, a40, a43, a41, a44, a42, a20, a23, a21, a24, a22
+#define P19   a00, a40, a30, a20, a10, a33, a23, a13, a03, a43, a11, a01, \
+              a41, a31, a21, a44, a34, a24, a14, a04, a22, a12, a02, a42, a32
+#define P20   a00, a44, a33, a22, a11, a23, a12, a01, a40, a34, a41, a30, \
+              a24, a13, a02, a14, a03, a42, a31, a20, a32, a21, a10, a04, a43
+#define P21   a00, a14, a23, a32, a41, a12, a21, a30, a44, a03, a24, a33, \
+              a42, a01, a10, a31, a40, a04, a13, a22, a43, a02, a11, a20, a34
+#define P22   a00, a31, a12, a43, a24, a21, a02, a33, a14, a40, a42, a23, \
+              a04, a30, a11, a13, a44, a20, a01, a32, a34, a10, a41, a22, a03
+#define P23   a00, a13, a21, a34, a42, a02, a10, a23, a31, a44, a04, a12, \
+              a20, a33, a41, a01, a14, a22, a30, a43, a03, a11, a24, a32, a40
+
+#ifdef P8_TO_P0
+#undef P8_TO_P0
+#endif
+#define P8_TO_P0   do { \
+                DECL64(t); \
+                MOV64(t, a01); \
+                MOV64(a01, a11); \
+                MOV64(a11, a43); \
+                MOV64(a43, t); \
+                MOV64(t, a02); \
+                MOV64(a02, a22); \
+                MOV64(a22, a31); \
+                MOV64(a31, t); \
+                MOV64(t, a03); \
+                MOV64(a03, a33); \
+                MOV64(a33, a24); \
+                MOV64(a24, t); \
+                MOV64(t, a04); \
+                MOV64(a04, a44); \
+                MOV64(a44, a12); \
+                MOV64(a12, t); \
+                MOV64(t, a10); \
+                MOV64(a10, a32); \
+                MOV64(a32, a13); \
+                MOV64(a13, t); \
+                MOV64(t, a14); \
+                MOV64(a14, a21); \
+                MOV64(a21, a20); \
+                MOV64(a20, t); \
+                MOV64(t, a23); \
+                MOV64(a23, a42); \
+                MOV64(a42, a40); \
+                MOV64(a40, t); \
+                MOV64(t, a30); \
+                MOV64(a30, a41); \
+                MOV64(a41, a34); \
+                MOV64(a34, t); \
+        } while (0)
+
+#define KF_ELT(r, s, k)   do { \
+                THETA LPAR P ## r RPAR; \
+                RHO LPAR P ## r RPAR; \
+                KHI LPAR P ## s RPAR; \
+                IOTA(k); \
+        } while (0)
+
+
--- a/algo/lanehash/lane.c
+++ b/algo/lanehash/lane.c
--- a/algo/lanehash/lane.h
+++ b/algo/lanehash/lane.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2008 Sebastiaan Indesteege
+ *                              <sebastiaan.indesteege@esat.kuleuven.be>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Optimised ANSI-C implementation of LANE
+ */
+
+#ifndef LANE_H
+#define LANE_H
+
+#include <string.h>
+//#include "algo/sha/sha3-defs.h"
+#include <stdint.h>
+
+typedef unsigned char BitSequence;
+typedef unsigned long long DataLength;
+
+//typedef enum { SUCCESS = 0, FAIL = 1, BAD_HASHBITLEN = 2, BAD_DATABITLEN = 3 } HashReturn;
+
+//typedef unsigned char u8;
+//typedef unsigned int u32;
+//typedef unsigned long long u64;
+
+typedef struct {
+  int hashbitlen;
+  uint64_t ctr;
+  uint32_t h[16];
+  uint8_t buffer[128];
+} hashState;
+
+void laneInit (hashState *state, int hashbitlen);
+void laneUpdate (hashState *state, const BitSequence *data, DataLength databitlen);
+void laneFinal (hashState *state, BitSequence *hashval);
+void laneHash (int hashbitlen, const BitSequence *data, DataLength databitlen, BitSequence *hashval);
+
+#endif /* LANE_H */
--- a/algo/luffa/luffa-hash-2way.c
+++ b/algo/luffa/luffa-hash-2way.c
--- a/algo/luffa/luffa-hash-2way.h
+++ b/algo/luffa/luffa-hash-2way.h
@@ -51,12 +51,30 @@
 #define LIMIT_512 128
 /*********************************/

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
 typedef struct {
-    uint32 buffer[8*2] __attribute((aligned(64)));
-    __m256i chainv[10] __attribute((aligned(32)));   /* Chaining values */
+    uint32 buffer[8*4];
+    __m512i chainv[10];   /* Chaining values */
    int hashbitlen;
    int rembytes;
-} luffa_2way_context;
+} luffa_4way_context __attribute((aligned(128)));
+
+int luffa_4way_init( luffa_4way_context *state, int hashbitlen );
+int luffa_4way_update( luffa_4way_context *state, const void *data,
+                       size_t len );
+int luffa_4way_close( luffa_4way_context *state, void *hashval );
+int luffa_4way_update_close( luffa_4way_context *state, void *output,
+                                   const void *data, size_t inlen );
+
+#endif
+
+typedef struct {
+    uint32 buffer[8*2];
+    __m256i chainv[10];   /* Chaining values */
+    int hashbitlen;
+    int rembytes;
+} luffa_2way_context __attribute((aligned(128)));

 int luffa_2way_init( luffa_2way_context *state, int hashbitlen );
 int luffa_2way_update( luffa_2way_context *state, const void *data,
--- a/algo/luffa/luffa_for_sse2.c
+++ b/algo/luffa/luffa_for_sse2.c
@@ -541,7 +541,11 @@ static void finalization512( hashState_luffa *state, uint32 *b )
    uint32   hash[8] __attribute((aligned(64)));
    __m256i* chainv = (__m256i*)state->chainv;
    __m256i  t;
-    const __m128i zero = _mm_setzero_si128();
+    const __m128i zero = m128_zero;
+    const __m256i shuff_bswap32 = m256_const_64( 0x1c1d1e1f18191a1b,
+                                                 0x1415161710111213,
+                                                 0x0c0d0e0f08090a0b,
+                                                 0x0405060700010203 );

    rnd512( state, zero, zero );

@@ -555,7 +559,9 @@ static void finalization512( hashState_luffa *state, uint32 *b )

    _mm256_store_si256( (__m256i*)hash, t );

-    casti_m256i( b, 0 ) = mm256_bswap_32( casti_m256i( hash, 0 ) );
+    casti_m256i( b, 0 ) = _mm256_shuffle_epi8(
+                                 casti_m256i( hash, 0 ), shuff_bswap32 );
+//    casti_m256i( b, 0 ) = mm256_bswap_32( casti_m256i( hash, 0 ) );

    rnd512( state, zero, zero );

@@ -568,7 +574,9 @@ static void finalization512( hashState_luffa *state, uint32 *b )

    _mm256_store_si256( (__m256i*)hash, t );

-    casti_m256i( b, 1 ) = mm256_bswap_32( casti_m256i( hash, 0 ) );
+    casti_m256i( b, 1 ) = _mm256_shuffle_epi8( 
+                                 casti_m256i( hash, 0 ), shuff_bswap32 );
+//    casti_m256i( b, 1 ) = mm256_bswap_32( casti_m256i( hash, 0 ) );
 }

 #else
--- a/algo/luffa/sph_luffa.c
+++ b/algo/luffa/sph_luffa.c
@@ -77,6 +77,24 @@ static const sph_u32 V_INIT[5][8] = {
 	}
 };

+#if SPH_LUFFA_PARALLEL
+
+static const sph_u64 RCW010[8] = {
+   SPH_C64(0xb6de10ed303994a6), SPH_C64(0x70f47aaec0e65299),
+   SPH_C64(0x0707a3d46cc33a12), SPH_C64(0x1c1e8f51dc56983e),
+   SPH_C64(0x707a3d451e00108f), SPH_C64(0xaeb285627800423d),
+   SPH_C64(0xbaca15898f5b7882), SPH_C64(0x40a46f3e96e1db12)
+};
+
+static const sph_u64 RCW014[8] = {
+   SPH_C64(0x01685f3de0337818), SPH_C64(0x05a17cf4441ba90d),
+   SPH_C64(0xbd09caca7f34d442), SPH_C64(0xf4272b289389217f),
+   SPH_C64(0x144ae5cce5a8bce6), SPH_C64(0xfaa7ae2b5274baf4),
+   SPH_C64(0x2e48f1c126889ba7), SPH_C64(0xb923c7049a226e9d)
+};
+
+#else
+
 static const sph_u32 RC00[8] = {
 	SPH_C32(0x303994a6), SPH_C32(0xc0e65299),
 	SPH_C32(0x6cc33a12), SPH_C32(0xdc56983e),
@@ -105,20 +123,18 @@ static const sph_u32 RC14[8] = {
 	SPH_C32(0x2e48f1c1), SPH_C32(0xb923c704)
 };

-#if SPH_LUFFA_PARALLEL
-
-static const sph_u64 RCW010[8] = {
-	SPH_C64(0xb6de10ed303994a6), SPH_C64(0x70f47aaec0e65299),
-	SPH_C64(0x0707a3d46cc33a12), SPH_C64(0x1c1e8f51dc56983e),
-	SPH_C64(0x707a3d451e00108f), SPH_C64(0xaeb285627800423d),
-	SPH_C64(0xbaca15898f5b7882), SPH_C64(0x40a46f3e96e1db12)
+static const sph_u32 RC30[8] = {
+   SPH_C32(0xb213afa5), SPH_C32(0xc84ebe95),
+   SPH_C32(0x4e608a22), SPH_C32(0x56d858fe),
+   SPH_C32(0x343b138f), SPH_C32(0xd0ec4e3d),
+   SPH_C32(0x2ceb4882), SPH_C32(0xb3ad2208)
 };

-static const sph_u64 RCW014[8] = {
-	SPH_C64(0x01685f3de0337818), SPH_C64(0x05a17cf4441ba90d),
-	SPH_C64(0xbd09caca7f34d442), SPH_C64(0xf4272b289389217f),
-	SPH_C64(0x144ae5cce5a8bce6), SPH_C64(0xfaa7ae2b5274baf4),
-	SPH_C64(0x2e48f1c126889ba7), SPH_C64(0xb923c7049a226e9d)
+static const sph_u32 RC34[8] = {
+   SPH_C32(0xe028c9bf), SPH_C32(0x44756f91),
+   SPH_C32(0x7e8fce32), SPH_C32(0x956548be),
+   SPH_C32(0xfe191be2), SPH_C32(0x3cb226e5),
+   SPH_C32(0x5944a28e), SPH_C32(0xa1c4c355)
 };

 #endif
@@ -137,19 +153,6 @@ static const sph_u32 RC24[8] = {
 	SPH_C32(0x36eda57f), SPH_C32(0x703aace7)
 };

-static const sph_u32 RC30[8] = {
-	SPH_C32(0xb213afa5), SPH_C32(0xc84ebe95),
-	SPH_C32(0x4e608a22), SPH_C32(0x56d858fe),
-	SPH_C32(0x343b138f), SPH_C32(0xd0ec4e3d),
-	SPH_C32(0x2ceb4882), SPH_C32(0xb3ad2208)
-};
-
-static const sph_u32 RC34[8] = {
-	SPH_C32(0xe028c9bf), SPH_C32(0x44756f91),
-	SPH_C32(0x7e8fce32), SPH_C32(0x956548be),
-	SPH_C32(0xfe191be2), SPH_C32(0x3cb226e5),
-	SPH_C32(0x5944a28e), SPH_C32(0xa1c4c355)
-};

 #if SPH_LUFFA_PARALLEL

--- a/algo/lyra2/allium-4way.c
+++ b/algo/lyra2/allium-4way.c
@@ -44,11 +44,11 @@ void allium_4way_hash( void *state, const void *input )
   blake256_4way( &ctx.blake, input + (64<<2), 16 );
   blake256_4way_close( &ctx.blake, vhash32 );

-   mm256_rintrlv_4x32_4x64( vhash64, vhash32, 256 );
+   rintrlv_4x32_4x64( vhash64, vhash32, 256 );
   keccak256_4way( &ctx.keccak, vhash64, 32 );
   keccak256_4way_close( &ctx.keccak, vhash64 );

-   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
+   dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );

   LYRA2RE( hash0, 32, hash0, 32, hash0, 32, 1, 8, 8 );
   LYRA2RE( hash1, 32, hash1, 32, hash1, 32, 1, 8, 8 );
@@ -68,12 +68,12 @@ void allium_4way_hash( void *state, const void *input )
   LYRA2RE( hash2, 32, hash2, 32, hash2, 32, 1, 8, 8 );
   LYRA2RE( hash3, 32, hash3, 32, hash3, 32, 1, 8, 8 );

-   mm256_intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
+   intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );

   skein256_4way( &ctx.skein, vhash64, 32 );
   skein256_4way_close( &ctx.skein, vhash64 );

-   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
+   dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );

   update_and_final_groestl256( &ctx.groestl, state, hash0, 256 );
   memcpy( &ctx.groestl, &allium_4way_ctx.groestl,
@@ -103,7 +103,7 @@ int scanhash_allium_4way( struct work *work, uint32_t max_nonce,
   if ( opt_benchmark )
      ( (uint32_t*)ptarget )[7] = 0x0000ff;

-   mm128_bswap_intrlv80_4x32( vdata, pdata );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
   blake256_4way_init( &allium_4way_ctx.blake );
   blake256_4way( &allium_4way_ctx.blake, vdata, 64 );

--- a/algo/lyra2/lyra2-gate.c
+++ b/algo/lyra2/lyra2-gate.c
@@ -44,8 +44,13 @@ bool lyra2rev3_thread_init()
 {
   const int64_t ROW_LEN_INT64 = BLOCK_LEN_INT64 * 4; // nCols
   const int64_t ROW_LEN_BYTES = ROW_LEN_INT64 * 8;
+   int size = ROW_LEN_BYTES * 4; // nRows;

-   int size = (int64_t)ROW_LEN_BYTES * 4; // nRows;
+#if defined(LYRA2REV3_16WAY)
+//   l2v3_wholeMatrix = _mm_malloc( 2*size, 128 );
+   l2v3_wholeMatrix = _mm_malloc( 2*size, 64 );
+   init_lyra2rev3_16way_ctx();;
+#else
   l2v3_wholeMatrix = _mm_malloc( size, 64 );
 #if defined (LYRA2REV3_8WAY)
   init_lyra2rev3_8way_ctx();;
@@ -53,13 +58,17 @@ bool lyra2rev3_thread_init()
   init_lyra2rev3_4way_ctx();;
 #else
   init_lyra2rev3_ctx();
+#endif
 #endif
   return l2v3_wholeMatrix;
 }

 bool register_lyra2rev3_algo( algo_gate_t* gate )
 {
-#if defined (LYRA2REV3_8WAY)
+#if defined(LYRA2REV3_16WAY)
+  gate->scanhash  = (void*)&scanhash_lyra2rev3_16way;
+  gate->hash      = (void*)&lyra2rev3_16way_hash;
+#elif defined (LYRA2REV3_8WAY)
  gate->scanhash  = (void*)&scanhash_lyra2rev3_8way;
  gate->hash      = (void*)&lyra2rev3_8way_hash;
 #elif defined (LYRA2REV3_4WAY)
@@ -69,9 +78,10 @@ bool register_lyra2rev3_algo( algo_gate_t* gate )
  gate->scanhash  = (void*)&scanhash_lyra2rev3;
  gate->hash      = (void*)&lyra2rev3_hash;
 #endif
+//  gate->optimizations = SSE2_OPT | SSE42_OPT | AVX2_OPT | AVX512_OPT;
  gate->optimizations = SSE2_OPT | SSE42_OPT | AVX2_OPT;
  gate->miner_thread_init = (void*)&lyra2rev3_thread_init;
-  gate->set_target        = (void*)&alt_set_target;
+  opt_target_factor = 256.0;
  return true;
 };

@@ -105,7 +115,7 @@ bool register_lyra2rev2_algo( algo_gate_t* gate )
 #endif
  gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT;
  gate->miner_thread_init = (void*)&lyra2rev2_thread_init;
-  gate->set_target        = (void*)&alt_set_target;
+  opt_target_factor = 256.0;
  return true;
 };

@@ -127,8 +137,7 @@ bool register_lyra2z_algo( algo_gate_t* gate )
  gate->hash       = (void*)&lyra2z_hash;
 #endif
  gate->optimizations = SSE42_OPT | AVX2_OPT;
-  gate->get_max64  = (void*)&get_max64_0xffffLL;
-  gate->set_target = (void*)&alt_set_target;
+  opt_target_factor = 256.0;
  return true;
 };

@@ -147,15 +156,12 @@ bool register_lyra2h_algo( algo_gate_t* gate )
  gate->hash       = (void*)&lyra2h_hash;
 #endif
  gate->optimizations = SSE42_OPT | AVX2_OPT;
-  gate->get_max64  = (void*)&get_max64_0xffffLL;
-  gate->set_target = (void*)&alt_set_target;
+  opt_target_factor = 256.0;
  return true;
 };

 /////////////////////////////////

-int64_t allium_get_max64_0xFFFFLL() { return 0xFFFFLL; }
-
 bool register_allium_algo( algo_gate_t* gate )
 {
 #if defined (ALLIUM_4WAY)
@@ -168,8 +174,7 @@ bool register_allium_algo( algo_gate_t* gate )
  gate->hash      = (void*)&allium_hash;
 #endif
  gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT;
-  gate->set_target        = (void*)&alt_set_target;
-  gate->get_max64         = (void*)&allium_get_max64_0xFFFFLL;
+  opt_target_factor = 256.0;
  return true;
 };

@@ -182,6 +187,7 @@ int phi2_get_work_data_size() { return phi2_use_roots ? 144 : 128; }

 void phi2_decode_extra_data( struct work *work )
 {
+   phi2_use_roots = false;
   if ( work->data[0] & ( 1<<30 ) ) phi2_use_roots = true;
   else for ( int i = 20; i < 36; i++ )
   {
@@ -213,8 +219,7 @@ bool register_phi2_algo( algo_gate_t* gate )
   gate->get_work_data_size = (void*)&phi2_get_work_data_size;
   gate->decode_extra_data  = (void*)&phi2_decode_extra_data;
   gate->build_extraheader  = (void*)&phi2_build_extraheader;
-   gate->set_target         = (void*)&alt_set_target; 
-   gate->get_max64          = (void*)&get_max64_0xffffLL;
+   opt_target_factor = 256.0;
 #if defined(PHI2_4WAY)
   gate->scanhash           = (void*)&scanhash_phi2_4way;
 #else
--- a/algo/lyra2/lyra2-gate.h
+++ b/algo/lyra2/lyra2-gate.h
@@ -5,18 +5,27 @@
 #include <stdint.h>
 #include "lyra2.h"

+//#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+//  #define LYRA2REV3_16WAY 1
+//#elif defined(__AVX2__)
 #if defined(__AVX2__)
-  #define LYRA2REV3_8WAY
-#endif
-
-#if defined(__SSE2__)
-  #define LYRA2REV3_4WAY
+  #define LYRA2REV3_8WAY 1
+#elif defined(__SSE2__)
+  #define LYRA2REV3_4WAY 1
 #endif

 extern __thread uint64_t* l2v3_wholeMatrix;

 bool register_lyra2rev3_algo( algo_gate_t* gate );
-#if defined(LYRA2REV3_8WAY)
+
+#if defined(LYRA2REV3_16WAY)
+
+void lyra2rev3_16way_hash( void *state, const void *input );
+int scanhash_lyra2rev3_16way( struct work *work, uint32_t max_nonce,
+                             uint64_t *hashes_done, struct thr_info *mythr );
+bool init_lyra2rev3_16way_ctx();
+
+#elif defined(LYRA2REV3_8WAY)

 void lyra2rev3_8way_hash( void *state, const void *input );
 int scanhash_lyra2rev3_8way( struct work *work, uint32_t max_nonce,
--- a/algo/lyra2/lyra2.c
+++ b/algo/lyra2/lyra2.c
@@ -60,7 +60,7 @@ int LYRA2REV2( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
   int64_t step = 1; //Visitation step (used during Setup and Wandering phases)
   int64_t window = 2; //Visitation window (used to define which rows can be revisited during Setup)
   int64_t gap = 1; //Modifier to the step, assuming the values 1 or -1
-   int64_t i; //auxiliary iteration counter
+//   int64_t i; //auxiliary iteration counter
   int64_t v64; // 64bit var for memcpy
   //====================================================================/

@@ -128,17 +128,22 @@ int LYRA2REV2( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
   //================= Initializing the Sponge State ====================//
   //Sponge state: 16 uint64_t, BLOCK_LEN_INT64 words of them for the bitrate (b) and the remainder for the capacity (c)

-   initState( state );
+//   initState( state );

   //========================= Setup Phase =============================//
   //Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits
   
   ptrWord = wholeMatrix;
+
+   absorbBlockBlake2Safe( state, ptrWord, nBlocksInput, BLOCK_LEN );
+/*
   for (i = 0; i < nBlocksInput; i++)
   {
       absorbBlockBlake2Safe( state, ptrWord ); //absorbs each block of pad(pwd || salt || basil)
       ptrWord += BLOCK_LEN; //goes to next block of pad(pwd || salt || basil)
   }
+*/
+
   //Initializes M[0] and M[1]
   reducedSqueezeRow0( state, &wholeMatrix[0], nCols ); //The locally copied password is most likely overwritten here

@@ -227,7 +232,7 @@ int LYRA2REV3( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
   int64_t step = 1; //Visitation step (used during Setup and Wandering phases)
   int64_t window = 2; //Visitation window (used to define which rows can be revisited during Setup)
   int64_t gap = 1; //Modifier to the step, assuming the values 1 or -1
-   int64_t i; //auxiliary iteration counter
+//   int64_t i; //auxiliary iteration counter
   int64_t v64; // 64bit var for memcpy
   uint64_t instance = 0;
   //====================================================================/
@@ -302,17 +307,21 @@ int LYRA2REV3( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
   //================= Initializing the Sponge State ====================//
   //Sponge state: 16 uint64_t, BLOCK_LEN_INT64 words of them for the bitrate (b) and the remainder for the capacity (c)

-   initState( state );
+//   initState( state );

   //========================= Setup Phase =============================//
   //Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits

   ptrWord = wholeMatrix;
+
+   absorbBlockBlake2Safe( state, ptrWord, nBlocksInput, BLOCK_LEN );
+/*
   for (i = 0; i < nBlocksInput; i++)
   {
       absorbBlockBlake2Safe( state, ptrWord ); //absorbs each block of pad(pwd || salt || basil)
       ptrWord += BLOCK_LEN; //goes to next block of pad(pwd || salt || basil)
   }
+*/
   //Initializes M[0] and M[1]
   reducedSqueezeRow0( state, &wholeMatrix[0], nCols ); //The locally copied password is most likely overwritten here

@@ -405,7 +414,7 @@ int LYRA2Z( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
    int64_t step = 1; //Visitation step (used during Setup and Wandering phases)
    int64_t window = 2; //Visitation window (used to define which rows can be revisited during Setup)
    int64_t gap = 1; //Modifier to the step, assuming the values 1 or -1
-    int64_t i; //auxiliary iteration counter
+//    int64_t i; //auxiliary iteration counter
    //=======================================================================/

    //======= Initializing the Memory Matrix and pointers to it =============//
@@ -459,17 +468,21 @@ int LYRA2Z( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
 //        if (state == NULL) {
 //                return -1;
 //        }
-    initState( state );
+//    initState( state );

    //============================== Setup Phase =============================//
    //Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits
-        uint64_t *ptrWord = wholeMatrix;
+    uint64_t *ptrWord = wholeMatrix;
+
+    absorbBlockBlake2Safe( state, ptrWord, nBlocksInput,
+                           BLOCK_LEN_BLAKE2_SAFE_INT64 );
+/*
    for ( i = 0; i < nBlocksInput; i++ )
    {
      absorbBlockBlake2Safe( state, ptrWord ); //absorbs each block of pad(pwd || salt || basil)
      ptrWord += BLOCK_LEN_BLAKE2_SAFE_INT64; //goes to next block of pad(pwd || salt || basil)
    }
-
+*/
    //Initializes M[0] and M[1]
        reducedSqueezeRow0(state, &wholeMatrix[0], nCols); //The locally copied password is most likely overwritten here
        reducedDuplexRow1(state, &wholeMatrix[0], &wholeMatrix[ROW_LEN_INT64], nCols);
@@ -623,17 +636,21 @@ int LYRA2RE( void *K, uint64_t kLen, const void *pwd, const uint64_t pwdlen,
   //================= Initializing the Sponge State ====================//
   //Sponge state: 16 uint64_t, BLOCK_LEN_INT64 words of them for the bitrate (b) and the remainder for the capacity (c)

-   initState( state );
+//   initState( state );

   //========================= Setup Phase =============================//
   //Absorbing salt, password and basil: this is the only place in which the block length is hard-coded to 512 bits

   ptrWord = wholeMatrix;
+
+   absorbBlockBlake2Safe( state, ptrWord, nBlocksInput, BLOCK_LEN );
+/*
   for (i = 0; i < nBlocksInput; i++)
   {
       absorbBlockBlake2Safe( state, ptrWord ); //absorbs each block of pad(pwd || salt || basil)
       ptrWord += BLOCK_LEN; //goes to next block of pad(pwd || salt || basil)
   }
+*/
   //Initializes M[0] and M[1]
   reducedSqueezeRow0( state, &wholeMatrix[0], nCols ); //The locally copied password is most likely overwritten here

--- a/algo/lyra2/lyra2.h
+++ b/algo/lyra2/lyra2.h
@@ -60,4 +60,15 @@ int LYRA2Z( uint64_t*, void *K, uint64_t kLen, const void *pwd,

 int LYRA2(void *K, int64_t kLen, const void *pwd, int32_t pwdlen, const void *salt, int32_t saltlen, int64_t timeCost, const int16_t nRows, const int16_t nCols);

+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+int LYRA2REV3_2WAY( uint64_t*, void *K, uint64_t kLen, const void *pwd,
+               uint64_t pwdlen, const void *salt, uint64_t saltlen,
+               uint64_t timeCost, uint64_t nRows, uint64_t nCols );
+
+//int LYRA2REV3_2WAY( uint64_t*, void *K, uint64_t kLen, const void *pwd,
+//        uint64_t pwdlen, uint64_t timeCost, uint64_t nRows, uint64_t nCols );
+
+#endif
+
 #endif /* LYRA2_H_ */
--- a/algo/lyra2/lyra2h-4way.c
+++ b/algo/lyra2/lyra2h-4way.c
@@ -5,7 +5,7 @@
 #include <memory.h>
 #include <mm_malloc.h>
 #include "lyra2.h"
-#include "algo/blake/sph_blake.h"
+//#include "algo/blake/sph_blake.h"
 #include "algo/blake/blake-hash-4way.h"

 __thread uint64_t* lyra2h_4way_matrix;
@@ -64,7 +64,7 @@ int scanhash_lyra2h_4way( struct work *work, uint32_t max_nonce,
   if ( opt_benchmark )
      ptarget[7] = 0x0000ff;

-   mm128_bswap_intrlv80_4x32( vdata, pdata );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
   lyra2h_4way_midstate( vdata );

   do {
--- a/algo/lyra2/lyra2re.c
+++ b/algo/lyra2/lyra2re.c
@@ -113,24 +113,13 @@ int scanhash_lyra2re( struct work *work, uint32_t max_nonce,
 	return 0;
 }

-int64_t lyra2re_get_max64 ()
-{
-  return 0xffffLL;
-}
-
-void lyra2re_set_target ( struct work* work, double job_diff )
-{
-   work_set_target(work, job_diff / (128.0 * opt_diff_factor) );
-}
-
 bool register_lyra2re_algo( algo_gate_t* gate )
 {
  init_lyra2re_ctx();
  gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT;
  gate->scanhash   = (void*)&scanhash_lyra2re;
  gate->hash       = (void*)&lyra2re_hash;
-  gate->get_max64  = (void*)&lyra2re_get_max64;
-  gate->set_target = (void*)&lyra2re_set_target;
+  opt_target_factor = 128.0;
  return true;
 };

--- a/algo/lyra2/lyra2rev2-4way.c
+++ b/algo/lyra2/lyra2rev2-4way.c
@@ -42,12 +42,12 @@ void lyra2rev2_4way_hash( void *state, const void *input )
   blake256_4way( &ctx.blake, input + (64<<2), 16 );
   blake256_4way_close( &ctx.blake, vhash );

-   mm256_rintrlv_4x32_4x64( vhash64, vhash, 256 );
+   rintrlv_4x32_4x64( vhash64, vhash, 256 );

   keccak256_4way( &ctx.keccak, vhash64, 32 );
   keccak256_4way_close( &ctx.keccak, vhash64 );

-   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
+   dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );

   cubehashUpdateDigest( &ctx.cube, (byte*) hash0, (const byte*) hash0, 32 );
   cubehashInit( &ctx.cube, 256, 16, 32 );
@@ -62,12 +62,12 @@ void lyra2rev2_4way_hash( void *state, const void *input )
   LYRA2REV2( l2v2_wholeMatrix, hash2, 32, hash2, 32, hash2, 32, 1, 4, 4 );
   LYRA2REV2( l2v2_wholeMatrix, hash3, 32, hash3, 32, hash3, 32, 1, 4, 4 );

-   mm256_intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
+   intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );

   skein256_4way( &ctx.skein, vhash64, 32 );
   skein256_4way_close( &ctx.skein, vhash64 );

-   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
+   dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );

   cubehashInit( &ctx.cube, 256, 16, 32 );
   cubehashUpdateDigest( &ctx.cube, (byte*) hash0, (const byte*) hash0, 32 );
@@ -102,7 +102,7 @@ int scanhash_lyra2rev2_4way( struct work *work, uint32_t max_nonce,
   if ( opt_benchmark )
      ( (uint32_t*)ptarget )[7] = 0x0000ff;

-   mm128_bswap_intrlv80_4x32( vdata, pdata );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );

   blake256_4way_init( &l2v2_4way_ctx.blake );
   blake256_4way( &l2v2_4way_ctx.blake, vdata, 64 );
--- a/algo/lyra2/lyra2rev3-4way.c
+++ b/algo/lyra2/lyra2rev3-4way.c
@@ -5,7 +5,6 @@
 #include "algo/bmw/bmw-hash-4way.h"
 #include "algo/cubehash/cubehash_sse2.h" 

-
 #if defined (LYRA2REV3_8WAY)

 typedef struct {
@@ -14,7 +13,7 @@ typedef struct {
   bmw256_8way_context       bmw;
 } lyra2v3_8way_ctx_holder;

-static lyra2v3_8way_ctx_holder l2v3_8way_ctx;
+static __thread lyra2v3_8way_ctx_holder l2v3_8way_ctx;

 bool init_lyra2rev3_8way_ctx()
 {
@@ -38,10 +37,10 @@ void lyra2rev3_8way_hash( void *state, const void *input )
   lyra2v3_8way_ctx_holder ctx __attribute__ ((aligned (64)));
   memcpy( &ctx, &l2v3_8way_ctx, sizeof(l2v3_8way_ctx) );

-   blake256_8way( &ctx.blake, input, 80 );
+   blake256_8way( &ctx.blake, input + (64*8), 16 );
   blake256_8way_close( &ctx.blake, vhash );

-   mm256_dintrlv_8x32( hash0, hash1, hash2, hash3,
+   dintrlv_8x32( hash0, hash1, hash2, hash3,
                       hash4, hash5, hash6, hash7, vhash, 256 );

   LYRA2REV3( l2v3_wholeMatrix, hash0, 32, hash0, 32, hash0, 32, 1, 4, 4 );
@@ -78,7 +77,7 @@ void lyra2rev3_8way_hash( void *state, const void *input )
   LYRA2REV3( l2v3_wholeMatrix, hash6, 32, hash6, 32, hash6, 32, 1, 4, 4 );
   LYRA2REV3( l2v3_wholeMatrix, hash7, 32, hash7, 32, hash7, 32, 1, 4, 4 );

-   mm256_intrlv_8x32( vhash, hash0, hash1, hash2, hash3,
+   intrlv_8x32( vhash, hash0, hash1, hash2, hash3,
                             hash4, hash5, hash6, hash7, 256 );

   bmw256_8way( &ctx.bmw, vhash, 32 );
@@ -86,25 +85,28 @@ void lyra2rev3_8way_hash( void *state, const void *input )

   }

-int scanhash_lyra2rev3_8way( struct work *work, uint32_t max_nonce,
+int scanhash_lyra2rev3_8way( struct work *work, const uint32_t max_nonce,
                             uint64_t *hashes_done, struct thr_info *mythr )
 {
   uint32_t hash[8*8] __attribute__ ((aligned (64)));
   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t *hash7 = &(hash[7<<3]);
+   uint32_t *hash7 = &hash[7<<3];
   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
   uint32_t *pdata = work->data;
-   uint32_t *ptarget = work->target;
+   const uint32_t *ptarget = work->target;
   const uint32_t first_nonce = pdata[19];
   uint32_t n = first_nonce;
   const uint32_t Htarg = ptarget[7];
   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
-   int thr_id = mythr->id;  // thr_id arg is deprecated
+   const int thr_id = mythr->id;

-   if ( opt_benchmark )
-      ( (uint32_t*)ptarget )[7] = 0x0000ff;
+   if ( opt_benchmark )  ( (uint32_t*)ptarget )[7] = 0x0000ff;
+
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
+
+   blake256_8way_init( &l2v3_8way_ctx.blake );
+   blake256_8way( &l2v3_8way_ctx.blake, vdata, 64 );

-   mm256_bswap_intrlv80_8x32( vdata, pdata );
   do
   {
      *noncev = mm256_bswap_32( _mm256_set_epi32( n+7, n+6, n+5, n+4,
@@ -113,17 +115,18 @@ int scanhash_lyra2rev3_8way( struct work *work, uint32_t max_nonce,
      lyra2rev3_8way_hash( hash, vdata );
      pdata[19] = n;

-      for ( int lane = 0; lane < 8; lane++ ) if ( hash7[lane] <= Htarg )
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( hash7[lane] <= Htarg ) )
      {
-         mm256_extr_lane_8x32( lane_hash, hash, lane, 256 );
-         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+         extr_lane_8x32( lane_hash, hash, lane, 256 );
+         if ( likely( fulltest( lane_hash, ptarget ) && !opt_benchmark ) )
         {
-              pdata[19] = n + lane;
-              submit_lane_solution( work, lane_hash, mythr, lane );
+             pdata[19] = n + lane;
+             submit_lane_solution( work, lane_hash, mythr, lane );
         }
      }
      n += 8;
-   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
+   } while ( likely( (n < max_nonce-8) && !work_restart[thr_id].restart ) );
   *hashes_done = n - first_nonce + 1;
   return 0;
 }
@@ -132,14 +135,14 @@ int scanhash_lyra2rev3_8way( struct work *work, uint32_t max_nonce,

 #if defined (LYRA2REV3_4WAY)  

-
 typedef struct {
   blake256_4way_context     blake;
   cubehashParam             cube;
   bmw256_4way_context       bmw;
 } lyra2v3_4way_ctx_holder;

-static lyra2v3_4way_ctx_holder l2v3_4way_ctx;
+//static lyra2v3_4way_ctx_holder l2v3_4way_ctx;
+static __thread lyra2v3_4way_ctx_holder l2v3_4way_ctx;

 bool init_lyra2rev3_4way_ctx()
 {
@@ -159,7 +162,8 @@ void lyra2rev3_4way_hash( void *state, const void *input )
   lyra2v3_4way_ctx_holder ctx __attribute__ ((aligned (64))); 
   memcpy( &ctx, &l2v3_4way_ctx, sizeof(l2v3_4way_ctx) );

-   blake256_4way( &ctx.blake, input, 80 );
+//   blake256_4way( &ctx.blake, input, 80 );
+   blake256_4way( &ctx.blake, input + (64*4), 16 );
   blake256_4way_close( &ctx.blake, vhash );
   dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 256 );

@@ -186,7 +190,7 @@ void lyra2rev3_4way_hash( void *state, const void *input )
   bmw256_4way_close( &ctx.bmw, state );
 }

-int scanhash_lyra2rev3_4way( struct work *work, uint32_t max_nonce,
+int scanhash_lyra2rev3_4way( struct work *work, const uint32_t max_nonce,
                             uint64_t *hashes_done, struct thr_info *mythr ) 
 {
   uint32_t hash[8*4] __attribute__ ((aligned (64)));
@@ -194,17 +198,21 @@ int scanhash_lyra2rev3_4way( struct work *work, uint32_t max_nonce,
   uint32_t *hash7 = &(hash[7<<2]);
   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
   uint32_t *pdata = work->data;
-   uint32_t *ptarget = work->target;
+   const uint32_t *ptarget = work->target;
   const uint32_t first_nonce = pdata[19];
   uint32_t n = first_nonce;
   const uint32_t Htarg = ptarget[7];
   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
-   int thr_id = mythr->id;  // thr_id arg is deprecated
+   const int thr_id = mythr->id;  // thr_id arg is deprecated
   
   if ( opt_benchmark )
      ( (uint32_t*)ptarget )[7] = 0x0000ff;

-   mm128_bswap_intrlv80_4x32( vdata, pdata );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
+
+   blake256_4way_init( &l2v3_4way_ctx.blake );
+   blake256_4way( &l2v3_4way_ctx.blake, vdata, 64 );
+
   do
   {
      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
--- a/algo/lyra2/lyra2rev3.c
+++ b/algo/lyra2/lyra2rev3.c
@@ -32,27 +32,27 @@ void l2v3_blake256_midstate( const void* input )

 void lyra2rev3_hash( void *state, const void *input )
 {
-        lyra2v3_ctx_holder ctx __attribute__ ((aligned (64))); 
-        memcpy( &ctx, &lyra2v3_ctx, sizeof(lyra2v3_ctx) );
-        uint8_t hash[128] __attribute__ ((aligned (64)));
-        #define hashA hash
-        #define hashB hash+64
-        const int midlen = 64;            // bytes
-        const int tail   = 80 - midlen;   // 16
+   lyra2v3_ctx_holder ctx __attribute__ ((aligned (64))); 
+   memcpy( &ctx, &lyra2v3_ctx, sizeof(lyra2v3_ctx) );
+   uint8_t hash[128] __attribute__ ((aligned (64)));
+   #define hashA hash
+   #define hashB hash+64
+   const int midlen = 64;            // bytes
+   const int tail   = 80 - midlen;   // 16

-        memcpy( &ctx.blake, &l2v3_blake_mid, sizeof l2v3_blake_mid );
-	sph_blake256( &ctx.blake, (uint8_t*)input + midlen, tail );
-	sph_blake256_close( &ctx.blake, hash );
+   memcpy( &ctx.blake, &l2v3_blake_mid, sizeof l2v3_blake_mid );
+   sph_blake256( &ctx.blake, (uint8_t*)input + midlen, tail );
+   sph_blake256_close( &ctx.blake, hash );

-        LYRA2REV3( l2v3_wholeMatrix, hash, 32, hash, 32, hash, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash, 32, hash, 32, hash, 32, 1, 4, 4 );

-        cubehashUpdateDigest( &ctx.cube, (byte*) hashA,
-                              (const byte*) hash, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hashA,
+                         (const byte*) hash, 32 );

-	LYRA2REV3( l2v3_wholeMatrix, hash, 32, hash, 32, hash, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash, 32, hash, 32, hash, 32, 1, 4, 4 );

-	sph_bmw256( &ctx.bmw, hash, 32 );
-	sph_bmw256_close( &ctx.bmw, hash );
+   sph_bmw256( &ctx.bmw, hash, 32 );
+   sph_bmw256_close( &ctx.bmw, hash );

 	memcpy( state, hash, 32 );
 }
--- a/algo/lyra2/lyra2z-4way.c
+++ b/algo/lyra2/lyra2z-4way.c
@@ -60,7 +60,7 @@ int scanhash_lyra2z_4way( struct work *work, uint32_t max_nonce,
   if ( opt_benchmark )
      ptarget[7] = 0x0000ff;

-   mm128_bswap_intrlv80_4x32( vdata, pdata );
+   mm128_bswap32_intrlv80_4x32( vdata, pdata );
   lyra2z_4way_midstate( vdata );

   do {
@@ -119,8 +119,8 @@ void lyra2z_8way_hash( void *state, const void *input )
     blake256_8way( &ctx_blake, input + (64*8), 16 );
     blake256_8way_close( &ctx_blake, vhash );

-     mm256_dintrlv_8x32( hash0, hash1, hash2, hash3,
-                         hash4, hash5, hash6, hash7, vhash, 256 );
+     dintrlv_8x32( hash0, hash1, hash2, hash3,
+                   hash4, hash5, hash6, hash7, vhash, 256 );

     LYRA2Z( lyra2z_8way_matrix, hash0, 32, hash0, 32, hash0, 32, 8, 8, 8 );
     LYRA2Z( lyra2z_8way_matrix, hash1, 32, hash1, 32, hash1, 32, 8, 8, 8 );
@@ -157,7 +157,7 @@ int scanhash_lyra2z_8way( struct work *work, uint32_t max_nonce,
   if ( opt_benchmark )
      ptarget[7] = 0x0000ff;

-   mm256_bswap_intrlv80_8x32( vdata, pdata );
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
   lyra2z_8way_midstate( vdata );

   do {
--- a/algo/lyra2/lyra2z330.c
+++ b/algo/lyra2/lyra2z330.c
@@ -53,11 +53,6 @@ int scanhash_lyra2z330( struct work *work, uint32_t max_nonce,
   return 0;
 }

-void lyra2z330_set_target( struct work* work, double job_diff )
-{
- work_set_target( work, job_diff / (256.0 * opt_diff_factor) );
-}
-
 bool lyra2z330_thread_init()
 {
   const int64_t ROW_LEN_INT64 = BLOCK_LEN_INT64 * 256; // nCols
@@ -75,8 +70,7 @@ bool register_lyra2z330_algo( algo_gate_t* gate )
  gate->miner_thread_init = (void*)&lyra2z330_thread_init;
  gate->scanhash   = (void*)&scanhash_lyra2z330;
  gate->hash       = (void*)&lyra2z330_hash;
-  gate->get_max64  = (void*)&get_max64_0xffffLL;
-  gate->set_target = (void*)&lyra2z330_set_target;
+  opt_target_factor = 256.0;
  return true;
 };

--- a/algo/lyra2/phi2-4way.c
+++ b/algo/lyra2/phi2-4way.c
@@ -69,13 +69,13 @@ void phi2_hash_4way( void *state, const void *input )
   LYRA2RE( &hashA[3][0], 32, &hashB[3][0], 32, &hashB[3][0], 32, 1, 8, 8 );
   LYRA2RE( &hashA[3][8], 32, &hashB[3][8], 32, &hashB[3][8], 32, 1, 8, 8 );

-   mm256_intrlv_4x64( vhash, hashA[0], hashA[1], hashA[2], hashA[3], 512 );
+   intrlv_4x64( vhash, hashA[0], hashA[1], hashA[2], hashA[3], 512 );

   jh512_4way_init( &ctx.jh );
   jh512_4way( &ctx.jh, vhash, 64 );
   jh512_4way_close( &ctx.jh, vhash );

-   mm256_dintrlv_4x64( hash[0], hash[1], hash[2], hash[3], vhash, 512 );
+   dintrlv_4x64( hash[0], hash[1], hash[2], hash[3], vhash, 512 );

   if ( hash[0][0] & 1 )
  	{
@@ -141,7 +141,7 @@ void phi2_hash_4way( void *state, const void *input )
                          (const BitSequence *)hash[3], 512 );
   }

-   mm256_intrlv_4x64( vhash, hash[0], hash[1], hash[2], hash[3], 512 );
+   intrlv_4x64( vhash, hash[0], hash[1], hash[2], hash[3], 512 );
   
   skein512_4way_init( &ctx.skein );
 	skein512_4way( &ctx.skein, vhash, 64 );
@@ -217,7 +217,7 @@ int scanhash_phi2_4way( struct work *work, uint32_t max_nonce,

      for ( int lane = 0; lane < 4; lane++ ) if (  hash7[ lane<<1 ] < Htarg )
      {
-          mm256_extr_lane_4x64( lane_hash, hash, lane, 256 );
+          extr_lane_4x64( lane_hash, hash, lane, 256 );
          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
          {
              pdata[19] = n + lane;
--- a/algo/lyra2/sponge-2way.c
+++ b/algo/lyra2/sponge-2way.c
@@ -0,0 +1,320 @@
+/**
+ * A simple implementation of Blake2b's internal permutation
+ * in the form of a sponge.
+ *
+ * Author: The Lyra PHC team (http://www.lyra-kdf.net/) -- 2014.
+ *
+ * This software is hereby placed in the public domain.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "algo-gate-api.h"
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+#include <immintrin.h>
+#include "sponge.h"
+#include "lyra2.h"
+
+#if 0
+//#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+inline void squeeze_2way( uint64_t *State, byte *Out, unsigned int len )
+{
+    const int len_m256i = len / 32;
+    const int fullBlocks = len_m256i / BLOCK_LEN_M256I;
+    __m512i* state = (__m512i*)State;
+    __m512i* out   = (__m512i*)Out;
+    int i;
+
+    //Squeezes full blocks
+    for ( i = 0; i < fullBlocks; i++ )
+    {
+       memcpy_512( out, state, BLOCK_LEN_M256I*2 );
+       LYRA_ROUND_2WAY_AVX2( state[0], state[1], state[2], state[3] );
+       out += BLOCK_LEN_M256I*2;
+    }
+    //Squeezes remaining bytes
+    memcpy_512( out, state, ( (len_m256i % BLOCK_LEN_M256I) * 2 ) );
+}
+
+inline void absorbBlock_2way( uint64_t *State, const uint64_t *In ) 
+{
+    register __m512i state0, state1, state2, state3;
+    __m512i *in = (__m512i*)In;
+
+    state0 = _mm512_load_si512( (__m512i*)State     );
+    state1 = _mm512_load_si512( (__m512i*)State + 1 );
+    state2 = _mm512_load_si512( (__m512i*)State + 2 );
+    state3 = _mm512_load_si512( (__m512i*)State + 3 );
+
+    state0 = _mm512_xor_si512( state0, in[0] );
+    state1 = _mm512_xor_si512( state1, in[1] );
+    state2 = _mm512_xor_si512( state2, in[2] );
+
+    LYRA_12_ROUNDS_2WAY_AVX512( state0, state1, state2, state3 );
+
+    _mm512_store_si512( (__m512i*)State,     state0 );
+    _mm512_store_si512( (__m512i*)State + 1, state1 );
+    _mm512_store_si512( (__m512i*)State + 2, state2 );
+    _mm512_store_si512( (__m512i*)State + 3, state3 );
+
+}
+
+inline void absorbBlockBlake2Safe_2way( uint64_t *State, const uint64_t *In,
+                      const uint64_t nBlocks, const uint64_t block_len )
+{
+  register __m512i state0, state1, state2, state3;
+
+  state0 = 
+  state1 = m512_zero;
+  state2 = m512_const4_64( 0xa54ff53a5f1d36f1ULL, 0x3c6ef372fe94f82bULL,
+                           0xbb67ae8584caa73bULL, 0x6a09e667f3bcc908ULL );
+  state3 = m512_const4_64( 0x5be0cd19137e2179ULL, 0x1f83d9abfb41bd6bULL,
+                           0x9b05688c2b3e6c1fULL, 0x510e527fade682d1ULL );
+
+  for ( int i = 0; i < nBlocks; i++ )
+  { 
+    __m512i *in = (__m512i*)In;
+    state0 = _mm512_xor_si512( state0, in[0] );
+    state1 = _mm512_xor_si512( state1, in[1] );
+
+    LYRA_12_ROUNDS_2WAY_AVX512( state0, state1, state2, state3 );
+    In += block_len * 2;
+  }
+
+  _mm512_store_si512( (__m512i*)State,     state0 );
+  _mm512_store_si512( (__m512i*)State + 1, state1 );
+  _mm512_store_si512( (__m512i*)State + 2, state2 );
+  _mm512_store_si512( (__m512i*)State + 3, state3 );
+
+}
+
+inline void reducedSqueezeRow0_2way( uint64_t* State, uint64_t* rowOut,
+                                     uint64_t nCols )
+{
+    int i;
+
+    //M[row][C-1-col] = H.reduced_squeeze()
+
+
+    register __m512i state0, state1, state2, state3;
+    __m512i* out   = (__m512i*)rowOut + ( (nCols-1) * BLOCK_LEN_M256I * 2 );
+
+    state0 = _mm512_load_si512( (__m512i*)State     );
+    state1 = _mm512_load_si512( (__m512i*)State + 1 );
+    state2 = _mm512_load_si512( (__m512i*)State + 2 );
+    state3 = _mm512_load_si512( (__m512i*)State + 3 );
+
+    for ( i = 0; i < 9; i += 3)
+    {
+        _mm_prefetch( out - i,     _MM_HINT_T0 );
+        _mm_prefetch( out - i - 2, _MM_HINT_T0 );
+    }
+
+    for ( i = 0; i < nCols; i++ )
+    {
+       _mm_prefetch( out -  9, _MM_HINT_T0 );
+       _mm_prefetch( out - 11, _MM_HINT_T0 );
+                   
+       out[0] = state0;
+       out[1] = state1;
+       out[2] = state2;
+
+       //Goes to next block (column) that will receive the squeezed data
+       out -= BLOCK_LEN_M256I * 2;
+
+       LYRA_ROUND_2WAY_AVX512( state0, state1, state2, state3 );
+    }
+
+    _mm512_store_si512( (__m512i*)State,     state0 );
+    _mm512_store_si512( (__m512i*)State + 1, state1 );
+    _mm512_store_si512( (__m512i*)State + 2, state2 );
+    _mm512_store_si512( (__m512i*)State + 3, state3 );
+}
+
+// This function has to deal with gathering 2 256 bit rowin vectors from
+// non-contiguous memory. Extra work and performance penalty.
+
+inline void reducedDuplexRow1_2way( uint64_t *State, uint64_t *rowIn,
+                 uint64_t *rowOut, uint64_t nCols )
+{
+    int i;
+    register __m512i state0, state1, state2, state3;
+    __m512i *in = (__m256i*)rowIn;
+
+    state0 = _mm512_load_si512( (__m512i*)State     );
+    state1 = _mm512_load_si512( (__m512i*)State + 1 );
+    state2 = _mm512_load_si512( (__m512i*)State + 2 );
+    state3 = _mm512_load_si512( (__m512i*)State + 3 );
+
+    for ( i = 0; i < nCols; i++ )
+    {
+         state0 = _mm512_xor_si512( state0, in[0] );
+         state1 = _mm512_xor_si512( state1, in[1] );
+         state2 = _mm512_xor_si512( state2, in[2] );
+
+         LYRA_ROUND_2WAY_AVX512( state0, state1, state2, state3 );
+
+         out[0] = _mm512_xor_si512( state0, in[0] );
+         out[1] = _mm512_xor_si512( state1, in[1] );
+         out[2] = _mm512_xor_si512( state2, in[2] );
+
+         //Input: next column (i.e., next block in sequence)
+         in0 += BLOCK_LEN_M256I;
+         in1 += BLOCK_LEN_M256I;
+         //Output: goes to previous column
+         out -= BLOCK_LEN_M256I * 2;
+    }
+
+    _mm512_store_si256( (__m512i*)State,     state0 );
+    _mm512_store_si256( (__m512i*)State + 1, state1 );
+    _mm512_store_si256( (__m512i*)State + 2, state2 );
+    _mm512_store_si256( (__m512i*)State + 3, state3 );
+   }
+}
+
+inline void reducedDuplexRowSetup_2way( uint64_t *State, uint64_t *rowIn,
+                       uint64_t *rowInOut, uint64_t *rowOut, uint64_t nCols )
+{
+    int i;
+
+    register __m512i state0, state1, state2, state3;
+    __m512i* in    = (__m512i*)rowIn;
+    __m512i* inout = (__m512i*)rowInOut;
+    __m512i* out   = (__m512i*)rowOut + ( (nCols-1) * BLOCK_LEN_M256I * 2 );
+    __m512i  t0, t1, t2;
+
+    state0 = _mm512_load_si512( (__m512i*)State     );
+    state1 = _mm512_load_si512( (__m512i*)State + 1 );
+    state2 = _mm512_load_si512( (__m512i*)State + 2 );
+    state3 = _mm512_load_si512( (__m512i*)State + 3 );
+
+    for ( i = 0; i < nCols; i++ )
+    {
+       state0 = _mm512_xor_si512( state0,
+                                  _mm512_add_epi64( in[0], inout[0] ) );
+       state1 = _mm512_xor_si512( state1,
+                                  _mm512_add_epi64( in[1], inout[1] ) );
+       state2 = _mm512_xor_si512( state2,
+                                  _mm512_add_epi64( in[2], inout[2] ) );
+
+       LYRA_ROUND_2WAY AVX512( state0, state1, state2, state3 );
+
+       out[0] = _mm512_xor_si512( state0, in[0] );
+       out[1] = _mm512_xor_si512( state1, in[1] );
+       out[2] = _mm512_xor_si512( state2, in[2] );
+
+       //M[row*][col] = M[row*][col] XOR rotW(rand)
+       t0 = _mm512_permutex_epi64( state0, 0x93 );
+       t1 = _mm512_permutex_epi64( state1, 0x93 );
+       t2 = _mm512_permutex_epi64( state2, 0x93 );
+
+       inout[0] = _mm512_xor_si512( inout[0],
+                                 _mm512_mask_blend_epi32( t0, t2, 0x03 ) );
+       inout[1] = _mm512_xor_si512( inout[1],
+                                 _mm512_mask_blend_epi32( t1, t0, 0x03 ) );
+       inout[2] = _mm512_xor_si512( inout[2],
+                                 _mm512_mask_blend_epi32( t2, t1, 0x03 ) );
+
+       //Inputs: next column (i.e., next block in sequence)
+       in    += BLOCK_LEN_M256I * 2;
+       inout += BLOCK_LEN_M256I * 2;
+       //Output: goes to previous column
+       out   -= BLOCK_LEN_M256I * 2;
+    }
+
+    _mm512_store_si512( (__m512i*)State,     state0 );
+    _mm512_store_si512( (__m512i*)State + 1, state1 );
+    _mm512_store_si512( (__m512i*)State + 2, state2 );
+    _mm512_store_si512( (__m512i*)State + 3, state3 );
+}
+
+inline void reducedDuplexRow_2way( uint64_t *State, uint64_t *rowIn1,
+                uint64_t *rowIn0, uint64_t *rowInOut, uint64_t *rowOut,
+                uint64_t nCols )
+{
+   int i;
+
+   register __m512i state0, state1, state2, state3;
+    __m256i *in0 = (__m256i*)rowIn0;
+    __m256i *in0 = (__m256i*)rowIn0;
+    __m2512* in    = (__m512i*)rowIn;
+    __m2512* inout = (__m512i*)rowInOut;
+    __m512i* out   = (__m512i*)rowOut;
+    __m512i  t0, t1, t2;
+
+    _mm_prefetch( in0,     _MM_HINT_T0 );
+    _mm_prefetch( in1,     _MM_HINT_T0 );
+    _mm_prefetch( in0 + 2, _MM_HINT_T0 );
+    _mm_prefetch( in1 + 2, _MM_HINT_T0 );
+    _mm_prefetch( in0 + 4, _MM_HINT_T0 );
+    _mm_prefetch( in1 + 4, _MM_HINT_T0 );
+    _mm_prefetch( in0 + 6, _MM_HINT_T0 );
+    _mm_prefetch( in1 + 6, _MM_HINT_T0 );
+   
+   state0 = _mm512_load_si512( (__m512i*)State     );
+   state1 = _mm512_load_si512( (__m512i*)State + 1 );
+   state2 = _mm512_load_si512( (__m512i*)State + 2 );
+   state3 = _mm512_load_si512( (__m512i*)State + 3 );
+
+      //Absorbing "M[prev] [+] M[row*]"
+
+//         state0 = _mm512_xor_si512( state0, mm512_concat_256( in1[0], in0[0] );
+//         state1 = _mm512_xor_si512( state1, mm512_concat_256( in1[1], in0[1] );
+//         state2 = _mm512_xor_si512( state2, mm512_concat_256( in1[2], in0[2] );
+      t0 = mm512_concat_256( in1[0], in0[0] );
+      t1 = mm512_concat_256( in1[1], in0[1] );
+      t2 = mm512_concat_256( in1[2], in0[2] );
+      
+      state0 = _mm512_xor_si512( state0,
+                                     _mm512_add_epi64( t0, inout[0] ) );
+      state1 = _mm512_xor_si512( state1,
+                                     _mm512_add_epi64( t1, inout[1] ) );
+      state2 = _mm512_xor_si512( state2,
+                                     _mm512_add_epi64( t2, inout[2] ) );
+
+      //Applies the reduced-round transformation f to the sponge's state
+      LYRA_ROUND_2WAY_AVX512( state0, state1, state2, state3 );
+
+      //M[rowOut][col] = M[rowOut][col] XOR rand
+      out[0] = _mm512_xor_si512( out[0], state0 );
+      out[1] = _mm512_xor_si512( out[1], state1 );
+      out[2] = _mm512_xor_si512( out[2], state2 );
+
+      //M[rowInOut][col] = M[rowInOut][col] XOR rotW(rand)
+      t0 = _mm512_permutex_epi64( state0, 0x93 );
+      t1 = _mm512_permutex_epi64( state1, 0x93 );
+      t2 = _mm512_permutex_epi64( state2, 0x93 );
+
+      inout[0] = _mm512_xor_si512( inout[0],
+                                   _mm512_mask_blend_epi32( t0, t2, 0x03 ) );
+      inout[1] = _mm512_xor_si512( inout[1],
+                                   _mm512_mask_blend_epi32( t1, t0, 0x03 ) );
+      inout[2] = _mm512_xor_si512( inout[2],
+                                   _mm512_mask_blend_epi32( t2, t1, 0x03 ) );
+
+       //Goes to next block
+       in    += BLOCK_LEN_M256I * 2;
+       out   += BLOCK_LEN_M256I * 2;
+       inout += BLOCK_LEN_M256I * 2;
+   }
+
+   _mm512_store_si512( (__m512i*)State,     state0 );
+   _mm512_store_si512( (__m512i*)State + 1, state1 );
+   _mm512_store_si512( (__m512i*)State + 2, state2 );
+   _mm512_store_si512( (__m512i*)State + 3, state3 );
+}
+
+#endif // AVX512
--- a/algo/lyra2/sponge.c
+++ b/algo/lyra2/sponge.c
@@ -40,29 +40,32 @@
 */
 inline void initState( uint64_t State[/*16*/] )
 {
+
+   /*
 #if defined (__AVX2__)

  __m256i* state = (__m256i*)State;
- 
-  state[0] = _mm256_setzero_si256();
-  state[1] = _mm256_setzero_si256();
-  state[2] = _mm256_set_epi64x( blake2b_IV[3], blake2b_IV[2],
-                                blake2b_IV[1], blake2b_IV[0] );
-  state[3] = _mm256_set_epi64x( blake2b_IV[7], blake2b_IV[6],
-                                blake2b_IV[5], blake2b_IV[4] );
+  const __m256i zero = m256_zero; 
+  state[0] = zero;
+  state[1] = zero;
+  state[2] = m256_const_64( 0xa54ff53a5f1d36f1ULL, 0x3c6ef372fe94f82bULL,
+                            0xbb67ae8584caa73bULL, 0x6a09e667f3bcc908ULL );
+  state[3] = m256_const_64( 0x5be0cd19137e2179ULL, 0x1f83d9abfb41bd6bULL,
+                            0x9b05688c2b3e6c1fULL, 0x510e527fade682d1ULL );

 #elif defined (__SSE2__)

  __m128i* state = (__m128i*)State;
+  const __m128i zero = m128_zero;   

-  state[0] = _mm_setzero_si128();
-  state[1] = _mm_setzero_si128();
-  state[2] = _mm_setzero_si128();
-  state[3] = _mm_setzero_si128();
-  state[4] = _mm_set_epi64x( blake2b_IV[1], blake2b_IV[0] );
-  state[5] = _mm_set_epi64x( blake2b_IV[3], blake2b_IV[2] );
-  state[6] = _mm_set_epi64x( blake2b_IV[5], blake2b_IV[4] );
-  state[7] = _mm_set_epi64x( blake2b_IV[7], blake2b_IV[6] );
+  state[0] = zero;
+  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 );

 #else
    //First 512 bis are zeros
@@ -77,6 +80,8 @@ inline void initState( uint64_t State[/*16*/] )
    State[14] = blake2b_IV[6];
    State[15] = blake2b_IV[7];
 #endif
+*/
+
 }

 /**
@@ -250,43 +255,74 @@ inline void absorbBlock( uint64_t *State, const uint64_t *In )
 * @param state The current state of the sponge
 * @param in    The block to be absorbed (BLOCK_LEN_BLAKE2_SAFE_INT64 words)
 */
-inline void absorbBlockBlake2Safe( uint64_t *State, const uint64_t *In )
+inline void absorbBlockBlake2Safe( uint64_t *State, const uint64_t *In,
+                      const uint64_t nBlocks, const uint64_t block_len )
 {
-    //XORs the first BLOCK_LEN_BLAKE2_SAFE_INT64 words of "in" with the current state
+// XORs the first BLOCK_LEN_BLAKE2_SAFE_INT64 words of "in" with
+// the IV.
 #if defined (__AVX2__)

-    register __m256i state0, state1, state2, state3;
+  register __m256i state0, state1, state2, state3;
+
+  state0 = 
+  state1 = m256_zero;
+  state2 = m256_const_64( 0xa54ff53a5f1d36f1ULL, 0x3c6ef372fe94f82bULL,
+                          0xbb67ae8584caa73bULL, 0x6a09e667f3bcc908ULL );
+  state3 = m256_const_64( 0x5be0cd19137e2179ULL, 0x1f83d9abfb41bd6bULL,
+                          0x9b05688c2b3e6c1fULL, 0x510e527fade682d1ULL );
+
+  for ( int i = 0; i < nBlocks; i++ )
+  { 
    __m256i *in = (__m256i*)In;
-
-    state0 = _mm256_load_si256( (__m256i*)State     );
-    state1 = _mm256_load_si256( (__m256i*)State + 1 );
-    state2 = _mm256_load_si256( (__m256i*)State + 2 );
-    state3 = _mm256_load_si256( (__m256i*)State + 3 );
-
    state0 = _mm256_xor_si256( state0, in[0] );
    state1 = _mm256_xor_si256( state1, in[1] );

    LYRA_12_ROUNDS_AVX2( state0, state1, state2, state3 );
+    In += block_len;
+  }

-    _mm256_store_si256( (__m256i*)State,     state0 );
-    _mm256_store_si256( (__m256i*)State + 1, state1 );
-    _mm256_store_si256( (__m256i*)State + 2, state2 );
-    _mm256_store_si256( (__m256i*)State + 3, state3 );
+  _mm256_store_si256( (__m256i*)State,     state0 );
+  _mm256_store_si256( (__m256i*)State + 1, state1 );
+  _mm256_store_si256( (__m256i*)State + 2, state2 );
+  _mm256_store_si256( (__m256i*)State + 3, state3 );

 #elif defined (__SSE2__)

-    __m128i* state = (__m128i*)State;
+  __m128i state0, state1, state2, state3, state4, state5, state6, state7;
+
+  state0 = 
+  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 );
+
+  for ( int i = 0; i < nBlocks; i++ )
+  { 
    __m128i* in    = (__m128i*)In;

-    state[0] = _mm_xor_si128( state[0], in[0] );
-    state[1] = _mm_xor_si128( state[1], in[1] );
-    state[2] = _mm_xor_si128( state[2], in[2] );
-    state[3] = _mm_xor_si128( state[3], in[3] );
+    state0 = _mm_xor_si128( state0, in[0] );
+    state1 = _mm_xor_si128( state1, in[1] );
+    state2 = _mm_xor_si128( state2, in[2] );
+    state3 = _mm_xor_si128( state3, in[3] );

    //Applies the transformation f to the sponge's state
-    LYRA_12_ROUNDS_AVX( state[0], state[1], state[2], state[3],
-                        state[4], state[5], state[6], state[7] );
+    LYRA_12_ROUNDS_AVX( state0, state1, state2, state3,
+                        state4, state5, state6, state7 );
+    In += block_len;
+  }

+  _mm_store_si128( (__m128i*)State,     state0 );
+  _mm_store_si128( (__m128i*)State + 1, state1 );
+  _mm_store_si128( (__m128i*)State + 2, state2 );
+  _mm_store_si128( (__m128i*)State + 3, state3 );
+  _mm_store_si128( (__m128i*)State + 4, state4 );
+  _mm_store_si128( (__m128i*)State + 5, state5 );
+  _mm_store_si128( (__m128i*)State + 6, state6 );
+  _mm_store_si128( (__m128i*)State + 7, state7 );
+  
 #else

    State[0] ^= In[0];
--- a/algo/lyra2/sponge.h
+++ b/algo/lyra2/sponge.h
@@ -52,8 +52,46 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
 // 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 ); \
+   c = _mm512_add_epi64( c, d ); \
+   b = mm512_ror_64( _mm512_xor_si512( b, c ), 24 ); \
+   a = _mm512_add_epi64( a, b ); \
+   d = mm512_ror_64( _mm512_xor_si512( d, a ), 16 ); \
+   c = _mm512_add_epi64( c, d ); \
+   b = mm512_ror_64( _mm512_xor_si512( b, c ), 63 );
+
+#define LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   G2W_4X64( s0, s1, s2, s3 ); \
+   s1 = mm512_ror256_64( s1); \
+   s2 = mm512_swap256_128( s2 ); \
+   s3 = mm512_rol256_64( s3 ); \
+   G2W_4X64( s0, s1, s2, s3 ); \
+   s1 = mm512_rol256_64( s1 ); \
+   s2 = mm512_swap256_128( s2 ); \
+   s3 = mm512_ror256_64( s3 );
+
+#define LYRA_12_ROUNDS_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 ) \
+   LYRA_ROUND_2WAY_AVX512( s0, s1, s2, s3 )
+
+
+#endif  // AVX512
+
 #if defined __AVX2__
-// only available with avx2

 // process 4 columns in parallel
 // returns void, updates all args
@@ -89,9 +127,11 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
   LYRA_ROUND_AVX2( s0, s1, s2, s3 ) \
   LYRA_ROUND_AVX2( s0, s1, s2, s3 ) \
   LYRA_ROUND_AVX2( s0, s1, s2, s3 ) \
-   LYRA_ROUND_AVX2( s0, s1, s2, s3 ) \
+   LYRA_ROUND_AVX2( s0, s1, s2, s3 )

-#elif defined(__SSE2__)
+#endif
+
+#if defined(__SSE2__)

 // process 2 columns in parallel
 // returns void, all args updated
@@ -108,14 +148,14 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
 #define LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
   G_2X64( s0, s2, s4, s6 ); \
   G_2X64( s1, s3, s5, s7 ); \
-   mm128_ror1x64_256( s2, s3 ); \
-   mm128_swap128_256( s4, s5 ); \
-   mm128_rol1x64_256( s6, s7 ); \
+   mm128_ror256_64( s2, s3 ); \
+   mm128_swap256_128( s4, s5 ); \
+   mm128_rol256_64( s6, s7 ); \
   G_2X64( s0, s2, s4, s6 ); \
   G_2X64( s1, s3, s5, s7 ); \
-   mm128_rol1x64_256( s2, s3 ); \
-   mm128_swap128_256( s4, s5 ); \
-   mm128_ror1x64_256( s6, s7 );
+   mm128_rol256_64( s2, s3 ); \
+   mm128_swap256_128( s4, s5 ); \
+   mm128_ror256_64( s6, s7 );

 #define LYRA_12_ROUNDS_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
   LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
@@ -129,7 +169,7 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
   LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
   LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
   LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
-   LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
+   LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7)


 #endif // AVX2 else SSE2
@@ -161,6 +201,30 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
    G(r,7,v[ 3],v[ 4],v[ 9],v[14]);


+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//---- Housekeeping
+void initState_2way( uint64_t state[/*16*/] );
+
+//---- Squeezes
+void squeeze_2way( uint64_t *state, unsigned char *out, unsigned int len );
+void reducedSqueezeRow0_2way( uint64_t* state, uint64_t* row, uint64_t nCols );
+
+//---- Absorbs
+void absorbBlock_2way( uint64_t *state, const uint64_t *in );
+void absorbBlockBlake2Safe_2way( uint64_t *state, const uint64_t *in,
+                            const uint64_t nBlocks, const uint64_t block_len );
+
+//---- Duplexes
+void reducedDuplexRow1_2way( uint64_t *state, uint64_t *rowIn,
+                             uint64_t *rowOut, uint64_t nCols);
+void reducedDuplexRowSetup_2way( uint64_t *state, uint64_t *rowIn,
+                    uint64_t *rowInOut, uint64_t *rowOut, uint64_t nCols );
+void reducedDuplexRow_2way(uint64_t *state, uint64_t *rowIn1, uint64_t *rowIn0, uint64_t *rowInOut, uint64_t *rowOut, uint64_t nCols);
+
+#endif
+
+
 //---- Housekeeping
 void initState(uint64_t state[/*16*/]);

@@ -170,27 +234,12 @@ void reducedSqueezeRow0(uint64_t* state, uint64_t* row, uint64_t nCols);

 //---- Absorbs
 void absorbBlock(uint64_t *state, const uint64_t *in);
-void absorbBlockBlake2Safe(uint64_t *state, const uint64_t *in);
+void absorbBlockBlake2Safe( uint64_t *state, const uint64_t *in,
+                            const uint64_t nBlocks, const uint64_t block_len );

 //---- Duplexes
 void reducedDuplexRow1(uint64_t *state, uint64_t *rowIn, uint64_t *rowOut, uint64_t nCols);
 void reducedDuplexRowSetup(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut, uint64_t nCols);
 void reducedDuplexRow(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut, uint64_t nCols);

-//---- Misc
-void printArray(unsigned char *array, unsigned int size, char *name);
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-////TESTS////
-//void reducedDuplexRowc(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
-//void reducedDuplexRowd(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
-//void reducedDuplexRowSetupv4(uint64_t *state, uint64_t *rowIn1, uint64_t *rowIn2, uint64_t *rowOut1, uint64_t *rowOut2);
-//void reducedDuplexRowSetupv5(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
-//void reducedDuplexRowSetupv5c(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
-//void reducedDuplexRowSetupv5d(uint64_t *state, uint64_t *rowIn, uint64_t *rowInOut, uint64_t *rowOut);
-/////////////
-
-
 #endif /* SPONGE_H_ */
--- a/algo/m7m.c
+++ b/algo/m7m.c
@@ -19,100 +19,89 @@
 #define EPS1 DBL_EPSILON
 #define EPS2 3.0e-11

-inline double exp_n(double xt)
+inline double exp_n( double xt )
 {
-    if(xt < -700.0)
+    if ( xt < -700.0 )
        return 0;
-    else if(xt > 700.0)
+    else if ( xt > 700.0 )
        return 1e200;
-    else if(xt > -0.8e-8 && xt < 0.8e-8)
-        return (1.0 + xt);
+    else if ( xt > -0.8e-8 && xt < 0.8e-8 )
+        return ( 1.0 + xt );
    else
-        return exp(xt);
+        return exp( xt );
 }

-inline double exp_n2(double x1, double x2)
+inline double exp_n2( double x1, double x2 )
 {
-    double p1 = -700., p2 = -37., p3 = -0.8e-8, p4 = 0.8e-8, p5 = 37., p6 = 700.;
+    double p1 = -700., p2 = -37., p3 = -0.8e-8, p4 = 0.8e-8,
+           p5 = 37., p6 = 700.;
    double xt = x1 - x2;
-    if (xt < p1+1.e-200)
+    if ( xt < p1+1.e-200 )
        return 1.;
-    else if (xt > p1 && xt < p2 + 1.e-200)
+    else if ( xt > p1 && xt < p2 + 1.e-200 )
        return ( 1. - exp(xt) );
-    else if (xt > p2 && xt < p3 + 1.e-200)
-        return ( 1. / (1. + exp(xt)) );
-    else if (xt > p3 && xt < p4)
+    else if ( xt > p2 && xt < p3 + 1.e-200 )
+        return ( 1. / ( 1. + exp(xt) ) );
+    else if ( xt > p3 && xt < p4 )
        return ( 1. / (2. + xt) );
-    else if (xt > p4 - 1.e-200 && xt < p5)
-        return ( exp(-xt) / (1. + exp(-xt)) );
-    else if (xt > p5 - 1.e-200 && xt < p6)
+    else if ( xt > p4 - 1.e-200 && xt < p5 )
+        return ( exp(-xt) / ( 1. + exp(-xt) ) );
+    else if ( xt > p5 - 1.e-200 && xt < p6 )
        return ( exp(-xt) );
-    else if (xt > p6 - 1.e-200)
+    else if ( xt > p6 - 1.e-200 )
        return 0.;
 }

-double swit2_(double wvnmb)
+double swit2_( double wvnmb )
 {
-    return pow( (5.55243*(exp_n(-0.3*wvnmb/15.762) - exp_n(-0.6*wvnmb/15.762)))*wvnmb, 0.5) 
-	  / 1034.66 * pow(sin(wvnmb/65.), 2.);
+    return pow( ( 5.55243 * ( exp_n( -0.3 * wvnmb / 15.762 )
+                - exp_n( -0.6 * wvnmb / 15.762 ) ) ) * wvnmb, 0.5 ) 
+	        / 1034.66 * pow( sin( wvnmb / 65. ), 2. );
 }

-
-double GaussianQuad_N2(const double x1, const double x2)
+double GaussianQuad_N2( const double x1, const double x2 )
 {
-    double s=0.0;
+    double s = 0.0;
    double x[6], w[6];
    //gauleg(a2, b2, x, w);
    
    double z1, z, xm, xl, pp, p3, p2, p1;
-    xm=0.5*(x2+x1);
-    xl=0.5*(x2-x1);
-    for(int i=1;i<=3;i++)
+    xm = 0.5 * ( x2 + x1 );
+    xl = 0.5 * ( x2 - x1 );
+    for( int i = 1; i <= 3; i++ )
    {
-		z = (i == 1) ? 0.909632 : -0.0;
-		z = (i == 2) ? 0.540641 : z;
-	    do
+      z = (i == 2) ? 0.540641 : ( (i == 1) ? 0.909632 : -0.0 );
+      do
 	    {
-			p1 = z;
-			p2 = 1;
-			p3 = 0;
-			
-			p3=1;
-			p2=z;
-			p1=((3.0 * z * z) - 1) / 2;
-			
-			p3=p2;
-			p2=p1;
-			p1=((5.0 * z * p2) - (2.0 * z)) / 3;
-			
-			p3=p2;
-			p2=p1;
-			p1=((7.0 * z * p2) - (3.0 * p3)) / 4;
-			
-			p3=p2;
-			p2=p1;
-			p1=((9.0 * z * p2) - (4.0 * p3)) / 5;
-		    
-		    pp=5*(z*p1-p2)/(z*z-1.0);
-		    z1=z;
-		    z=z1-p1/pp;
-	    } while (fabs(z-z1) > 3.0e-11);
+			p1 = ( ( 3.0 * z * z ) - 1 ) / 2;
+			p2 = p1;
+         p1 = ( ( 5.0 * z * p2 ) - ( 2.0 * z ) ) / 3;
+			p3 = p2;
+			p2 = p1;
+			p1 = ( ( 7.0 * z * p2 ) - ( 3.0 * p3 ) ) / 4;
+			p3 = p2;
+			p2 = p1;
+			p1 = ( ( 9.0 * z * p2 ) - ( 4.0 * p3 ) ) / 5;
+         pp = 5 * ( z * p1 - p2 ) / ( z * z - 1.0 );
+		   z1 = z;
+		   z = z1 - p1 / pp;
+	    } while ( fabs( z - z1 ) > 3.0e-11 );
 	    
-	    x[i]=xm-xl*z;
-	    x[5+1-i]=xm+xl*z;
-	    w[i]=2.0*xl/((1.0-z*z)*pp*pp);
-	    w[5+1-i]=w[i];
+	    x[i]       = xm - xl * z;
+	    x[ 5+1-i ] = xm + xl * z;
+	    w[i]       = 2.0 * xl / ( ( 1.0 - z * z ) * pp * pp );
+	    w[ 5+1-i ] = w [i];
    }
    
-    for(int j=1; j<=5; j++) s += w[j]*swit2_(x[j]);
+    for( int j = 1; j <= 5; j++ ) s += w[j] * swit2_( x[j] );
    
    return s;
 }

-uint32_t sw2_(int nnounce)
+uint32_t sw2_( int nnounce )
 {
-    double wmax = ((sqrt((double)(nnounce))*(1.+EPSa))/450+100);
-    return ((uint32_t)(GaussianQuad_N2(0., wmax)*(1.+EPSa)*1.e6));
+    double wmax = ( ( sqrt( (double)(nnounce) ) * ( 1.+EPSa ) ) / 450+100 );
+    return ( (uint32_t)( GaussianQuad_N2( 0., wmax ) * ( 1.+EPSa ) * 1.e6 ) );
 }

 typedef struct {
@@ -307,8 +296,6 @@ int scanhash_m7m_hash( struct work* work, uint64_t max_nonce,

     pdata[19] = n;

-// can this be skipped after finding a share? Seems to work ok.
-//out:
     mpf_set_prec_raw(magifpi, prec0);
     mpf_set_prec_raw(magifpi0, prec0);
     mpf_set_prec_raw(mptmp, prec0);
@@ -323,7 +310,7 @@ int scanhash_m7m_hash( struct work* work, uint64_t max_nonce,
     mpz_clears(magipi, magisw, product, bns0, bns1, NULL);

    *hashes_done = n - first_nonce + 1;
-    return rc;
+    return 0;
 }

 bool register_m7m_algo( algo_gate_t *gate )
@@ -334,9 +321,8 @@ bool register_m7m_algo( algo_gate_t *gate )
  gate->build_stratum_request = (void*)&std_be_build_stratum_request;
  gate->work_decode           = (void*)&std_be_work_decode;
  gate->submit_getwork_result = (void*)&std_be_submit_getwork_result;
-  gate->set_target            = (void*)&scrypt_set_target;
-  gate->get_max64             = (void*)&get_max64_0x1ffff;
  gate->set_work_data_endian  = (void*)&set_work_data_big_endian;
+  opt_target_factor = 65536.0;
  return true;
 }

--- a/algo/nist5/nist5-4way.c
+++ b/algo/nist5/nist5-4way.c
@@ -3,39 +3,140 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-
-#if defined(NIST5_4WAY)
-
 #include "algo/blake/blake-hash-4way.h"
 #include "algo/skein/skein-hash-4way.h"
 #include "algo/jh/jh-hash-4way.h"
 #include "algo/keccak/keccak-hash-4way.h"
 #include "algo/groestl/aes_ni/hash-groestl.h"

-// no improvement with midstate
-//static __thread blake512_4way_context ctx_mid;
+#if defined(NIST5_8WAY)

-void nist5hash_4way( void *out, const void *input )
+void nist5hash_8way( void *out, const void *input )
 {
+     uint64_t vhash[8*16] __attribute__ ((aligned (128)));
+     uint64_t hash0[8] __attribute__ ((aligned (64)));
+     uint64_t hash1[8] __attribute__ ((aligned (64)));
+     uint64_t hash2[8] __attribute__ ((aligned (64)));
+     uint64_t hash3[8] __attribute__ ((aligned (64)));
+     uint64_t hash4[8] __attribute__ ((aligned (64)));
+     uint64_t hash5[8] __attribute__ ((aligned (64)));
+     uint64_t hash6[8] __attribute__ ((aligned (64)));
+     uint64_t hash7[8] __attribute__ ((aligned (64)));
+
+     blake512_8way_context  ctx_blake;
+     hashState_groestl      ctx_groestl;
+     jh512_8way_context     ctx_jh;
+     skein512_8way_context  ctx_skein;
+     keccak512_8way_context ctx_keccak;
+
+     blake512_8way_init( &ctx_blake );
+     blake512_8way_update( &ctx_blake, input, 80 );
+     blake512_8way_close( &ctx_blake, vhash );
+
+     dintrlv_8x64( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
+                   vhash, 512 );
+
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash0,
+                               (const char*)hash0, 512 );
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash1,
+                               (const char*)hash1, 512 );
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash2,
+                               (const char*)hash2, 512 );
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash3,
+                               (const char*)hash3, 512 );
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash4,
+                               (const char*)hash4, 512 );
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash5,
+                               (const char*)hash5, 512 );
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash6,
+                               (const char*)hash6, 512 );
+     init_groestl( &ctx_groestl, 64 );
+     update_and_final_groestl( &ctx_groestl, (char*)hash7,
+                               (const char*)hash7, 512 );
+
+     intrlv_8x64( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
+                         hash7, 512 );
+
+     jh512_8way_init( &ctx_jh );
+     jh512_8way_update( &ctx_jh, vhash, 64 );
+     jh512_8way_close( &ctx_jh, vhash );
+
+     keccak512_8way_init( &ctx_keccak );
+     keccak512_8way_update( &ctx_keccak, vhash, 64 );
+     keccak512_8way_close( &ctx_keccak, vhash );
+
+     skein512_8way_init( &ctx_skein );
+     skein512_8way_update( &ctx_skein, vhash, 64 );
+     skein512_8way_close( &ctx_skein, out );
+}
+
+int scanhash_nist5_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
+{
+     uint32_t hash[16*8] __attribute__ ((aligned (128)));
+     uint32_t vdata[24*8] __attribute__ ((aligned (64)));
+     uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+     uint32_t *hash7 = &(hash[49]);
+     uint32_t *pdata = work->data;
+     uint32_t *ptarget = work->target;
+     uint32_t n = pdata[19];
+     const uint32_t first_nonce = pdata[19];
+     const uint32_t Htarg = ptarget[7];
+     __m512i  *noncev = (__m512i*)vdata + 9;   // aligned
+     int thr_id = mythr->id;  
+
+     mm512_bswap32_intrlv80_8x64( vdata, pdata );
+
+     do {
+        *noncev = mm512_intrlv_blend_32( mm512_bswap_32(
+               _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
+                                 n+3, 0, n+2, 0, n+1, 0, n  , 0 ) ), *noncev );
+
+        nist5hash_8way( hash, vdata );
+
+        for ( int lane = 0; lane < 8; lane++ )
+        if ( hash7[ lane<<1 ] < Htarg )
+        {
+           extr_lane_8x64( lane_hash, hash, lane, 256 );
+           if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+           {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+           }
+        }
+        n += 8;
+     } while ( ( n < max_nonce-8 ) && !work_restart[thr_id].restart );
+     *hashes_done = n - first_nonce;
+     return 0;
+}
+
+#elif defined(NIST5_4WAY)
+
+void nist5hash_4way( void *out, const void *input )
+{
+     uint64_t vhash[8*4] __attribute__ ((aligned (128)));
     uint64_t hash0[8] __attribute__ ((aligned (64)));
     uint64_t hash1[8] __attribute__ ((aligned (64)));
     uint64_t hash2[8] __attribute__ ((aligned (64)));
     uint64_t hash3[8] __attribute__ ((aligned (64)));
-     uint64_t vhash[8*4] __attribute__ ((aligned (64)));
     blake512_4way_context  ctx_blake;
     hashState_groestl      ctx_groestl;
     jh512_4way_context     ctx_jh;
     skein512_4way_context  ctx_skein;
     keccak512_4way_context ctx_keccak;

-//     memcpy( &ctx_blake, &ctx_mid, sizeof(ctx_mid) );
-//     blake512_4way( &ctx_blake, input + (64<<2), 16 );
-
     blake512_4way_init( &ctx_blake );
     blake512_4way( &ctx_blake, input, 80 );
     blake512_4way_close( &ctx_blake, vhash );

-     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+     dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );

     init_groestl( &ctx_groestl, 64 );
     update_and_final_groestl( &ctx_groestl, (char*)hash0,
@@ -50,7 +151,7 @@ void nist5hash_4way( void *out, const void *input )
     update_and_final_groestl( &ctx_groestl, (char*)hash3,
                               (const char*)hash3, 512 );

-     mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+     intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );

     jh512_4way_init( &ctx_jh );
     jh512_4way( &ctx_jh, vhash, 64 );
@@ -68,73 +169,39 @@ void nist5hash_4way( void *out, const void *input )
 int scanhash_nist5_4way( struct work *work, uint32_t max_nonce,
                         uint64_t *hashes_done, struct thr_info *mythr )
 {
+     uint32_t vdata[4*24] __attribute__ ((aligned (128)));
     uint32_t hash[4*16] __attribute__ ((aligned (64)));
     uint32_t *hash7 = &(hash[25]);
     uint32_t lane_hash[8] __attribute__ ((aligned (32)));
-     uint32_t vdata[24*4] __attribute__ ((aligned (64)));
-     uint32_t endiandata[20] __attribute__((aligned(64)));
     uint32_t *pdata = work->data;
     uint32_t *ptarget = work->target;
     uint32_t n = pdata[19];
     const uint32_t first_nonce = pdata[19];
     const uint32_t Htarg = ptarget[7];
-     uint32_t *noncep = vdata + 73;   // 9*8 + 1
-     int thr_id = mythr->id;  // thr_id arg is deprecated
+     __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+     int thr_id = mythr->id;  

-     uint64_t htmax[] = {          0,
-                                 0xF,
-                                0xFF,
-                               0xFFF,
-                              0xFFFF,
-                          0x10000000 };
+     mm256_bswap32_intrlv80_4x64( vdata, pdata );

-     uint32_t masks[] = { 0xFFFFFFFF,
-                          0xFFFFFFF0,
-                          0xFFFFFF00,
-                          0xFFFFF000,
-                          0xFFFF0000,
-                                   0 };
+     do {
+        *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+               _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );

-     // we need bigendian data...
-     swab32_array( endiandata, pdata, 20 );
+        nist5hash_4way( hash, vdata );

-     uint64_t *edata = (uint64_t*)endiandata;
-     mm256_intrlv_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
-
-     // precalc midstate
-//     blake512_4way_init( &ctx_mid );
-//     blake512_4way( &ctx_mid, vdata, 64 );
-
-     for ( int m=0; m < 6; m++ )
-     {
-        if (Htarg <= htmax[m])
+        for ( int lane = 0; lane < 4; lane++ )
+        if ( hash7[ lane<<1 ] < Htarg )
        {
-           uint32_t mask = masks[m];
-
-           do {
-              be32enc( noncep,   n   );
-              be32enc( noncep+2, n+1 );
-              be32enc( noncep+4, n+2 );
-              be32enc( noncep+6, n+3 );
-
-              nist5hash_4way( hash, vdata );
-
-              for ( int lane = 0; lane < 4; lane++ )
-              if ( ( hash7[ lane ] & mask ) == 0 )
-              {
-                 mm256_extr_lane_4x64( lane_hash, hash, lane, 256 );
-                 if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
-                 {
-                    pdata[19] = n + lane;
-                    submit_lane_solution( work, lane_hash, mythr, lane );
-                 }
-              }
-              n += 4;
-           } while ( ( n < max_nonce ) && !work_restart[thr_id].restart );
-           break;
+           extr_lane_4x64( lane_hash, hash, lane, 256 );
+           if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+           {
+              pdata[19] = n + lane;
+              submit_lane_solution( work, lane_hash, mythr, lane );
+           }
        }
-     }
-     *hashes_done = n - first_nonce + 1;
+        n += 4;
+     } while ( ( n < max_nonce-4 ) && !work_restart[thr_id].restart );
+     *hashes_done = n - first_nonce;
     return 0;
 }

--- a/algo/nist5/nist5-gate.c
+++ b/algo/nist5/nist5-gate.c
@@ -2,8 +2,11 @@

 bool register_nist5_algo( algo_gate_t* gate )
 {
-    gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT;
-#if defined (NIST5_4WAY)
+    gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT;
+#if defined (NIST5_8WAY)
+    gate->scanhash = (void*)&scanhash_nist5_8way;
+    gate->hash     = (void*)&nist5hash_8way;
+#elif defined (NIST5_4WAY)
    gate->scanhash = (void*)&scanhash_nist5_4way;
    gate->hash     = (void*)&nist5hash_4way;
 #else
--- a/algo/nist5/nist5-gate.h
+++ b/algo/nist5/nist5-gate.h
@@ -1,14 +1,23 @@
 #ifndef __NIST5_GATE_H__
-#define __NIST5_GATE_H__
+#define __NIST5_GATE_H__ 1

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

-#if defined(__AVX2__) && defined(__AES__)
-  #define NIST5_4WAY
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define NIST5_8WAY 1
+#elif defined(__AVX2__) && defined(__AES__)
+  #define NIST5_4WAY 1
 #endif

-#if defined(NIST5_4WAY)
+#if defined(NIST5_8WAY)
+
+void nist5hash_8way( void *state, const void *input );
+
+int scanhash_nist5_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined(NIST5_4WAY)

 void nist5hash_4way( void *state, const void *input );

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jay D Dee	3d1b6c87dc	v3.10.3	2019-12-14 01:01:54 -05:00
Jay D Dee	a17ff6f189	v3.10.2	2019-12-09 15:59:02 -05:00
Jay D Dee	73430b13b1	v3.10.1	2019-12-05 19:09:23 -05:00
Jay D Dee	40039386a0	v3.10.0	2019-12-03 12:26:11 -05:00
Jay D Dee	91ec6f1771	v3.9.11	2019-11-26 09:22:03 -05:00
Jay D Dee	a52c5eccf7	v3.9.10	2019-11-22 20:29:18 -05:00
Jay D Dee	86b889e1b0	v3.9.9.1	2019-10-24 14:11:26 -04:00
Jay D Dee	72330eb5a7	v3.9.9	2019-10-10 19:58:34 -04:00
Jay D Dee	789c8b70bc	v3.9.8.1	2019-10-01 14:17:36 -04:00
Jay D Dee	01550d94a2	v3.9.8	2019-09-26 22:37:26 -04:00
Jay D Dee	a042fb7612	v3.9.7	2019-08-03 10:39:54 -04:00
Jay D Dee	9d49e0be7a	v3.9.6.2	2019-07-30 10:16:43 -04:00
Jay D Dee	a51f59086b	v3.9.6.1	2019-07-18 19:46:57 -04:00
Jay D Dee	6f49ba09b7	v3.9.6	2019-07-17 17:54:38 -04:00
Jay D Dee	e2d5762ef2	v3.9.5.4	2019-07-15 17:00:26 -04:00
Jay D Dee	e625ed5420	v3.9.5.3	2019-07-12 10:42:38 -04:00
Jay D Dee	9abc19a30a	v3.9.5.2	2019-07-04 12:12:11 -04:00