diff --git a/Makefile.am b/Makefile.am
index 0d802ed..b0af412 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -69,7 +69,7 @@ ccminer_SOURCES = elist.h miner.h compat.h \
lbry/lbry.cu lbry/cuda_sha256_lbry.cu lbry/cuda_sha512_lbry.cu lbry/cuda_lbry_merged.cu \
qubit/qubit.cu qubit/qubit_luffa512.cu qubit/deep.cu qubit/luffa.cu \
tribus/tribus.cu tribus/cuda_echo512_final.cu \
- x11/x11.cu x11/fresh.cu x11/cuda_x11_luffa512.cu x11/cuda_x11_cubehash512.cu \
+ x11/x11.cu x12/x12.cu x11/fresh.cu x11/cuda_x11_luffa512.cu x11/cuda_x11_cubehash512.cu \
x11/cuda_x11_shavite512.cu x11/cuda_x11_simd512.cu x11/cuda_x11_echo.cu \
x11/cuda_x11_luffa512_Cubehash.cu x11/x11evo.cu x11/timetravel.cu x11/bitcore.cu \
x13/x13.cu x13/cuda_x13_hamsi512.cu x13/cuda_x13_fugue512.cu \
diff --git a/algos.h b/algos.h
index 014b4cb..545d4a4 100644
--- a/algos.h
+++ b/algos.h
@@ -56,6 +56,7 @@ enum sha_algos {
ALGO_BITCORE,
ALGO_X11EVO,
ALGO_X11,
+ ALGO_X12,
ALGO_X13,
ALGO_X14,
ALGO_X15,
@@ -126,6 +127,7 @@ static const char *algo_names[] = {
"bitcore",
"x11evo",
"x11",
+ "x12",
"x13",
"x14",
"x15",
diff --git a/ccminer.cpp b/ccminer.cpp
index 46957e7..614ba43 100644
--- a/ccminer.cpp
+++ b/ccminer.cpp
@@ -290,6 +290,7 @@ Options:\n\
whirlpool Whirlpool algo\n\
x11evo Permuted x11 (Revolver)\n\
x11 X11 (DarkCoin)\n\
+ x12 X12 (GalaxyCash)\n\
x13 X13 (MaruCoin)\n\
x14 X14\n\
x15 X15\n\
@@ -2246,6 +2247,7 @@ static void *miner_thread(void *userdata)
case ALGO_BITCORE:
case ALGO_X11EVO:
case ALGO_X11:
+ case ALGO_X12:
case ALGO_X13:
case ALGO_WHIRLCOIN:
case ALGO_WHIRLPOOL:
@@ -2492,6 +2494,9 @@ static void *miner_thread(void *userdata)
case ALGO_X11:
rc = scanhash_x11(thr_id, &work, max_nonce, &hashes_done);
break;
+ case ALGO_X12:
+ rc = scanhash_x12(thr_id, &work, max_nonce, &hashes_done);
+ break;
case ALGO_X13:
rc = scanhash_x13(thr_id, &work, max_nonce, &hashes_done);
break;
diff --git a/ccminer.vcxproj b/ccminer.vcxproj
index 5fe11d7..d44d4d4 100644
--- a/ccminer.vcxproj
+++ b/ccminer.vcxproj
@@ -435,12 +435,6 @@
-
-
-
-
-
-
@@ -580,6 +574,7 @@
+
72
@@ -594,6 +589,12 @@
+
+
+
+
+
+
diff --git a/ccminer.vcxproj.filters b/ccminer.vcxproj.filters
index a8f149e..2ed09a3 100644
--- a/ccminer.vcxproj.filters
+++ b/ccminer.vcxproj.filters
@@ -114,6 +114,9 @@
{1e548d79-c217-4203-989a-a592fe2b2de3}
+
+
+ {xde48d89-fx12-1323-129a-b592fe2b2de3}
@@ -811,6 +814,9 @@
Source Files\CUDA\x11
+
+ Source Files\CUDA\x12
+
Source Files\CUDA\x11
diff --git a/miner.h b/miner.h
index 86b1c1d..136c8ab 100644
--- a/miner.h
+++ b/miner.h
@@ -322,6 +322,7 @@ extern int scanhash_whirl(int thr_id, struct work* work, uint32_t max_nonce, uns
extern int scanhash_wildkeccak(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x11evo(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
+extern int scanhash_x12(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x13(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x14(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x15(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
@@ -387,6 +388,7 @@ extern void free_whirl(int thr_id);
extern void free_wildkeccak(int thr_id);
extern void free_x11evo(int thr_id);
extern void free_x11(int thr_id);
+extern void free_x12(int thr_id);
extern void free_x13(int thr_id);
extern void free_x14(int thr_id);
extern void free_x15(int thr_id);
@@ -932,6 +934,7 @@ void wcoinhash(void *state, const void *input);
void whirlxHash(void *state, const void *input);
void x11evo_hash(void *output, const void *input);
void x11hash(void *output, const void *input);
+void x12hash(void *output, const void *input);
void x13hash(void *output, const void *input);
void x14hash(void *output, const void *input);
void x15hash(void *output, const void *input);
diff --git a/x12/x12.cu b/x12/x12.cu
new file mode 100644
index 0000000..791ef45
--- /dev/null
+++ b/x12/x12.cu
@@ -0,0 +1,242 @@
+/*
+ * X13 algorithm
+ */
+extern "C"
+{
+#include "sph/sph_blake.h"
+#include "sph/sph_bmw.h"
+#include "sph/sph_groestl.h"
+#include "sph/sph_skein.h"
+#include "sph/sph_jh.h"
+#include "sph/sph_keccak.h"
+
+#include "sph/sph_luffa.h"
+#include "sph/sph_cubehash.h"
+#include "sph/sph_shavite.h"
+#include "sph/sph_simd.h"
+#include "sph/sph_echo.h"
+
+#include "sph/sph_hamsi.h"
+#include "sph/sph_fugue.h"
+}
+#include "miner.h"
+
+#include "cuda_helper.h"
+#include "x11/cuda_x11.h"
+
+static uint32_t *d_hash[MAX_GPUS];
+
+extern void x13_hamsi512_cpu_init(int thr_id, uint32_t threads);
+extern void x13_hamsi512_cpu_hash_64(int thr_id, uint32_t threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
+
+// X13 CPU Hash
+extern "C" void x12hash(void *output, const void *input)
+{
+ // blake1-bmw2-grs3-skein4-jh5-keccak6-luffa7-cubehash8-shavite9-simd10-echo11-hamsi12-fugue13
+
+ sph_blake512_context ctx_blake;
+ sph_bmw512_context ctx_bmw;
+ sph_groestl512_context ctx_groestl;
+ sph_jh512_context ctx_jh;
+ sph_keccak512_context ctx_keccak;
+ sph_skein512_context ctx_skein;
+ sph_luffa512_context ctx_luffa;
+ sph_cubehash512_context ctx_cubehash;
+ sph_shavite512_context ctx_shavite;
+ sph_simd512_context ctx_simd;
+ sph_echo512_context ctx_echo;
+ sph_hamsi512_context ctx_hamsi;
+
+ uint32_t hash[32];
+ memset(hash, 0, sizeof hash);
+
+ sph_blake512_init(&ctx_blake);
+ sph_blake512 (&ctx_blake, input, 80);
+ sph_blake512_close(&ctx_blake, (void*) hash);
+
+ sph_bmw512_init(&ctx_bmw);
+ sph_bmw512 (&ctx_bmw, (const void*) hash, 64);
+ sph_bmw512_close(&ctx_bmw, (void*) hash);
+
+ sph_luffa512_init(&ctx_luffa);
+ sph_luffa512(&ctx_luffa, (const void*)hash, 64);
+ sph_luffa512_close(&ctx_luffa, (void*)hash);
+
+ sph_cubehash512_init(&ctx_cubehash);
+ sph_cubehash512(&ctx_cubehash, (const void*)hash, 64);
+ sph_cubehash512_close(&ctx_cubehash, (void*)hash);
+
+ sph_shavite512_init(&ctx_shavite);
+ sph_shavite512(&ctx_shavite, (const void*)hash, 64);
+ sph_shavite512_close(&ctx_shavite, (void*)hash);
+
+ sph_simd512_init(&ctx_simd);
+ sph_simd512(&ctx_simd, (const void*)hash, 64);
+ sph_simd512_close(&ctx_simd, (void*)hash);
+
+ sph_echo512_init(&ctx_echo);
+ sph_echo512(&ctx_echo, (const void*)hash, 64);
+ sph_echo512_close(&ctx_echo, (void*)hash);
+
+ sph_groestl512_init(&ctx_groestl);
+ sph_groestl512 (&ctx_groestl, (const void*) hash, 64);
+ sph_groestl512_close(&ctx_groestl, (void*) hash);
+
+ sph_skein512_init(&ctx_skein);
+ sph_skein512 (&ctx_skein, (const void*) hash, 64);
+ sph_skein512_close(&ctx_skein, (void*) hash);
+
+ sph_jh512_init(&ctx_jh);
+ sph_jh512 (&ctx_jh, (const void*) hash, 64);
+ sph_jh512_close(&ctx_jh, (void*) hash);
+
+ sph_keccak512_init(&ctx_keccak);
+ sph_keccak512 (&ctx_keccak, (const void*) hash, 64);
+ sph_keccak512_close(&ctx_keccak, (void*) hash);
+
+ sph_hamsi512_init(&ctx_hamsi);
+ sph_hamsi512 (&ctx_hamsi, (const void*) hash, 64);
+ sph_hamsi512_close(&ctx_hamsi, (void*) hash);
+
+ memcpy(output, hash, 32);
+}
+
+static bool init[MAX_GPUS] = { 0 };
+
+extern "C" int scanhash_x12(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
+{
+ uint32_t *pdata = work->data;
+ uint32_t *ptarget = work->target;
+ const uint32_t first_nonce = pdata[19];
+ int intensity = 19; // (device_sm[device_map[thr_id]] > 500 && !is_windows()) ? 20 : 19;
+ uint32_t throughput = cuda_default_throughput(thr_id, 1 << intensity); // 19=256*256*8;
+ //if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce);
+
+ if (opt_benchmark)
+ ((uint32_t*)ptarget)[7] = 0x000f;
+
+ if (!init[thr_id])
+ {
+ cudaSetDevice(device_map[thr_id]);
+ if (opt_cudaschedule == -1 && gpu_threads == 1) {
+ cudaDeviceReset();
+ // reduce cpu usage
+ cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);
+ CUDA_LOG_ERROR();
+ }
+ gpulog(LOG_INFO, thr_id, "Intensity set to %g, %u cuda threads", throughput2intensity(throughput), throughput);
+
+ quark_blake512_cpu_init(thr_id, throughput);
+ x11_luffaCubehash512_cpu_init(thr_id, throughput);
+ x11_shavite512_cpu_init(thr_id, throughput);
+ if (x11_simd512_cpu_init(thr_id, throughput) != 0) {
+ return 0;
+ }
+ x11_echo512_cpu_init(thr_id, throughput);
+ quark_groestl512_cpu_init(thr_id, throughput);
+ quark_skein512_cpu_init(thr_id, throughput);
+ quark_bmw512_cpu_init(thr_id, throughput);
+ quark_keccak512_cpu_init(thr_id, throughput);
+ quark_jh512_cpu_init(thr_id, throughput);
+ x13_hamsi512_cpu_init(thr_id, throughput);
+
+ CUDA_CALL_OR_RET_X(cudaMalloc(&d_hash[thr_id], 16 * sizeof(uint32_t) * throughput), 0);
+
+ cuda_check_cpu_init(thr_id, throughput);
+
+ init[thr_id] = true;
+ }
+
+ uint32_t endiandata[20];
+ for (int k=0; k < 20; k++)
+ be32enc(&endiandata[k], pdata[k]);
+
+ quark_blake512_cpu_setBlock_80(thr_id, endiandata);
+ cuda_check_cpu_setTarget(ptarget);
+
+ do {
+ int order = 0;
+
+ quark_blake512_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id]); order++;
+ quark_bmw512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ x11_luffaCubehash512_cpu_hash_64(thr_id, throughput, d_hash[thr_id], order++);
+ x11_shavite512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ quark_groestl512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ quark_jh512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+ x13_hamsi512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+
+ *hashes_done = pdata[19] - first_nonce + throughput;
+
+ CUDA_LOG_ERROR();
+
+ work->nonces[0] = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
+ if (work->nonces[0] != UINT32_MAX)
+ {
+ const uint32_t Htarg = ptarget[7];
+ uint32_t _ALIGN(64) vhash[8];
+ be32enc(&endiandata[19], work->nonces[0]);
+ x12hash(vhash, endiandata);
+
+ if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
+ work->valid_nonces = 1;
+ work->nonces[1] = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
+ work_set_target_ratio(work, vhash);
+ if (work->nonces[1] != 0) {
+ be32enc(&endiandata[19], work->nonces[1]);
+ x13hash(vhash, endiandata);
+ bn_set_target_ratio(work, vhash, 1);
+ work->valid_nonces++;
+ pdata[19] = max(work->nonces[0], work->nonces[1]) + 1;
+ } else {
+ pdata[19] = work->nonces[0] + 1; // cursor
+ }
+ return work->valid_nonces;
+ }
+ else if (vhash[7] > Htarg) {
+ gpu_increment_reject(thr_id);
+ if (!opt_quiet)
+ gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", work->nonces[0]);
+ pdata[19] = work->nonces[0] + 1;
+ continue;
+ }
+ }
+
+ if ((uint64_t)throughput + pdata[19] >= max_nonce) {
+ pdata[19] = max_nonce;
+ break;
+ }
+ pdata[19] += throughput;
+
+ } while (!work_restart[thr_id].restart);
+
+ *hashes_done = pdata[19] - first_nonce;
+
+ CUDA_LOG_ERROR();
+
+ return 0;
+}
+
+// cleanup
+extern "C" void free_x12(int thr_id)
+{
+ if (!init[thr_id])
+ return;
+
+ cudaThreadSynchronize();
+
+ cudaFree(d_hash[thr_id]);
+
+ quark_blake512_cpu_free(thr_id);
+ quark_groestl512_cpu_free(thr_id);
+ x11_simd512_cpu_free(thr_id);
+
+ cuda_check_cpu_free(thr_id);
+ CUDA_LOG_ERROR();
+
+ cudaDeviceSynchronize();
+ init[thr_id] = false;
+}