v3.7.9

algo/x14/axiom.c

@@ -0,0 +1,86 @@
+#include "algo-gate-api.h"
+
+#include <string.h>
+#include <stdint.h>
+
+#include "algo/shabal/sph_shabal.h"
+
+static __thread uint32_t _ALIGN(64) M[65536][8];
+
+void axiomhash(void *output, const void *input)
+{
+	sph_shabal256_context ctx __attribute__ ((aligned (64)));
+	const int N = 65536;
+
+	sph_shabal256_init(&ctx);
+	sph_shabal256(&ctx, input, 80);
+	sph_shabal256_close(&ctx, M[0]);
+
+	for(int i = 1; i < N; i++) {
+		sph_shabal256_init(&ctx);
+		sph_shabal256(&ctx, M[i-1], 32);
+		sph_shabal256_close(&ctx, M[i]);
+	}
+
+	for(int b = 0; b < N; b++)
+	{
+		const int p = b > 0 ? b - 1 : 0xFFFF;
+		const int q = M[p][0] % 0xFFFF;
+		const int j = (b + q) % N;
+
+		sph_shabal256_init(&ctx);
+#if 0
+		sph_shabal256(&ctx, M[p], 32);
+		sph_shabal256(&ctx, M[j], 32);
+#else
+		uint8_t _ALIGN(64) hash[64];
+		memcpy(hash, M[p], 32);
+		memcpy(&hash[32], M[j], 32);
+		sph_shabal256(&ctx, hash, 64);
+#endif
+		sph_shabal256_close(&ctx, M[b]);
+	}
+	memcpy(output, M[N-1], 32);
+}
+
+int scanhash_axiom(int thr_id, struct work *work,
+	uint32_t max_nonce, uint64_t *hashes_done)
+{
+        uint32_t *pdata = work->data;
+        uint32_t *ptarget = work->target;
+	uint32_t _ALIGN(64) hash64[8];
+	uint32_t _ALIGN(64) endiandata[20];
+
+	const uint32_t Htarg = ptarget[7];
+	const uint32_t first_nonce = pdata[19];
+
+	uint32_t n = first_nonce;
+
+        for (int k = 0; k < 19; k++)
+                be32enc(&endiandata[k], pdata[k]);
+
+	do {
+		be32enc(&endiandata[19], n);
+		axiomhash(hash64, endiandata);
+		if (hash64[7] < Htarg && fulltest(hash64, ptarget)) {
+			*hashes_done = n - first_nonce + 1;
+			pdata[19] = n;
+			return true;
+		}
+		n++;
+
+	} while (n < max_nonce && !work_restart[thr_id].restart);
+
+	*hashes_done = n - first_nonce + 1;
+	pdata[19] = n;
+
+	return 0;
+}
+
+bool register_axiom_algo( algo_gate_t* gate )
+{
+    gate->scanhash  = (void*)&scanhash_axiom;
+    gate->hash      = (void*)&axiomhash;
+    gate->get_max64 = (void*)&get_max64_0x40LL;
+    return true;
+}

algo/x14/polytimos-4way.c

@@ -0,0 +1,185 @@
+#include "polytimos-gate.h"
+
+#if defined(__AVX2__) && defined(__AES__)
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include "algo/skein/skein-hash-4way.h"
+#include "algo/shabal/shabal-hash-4way.h"
+#include "algo/fugue//sph_fugue.h"
+#include "algo/luffa/sse2/luffa_for_sse2.h"
+//#include "algo/shabal/sph_shabal.h"
+#include "algo/gost/sph_gost.h"
+#include "algo/echo/aes_ni/hash_api.h"
+
+typedef struct {
+   skein512_4way_context   skein;
+   shabal512_4way_context  shabal;
+   hashState_echo          echo;
+   hashState_luffa         luffa;
+   sph_fugue512_context    fugue;
+   sph_gost512_context     gost;
+} poly_4way_ctx_holder;
+
+poly_4way_ctx_holder poly_4way_ctx;
+
+void init_polytimos_4way_ctx()
+{
+   skein512_4way_init( &poly_4way_ctx.skein );
+   shabal512_4way_init( &poly_4way_ctx.shabal );
+   init_echo( &poly_4way_ctx.echo, 512  );
+   init_luffa( &poly_4way_ctx.luffa, 512 );
+   sph_fugue512_init( &poly_4way_ctx.fugue );
+   sph_gost512_init( &poly_4way_ctx.gost );
+}
+
+void polytimos_4way_hash( void *output, const void *input )
+{
+     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)));
+     poly_4way_ctx_holder ctx __attribute__ ((aligned (64)));
+     memcpy( &ctx, &poly_4way_ctx, sizeof(poly_4way_ctx) );
+
+     skein512_4way( &ctx.skein, input, 80 );
+     skein512_4way_close( &ctx.skein, vhash );
+
+     // Need to convert from 64 bit interleaved to 32 bit interleaved.
+     uint32_t vhash32[16*4];
+     mm256_reinterleave_4x32( vhash32, vhash, 512 );
+     shabal512_4way( &ctx.shabal, vhash32, 64 );
+     shabal512_4way_close( &ctx.shabal, vhash32 );
+     mm_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash32, 512 );
+
+     update_final_echo ( &ctx.echo, (BitSequence *)hash0,
+                         (const BitSequence *)hash0, 512 );
+     memcpy( &ctx.echo, &poly_4way_ctx.echo, sizeof(hashState_echo) );
+     update_final_echo( &ctx.echo, (BitSequence *)hash1,
+                       (const BitSequence *) hash1, 512 );
+     memcpy( &ctx.echo, &poly_4way_ctx.echo, sizeof(hashState_echo) );
+     update_final_echo( &ctx.echo, (BitSequence *)hash2,
+                       (const BitSequence *) hash2, 512 );
+     memcpy( &ctx.echo, &poly_4way_ctx.echo, sizeof(hashState_echo) );
+     update_final_echo( &ctx.echo, (BitSequence *)hash3,
+                       (const BitSequence *) hash3, 512 );
+
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash0,
+                             (const BitSequence*)hash0, 64 );
+     memcpy( &ctx.luffa, &poly_4way_ctx.luffa, sizeof(hashState_luffa) );
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash1,
+                             (const BitSequence*)hash1, 64 );
+     memcpy( &ctx.luffa, &poly_4way_ctx.luffa, sizeof(hashState_luffa) );
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash2,
+                             (const BitSequence*)hash2, 64 );
+     memcpy( &ctx.luffa, &poly_4way_ctx.luffa, sizeof(hashState_luffa) );
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash3,
+                             (const BitSequence*)hash3, 64 );
+
+     sph_fugue512( &ctx.fugue, hash0, 64 );
+     sph_fugue512_close( &ctx.fugue, hash0 );
+     memcpy( &ctx.fugue, &poly_4way_ctx.fugue, sizeof(sph_fugue512_context) );
+     sph_fugue512( &ctx.fugue, hash1, 64 );
+     sph_fugue512_close( &ctx.fugue, hash1 );
+     memcpy( &ctx.fugue, &poly_4way_ctx.fugue, sizeof(sph_fugue512_context) );
+     sph_fugue512( &ctx.fugue, hash2, 64 );
+     sph_fugue512_close( &ctx.fugue, hash2 );
+     memcpy( &ctx.fugue, &poly_4way_ctx.fugue, sizeof(sph_fugue512_context) );
+     sph_fugue512( &ctx.fugue, hash3, 64 );
+     sph_fugue512_close( &ctx.fugue, hash3 );
+
+     sph_gost512( &ctx.gost, hash0, 64 );
+     sph_gost512_close( &ctx.gost, hash0 );
+     sph_gost512_init( &ctx.gost );
+     sph_gost512( &ctx.gost, hash1, 64 );
+     sph_gost512_close( &ctx.gost, hash1 );
+     sph_gost512_init( &ctx.gost );
+     sph_gost512( &ctx.gost, hash2, 64 );
+     sph_gost512_close( &ctx.gost, hash2 );
+     sph_gost512_init( &ctx.gost );
+     sph_gost512( &ctx.gost, hash3, 64 );
+     sph_gost512_close( &ctx.gost, hash3 );
+
+     memcpy( output,    hash0, 32 );
+     memcpy( output+32, hash1, 32 );
+     memcpy( output+64, hash2, 32 );
+     memcpy( output+96, hash3, 32 );
+}
+
+int scanhash_polytimos_4way( int thr_id, struct work *work, uint32_t max_nonce,                              uint64_t *hashes_done )
+{
+   uint32_t hash[4*8] __attribute__ ((aligned (64)));
+   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;
+   const uint32_t first_nonce = pdata[19];
+   uint32_t n = first_nonce;
+   uint32_t *nonces = work->nonces;
+   bool *found = work->nfound;
+   int num_found = 0;
+   uint32_t *noncep0 = vdata + 73;   // 9*8 + 1
+   uint32_t *noncep1 = vdata + 75;
+   uint32_t *noncep2 = vdata + 77;
+   uint32_t *noncep3 = vdata + 79;
+   const uint32_t Htarg = ptarget[7];
+   volatile uint8_t *restart = &(work_restart[thr_id].restart);
+
+   if ( opt_benchmark )
+      ptarget[7] = 0x0cff;
+
+   for ( int i=0; i < 19; i++ )
+      be32enc( &endiandata[i], pdata[i] );
+
+   uint64_t *edata = (uint64_t*)endiandata;
+   mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+   do {
+      found[0] = found[1] = found[2] = found[3] = false;
+      be32enc( noncep0, n   );
+      be32enc( noncep1, n+1 );
+      be32enc( noncep2, n+2 );
+      be32enc( noncep3, n+3 );
+
+      polytimos_4way_hash(hash, vdata);
+      pdata[19] = n;
+
+      if ( hash[7] <= Htarg && fulltest( hash, ptarget ) )
+      {
+         found[0] = true;
+         num_found++;
+         nonces[0] = n;
+         work_set_target_ratio( work, hash );
+      }
+      if ( (hash+8)[7] <= Htarg && fulltest( hash+8, ptarget ) )
+      {
+         found[1] = true;
+         num_found++;
+         nonces[1] = n+1;
+         work_set_target_ratio( work, hash+8 );
+      }
+      if ( (hash+16)[7] <= Htarg && fulltest( hash+16, ptarget ) )
+      {
+         found[2] = true;
+         num_found++;
+         nonces[2] = n+2;
+         work_set_target_ratio( work, hash+16 );
+      }
+      if ( (hash+24)[7] <= Htarg && fulltest( hash+24, ptarget ) )
+      {
+         found[3] = true;
+         num_found++;
+         nonces[3] = n+3;
+         work_set_target_ratio( work, hash+24 );
+      }
+      n += 4;
+
+   } while ( ( num_found == 0 ) && ( n < max_nonce ) && !(*restart));
+
+   *hashes_done = n - first_nonce + 1;
+   return num_found;
+}
+
+#endif

algo/x14/polytimos-gate.c

@@ -0,0 +1,18 @@
+#include "polytimos-gate.h"
+
+bool register_polytimos_algo( algo_gate_t* gate )
+{
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX_OPT | AVX2_OPT | FOUR_WAY_OPT;
+#ifdef POLYTIMOS_4WAY
+  init_polytimos_4way_ctx();
+  gate->scanhash  = (void*)&scanhash_polytimos_4way;
+  gate->hash      = (void*)&polytimos_4way_hash;
+#else
+  init_polytimos_context();
+  gate->scanhash  = (void*)&scanhash_polytimos;
+  gate->hash      = (void*)&polytimos_hash;
+#endif
+  gate->get_max64 = (void*)&get_max64_0x3ffff;
+  return true;
+};
+

algo/x14/polytimos-gate.h

@@ -0,0 +1,32 @@
+#ifndef POLYTIMOS_GATE_H__
+#define POLYTIMOS_GATE_H__ 1
+
+#include "algo-gate-api.h"
+#include <stdint.h>
+
+#if defined(HASH_4WAY) && defined(__AES__)
+  #define POLYTIMOS_4WAY
+#endif
+
+bool register_polytimos_algo( algo_gate_t* gate );
+
+#if defined(POLYTIMOS_4WAY)
+
+void polytimos_4way_hash( void *state, const void *input );
+
+int scanhash_polytimos_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                       uint64_t *hashes_done );
+
+void init_polytimos_4way_ctx();
+
+#endif
+
+void polytimos_hash( void *state, const void *input );
+
+int scanhash_polytimos( int thr_id, struct work *work, uint32_t max_nonce,
+                  uint64_t *hashes_done );
+
+void init_polytimos_ctx();
+
+#endif
+

algo/x14/polytimos.c

@@ -0,0 +1,115 @@
+#include "polytimos-gate.h"
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "algo/skein/sph_skein.h"
+#include "algo/echo/sph_echo.h"
+#include "algo/fugue//sph_fugue.h"
+#include "algo/luffa/sse2/luffa_for_sse2.h"
+#include "algo/shabal/sph_shabal.h"
+#include "algo/gost/sph_gost.h"
+#ifndef NO_AES_NI
+  #include "algo/echo/aes_ni/hash_api.h"
+#endif
+
+typedef struct {
+	sph_skein512_context    skein;
+        sph_shabal512_context   shabal;
+#ifdef NO_AES_NI
+	sph_echo512_context		echo;
+#else
+        hashState_echo          echo;
+#endif
+        hashState_luffa         luffa;
+	sph_fugue512_context    fugue;
+	sph_gost512_context     gost;
+} poly_ctx_holder;
+
+poly_ctx_holder poly_ctx;
+
+void init_polytimos_context()
+{
+	sph_skein512_init(&poly_ctx.skein);
+        sph_shabal512_init(&poly_ctx.shabal);
+#ifdef NO_AES_NI
+        sph_echo512_init(&poly_ctx.echo);
+#else
+        init_echo( &poly_ctx.echo, 512 );
+#endif
+        init_luffa( &poly_ctx.luffa, 512 );
+        sph_fugue512_init(&poly_ctx.fugue);
+        sph_gost512_init(&poly_ctx.gost);
+}
+
+void polytimos_hash(void *output, const void *input)
+{
+        uint32_t hashA[16] __attribute__ ((aligned (64)));
+        poly_ctx_holder ctx __attribute__ ((aligned (64)));
+        memcpy( &ctx, &poly_ctx, sizeof(poly_ctx) );
+
+	sph_skein512(&ctx.skein, input, 80);
+	sph_skein512_close(&ctx.skein, hashA);
+
+	sph_shabal512(&ctx.shabal, hashA, 64);
+	sph_shabal512_close(&ctx.shabal, hashA);
+
+#ifdef NO_AES_NI
+	sph_echo512(&ctx.echo, hashA, 64);
+	sph_echo512_close(&ctx.echo, hashA);
+#else
+        update_final_echo ( &ctx.echo, (BitSequence *)hashA,
+                            (const BitSequence *)hashA, 512 );
+#endif
+
+        update_and_final_luffa( &ctx.luffa, (BitSequence*)hashA,
+                                (const BitSequence*)hashA, 64 );
+
+	sph_fugue512(&ctx.fugue, hashA, 64);
+	sph_fugue512_close(&ctx.fugue, hashA);
+
+	sph_gost512(&ctx.gost, hashA, 64);
+	sph_gost512_close(&ctx.gost, hashA);
+
+	memcpy(output, hashA, 32);
+}
+
+int scanhash_polytimos(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
+{
+	uint32_t _ALIGN(128) hash[8];
+	uint32_t _ALIGN(128) endiandata[20];
+	uint32_t *pdata = work->data;
+	uint32_t *ptarget = work->target;
+
+	const uint32_t Htarg = ptarget[7];
+	const uint32_t first_nonce = pdata[19];
+	uint32_t nonce = first_nonce;
+	volatile uint8_t *restart = &(work_restart[thr_id].restart);
+
+	if (opt_benchmark)
+		ptarget[7] = 0x0cff;
+
+	// we need bigendian data...
+	for (int i=0; i < 19; i++) {
+		be32enc(&endiandata[i], pdata[i]);
+	}
+	do {
+		be32enc(&endiandata[19], nonce);
+		polytimos_hash(hash, endiandata);
+
+		if (hash[7] <= Htarg && fulltest(hash, ptarget)) {
+			work_set_target_ratio(work, hash);
+			pdata[19] = nonce;
+			*hashes_done = pdata[19] - first_nonce;
+			return 1;
+		}
+		nonce++;
+
+	} while (nonce < max_nonce && !(*restart));
+
+	pdata[19] = nonce;
+	*hashes_done = pdata[19] - first_nonce + 1;
+	return 0;
+}

algo/x14/veltor-4way.c

@@ -0,0 +1,154 @@
+#include "veltor-gate.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#if defined(__AVX2__) && defined(__AES__)
+
+#include "algo/skein/skein-hash-4way.h"
+#include "algo/shavite/sph_shavite.h"
+#include "algo/shabal/shabal-hash-4way.h"
+#include "algo/gost/sph_gost.h"
+
+typedef struct {
+    skein512_4way_context   skein;
+    sph_shavite512_context  shavite;
+    shabal512_4way_context  shabal;
+    sph_gost512_context     gost;
+} veltor_4way_ctx_holder;
+
+veltor_4way_ctx_holder veltor_4way_ctx __attribute__ ((aligned (64)));
+
+void init_veltor_4way_ctx()
+{
+     skein512_4way_init( &veltor_4way_ctx.skein );
+     sph_shavite512_init( &veltor_4way_ctx.shavite );
+     shabal512_4way_init( &veltor_4way_ctx.shabal );
+     sph_gost512_init( &veltor_4way_ctx.gost );
+}
+
+void veltor_4way_hash( void *output, const void *input )
+{
+     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)));
+     veltor_4way_ctx_holder ctx __attribute__ ((aligned (64)));
+     memcpy( &ctx, &veltor_4way_ctx, sizeof(veltor_4way_ctx) );
+
+     skein512_4way( &ctx.skein, input, 80 );
+     skein512_4way_close( &ctx.skein, vhash );
+     mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+     sph_shavite512( &ctx.shavite, hash0, 64 );
+     sph_shavite512_close( &ctx.shavite, hash0 );
+     sph_shavite512_init( &ctx.shavite );
+     sph_shavite512( &ctx.shavite, hash1, 64 );
+     sph_shavite512_close( &ctx.shavite, hash1 );
+     sph_shavite512_init( &ctx.shavite );
+     sph_shavite512( &ctx.shavite, hash2, 64 );
+     sph_shavite512_close( &ctx.shavite, hash2 );
+     sph_shavite512_init( &ctx.shavite );
+     sph_shavite512( &ctx.shavite, hash3, 64 );
+     sph_shavite512_close( &ctx.shavite, hash3 );
+
+     mm_interleave_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
+     shabal512_4way( &ctx.shabal, vhash, 64 );
+     shabal512_4way_close( &ctx.shabal, vhash );
+     mm_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
+
+     sph_gost512( &ctx.gost, hash0, 64 );
+     sph_gost512_close( &ctx.gost, hash0 );
+     sph_gost512_init( &ctx.gost );
+     sph_gost512( &ctx.gost, hash1, 64 );
+     sph_gost512_close( &ctx.gost, hash1 );
+     sph_gost512_init( &ctx.gost );
+     sph_gost512( &ctx.gost, hash2, 64 );
+     sph_gost512_close( &ctx.gost, hash2 );
+     sph_gost512_init( &ctx.gost );
+     sph_gost512( &ctx.gost, hash3, 64 );
+     sph_gost512_close( &ctx.gost, hash3 );
+
+     memcpy( output,    hash0, 32 );
+     memcpy( output+32, hash1, 32 );
+     memcpy( output+64, hash2, 32 );
+     memcpy( output+96, hash3, 32 );
+}
+
+int scanhash_veltor_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done )
+{
+     uint32_t hash[4*8] __attribute__ ((aligned (64)));
+     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;
+     const uint32_t Htarg = ptarget[7];
+     const uint32_t first_nonce = pdata[19];
+     uint32_t n = first_nonce;
+     uint32_t *nonces = work->nonces;
+     bool *found = work->nfound;
+     int num_found = 0;
+     uint32_t *noncep0 = vdata + 73;   // 9*8 + 1
+     uint32_t *noncep1 = vdata + 75;
+     uint32_t *noncep2 = vdata + 77;
+     uint32_t *noncep3 = vdata + 79;
+     volatile uint8_t *restart = &(work_restart[thr_id].restart);
+
+     if ( opt_benchmark )
+        ptarget[7] = 0x0cff;
+     for ( int i=0; i < 19; i++ )
+     {
+        be32enc( &endiandata[i], pdata[i] );
+     }
+
+     uint64_t *edata = (uint64_t*)endiandata;
+     mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+     do
+     {
+         found[0] = found[1] = found[2] = found[3] = false;
+         be32enc( noncep0, n   );
+         be32enc( noncep1, n+1 );
+         be32enc( noncep2, n+2 );
+         be32enc( noncep3, n+3 );
+
+         veltor_4way_hash( hash, vdata );
+         pdata[19] = n;
+
+         if ( hash[7] <= Htarg && fulltest( hash, ptarget ) )
+         {
+            found[0] = true;
+            num_found++;
+            nonces[0] = n;
+            work_set_target_ratio( work, hash );
+         }
+         if ( (hash+8)[7] <= Htarg && fulltest( hash+8, ptarget ) ) 
+         {
+            found[1] = true;
+            num_found++;
+            nonces[1] = n+1;
+            work_set_target_ratio( work, hash+8 );
+         }
+         if ( (hash+16)[7] <= Htarg && fulltest( hash+16, ptarget ) ) 
+         {
+            found[2] = true;
+            num_found++;
+            nonces[2] = n+2;
+            work_set_target_ratio( work, hash+16 );
+         }
+         if ( (hash+24)[7] <= Htarg && fulltest( hash+24, ptarget ) ) 
+         {
+            found[3] = true;
+            num_found++;
+            nonces[3] = n+3;
+            work_set_target_ratio( work, hash+24 );
+         }
+         n += 4;
+     } while ( ( num_found == 0 ) && ( n < max_nonce ) && !(*restart) );
+     *hashes_done = n - first_nonce + 1;
+     return num_found;
+}
+
+#endif

algo/x14/veltor-gate.c

@@ -0,0 +1,18 @@
+#include "veltor-gate.h"
+
+bool register_veltor_algo( algo_gate_t* gate )
+{
+#if defined (VELTOR_4WAY)
+  init_veltor_4way_ctx();
+  gate->scanhash  = (void*)&scanhash_veltor_4way;
+  gate->hash      = (void*)&veltor_4way_hash;
+#else
+  init_veltor_ctx();
+  gate->scanhash  = (void*)&scanhash_veltor;
+  gate->hash      = (void*)&veltor_hash;
+#endif
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX_OPT | AVX2_OPT | FOUR_WAY_OPT;
+  gate->get_max64 = (void*)&get_max64_0x3ffff;
+  return true;
+};
+

algo/x14/veltor-gate.h

@@ -0,0 +1,32 @@
+#ifndef VELTOR_GATE_H__
+#define VELTOR_GATE_H__ 1
+
+#include "algo-gate-api.h"
+#include <stdint.h>
+
+#if defined(HASH_4WAY) && defined(__AES__)
+  #define VELTOR_4WAY
+#endif
+
+bool register_veltor_algo( algo_gate_t* gate );
+
+#if defined(VELTOR_4WAY)
+
+void veltor_4way_hash( void *state, const void *input );
+
+int scanhash_veltor_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                       uint64_t *hashes_done );
+
+void init_veltor_4way_ctx();
+
+#endif
+
+void veltor_hash( void *state, const void *input );
+
+int scanhash_veltor( int thr_id, struct work *work, uint32_t max_nonce,
+                  uint64_t *hashes_done );
+
+void init_veltor_ctx();
+
+#endif
+

algo/x14/veltor.c

@@ -0,0 +1,103 @@
+#include "veltor-gate.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "algo/skein/sph_skein.h"
+#include "algo/gost/sph_gost.h"
+#include "algo/shavite/sph_shavite.h"
+#include "algo/shabal/sph_shabal.h"
+
+typedef struct {
+     sph_gost512_context     gost;
+     sph_shavite512_context  shavite;
+     sph_skein512_context    skein;
+     sph_shabal512_context   shabal;
+} veltor_ctx_holder;
+
+veltor_ctx_holder veltor_ctx __attribute__ ((aligned (64)));
+static __thread sph_skein512_context veltor_skein_mid
+                               __attribute__ ((aligned (64)));
+
+void init_veltor_ctx()
+{
+     sph_gost512_init( &veltor_ctx.gost );
+     sph_shavite512_init( &veltor_ctx.shavite );
+     sph_skein512_init( &veltor_ctx.skein);
+     sph_shabal512_init( &veltor_ctx.shabal);
+}
+
+void veltor_skein512_midstate( const void* input )
+{
+    memcpy( &veltor_skein_mid, &veltor_ctx.skein, sizeof veltor_skein_mid );
+    sph_skein512( &veltor_skein_mid, input, 64 );
+}
+
+void veltor_hash(void *output, const void *input)
+{
+	uint32_t _ALIGN(64) hashA[16], hashB[16];
+
+        veltor_ctx_holder ctx __attribute__ ((aligned (64)));
+        memcpy( &ctx, &veltor_ctx, sizeof(veltor_ctx) );
+
+        const int midlen = 64;            // bytes
+        const int tail   = 80 - midlen;   // 16
+
+        memcpy( &ctx.skein, &veltor_skein_mid, sizeof veltor_skein_mid );
+        sph_skein512( &ctx.skein, input + midlen, tail );
+
+	sph_skein512_close(&ctx.skein, hashA);
+
+        sph_shavite512(&ctx.shavite, hashA, 64);
+        sph_shavite512_close(&ctx.shavite, hashB);
+
+        sph_shabal512(&ctx.shabal, hashB, 64);
+        sph_shabal512_close(&ctx.shabal, hashA);
+
+	sph_gost512(&ctx.gost, hashA, 64);
+	sph_gost512_close(&ctx.gost, hashB);
+
+	memcpy(output, hashB, 32);
+}
+
+int scanhash_veltor(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
+{
+	uint32_t _ALIGN(128) hash[8];
+	uint32_t _ALIGN(128) endiandata[20];
+	uint32_t *pdata = work->data;
+	uint32_t *ptarget = work->target;
+
+	const uint32_t Htarg = ptarget[7];
+	const uint32_t first_nonce = pdata[19];
+	uint32_t nonce = first_nonce;
+	volatile uint8_t *restart = &(work_restart[thr_id].restart);
+
+	if (opt_benchmark)
+		ptarget[7] = 0x0cff;
+
+	// we need bigendian data...
+	for (int i=0; i < 19; i++) {
+		be32enc(&endiandata[i], pdata[i]);
+	}
+
+        veltor_skein512_midstate( endiandata );
+
+	do {
+		be32enc(&endiandata[19], nonce);
+		veltor_hash(hash, endiandata);
+
+		if (hash[7] <= Htarg && fulltest(hash, ptarget)) {
+			work_set_target_ratio(work, hash);
+			pdata[19] = nonce;
+			*hashes_done = pdata[19] - first_nonce;
+			return 1;
+		}
+		nonce++;
+
+	} while (nonce < max_nonce && !(*restart));
+
+	pdata[19] = nonce;
+	*hashes_done = pdata[19] - first_nonce + 1;
+	return 0;
+}

algo/x14/x14-4way.c

@@ -7,7 +7,7 @@
 #include <string.h>
 #include <stdio.h>
 #include "algo/blake/blake-hash-4way.h"
-#include "algo/bmw/sph_bmw.h"
+#include "algo/bmw/bmw-hash-4way.h"
 #include "algo/groestl/aes_ni/hash-groestl.h"
 #include "algo/skein/skein-hash-4way.h"
 #include "algo/jh/jh-hash-4way.h"
@@ -20,11 +20,11 @@
 #include "algo/echo/sph_echo.h"
 #include "algo/hamsi/sph_hamsi.h"
 #include "algo/fugue/sph_fugue.h"
-#include "algo/shabal/sph_shabal.h"
+#include "algo/shabal/shabal-hash-4way.h"
 
 typedef struct {
     blake512_4way_context   blake;
-    sph_bmw512_context      bmw;
+    bmw512_4way_context     bmw;
     hashState_groestl       groestl;
     skein512_4way_context   skein;
     jh512_4way_context      jh;
@@ -36,7 +36,7 @@ typedef struct {
     hashState_echo          echo;
     sph_hamsi512_context    hamsi;
     sph_fugue512_context    fugue;
-    sph_shabal512_context   shabal;
+    shabal512_4way_context  shabal;
 } x14_4way_ctx_holder;
 
 x14_4way_ctx_holder x14_4way_ctx __attribute__ ((aligned (64)));
@@ -44,6 +44,7 @@ x14_4way_ctx_holder x14_4way_ctx __attribute__ ((aligned (64)));
 void init_x14_4way_ctx()
 {
      blake512_4way_init( &x14_4way_ctx.blake );
+     bmw512_4way_init( &x14_4way_ctx.bmw );
      sph_bmw512_init( &x14_4way_ctx.bmw );
      init_groestl( &x14_4way_ctx.groestl, 64 );
      skein512_4way_init( &x14_4way_ctx.skein );
@@ -56,7 +57,7 @@ void init_x14_4way_ctx()
      init_echo( &x14_4way_ctx.echo, 512 );
      sph_hamsi512_init( &x14_4way_ctx.hamsi );
      sph_fugue512_init( &x14_4way_ctx.fugue );
-     sph_shabal512_init( &x14_4way_ctx.shabal );
+     shabal512_4way_init( &x14_4way_ctx.shabal );
 };
 
 void x14_4way_hash( void *state, const void *input )
@@ -73,22 +74,13 @@ void x14_4way_hash( void *state, const void *input )
      blake512_4way( &ctx.blake, input, 80 );
      blake512_4way_close( &ctx.blake, vhash );
 
+     // 2 Bmw
+     bmw512_4way( &ctx.bmw, vhash, 64 );
+     bmw512_4way_close( &ctx.bmw, vhash );
+
      // Serial
      mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
-     // 2 Bmw
-     sph_bmw512( &ctx.bmw, hash0, 64 );
-     sph_bmw512_close( &ctx.bmw, hash0 );
-     memcpy( &ctx.bmw, &x14_4way_ctx.bmw, sizeof(sph_bmw512_context) );
-     sph_bmw512( &ctx.bmw, hash1, 64 );
-     sph_bmw512_close( &ctx.bmw, hash1 );
-     memcpy( &ctx.bmw, &x14_4way_ctx.bmw, sizeof(sph_bmw512_context) );
-     sph_bmw512( &ctx.bmw, hash2, 64 );
-     sph_bmw512_close( &ctx.bmw, hash2 );
-     memcpy( &ctx.bmw, &x14_4way_ctx.bmw, sizeof(sph_bmw512_context) );
-     sph_bmw512( &ctx.bmw, hash3, 64 );
-     sph_bmw512_close( &ctx.bmw, hash3 );
-
      // 3 Groestl
      update_and_final_groestl( &ctx.groestl, (char*)hash0, (char*)hash0, 512 );
      memcpy( &ctx.groestl, &x14_4way_ctx.groestl, sizeof(hashState_groestl) );
@@ -113,7 +105,7 @@ void x14_4way_hash( void *state, const void *input )
      keccak512_4way( &ctx.keccak, vhash, 64 );
      keccak512_4way_close( &ctx.keccak, vhash );
 
-     // Serial to the end
+     // Serial
      mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
      // 7 Luffa
@@ -144,9 +136,9 @@ void x14_4way_hash( void *state, const void *input )
      memcpy( &ctx.shavite, &x14_4way_ctx.shavite,
              sizeof(sph_shavite512_context) );
      sph_shavite512( &ctx.shavite, hash1, 64 );
+     sph_shavite512_close( &ctx.shavite, hash1 );
      memcpy( &ctx.shavite, &x14_4way_ctx.shavite,
              sizeof(sph_shavite512_context) );
-     sph_shavite512_close( &ctx.shavite, hash1 );
      sph_shavite512( &ctx.shavite, hash2, 64 );
      sph_shavite512_close( &ctx.shavite, hash2 );
      memcpy( &ctx.shavite, &x14_4way_ctx.shavite,
@@ -206,19 +198,12 @@ void x14_4way_hash( void *state, const void *input )
      sph_fugue512( &ctx.fugue, hash3, 64 );
      sph_fugue512_close( &ctx.fugue, hash3 );
 
-     // 14 Shabal
-     sph_shabal512( &ctx.shabal, hash0, 64 );
-     sph_shabal512_close( &ctx.shabal, hash0 );
-     memcpy( &ctx.shabal, &x14_4way_ctx.shabal, sizeof(sph_shabal512_context) );
-     sph_shabal512( &ctx.shabal, hash1, 64 );
-     sph_shabal512_close( &ctx.shabal, hash1 );
-     memcpy( &ctx.shabal, &x14_4way_ctx.shabal, sizeof(sph_shabal512_context) );
-     sph_shabal512( &ctx.shabal, hash2, 64 );
-     sph_shabal512_close( &ctx.shabal, hash2 );
-     memcpy( &ctx.shabal, &x14_4way_ctx.shabal, sizeof(sph_shabal512_context) );
-     sph_shabal512( &ctx.shabal, hash3, 64 );
-     sph_shabal512_close( &ctx.shabal, hash3 );
-       
+     // 14 Shabal, parallel 32 bit
+     mm_interleave_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
+     shabal512_4way( &ctx.shabal, vhash, 64 );
+     shabal512_4way_close( &ctx.shabal, vhash );
+     mm_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
+     
      memcpy( state,    hash0, 32 );
      memcpy( state+32, hash1, 32 );
      memcpy( state+64, hash2, 32 );

algo/x14/x14-gate.c

@@ -11,7 +11,7 @@ bool register_x14_algo( algo_gate_t* gate )
   gate->scanhash  = (void*)&scanhash_x14;
   gate->hash      = (void*)&x14hash;
 #endif
-  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | FOUR_WAY_OPT;
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX_OPT | AVX2_OPT | FOUR_WAY_OPT;
   gate->get_max64 = (void*)&get_max64_0x3ffff;
   return true;
 };