diff --git a/ccminer.cpp b/ccminer.cpp
index e85e222..dd22e31 100644
--- a/ccminer.cpp
+++ b/ccminer.cpp
@@ -83,6 +83,7 @@ enum sha_algos {
 	ALGO_BLAKE,
 	ALGO_BLAKECOIN,
 	ALGO_DEEP,
+	ALGO_DMD_GR,
 	ALGO_DOOM,
 	ALGO_FRESH,
 	ALGO_FUGUE256,		/* Fugue256 */
@@ -105,7 +106,6 @@ enum sha_algos {
 	ALGO_X14,
 	ALGO_X15,
 	ALGO_X17,
-	ALGO_DMD_GR,
 };
 
 static const char *algo_names[] = {
@@ -113,6 +113,7 @@ static const char *algo_names[] = {
 	"blake",
 	"blakecoin",
 	"deep",
+	"dmd-gr",
 	"doom", /* is luffa */
 	"fresh",
 	"fugue256",
@@ -135,7 +136,6 @@ static const char *algo_names[] = {
 	"x14",
 	"x15",
 	"x17",
-	"dmd-gr",
 };
 
 bool opt_debug = false;
diff --git a/groestlcoin.cpp b/groestlcoin.cpp
index 0073744..1e33ff7 100644
--- a/groestlcoin.cpp
+++ b/groestlcoin.cpp
@@ -12,48 +12,21 @@
     ((((x) << 24) & 0xff000000u) | (((x) << 8) & 0x00ff0000u)   | \
       (((x) >> 8) & 0x0000ff00u) | (((x) >> 24) & 0x000000ffu))
 
-void sha256func(unsigned char *hash, const unsigned char *data, int len)
-{
-    uint32_t S[16], T[16];
-    int i, r;
-
-    sha256_init(S);
-    for (r = len; r > -9; r -= 64) {
-        if (r < 64)
-            memset(T, 0, 64);
-        memcpy(T, data + len - r, r > 64 ? 64 : (r < 0 ? 0 : r));
-        if (r >= 0 && r < 64)
-            ((unsigned char *)T)[r] = 0x80;
-        for (i = 0; i < 16; i++)
-            T[i] = be32dec(T + i);
-        if (r < 56)
-            T[15] = 8 * len;
-        sha256_transform(S, T, 0);
-    }
-    /*
-    memcpy(S + 8, sha256d_hash1 + 8, 32);
-    sha256_init(T);
-    sha256_transform(T, S, 0);
-    */
-    for (i = 0; i < 8; i++)
-        be32enc((uint32_t *)hash + i, T[i]);
-}
-
+// CPU-groestl
 extern "C" void groestlhash(void *state, const void *input)
 {
-    // CPU-groestl
-    sph_groestl512_context ctx_groestl[2];
+    sph_groestl512_context ctx_groestl;
 
     //these uint512 in the c++ source of the client are backed by an array of uint32
     uint32_t hashA[16], hashB[16];
 
-    sph_groestl512_init(&ctx_groestl[0]);
-    sph_groestl512 (&ctx_groestl[0], input, 80); //6
-    sph_groestl512_close(&ctx_groestl[0], hashA); //7
+    sph_groestl512_init(&ctx_groestl);
+    sph_groestl512 (&ctx_groestl, input, 80); //6
+    sph_groestl512_close(&ctx_groestl, hashA); //7
 
-    sph_groestl512_init(&ctx_groestl[1]);
-    sph_groestl512 (&ctx_groestl[1], hashA, 64); //6
-    sph_groestl512_close(&ctx_groestl[1], hashB); //7
+    sph_groestl512_init(&ctx_groestl);
+    sph_groestl512 (&ctx_groestl, hashA, 64); //6
+    sph_groestl512_close(&ctx_groestl, hashB); //7
 
     memcpy(state, hashB, 32);
 }
diff --git a/myriadgroestl.cpp b/myriadgroestl.cpp
index a19808a..c6db307 100644
--- a/myriadgroestl.cpp
+++ b/myriadgroestl.cpp
@@ -17,19 +17,19 @@ void myriadgroestl_cpu_hash(int thr_id, int threads, uint32_t startNounce, void
 
 extern "C" void myriadhash(void *state, const void *input)
 {
-    sph_groestl512_context     ctx_groestl;
+	uint32_t hashA[16], hashB[16];
+	sph_groestl512_context ctx_groestl;
+	SHA256_CTX sha256;
 
-    uint32_t hashA[16], hashB[16];
+	sph_groestl512_init(&ctx_groestl);
+	sph_groestl512 (&ctx_groestl, input, 80);
+	sph_groestl512_close(&ctx_groestl, hashA);
 
-    sph_groestl512_init(&ctx_groestl);
-    sph_groestl512 (&ctx_groestl, input, 80);
-    sph_groestl512_close(&ctx_groestl, hashA);
+	SHA256_Init(&sha256);
+	SHA256_Update(&sha256,(unsigned char *)hashA, 64);
+	SHA256_Final((unsigned char *)hashB, &sha256);
 
-    SHA256_CTX sha256;
-    SHA256_Init(&sha256);
-    SHA256_Update(&sha256,(unsigned char *)hashA, 64);
-    SHA256_Final((unsigned char *)hashB, &sha256);
-    memcpy(state, hashB, 32);
+	memcpy(state, hashB, 32);
 }
 
 static bool init[MAX_GPUS] = { 0 };
@@ -38,7 +38,7 @@ extern "C" int scanhash_myriad(int thr_id, uint32_t *pdata, const uint32_t *ptar
 	uint32_t max_nonce, unsigned long *hashes_done)
 {
 	uint32_t start_nonce = pdata[19]++;
-    uint32_t throughput = device_intensity(thr_id, __func__, 1 << 17);
+	uint32_t throughput = device_intensity(thr_id, __func__, 1 << 17);
 	throughput = min(throughput, max_nonce - start_nonce);
 
 	uint32_t *outputHash = (uint32_t*)malloc(throughput * 16 * sizeof(uint32_t));