void veltorhash(void *output, const void *input) { // sph_skein512_context ctx_skein; // sph_gost512_context ctx_gost; // sph_shabal512_context ctx_shabal; // sph_shavite512_context ctx_shavite; //these uint512 in the c++ source of the client are backed by an array of uint32 uint32_t _ALIGN(64) hashA[16], hashB[16]; veltor_ctx_holder ctx; memcpy( &ctx, &veltor_ctx, sizeof(veltor_ctx) ); // sph_skein512_init(&ctx_skein); sph_skein512(&ctx.skein, input, 80); sph_skein512_close(&ctx.skein, hashA); // sph_shavite512_init(&ctx_shavite); sph_shavite512(&ctx.shavite, hashA, 64); sph_shavite512_close(&ctx.shavite, hashB); // sph_shabal512_init(&ctx_shabal); sph_shabal512(&ctx.shabal, hashB, 64); sph_shabal512_close(&ctx.shabal, hashA); // sph_gost512_init(&ctx_gost); sph_gost512(&ctx.gost, hashA, 64); sph_gost512_close(&ctx.gost, hashB); memcpy(output, hashB, 32); }
int crypto_hash(unsigned char *out,const unsigned char *in,unsigned long long inlen) { sph_shabal512_context mc; sph_shabal512_init(&mc); sph_shabal512(&mc, in, inlen); sph_shabal512_close(&mc,out); return 0; }
inline void bitblockhash(void *state, const void *input) { init_Bhash_contexts(); Xhash_context_holder ctx; uint32_t hashA[16], hashB[16]; memcpy(&ctx, &base_contexts, sizeof(base_contexts)); sph_blake512 (&ctx.blake1, input, 80); sph_blake512_close (&ctx.blake1, hashA); sph_bmw512 (&ctx.bmw1, hashA, 64); sph_bmw512_close(&ctx.bmw1, hashB); sph_groestl512 (&ctx.groestl1, hashB, 64); sph_groestl512_close(&ctx.groestl1, hashA); sph_skein512 (&ctx.skein1, hashA, 64); sph_skein512_close(&ctx.skein1, hashB); sph_jh512 (&ctx.jh1, hashB, 64); sph_jh512_close(&ctx.jh1, hashA); sph_keccak512 (&ctx.keccak1, hashA, 64); sph_keccak512_close(&ctx.keccak1, hashB); sph_luffa512 (&ctx.luffa1, hashB, 64); sph_luffa512_close (&ctx.luffa1, hashA); sph_cubehash512 (&ctx.cubehash1, hashA, 64); sph_cubehash512_close(&ctx.cubehash1, hashB); sph_shavite512 (&ctx.shavite1, hashB, 64); sph_shavite512_close(&ctx.shavite1, hashA); sph_simd512 (&ctx.simd1, hashA, 64); sph_simd512_close(&ctx.simd1, hashB); sph_echo512 (&ctx.echo1, hashB, 64); sph_echo512_close(&ctx.echo1, hashA); sph_hamsi512 (&ctx.hamsi1, hashA, 64); sph_hamsi512_close(&ctx.hamsi1, hashB); sph_fugue512 (&ctx.fugue1, hashB, 64); sph_fugue512_close(&ctx.fugue1, hashA); sph_shabal512 (&ctx.shabal1, (const unsigned char*)hashA, 64); sph_shabal512_close(&ctx.shabal1, hashB); sph_whirlpool (&ctx.whirlpool1, hashB, 64); sph_whirlpool_close(&ctx.whirlpool1, hashA); memcpy(state, hashA, 32); }
void x15hash(void *output, const void *input) { uint32_t hash[16]; memset(hash, 0, 16 * sizeof(uint32_t)); sph_blake512(&ctx.blake, input, 80); sph_blake512_close(&ctx.blake, hash); sph_bmw512(&ctx.bmw, hash, 64); sph_bmw512_close(&ctx.bmw, hash); sph_groestl512(&ctx.groestl, hash, 64); sph_groestl512_close(&ctx.groestl, hash); sph_skein512(&ctx.skein, hash, 64); sph_skein512_close(&ctx.skein, hash); sph_jh512(&ctx.jh, hash, 64); sph_jh512_close(&ctx.jh, hash); sph_keccak512(&ctx.keccak, hash, 64); sph_keccak512_close(&ctx.keccak, hash); sph_luffa512(&ctx.luffa, hash, 64); sph_luffa512_close(&ctx.luffa, hash); sph_cubehash512(&ctx.cubehash, hash, 64); sph_cubehash512_close(&ctx.cubehash, hash); sph_shavite512(&ctx.shavite, hash, 64); sph_shavite512_close(&ctx.shavite, hash); sph_simd512(&ctx.simd, hash, 64); sph_simd512_close(&ctx.simd, hash); sph_echo512(&ctx.echo, hash, 64); sph_echo512_close(&ctx.echo, hash); sph_hamsi512(&ctx.hamsi, hash, 64); sph_hamsi512_close(&ctx.hamsi, hash); sph_fugue512(&ctx.fugue, hash, 64); sph_fugue512_close(&ctx.fugue, hash); sph_shabal512(&ctx.shabal, hash, 64); sph_shabal512_close(&ctx.shabal, hash); sph_whirlpool(&ctx.whirlpool, hash, 64); sph_whirlpool_close(&ctx.whirlpool, hash); memcpy(output, hash, 32); }
void x16r_hash(void* output, const void* input) { uint32_t _ALIGN(128) hash[64/4]; sph_blake512_context ctx_blake; sph_bmw512_context ctx_bmw; sph_groestl512_context ctx_groestl; sph_skein512_context ctx_skein; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; sph_luffa512_context ctx_luffa1; sph_cubehash512_context ctx_cubehash1; sph_shavite512_context ctx_shavite1; sph_simd512_context ctx_simd1; sph_echo512_context ctx_echo1; sph_hamsi512_context ctx_hamsi1; sph_fugue512_context ctx_fugue1; sph_shabal512_context ctx_shabal1; sph_whirlpool_context ctx_whirlpool1; sph_sha512_context ctx_sha512; void *in = (void*) input; int size = 80; if (s_ntime == UINT32_MAX) { const uint8_t* in8 = (uint8_t*) input; getAlgoString(&in8[4], hashOrder); } for (int i = 0; i < 16; i++) { const char elem = hashOrder[i]; const uint8_t algo = elem >= 'A' ? elem - 'A' + 10 : elem - '0'; switch (algo) { case BLAKE: sph_blake512_init(&ctx_blake); sph_blake512(&ctx_blake, in, size); sph_blake512_close(&ctx_blake, hash); break; case BMW: sph_bmw512_init(&ctx_bmw); sph_bmw512(&ctx_bmw, in, size); sph_bmw512_close(&ctx_bmw, hash); break; case GROESTL: sph_groestl512_init(&ctx_groestl); sph_groestl512(&ctx_groestl, in, size); sph_groestl512_close(&ctx_groestl, hash); break; case SKEIN: sph_skein512_init(&ctx_skein); sph_skein512(&ctx_skein, in, size); sph_skein512_close(&ctx_skein, hash); break; case JH: sph_jh512_init(&ctx_jh); sph_jh512(&ctx_jh, in, size); sph_jh512_close(&ctx_jh, hash); break; case KECCAK: sph_keccak512_init(&ctx_keccak); sph_keccak512(&ctx_keccak, in, size); sph_keccak512_close(&ctx_keccak, hash); break; case LUFFA: sph_luffa512_init(&ctx_luffa1); sph_luffa512(&ctx_luffa1, in, size); sph_luffa512_close(&ctx_luffa1, hash); break; case CUBEHASH: sph_cubehash512_init(&ctx_cubehash1); sph_cubehash512(&ctx_cubehash1, in, size); sph_cubehash512_close(&ctx_cubehash1, hash); break; case SHAVITE: sph_shavite512_init(&ctx_shavite1); sph_shavite512(&ctx_shavite1, in, size); sph_shavite512_close(&ctx_shavite1, hash); break; case SIMD: sph_simd512_init(&ctx_simd1); sph_simd512(&ctx_simd1, in, size); sph_simd512_close(&ctx_simd1, hash); break; case ECHO: sph_echo512_init(&ctx_echo1); sph_echo512(&ctx_echo1, in, size); sph_echo512_close(&ctx_echo1, hash); break; case HAMSI: sph_hamsi512_init(&ctx_hamsi1); sph_hamsi512(&ctx_hamsi1, in, size); sph_hamsi512_close(&ctx_hamsi1, hash); break; case FUGUE: sph_fugue512_init(&ctx_fugue1); sph_fugue512(&ctx_fugue1, in, size); sph_fugue512_close(&ctx_fugue1, hash); break; case SHABAL: sph_shabal512_init(&ctx_shabal1); sph_shabal512(&ctx_shabal1, in, size); sph_shabal512_close(&ctx_shabal1, hash); break; case WHIRLPOOL: sph_whirlpool_init(&ctx_whirlpool1); sph_whirlpool(&ctx_whirlpool1, in, size); sph_whirlpool_close(&ctx_whirlpool1, hash); break; case SHA512: sph_sha512_init(&ctx_sha512); sph_sha512(&ctx_sha512,(const void*) in, size); sph_sha512_close(&ctx_sha512,(void*) hash); break; } in = (void*) hash; size = 64; } memcpy(output, hash, 32); }
static #endif inline void hmq1725hash(void *state, const void *input) { 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; sph_fugue512_context ctx_fugue; sph_shabal512_context ctx_shabal; sph_whirlpool_context ctx_whirlpool; sph_sha512_context ctx_sha2; sph_haval256_5_context ctx_haval; uint32_t mask = 24; uint32_t zero = 0; uint32_t hashA[16], hashB[16]; sph_bmw512_init(&ctx_bmw); sph_bmw512 (&ctx_bmw, input, 80); sph_bmw512_close (&ctx_bmw, hashA); //0 sph_whirlpool_init(&ctx_whirlpool); sph_whirlpool (&ctx_whirlpool, hashA, 64); //0 sph_whirlpool_close(&ctx_whirlpool, hashB); //1 if ((hashB[0] & mask) != zero) //1 { sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, hashB, 64); //1 sph_groestl512_close(&ctx_groestl, hashA); //2 } else { sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, hashB, 64); //1 sph_skein512_close(&ctx_skein, hashA); //2 } sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, hashA, 64); //2 sph_jh512_close(&ctx_jh, hashB); //3 sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, hashB, 64); //3 sph_keccak512_close(&ctx_keccak, hashA); //4 if ((hashA[0] & mask) != zero) //4 { sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, hashA, 64); // sph_blake512_close(&ctx_blake, hashB); //5 } else { sph_bmw512_init(&ctx_bmw); sph_bmw512 (&ctx_bmw, hashA, 64); //4 sph_bmw512_close(&ctx_bmw, hashB); //5 } sph_luffa512_init(&ctx_luffa); sph_luffa512 (&ctx_luffa,hashB, 64); //5 sph_luffa512_close(&ctx_luffa, hashA); //6 sph_cubehash512_init(&ctx_cubehash); sph_cubehash512 (&ctx_cubehash, hashA, 64); //6 sph_cubehash512_close(&ctx_cubehash, hashB); //7 if ((hashB[0] & mask) != zero) //7 { sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, hashB, 64); // sph_keccak512_close(&ctx_keccak, hashA); //8 } else { sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, hashB, 64); //7 sph_jh512_close(&ctx_jh, hashA); //8 } sph_shavite512_init(&ctx_shavite); sph_shavite512 (&ctx_shavite,hashA, 64); //5 sph_shavite512_close(&ctx_shavite, hashB); //6 sph_simd512_init(&ctx_simd); sph_simd512 (&ctx_simd, hashB, 64); //6 sph_simd512_close(&ctx_simd, hashA); //7 if ((hashA[0] & mask) != zero) //4 { sph_whirlpool_init(&ctx_whirlpool); sph_whirlpool (&ctx_whirlpool, hashA, 64); // sph_whirlpool_close(&ctx_whirlpool, hashB); //5 } else { sph_haval256_5_init(&ctx_haval); sph_haval256_5 (&ctx_haval, hashA, 64); //4 sph_haval256_5_close(&ctx_haval, hashB); //5 memset(&hashB[8], 0, 32); } sph_echo512_init(&ctx_echo); sph_echo512 (&ctx_echo,hashB, 64); //5 sph_echo512_close(&ctx_echo, hashA); //6 sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, hashA, 64); //6 sph_blake512_close(&ctx_blake, hashB); //7 if ((hashB[0] & mask) != zero) //7 { sph_shavite512_init(&ctx_shavite); sph_shavite512 (&ctx_shavite, hashB, 64); // sph_shavite512_close(&ctx_shavite, hashA); //8 } else { sph_luffa512_init(&ctx_luffa); sph_luffa512 (&ctx_luffa, hashB, 64); //7 sph_luffa512_close(&ctx_luffa, hashA); //8 } sph_hamsi512_init(&ctx_hamsi); sph_hamsi512 (&ctx_hamsi,hashA, 64); //5 sph_hamsi512_close(&ctx_hamsi, hashB); //6 sph_fugue512_init(&ctx_fugue); sph_fugue512 (&ctx_fugue, hashB, 64); //6 sph_fugue512_close(&ctx_fugue, hashA); //7 if ((hashA[0] & mask) != zero) //4 { sph_echo512_init(&ctx_echo); sph_echo512 (&ctx_echo, hashA, 64); // sph_echo512_close(&ctx_echo, hashB); //5 } else { sph_simd512_init(&ctx_simd); sph_simd512 (&ctx_simd, hashA, 64); //4 sph_simd512_close(&ctx_simd, hashB); //5 } sph_shabal512_init(&ctx_shabal); sph_shabal512 (&ctx_shabal,hashB, 64); //5 sph_shabal512_close(&ctx_shabal, hashA); //6 sph_whirlpool_init(&ctx_whirlpool); sph_whirlpool (&ctx_whirlpool, hashA, 64); //6 sph_whirlpool_close(&ctx_whirlpool, hashB); //7 if ((hashB[0] & mask) != zero) //7 { sph_fugue512_init(&ctx_fugue); sph_fugue512 (&ctx_fugue, hashB, 64); // sph_fugue512_close(&ctx_fugue, hashA); //8 } else { sph_sha512_init(&ctx_sha2); sph_sha512 (&ctx_sha2, hashB, 64); //7 sph_sha512_close(&ctx_sha2, hashA); //8 } sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl,hashA, 64); //5 sph_groestl512_close(&ctx_groestl, hashB); //6 sph_sha512_init(&ctx_sha2); sph_sha512 (&ctx_sha2, hashB, 64); //6 sph_sha512_close(&ctx_sha2, hashA); //7 if ((hashA[0] & mask) != zero) //4 { sph_haval256_5_init(&ctx_haval); sph_haval256_5 (&ctx_haval, hashA, 64); // sph_haval256_5_close(&ctx_haval, hashB); //5 memset(&hashB[8], 0, 32); } else { sph_whirlpool_init(&ctx_whirlpool); sph_whirlpool (&ctx_whirlpool, hashA, 64); //4 sph_whirlpool_close(&ctx_whirlpool, hashB); //5 } sph_bmw512_init(&ctx_bmw); sph_bmw512 (&ctx_bmw,hashB, 64); //5 sph_bmw512_close(&ctx_bmw, hashA); //6 memcpy(state, hashA, 32); }
void X15_hash(const char* input, char* output) { sph_blake512_context ctx_blake; sph_bmw512_context ctx_bmw; sph_groestl512_context ctx_groestl; sph_skein512_context ctx_skein; sph_jh512_context ctx_jh; sph_keccak512_context ctx_keccak; sph_luffa512_context ctx_luffa1; sph_cubehash512_context ctx_cubehash1; sph_shavite512_context ctx_shavite1; sph_simd512_context ctx_simd1; sph_echo512_context ctx_echo1; sph_hamsi512_context ctx_hamsi1; sph_fugue512_context ctx_fugue1; sph_shabal512_context ctx_shabal1; sph_whirlpool_context ctx_whirlpool1; //these uint512 in the c++ source of the client are backed by an array of uint32 uint32_t hashA[16], hashB[16]; sph_blake512_init(&ctx_blake); sph_blake512 (&ctx_blake, input, 80); sph_blake512_close (&ctx_blake, hashA); sph_bmw512_init(&ctx_bmw); sph_bmw512 (&ctx_bmw, hashA, 64); sph_bmw512_close(&ctx_bmw, hashB); sph_groestl512_init(&ctx_groestl); sph_groestl512 (&ctx_groestl, hashB, 64); sph_groestl512_close(&ctx_groestl, hashA); sph_skein512_init(&ctx_skein); sph_skein512 (&ctx_skein, hashA, 64); sph_skein512_close (&ctx_skein, hashB); sph_jh512_init(&ctx_jh); sph_jh512 (&ctx_jh, hashB, 64); sph_jh512_close(&ctx_jh, hashA); sph_keccak512_init(&ctx_keccak); sph_keccak512 (&ctx_keccak, hashA, 64); sph_keccak512_close(&ctx_keccak, hashB); sph_luffa512_init (&ctx_luffa1); sph_luffa512 (&ctx_luffa1, hashB, 64); sph_luffa512_close (&ctx_luffa1, hashA); sph_cubehash512_init (&ctx_cubehash1); sph_cubehash512 (&ctx_cubehash1, hashA, 64); sph_cubehash512_close(&ctx_cubehash1, hashB); sph_shavite512_init (&ctx_shavite1); sph_shavite512 (&ctx_shavite1, hashB, 64); sph_shavite512_close(&ctx_shavite1, hashA); sph_simd512_init (&ctx_simd1); sph_simd512 (&ctx_simd1, hashA, 64); sph_simd512_close(&ctx_simd1, hashB); sph_echo512_init (&ctx_echo1); sph_echo512 (&ctx_echo1, hashB, 64); sph_echo512_close(&ctx_echo1, hashA); sph_hamsi512_init (&ctx_hamsi1); sph_hamsi512 (&ctx_hamsi1, hashA, 64); sph_hamsi512_close(&ctx_hamsi1, hashB); sph_fugue512_init (&ctx_fugue1); sph_fugue512 (&ctx_fugue1, hashB, 64); sph_fugue512_close(&ctx_fugue1, hashA); sph_shabal512_init (&ctx_shabal1); sph_shabal512 (&ctx_shabal1, hashA, 64); sph_shabal512_close(&ctx_shabal1, hashB); sph_whirlpool_init (&ctx_whirlpool1); sph_whirlpool (&ctx_whirlpool1, hashB, 64); sph_whirlpool_close(&ctx_whirlpool1, hashA); memcpy(output, hashA, 32); }
void x14hash(void *output, const void *input) { unsigned char hash[128]; // uint32_t hashA[16], hashB[16]; #define hashB hash+64 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; sph_fugue512_context ctx_fugue; sph_shabal512_context ctx_shabal; sph_blake512_init(&ctx_blake); sph_blake512(&ctx_blake, input, 80); sph_blake512_close(&ctx_blake, hash); sph_bmw512_init(&ctx_bmw); sph_bmw512(&ctx_bmw, hash, 64); sph_bmw512_close(&ctx_bmw, hashB); sph_groestl512_init(&ctx_groestl); sph_groestl512(&ctx_groestl, hashB, 64); sph_groestl512_close(&ctx_groestl, hash); sph_skein512_init(&ctx_skein); sph_skein512(&ctx_skein, hash, 64); sph_skein512_close(&ctx_skein, hashB); sph_jh512_init(&ctx_jh); sph_jh512(&ctx_jh, hashB, 64); sph_jh512_close(&ctx_jh, hash); sph_keccak512_init(&ctx_keccak); sph_keccak512(&ctx_keccak, hash, 64); sph_keccak512_close(&ctx_keccak, hashB); sph_luffa512_init(&ctx_luffa); sph_luffa512(&ctx_luffa, hashB, 64); sph_luffa512_close(&ctx_luffa, hash); sph_cubehash512_init(&ctx_cubehash); sph_cubehash512(&ctx_cubehash, hash, 64); sph_cubehash512_close(&ctx_cubehash, hashB); sph_shavite512_init(&ctx_shavite); sph_shavite512(&ctx_shavite, hashB, 64); sph_shavite512_close(&ctx_shavite, hash); sph_simd512_init(&ctx_simd); sph_simd512(&ctx_simd, hash, 64); sph_simd512_close(&ctx_simd, hashB); sph_echo512_init(&ctx_echo); sph_echo512(&ctx_echo, hashB, 64); sph_echo512_close(&ctx_echo, hash); sph_hamsi512_init(&ctx_hamsi); sph_hamsi512(&ctx_hamsi, hash, 64); sph_hamsi512_close(&ctx_hamsi, hashB); sph_fugue512_init(&ctx_fugue); sph_fugue512(&ctx_fugue, hashB, 64); sph_fugue512_close(&ctx_fugue, hash); sph_shabal512_init(&ctx_shabal); sph_shabal512(&ctx_shabal, hash, 64); sph_shabal512_close(&ctx_shabal, hash); memcpy(output, hash, 32); }
static void x14hash(void *output, const void *input) { unsigned char hash[128]; // uint32_t hashA[16], hashB[16]; #define hashB hash+64 x14_ctx_holder ctx; memcpy(&ctx, &x14_ctx, sizeof(x14_ctx)); #ifdef NO_AES_NI grsoState sts_grs; #endif unsigned char hashbuf[128]; size_t hashptr; sph_u64 hashctA; sph_u64 hashctB; //---blake1--- DECL_BLK; BLK_I; BLK_W; BLK_C; //---bmw2--- DECL_BMW; BMW_I; BMW_U; #define M(x) sph_dec64le_aligned(data + 8 * (x)) #define H(x) (h[x]) #define dH(x) (dh[x]) BMW_C; #undef M #undef H #undef dH //---groestl---- #ifdef NO_AES_NI // use SSE2 optimized GRS if possible GRS_I; GRS_U; GRS_C; // sph_groestl512 (&ctx.groestl, hash, 64); // sph_groestl512_close(&ctx.groestl, hash); #else update_groestl( &ctx.groestl, (char*)hash,512); final_groestl( &ctx.groestl, (char*)hash); #endif //---skein4--- DECL_SKN; SKN_I; SKN_U; SKN_C; //---jh5------ DECL_JH; JH_H; //---keccak6--- DECL_KEC; KEC_I; KEC_U; KEC_C; //--- luffa7 update_luffa( &ctx.luffa, (const BitSequence*)hash,512); final_luffa( &ctx.luffa, (BitSequence*)hashB); // 8 Cube cubehashUpdate( &ctx.cubehash, (const byte*) hashB,64); cubehashDigest( &ctx.cubehash, (byte*)hash); // 9 Shavite sph_shavite512( &ctx.shavite, hash, 64); sph_shavite512_close( &ctx.shavite, hashB); // 10 Simd update_sd( &ctx.simd, (const BitSequence *)hashB,512); final_sd( &ctx.simd, (BitSequence *)hash); //11---echo--- #ifdef NO_AES_NI sph_echo512(&ctx.echo, hash, 64); sph_echo512_close(&ctx.echo, hashB); #else update_echo ( &ctx.echo, (const BitSequence *) hash, 512); final_echo( &ctx.echo, (BitSequence *) hashB); #endif // X13 algos // 12 Hamsi sph_hamsi512(&ctx.hamsi, hashB, 64); sph_hamsi512_close(&ctx.hamsi, hash); // 13 Fugue sph_fugue512(&ctx.fugue, hash, 64); sph_fugue512_close(&ctx.fugue, hashB); // X14 Shabal sph_shabal512(&ctx.shabal, hashB, 64); sph_shabal512_close(&ctx.shabal, hash); asm volatile ("emms"); memcpy(output, hash, 32); }