demake 0.2.0 → 0.2.1

data/lib/data/libsrc/fast_sha2.h

@@ -0,0 +1,1840 @@
+/*
+
+   fast_sha2.h -- *Full Library* Header File
+
+   Uses version 2 of the Secure Hashing Algorithm to produce a message
+   digest as output.
+
+   Based on:
+   https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
+
+   With help from:
+   https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sha-extensions.html
+   https://developer.arm.com/architectures/instruction-sets/intrinsics/
+
+   Validated using sha-validation.rb along with:
+   https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA256.pdf
+   https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA512.pdf
+
+         1         2         3         4         5         6         7         8
+12345678901234567890123456789012345678901234567890123456789012345678901234567890
+────────────────────────────────────────────────────────────────────────────────
+
+*/
+
+#ifndef FAST_SHA2_H_Minaswan	/* Prevents multiple inclusions	*/
+#define FAST_SHA2_H_Minaswan
+  #define FAST_SHA2_VERSION	"0.1.0"
+  #ifndef TYPEDEFS_H_Minaswan	/* Header guard for typedefs.h	*/
+    #define TYPEDEFS_H_Minaswan	/* The SAME as typedefs.h	*/
+    #include <stdint.h>
+
+    typedef uint8_t b8;		/* Booleans			*/
+    typedef uint16_t b16;
+    typedef uint32_t b32;
+    typedef uint64_t b64;
+
+    typedef char c8;		/* Characters			*/
+    typedef unsigned char uc8;
+
+    typedef uint8_t u8;		/* Unsigned Numbers		*/
+    typedef uint16_t u16;
+    typedef uint32_t u32;
+    typedef uint64_t u64;
+
+    typedef int8_t i8;		/* Signed Numbers		*/
+    typedef int16_t i16;
+    typedef int32_t i32;
+    typedef int64_t i64;
+
+    typedef float f32;		/* Floating Point Numbers	*/
+    typedef double f64;
+  #endif			/* TYPEDEFS_H_Minaswan		*/
+
+  const c8 *fast_sha2_cpu_instructions[];
+
+  /* Public Functions */
+  b8 fast_sha2_list_cpu_instructions(c8 *output, b32 hardware_support);
+  b32 fast_sha2_supported_by_cpu(void);
+  c8 *fast_sha2_256_digest(uc8 *hash);
+  c8 *fast_sha2_512_digest(uc8 *hash);
+  uc8 *fast_sha2_256(uc8 *string, b8 software_only);
+  uc8 *fast_sha2_512(uc8 *string, b8 software_only);
+  uc8 *fast_sha2_256_hash(uc8 *message, u64 length, b8 software_only);
+  uc8 *fast_sha2_512_hash(uc8 *message, u64 length, b8 software_only);
+  void fast_sha2_256_show_hash(uc8 *hash);
+  void fast_sha2_512_show_hash(uc8 *hash);
+
+  #ifdef FAST_SHA2_IMPLEMENTATION   /* Effectively fast_sha2.c  */
+    #include <string.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+
+    #ifndef FALSE
+      #define FALSE			0
+    #endif
+
+    #ifndef TRUE
+      #define TRUE			1
+    #endif
+
+    #ifndef NULL
+      #define NULL			((void *) 0)
+    #endif
+
+    #ifndef ALIGN64
+      #define ALIGN64			__attribute__((aligned(64)))
+    #endif
+
+    #if defined(__x86_64__) || defined(_M_X64)
+      /* Used to Intel/AMD hardware acceleration */
+      /* Modern compiler -- supports __has_attribute */
+      #if defined(__has_attribute)
+        #if __has_attribute(target)
+          #define FAST_SHA2_ATTRIBUTES
+          #define FAST_SHA2_ATTRIBUTES_256 	__attribute__((target("ssse3,avx2,sha,sse4.1")))
+          #if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 14)	/* Need for target sha512 */
+            #define FAST_SHA2_ATTRIBUTES_512 	__attribute__((target("ssse3,avx2,sha512,avx512f,avx512bw,avx512vl,avx512vbmi2,avx512vnni")))
+          #else
+            #define FAST_SHA2_ATTRIBUTES_512 	__attribute__((target("ssse3,avx2,avx512f,avx512bw,avx512vl,avx512vbmi2,avx512vnni")))
+          #endif
+        #endif
+      #elif defined(__GNUC__) && (__GNUC__ >= 8)	/* Older compiler */
+        #define FAST_SHA2_ATTRIBUTES
+        #define FAST_SHA2_ATTRIBUTES_256	__attribute__((target("ssse3,avx2,sha,sse4.1")))
+        #if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 14)	/* Need for target sha512 */
+          #define FAST_SHA2_ATTRIBUTES_512 	__attribute__((target("ssse3,avx2,sha512,avx512f,avx512bw,avx512vl,avx512vbmi2,avx512vnni")))
+        #else
+          #define FAST_SHA2_ATTRIBUTES_512 	__attribute__((target("ssse3,avx2,avx512f,avx512bw,avx512vl,avx512vbmi2,avx512vnni")))
+        #endif
+      #endif
+      #if defined(FAST_SHA2_ATTRIBUTES)
+        #define FAST_SHA2_NI		TRUE
+        #include <immintrin.h>
+        typedef __m128i v128;
+        typedef __m256i v256;
+      #endif
+      /* Used to test if the CPU supports the instructions */
+      #ifndef cpuid
+        #define cpuid(ax, bx, cx, dx)   __asm__ __volatile__ ("cpuid" :		\
+					"+a"(ax), "=b"(bx), "+c"(cx), "=d"(dx))
+      #endif
+      #ifndef xgetbv
+        #define xgetbv(idx, lo, hi)	__asm__ __volatile__ ("xgetbv" :	\
+					"=a"(lo), "=d"(hi) : "c"(idx));
+      #endif
+    #elif defined(__ARM_NEON) || defined(_AARCH64_NEON_H_)
+      /* Used for ARM hardware acceleration */
+      #if defined(__has_attribute)
+        #if __has_attribute(target)
+          #define FAST_SHA2_ATTRIBUTES
+          #define FAST_SHA2_ATTRIBUTES_256	__attribute__((target("+crypto,+sha3")))
+          #define FAST_SHA2_ATTRIBUTES_512	__attribute__((target("+crypto,+sha3")))
+        #endif
+      #elif defined(__GNUC__) && (__GNUC__ >= 8)
+        #define FAST_SHA2_ATTRIBUTES
+        #define FAST_SHA2_ATTRIBUTES_256	__attribute__((target("+crypto,+sha3")))
+        #define FAST_SHA2_ATTRIBUTES_512	__attribute__((target("+crypto,+sha3")))
+      #endif
+      #if defined(FAST_SHA2_ATTRIBUTES)
+        #define FAST_SHA2_ARM		TRUE
+        #include <arm_neon.h>
+        #include <arm_acle.h>
+        #include <sys/auxv.h>
+        #include <asm/hwcap.h>
+        #if defined(__ARM_FEATURE_SVE)
+          #include <arm_sve.h>
+          typedef svuint32_t v32;	/* Scalable 32-bit */
+          typedef svuint64_t v64;	/* Scalable 64-bit */
+        #else
+          typedef uint32x4_t v128_32;	/* 32-bit for SHA-256 */
+          typedef uint64x2_t v128_64;	/* 64-bit for SHA-512 */
+        #endif
+      #endif
+    #elif defined(__riscv)
+/*      #if defined(__riscv_vector) || defined(HAVE_RISCV_V) */
+        #if defined(__has_attribute)
+          #if __has_attribute(target)
+            #define FAST_SHA2_ATTRIBUTES
+            #define FAST_SHA2_ATTRIBUTES_256
+            #define FAST_SHA2_ATTRIBUTES_512
+/*
+            #define FAST_SHA2_ATTRIBUTES_V	__attribute__((target("arch=+v")))
+            #define FAST_SHA2_ATTRIBUTES_256	__attribute__((target("arch=+v,+zvknha")))
+            #define FAST_SHA2_ATTRIBUTES_512	__attribute__((target("arch=+v,+zvknhb")))
+*/
+          #endif
+        #elif defined(__GNUC__) && (__GNUC__ >= 8)
+          #define FAST_SHA2_ATTRIBUTES
+          #define FAST_SHA2_ATTRIBUTES_256
+          #define FAST_SHA2_ATTRIBUTES_512
+/*
+          #define FAST_SHA2_ATTRIBUTES_V	__attribute__((target("arch=+v")))
+          #define FAST_SHA2_ATTRIBUTES_256	__attribute__((target("arch=+v,+zvknha")))
+          #define FAST_SHA2_ATTRIBUTES_512	__attribute__((target("arch=+v,+zvknhb")))
+*/
+        #endif
+        #if defined(FAST_SHA2_ATTRIBUTES)
+          #define FAST_SHA2_RISC_V	TRUE
+          #include <riscv_vector.h>
+          typedef vuint32m1_t v32;
+          typedef vuint64m1_t v64;
+/*
+          #include <asm/hwprobe.h>
+          #include <sys/hwprobe.h>
+          #include <sys/syscall.h>
+
+          typedef u32 v32 __attribute__((vector_size(32)));
+          typedef u64 v64 __attribute__((vector_size(32)));
+*/
+          #ifndef __riscv_hwprobe
+            #define FAST_SHA2_RISC_V_PROBE
+            struct riscv_hwprobe {
+              i64 key;
+              u64 value;
+            };
+            #define RISCV_HWPROBE_KEY_IMA_EXT_0	4
+
+            #define RISCV_HWPROBE_EXT_V		(1ULL << 0)
+            #define RISCV_HWPROBE_EXT_ZBA	(1ULL << 3)
+            #define RISCV_HWPROBE_EXT_ZBB	(1ULL << 4)
+            #define RISCV_HWPROBE_EXT_ZBKB	(1ULL << 8)
+            #define RISCV_HWPROBE_EXT_ZKNH	(1ULL << 13)
+            #define RISCV_HWPROBE_EXT_ZVKNHA	(1ULL << 34)
+            #define RISCV_HWPROBE_EXT_ZVKNHB	(1ULL << 35)
+            #define __riscv_hwprobe(pairs, pair_count, cpu_count, cpus, flags)		\
+                ({ long __ret;								\
+                   register void * __a0 __asm__("a0") = (void*)(pairs);			\
+                   register size_t __a1 __asm__("a1") = (size_t)(pair_count);		\
+                   register size_t __a2 __asm__("a2") = (size_t)(cpu_count);		\
+                   register void * __a3 __asm__("a3") = (void*)(cpus);			\
+                   register unsigned int __a4 __asm__("a4") = (unsigned int)(flags);	\
+                   register long __a7 __asm__("a7") = 258;				\
+                   __asm__ __volatile__ ("ecall" : "=r" (__ret) : "r" (__a0),		\
+                       "r" (__a1), "r" (__a2), "r" (__a3), "r" (__a4), "r" (__a7)	\
+                       : "memory"); __ret; })
+
+/*        long result = __riscv_hwprobe(kv_pair, 1, 0, NULL, 0); */
+
+          #endif
+        #endif
+    #endif
+
+    /* Main hash internal structures */
+    typedef struct fast_sha2_hash_context256 {
+      u64 length;
+      u32 hash[8];
+      u64 total;
+      uc8 buf[128];
+    } fast_sha2_hash_context256;
+
+    typedef struct fast_sha2_hash_context512 {
+      u64 length;
+      u64 hash[8];
+      u64 total;
+      uc8 buf[256];
+    } fast_sha2_hash_context512;
+
+    /* Padding Demarkation */
+    #define FAST_SHA2_PAD_MARK		0x80
+
+    /* Shift Right */
+    #define FAST_SHA2_SHR(x, n)		((x) >> (n))
+
+    /* Rotate Right */
+    #define FAST_SHA2_ROTR32(x, n)	(((x) >> (n)) | ((x) << (32 - (n))))
+    #define FAST_SHA2_ROTR64(x, n)	(((x) >> (n)) | ((x) << (64 - (n))))
+
+    /* SHA2 256+512 Functions Change & Majority */
+    #define FAST_SHA2_CH(x, y, z)	(((x) & (y)) ^ ((~(x)) & (z)))
+    #define FAST_SHA2_MAJ(x, y, z)	(((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+
+    /* Sigma0 & 1 and Gamma0 & 1 for SHA-256 */
+    #define FAST_SHA2_S0_32(x)		(FAST_SHA2_ROTR32((x), 2) ^ FAST_SHA2_ROTR32((x), 13) ^ FAST_SHA2_ROTR32((x), 22))
+    #define FAST_SHA2_S1_32(x)		(FAST_SHA2_ROTR32((x), 6) ^ FAST_SHA2_ROTR32((x), 11) ^ FAST_SHA2_ROTR32((x), 25))
+    #define FAST_SHA2_G0_32(x)		(FAST_SHA2_ROTR32((x), 7) ^ FAST_SHA2_ROTR32((x), 18) ^ FAST_SHA2_SHR((x), 3))
+    #define FAST_SHA2_G1_32(x)		(FAST_SHA2_ROTR32((x), 17) ^ FAST_SHA2_ROTR32((x), 19) ^ FAST_SHA2_SHR((x), 10))
+
+    /* Sigma0 & 1 and Gamma0 & 1 for SHA-512 */
+    #define FAST_SHA2_S0_64(x)		(FAST_SHA2_ROTR64((x), 28) ^ FAST_SHA2_ROTR64((x), 34) ^ FAST_SHA2_ROTR64((x), 39))
+    #define FAST_SHA2_S1_64(x)		(FAST_SHA2_ROTR64((x), 14) ^ FAST_SHA2_ROTR64((x), 18) ^ FAST_SHA2_ROTR64((x), 41))
+    #define FAST_SHA2_G0_64(x)		(FAST_SHA2_ROTR64((x), 1) ^ FAST_SHA2_ROTR64((x), 8) ^ FAST_SHA2_SHR((x), 7))
+    #define FAST_SHA2_G1_64(x)		(FAST_SHA2_ROTR64((x), 19) ^ FAST_SHA2_ROTR64((x), 61) ^ FAST_SHA2_SHR((x), 6))
+
+    /* Conversion */
+    #define FAST_SHA2_UNPACK32(x, s)	\
+    {					\
+      *((s) + 3) = (uc8) ((x));		\
+      *((s) + 2) = (uc8) ((x) >> 8);	\
+      *((s) + 1) = (uc8) ((x) >> 16);	\
+      *((s) + 0) = (uc8) ((x) >> 24);	\
+    }
+
+    #define FAST_SHA2_PACK32(x, s)	\
+    {					\
+      *(x) = ((u32) *((s) + 3)) |	\
+             ((u32) *((s) + 2) << 8) |	\
+             ((u32) *((s) + 1) << 16) |	\
+             ((u32) *((s) + 0) << 24);	\
+    }
+
+    #define FAST_SHA2_UNPACK64(x, s)	\
+    {					\
+      *((s) + 7) = (uc8) ((x));		\
+      *((s) + 6) = (uc8) ((x) >> 8);	\
+      *((s) + 5) = (uc8) ((x) >> 16);	\
+      *((s) + 4) = (uc8) ((x) >> 24);	\
+      *((s) + 3) = (uc8) ((x) >> 32);	\
+      *((s) + 2) = (uc8) ((x) >> 40);	\
+      *((s) + 1) = (uc8) ((x) >> 48);	\
+      *((s) + 0) = (uc8) ((x) >> 56);	\
+    }
+
+    #define FAST_SHA2_PACK64(x, s)	\
+    {					\
+      *(x) = ((u64) *((s) + 7)) |	\
+             ((u64) *((s) + 6) << 8) |	\
+             ((u64) *((s) + 5) << 16) |	\
+             ((u64) *((s) + 4) << 24) |	\
+             ((u64) *((s) + 3) << 32) |	\
+             ((u64) *((s) + 2) << 40) |	\
+             ((u64) *((s) + 1) << 48) |	\
+             ((u64) *((s) + 0) << 56);	\
+    }
+
+    ALIGN64
+    static const u32 fast_sha2_256_k_table[64] = {
+      0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+      0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+      0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+      0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+      0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+      0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+      0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+      0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+      0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+      0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+      0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+      0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+      0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    };
+
+    ALIGN64
+    static const u32 fast_sha2_256_initial_states[8] = {
+      0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+      0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    };
+
+    ALIGN64
+    static const u64 fast_sha2_512_k_table[80] = {
+      0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f,
+      0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019,
+      0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242,
+      0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
+      0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
+      0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3,
+      0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275,
+      0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
+      0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f,
+      0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
+      0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc,
+      0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
+      0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6,
+      0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001,
+      0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
+      0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
+      0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99,
+      0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb,
+      0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc,
+      0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
+      0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915,
+      0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207,
+      0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba,
+      0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
+      0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
+      0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,
+      0x5fcb6fab3ad6faec, 0x6c44198c4a475817
+    };
+
+    ALIGN64
+    static const u64 fast_sha2_512_initial_states[8] = {
+      0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b,
+      0xa54ff53a5f1d36f1, 0x510e527fade682d1, 0x9b05688c2b3e6c1f,
+      0x1f83d9abfb41bd6b, 0x5be0cd19137e2179
+    };
+
+    #define FAST_SHA2_BIT_IS_SET(field, bit)		((field) & (b32)(bit))
+    #define FAST_SHA2_CPU_SUPPORTS_SSSE3		(1 << 0)
+    #define FAST_SHA2_CPU_SUPPORTS_AVX2			(1 << 1)
+    #define FAST_SHA2_CPU_SUPPORTS_SHA256		(1 << 2)
+    #define FAST_SHA2_CPU_SUPPORTS_SHA512		(1 << 3)
+    #define FAST_SHA2_CPU_SUPPORTS_AVX512		(1 << 4)
+    #define FAST_SHA2_CPU_SUPPORTS_RVV1			(1 << 5)
+    #define FAST_SHA2_CPU_SUPPORTS_ZBA			(1 << 6)
+    #define FAST_SHA2_CPU_SUPPORTS_ZBB			(1 << 7)
+    #define FAST_SHA2_CPU_SUPPORTS_ZBKB			(1 << 8)
+    #define FAST_SHA2_CPU_SUPPORTS_ZKNH			(1 << 9)
+    #define FAST_SHA2_CPU_SUPPORTS_ZVKNHA		(1 << 10)
+    #define FAST_SHA2_CPU_SUPPORTS_ZVKNHB		(1 << 11)
+
+    const c8 *fast_sha2_cpu_instructions[] = {
+      "SSSE3",
+      "AVX2",
+      "SHA256",
+      "SHA512",
+      "AVX512",
+      "RVV1",
+      "ZBA",
+      "ZBB",
+      "ZBKB",
+      "ZKNH",
+      "ZVKNHA",
+      "ZVKNHB",
+      NULL
+    };
+
+    b8 fast_sha2_list_cpu_instructions(c8 *output, b32 hardware_support)
+    {
+      u32 i = 0;
+      b8 found = FALSE;
+
+      *output = '\0';
+      while(fast_sha2_cpu_instructions[i] != NULL) {
+        if(FAST_SHA2_BIT_IS_SET(hardware_support, (1 << i))) {
+          if(found) {
+            strcat(output, ", ");
+            if(fast_sha2_cpu_instructions[i])
+              strcat(output, fast_sha2_cpu_instructions[i]);
+            else
+              strcat(output, "UNDEFINED");
+          } else {
+            found = TRUE;
+            if(fast_sha2_cpu_instructions[i])
+              strcpy(output, fast_sha2_cpu_instructions[i]);
+            else
+              strcpy(output, "UNDEFINED");
+          }
+        }
+        i++;
+      }
+      return(found);
+    }
+
+    b32 fast_sha2_supported_by_cpu(void)
+    {
+      b32 hardware_support = 0;
+
+      /* Check for x86 SHA Instructions		*/
+      #if defined(FAST_SHA2_NI)
+        u32 a = 0, b = 0, c = 0, d = 0;
+
+        /* SSSE3: CPUID.1.ECX[9] */
+        a = 1; c = 0;
+        cpuid(a, b, c, d);
+        if((c >> 9) & 1)
+          hardware_support |= FAST_SHA2_CPU_SUPPORTS_SSSE3;
+        a = c = 0;
+        cpuid(a, b, c, d);
+        if(a < 7)	/* Otherwise bail if leaf 7 isn't supported */
+          return(hardware_support);
+        /* SHA256 CPUID.7.0.EBX[29] / EAX = 7, ECX = 0 */
+        a = 7, c = 0;
+        cpuid(a, b, c, d);
+        if((b >> 29) & 1)
+          hardware_support |= FAST_SHA2_CPU_SUPPORTS_SHA256;
+
+        /* SHA512 CPUID.7.1.EDX[0] / EAX = 7, ECX = 1 */
+        if(a > 0) {
+          a = 7, c = 1;
+          cpuid(a, b, c, d);
+          if(d & 1)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_SHA512;
+        }
+        /* AVX2: EBX[5] + XCR0[2:1] */
+        a = 7, c = 0;
+        cpuid(a, b, c, d);
+        if((b >> 5) & 1) {
+          a = 1; b = 0; c = 0; d = 0;
+          cpuid(a, b, c, d);
+          if((c >> 27) & 1) {
+            xgetbv(0, a, d);	/* Needs OS Support too */
+            if((((u64)d << 32) | (a & 0x6)) == 0x6)
+              hardware_support |= FAST_SHA2_CPU_SUPPORTS_AVX2;
+          }
+        }
+        /* AVX-512: EBX[16] + XCR0[7:5] */
+        a = 7, c = 0;
+        cpuid(a, b, c, d);
+        if((b >> 16) & 1) {
+          a = 1; b = 0; c = 0; d = 0;
+          cpuid(a, b, c, d);
+          if((c >> 27) & 1) {
+            xgetbv(0, a, d);	/* Needs OS Support too */
+            if((((u64)d << 32) | (a & 0xE6)) == 0xE6)
+              hardware_support |= FAST_SHA2_CPU_SUPPORTS_AVX512;
+          }
+        }
+      /* Check for ARM SHA Instructions		*/
+      #elif defined(FAST_SHA2_ARM)
+        #if defined(HWCAP_SHA2)
+        u64 hwcaps = getauxval(AT_HWCAP);
+        if(hwcaps & HWCAP_SHA2)
+          hardware_support |= FAST_SHA2_CPU_SUPPORTS_SHA256;
+          #if defined(HWCAP_SHA512)
+          if(hwcaps & HWCAP_SHA512)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_SHA512;
+          #endif
+        #endif
+      #elif defined(FAST_SHA2_RISC_V)
+        struct riscv_hwprobe kv_pair[] = {
+          { RISCV_HWPROBE_KEY_IMA_EXT_0, 0 }
+        };
+/* printf("rv = %ld\n", __riscv_hwprobe(kv_pair, 1, 0, NULL, 0)); */
+/*        if(__riscv_hwprobe(kv_pair, 1, 0, NULL, 0) == 0) { */
+
+        long result = __riscv_hwprobe(kv_pair, 1, 0, NULL, 0);
+printf("hardware probe = %ld %ld %lu\n", result, kv_pair[0].key, kv_pair[0].value);
+        if(kv_pair[0].value != 0) {
+          if(kv_pair[0].value & RISCV_HWPROBE_EXT_V)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_RVV1;
+          if(kv_pair[0].value & RISCV_HWPROBE_EXT_ZBA)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_ZBA;
+          if(kv_pair[0].value & RISCV_HWPROBE_EXT_ZBB)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_ZBB;
+          if(kv_pair[0].value & RISCV_HWPROBE_EXT_ZBKB)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_ZBKB;
+          if(kv_pair[0].value & RISCV_HWPROBE_EXT_ZKNH)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_ZKNH;
+          if(kv_pair[0].value & RISCV_HWPROBE_EXT_ZVKNHA)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_ZVKNHA;
+          if(kv_pair[0].value & RISCV_HWPROBE_EXT_ZVKNHB)
+            hardware_support |= FAST_SHA2_CPU_SUPPORTS_ZVKNHB;
+        }
+      #endif
+
+      return(hardware_support);
+    }
+
+    /*
+       Warning: unused function - if FAST_SHA2_NI and FAST_SHA2_ARM hardware support isn't
+       available, this function is empty. In this case, the function
+       fast_sha2_supported_by_cpu will return false, and so in this case the empty
+       function should never be called.
+
+       However, this *may* cause compiler warnings.
+    */
+  #if defined(FAST_SHA2_ATTRIBUTES)
+    FAST_SHA2_ATTRIBUTES_256
+  #endif
+    void fast_sha2_256_process_hardware_hash(fast_sha2_hash_context256 *context,
+        uc8 *message, u64 n)
+    {
+    #if defined(FAST_SHA2_ARM)
+      v128_32 state0, state1, save0, save1, keys;
+      v128_32 msg, tmp, tmsg0, tmsg1, tmsg2, tmsg3;
+    #elif defined(FAST_SHA2_NI)
+      v128 state0, state1, save0, save1, keys;
+      v128 msg, tmp, tmsg0, tmsg1, tmsg2, tmsg3;
+      const v128 shuffle_mask = _mm_set_epi8(12, 13, 14, 15, 8, 9, 10,
+          11, 4, 5, 6, 7, 0, 1, 2, 3);
+    #elif defined(FAST_SHA2_RISC_V)
+      v32 state0, state1, save0, save1, keys;
+      v32 msg, tmp, tmsg0, tmsg1, tmsg2, tmsg3;
+      u64 vlmax = __riscv_vsetvl_e32m1(0);	/* number of 32-bit elements */
+    #endif
+    #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM) || defined(FAST_SHA2_RISC_V)
+      u32 s0[16] = {0}, s1[16] = {0}, i = 0;
+      uc8 *p = NULL;
+    #endif
+    /* Initialize state from context */
+    #if defined(FAST_SHA2_NI)
+      state0 = _mm_set_epi32((i32)context->hash[0], (i32)context->hash[1],
+          (i32)context->hash[4], (i32)context->hash[5]);
+      state1 = _mm_set_epi32((i32)context->hash[2], (i32)context->hash[3],
+          (i32)context->hash[6], (i32)context->hash[7]);
+    #elif defined(FAST_SHA2_ARM)
+      state0 = vld1q_u32((const u32 *)&context->hash[0]);
+      state1 = vld1q_u32((const u32 *)&context->hash[4]);
+    #elif defined(FAST_SHA2_RISC_V)
+
+printf("Things are getting RISC-VY!\n");
+
+    #endif
+
+
+/*
+
+// We want to process 'n' message blocks in parallel
+void sha256_vector_parallel(uint32_t *data, size_t n) {
+    for (size_t vl; n > 0; n -= vl, data += (vl * 16)) {
+        // 1. Ask the hardware: "How many 32-bit elements can you handle at once?"
+        // This sets 'vl' to the hardware's max capacity (VLMAX) or 'n', whichever is smaller.
+        vl = __riscv_vsetvl_e32m1(n);
+
+        // 2. Load your data into the vector registers
+        // If VLEN=128, vl is 4. If VLEN=256, vl is 8.
+        vuint32m1_t v_data = __riscv_vle32_v_u32m1(data, vl);
+
+        // ... Perform SHA-256 rounds here ...
+    }
+}
+
+*/
+
+    #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM) || defined(FAST_SHA2_RISC_V)
+      for(i = 0; i < n; i++) {
+        p = message + (i << 6);
+
+        save0 = state0;	/* Save for next round */
+        save1 = state1;
+
+
+
+
+    #endif
+
+        /* key # corresponds to round number */
+    #if defined(FAST_SHA2_NI)
+        keys = _mm_set_epi32((i32)fast_sha2_256_k_table[3], (i32)fast_sha2_256_k_table[2],
+            (i32)fast_sha2_256_k_table[1], (i32)fast_sha2_256_k_table[0]);
+        msg = _mm_loadu_si128((v128 *)p);
+        tmsg0 = _mm_shuffle_epi8(msg, shuffle_mask);
+        msg = _mm_add_epi32(tmsg0, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[0]);
+        msg = vld1q_u32((const u32 *)p);
+        tmsg0 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(msg)));
+        msg = vaddq_u32(tmsg0, keys);
+        tmp = state1;
+	/* efgh = vsha256h2q_u32(efgh, abcd, wk); */
+        state1 = vsha256h2q_u32(state1, state0, msg);
+	/* abcd = vsha256hq_u32(abcd, efgh, wk);  */
+        state0 = vsha256hq_u32(state0, tmp, msg);
+    #elif defined(FAST_SHA2_RISC_V)
+
+/*
+// Assume 'state' vectors (vuint32m1_t) hold SHA-256 variables {a,b,c,d} and {e,f,g,h}
+// 'W_K' is a vector containing (Message Word W[i] + Round Constant K[i])
+for (int i = 0; i < 64; i += 4) {
+    // 1. Prepare message schedule expansion for future rounds if needed
+    // msg0 = __riscv_vsha2ms_vv_u32m1(msg0, msg1, msg2, vl);
+
+    // 2. Perform compression rounds (2 rounds per instruction pair)
+    // Round i and i+1
+    state0 = __riscv_vsha2cl_vv_u32m1(state0, state1, W_K[i], vl);
+    state1 = __riscv_vsha2ch_vv_u32m1(state1, state0, W_K[i], vl);
+
+    // Round i+2 and i+3
+    state0 = __riscv_vsha2cl_vv_u32m1(state0, state1, W_K[i+2], vl);
+    state1 = __riscv_vsha2ch_vv_u32m1(state1, state0, W_K[i+2], vl);
+}
+*/
+
+
+
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[7], (i32)fast_sha2_256_k_table[6],
+            (i32)fast_sha2_256_k_table[5], (i32)fast_sha2_256_k_table[4]);
+        msg = _mm_loadu_si128((v128 *)(p + 16));
+        tmsg1 = _mm_shuffle_epi8(msg, shuffle_mask);
+        msg = _mm_add_epi32(tmsg1, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg0 = _mm_sha256msg1_epu32(tmsg0, tmsg1);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[4]);
+        msg = vld1q_u32((const u32 *)(p + 16));
+        tmsg1 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(msg)));
+        msg = vaddq_u32(tmsg1, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg0 = vsha256su0q_u32(tmsg0, tmsg1);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[11], (i32)fast_sha2_256_k_table[10],
+            (i32)fast_sha2_256_k_table[9], (i32)fast_sha2_256_k_table[8]);
+        msg = _mm_loadu_si128((v128 *)(p + 32));
+        tmsg2 = _mm_shuffle_epi8(msg, shuffle_mask);
+        msg = _mm_add_epi32(tmsg2, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg1 = _mm_sha256msg1_epu32(tmsg1, tmsg2);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[8]);
+        msg = vld1q_u32((const u32 *)(p + 32));
+        tmsg2 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(msg)));
+        msg = vaddq_u32(tmsg2, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg1 = vsha256su0q_u32(tmsg1, tmsg2);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[15], (i32)fast_sha2_256_k_table[14],
+            (i32)fast_sha2_256_k_table[13], (i32)fast_sha2_256_k_table[12]);
+        msg = _mm_loadu_si128((v128 *)(p + 48));
+        tmsg3 = _mm_shuffle_epi8(msg, shuffle_mask);
+        msg = _mm_add_epi32(tmsg3, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg3, tmsg2, 4);
+        tmsg0 = _mm_add_epi32(tmsg0, tmp);
+        tmsg0 = _mm_sha256msg2_epu32(tmsg0, tmsg3);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg2 = _mm_sha256msg1_epu32(tmsg2, tmsg3);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[12]);
+        msg = vld1q_u32((const u32 *)(p + 48));
+        tmsg3 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(msg)));
+        msg = vaddq_u32(tmsg3, keys);
+        tmsg0 = vsha256su1q_u32(tmsg0, tmsg2, tmsg3);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg2 = vsha256su0q_u32(tmsg2, tmsg3);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[19], (i32)fast_sha2_256_k_table[18],
+            (i32)fast_sha2_256_k_table[17], (i32)fast_sha2_256_k_table[16]);
+        msg = _mm_add_epi32(tmsg0, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg0, tmsg3, 4);
+        tmsg1 = _mm_add_epi32(tmsg1, tmp);
+        tmsg1 = _mm_sha256msg2_epu32(tmsg1, tmsg0);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg3 = _mm_sha256msg1_epu32(tmsg3, tmsg0);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[16]);
+        msg = vaddq_u32(tmsg0, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg1 = vsha256su1q_u32(tmsg1, tmsg3, tmsg0);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg3 = vsha256su0q_u32(tmsg3, tmsg0);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[23], (i32)fast_sha2_256_k_table[22],
+            (i32)fast_sha2_256_k_table[21], (i32)fast_sha2_256_k_table[20]);
+        msg = _mm_add_epi32(tmsg1, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg1, tmsg0, 4);
+        tmsg2 = _mm_add_epi32(tmsg2, tmp);
+        tmsg2 = _mm_sha256msg2_epu32(tmsg2, tmsg1);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg0 = _mm_sha256msg1_epu32(tmsg0, tmsg1);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[20]);
+        msg = vaddq_u32(tmsg1, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg2 = vsha256su1q_u32(tmsg2, tmsg0, tmsg1);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg0 = vsha256su0q_u32(tmsg0, tmsg1);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[27], (i32)fast_sha2_256_k_table[26],
+            (i32)fast_sha2_256_k_table[25], (i32)fast_sha2_256_k_table[24]);
+        msg = _mm_add_epi32(tmsg2, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg2, tmsg1, 4);
+        tmsg3 = _mm_add_epi32(tmsg3, tmp);
+        tmsg3 = _mm_sha256msg2_epu32(tmsg3, tmsg2);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg1 = _mm_sha256msg1_epu32(tmsg1, tmsg2);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[24]);
+        msg = vaddq_u32(tmsg2, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg3 = vsha256su1q_u32(tmsg3, tmsg1, tmsg2);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg1 = vsha256su0q_u32(tmsg1, tmsg2);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[31], (i32)fast_sha2_256_k_table[30],
+            (i32)fast_sha2_256_k_table[29], (i32)fast_sha2_256_k_table[28]);
+        msg = _mm_add_epi32(tmsg3, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg3, tmsg2, 4);
+        tmsg0 = _mm_add_epi32(tmsg0, tmp);
+        tmsg0 = _mm_sha256msg2_epu32(tmsg0, tmsg3);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg2 = _mm_sha256msg1_epu32(tmsg2, tmsg3);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[28]);
+        msg = vaddq_u32(tmsg3, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg0 = vsha256su1q_u32(tmsg0, tmsg2, tmsg3);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg2 = vsha256su0q_u32(tmsg2, tmsg3);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[35], (i32)fast_sha2_256_k_table[34],
+            (i32)fast_sha2_256_k_table[33], (i32)fast_sha2_256_k_table[32]);
+        msg = _mm_add_epi32(tmsg0, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg0, tmsg3, 4);
+        tmsg1 = _mm_add_epi32(tmsg1, tmp);
+        tmsg1 = _mm_sha256msg2_epu32(tmsg1, tmsg0);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg3 = _mm_sha256msg1_epu32(tmsg3, tmsg0);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[32]);
+        msg = vaddq_u32(tmsg0, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg1 = vsha256su1q_u32(tmsg1, tmsg3, tmsg0);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg3 = vsha256su0q_u32(tmsg3, tmsg0);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[39], (i32)fast_sha2_256_k_table[38],
+            (i32)fast_sha2_256_k_table[37], (i32)fast_sha2_256_k_table[36]);
+        msg = _mm_add_epi32(tmsg1, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg1, tmsg0, 4);
+        tmsg2 = _mm_add_epi32(tmsg2, tmp);
+        tmsg2 = _mm_sha256msg2_epu32(tmsg2, tmsg1);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg0 = _mm_sha256msg1_epu32(tmsg0, tmsg1);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[36]);
+        msg = vaddq_u32(tmsg1, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg2 = vsha256su1q_u32(tmsg2, tmsg0, tmsg1);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg0 = vsha256su0q_u32(tmsg0, tmsg1);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[43], (i32)fast_sha2_256_k_table[42],
+            (i32)fast_sha2_256_k_table[41], (i32)fast_sha2_256_k_table[40]);
+        msg = _mm_add_epi32(tmsg2, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg2, tmsg1, 4);
+        tmsg3 = _mm_add_epi32(tmsg3, tmp);
+        tmsg3 = _mm_sha256msg2_epu32(tmsg3, tmsg2);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg1 = _mm_sha256msg1_epu32(tmsg1, tmsg2);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[40]);
+        msg = vaddq_u32(tmsg2, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg3 = vsha256su1q_u32(tmsg3, tmsg1, tmsg2);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg1 = vsha256su0q_u32(tmsg1, tmsg2);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[47], (i32)fast_sha2_256_k_table[46],
+            (i32)fast_sha2_256_k_table[45], (i32)fast_sha2_256_k_table[44]);
+        msg = _mm_add_epi32(tmsg3, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg3, tmsg2, 4);
+        tmsg0 = _mm_add_epi32(tmsg0, tmp);
+        tmsg0 = _mm_sha256msg2_epu32(tmsg0, tmsg3);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg2 = _mm_sha256msg1_epu32(tmsg2, tmsg3);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[44]);
+        msg = vaddq_u32(tmsg3, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg0 = vsha256su1q_u32(tmsg0, tmsg2, tmsg3);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg2 = vsha256su0q_u32(tmsg2, tmsg3);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[51], (i32)fast_sha2_256_k_table[50],
+            (i32)fast_sha2_256_k_table[49], (i32)fast_sha2_256_k_table[48]);
+        msg = _mm_add_epi32(tmsg0, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg0, tmsg3, 4);
+        tmsg1 = _mm_add_epi32(tmsg1, tmp);
+        tmsg1 = _mm_sha256msg2_epu32(tmsg1, tmsg0);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+        tmsg3 = _mm_sha256msg1_epu32(tmsg3, tmsg0);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[48]);
+        msg = vaddq_u32(tmsg0, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg1 = vsha256su1q_u32(tmsg1, tmsg3, tmsg0);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg3 = vsha256su0q_u32(tmsg3, tmsg0);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[55], (i32)fast_sha2_256_k_table[54],
+            (i32)fast_sha2_256_k_table[53], (i32)fast_sha2_256_k_table[52]);
+        msg = _mm_add_epi32(tmsg1, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg1, tmsg0, 4);
+        tmsg2 = _mm_add_epi32(tmsg2, tmp);
+        tmsg2 = _mm_sha256msg2_epu32(tmsg2, tmsg1);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[52]);
+        msg = vaddq_u32(tmsg1, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg2 = vsha256su1q_u32(tmsg2, tmsg0, tmsg1);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+        tmsg0 = vsha256su0q_u32(tmsg0, tmsg1);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[59], (i32)fast_sha2_256_k_table[58],
+            (i32)fast_sha2_256_k_table[57], (i32)fast_sha2_256_k_table[56]);
+        msg = _mm_add_epi32(tmsg2, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        tmp = _mm_alignr_epi8(tmsg2, tmsg1, 4);
+        tmsg3 = _mm_add_epi32(tmsg3, tmp);
+        tmsg3 = _mm_sha256msg2_epu32(tmsg3, tmsg2);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[56]);
+        msg = vaddq_u32(tmsg2, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        tmsg3 = vsha256su1q_u32(tmsg3, tmsg1, tmsg2);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        keys =_mm_set_epi32((i32)fast_sha2_256_k_table[63], (i32)fast_sha2_256_k_table[62],
+            (i32)fast_sha2_256_k_table[61], (i32)fast_sha2_256_k_table[60]);
+        msg = _mm_add_epi32(tmsg3, keys);
+        state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+        msg = _mm_shuffle_epi32(msg, 0x0E);
+        state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+    #elif defined(FAST_SHA2_ARM)
+        keys = vld1q_u32((const u32 *)&fast_sha2_256_k_table[60]);
+        msg = vaddq_u32(tmsg3, keys);
+        tmp = state1;
+        state1 = vsha256h2q_u32(state1, state0, msg);
+        state0 = vsha256hq_u32(state0, tmp, msg);
+    #endif
+
+    #ifdef FAST_SHA2_DEBUG
+      #if defined(FAST_SHA2_NI)
+        _mm_storeu_si128((v128 *) &s0, state0);
+        _mm_storeu_si128((v128 *) &s1, state1);
+      #elif defined(FAST_SHA2_ARM)
+        vst1q_u32((u32 *)&s0, state0);
+        vst1q_u32((u32 *)&s1, state1);
+      #endif
+
+      #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM)
+        context->hash[0] = s0[0];
+        context->hash[1] = s0[1];
+        context->hash[2] = s0[2];
+        context->hash[3] = s0[3];
+        context->hash[4] = s1[0];
+        context->hash[5] = s1[1];
+        context->hash[6] = s1[2];
+        context->hash[7] = s1[3];
+        printf("t60-63 = %08x %08x %08x %08x %08x %08x %08x %08x\n",
+           context->hash[0], context->hash[1], context->hash[2],
+           context->hash[3], context->hash[4], context->hash[5],
+           context->hash[6], context->hash[7]);
+      #endif
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        state0 = _mm_add_epi32(state0, save0);
+        state1 = _mm_add_epi32(state1, save1);
+    #elif defined(FAST_SHA2_ARM)
+        state0 = vaddq_u32(state0, save0);
+        state1 = vaddq_u32(state1, save1);
+    #endif
+
+    #ifdef FAST_SHA2_DEBUG
+      #if defined(FAST_SHA2_NI)
+        printf("s0     = %016llx %016llx\n", state0[0], state0[1]);
+        printf("s1     = %016llx %016llx\n", state1[0], state1[1]);
+      #elif defined(FAST_SHA2_ARM)
+        printf("s0     = %08x %08x %08x %08x\n",
+            state0[0], state0[1], state0[2], state0[3]);
+        printf("s1     = %08x %08x %08x %08x\n",
+            state1[0], state1[1], state1[2], state1[3]);
+      #endif
+    #endif
+
+    #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM) || defined(FAST_SHA2_RISC_V)
+      }
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+      _mm_storeu_si128((v128 *) &s0, state0);
+      _mm_storeu_si128((v128 *) &s1, state1);
+      context->hash[0] = s0[3];
+      context->hash[1] = s0[2];
+      context->hash[2] = s1[3];
+      context->hash[3] = s1[2];
+      context->hash[4] = s0[1];
+      context->hash[5] = s0[0];
+      context->hash[6] = s1[1];
+      context->hash[7] = s1[0];
+    #elif defined(FAST_SHA2_ARM)
+      vst1q_u32((u32 *)&s0, state0);
+      vst1q_u32((u32 *)&s1, state1);
+      context->hash[0] = s0[0];
+      context->hash[1] = s0[1];
+      context->hash[2] = s0[2];
+      context->hash[3] = s0[3];
+      context->hash[4] = s1[0];
+      context->hash[5] = s1[1];
+      context->hash[6] = s1[2];
+      context->hash[7] = s1[3];
+    #endif
+      return;
+    }
+
+    void fast_sha2_256_process_software_hash(fast_sha2_hash_context256 *context,
+        uc8 *message, u64 n)
+    {
+      u64 i = 0;
+      u32 a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, j = 0;
+      u32 t1 = 0, t2 = 0, w[64];
+      uc8 *p = NULL;
+
+      for(i = 0; i < n; i++) {
+        p = message + (i << 6);
+        for(j = 0; j < 16; j++) {
+          if(j < 16) {
+            FAST_SHA2_PACK32(&w[j], &p[j << 2]);
+          }
+        }
+        a = (u32)context->hash[0];
+        b = (u32)context->hash[1];
+        c = (u32)context->hash[2];
+        d = (u32)context->hash[3];
+        e = (u32)context->hash[4];
+        f = (u32)context->hash[5];
+        g = (u32)context->hash[6];
+        h = (u32)context->hash[7];
+        for(j = 0; j < 64; j++) {
+          if(j >= 16)
+            w[j] = FAST_SHA2_G1_32(w[j - 2]) + w[j - 7] + FAST_SHA2_G0_32(w[j - 15]) + w[j - 16];
+          t1 = h + FAST_SHA2_S1_32(e) + FAST_SHA2_CH(e, f, g) + fast_sha2_256_k_table[j] + w[j];
+          t2 = FAST_SHA2_S0_32(a) + FAST_SHA2_MAJ(a, b, c);
+          h = g;
+          g = f;
+          f = e;
+          e = d + t1;
+          d = c;
+          c = b;
+          b = a;
+          a = t1 + t2;
+    #ifdef FAST_SHA2_DEBUG
+          printf("t = %2d %08x %08x %08x %08x %08x %08x %08x %08x, "
+                 "k = %08x, w = %08x\n", j, a, b, c, d, e, f, g, h,
+              fast_sha2_256_k_table[j], w[j]);
+    #endif
+        }
+        context->hash[0] += a;
+        context->hash[1] += b;
+        context->hash[2] += c;
+        context->hash[3] += d;
+        context->hash[4] += e;
+        context->hash[5] += f;
+        context->hash[6] += g;
+        context->hash[7] += h;
+      }
+    }
+
+    uc8 *fast_sha2_256_hash(uc8 *message, u64 length, b8 software_only)
+    {
+      fast_sha2_hash_context256 context;
+      u64 i = 0, l = 0, n = 0;
+      uc8 *digest = NULL, *p = NULL;
+      b32 hardware_support = fast_sha2_supported_by_cpu();
+
+      memcpy(context.hash, fast_sha2_256_initial_states, (size_t)32);
+      memset(context.buf, 0, (size_t)128);
+      context.length = 0;
+      context.total = 0;
+      digest = calloc((size_t)sizeof(c8), (size_t)33);
+    #ifdef FAST_SHA2_DEBUG
+      printf("init = %08x %08x %08x %08x %08x %08x %08x %08x\n",
+          context.hash[0], context.hash[1], context.hash[2], context.hash[3],
+          context.hash[4], context.hash[5], context.hash[6], context.hash[7]);
+    #endif
+      if(software_only)
+        hardware_support = FALSE;
+      l = 64 - context.length;
+      if(length < l)
+        l = length;
+      memcpy(&context.buf[context.length], message, l);
+      if(context.length + length < 64)
+        context.length += length;
+      else {
+        length -= l;
+        n = length / 64;
+        p = (uc8 *)message + l;
+
+        if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_SHA256))
+          fast_sha2_256_process_hardware_hash(&context, context.buf, 1);
+        else
+          fast_sha2_256_process_software_hash(&context, context.buf, 1);
+
+        if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_SHA256))
+          fast_sha2_256_process_hardware_hash(&context, p, n);
+        else
+          fast_sha2_256_process_software_hash(&context, p, n);
+
+        length = length % 64;
+        memcpy(&context.buf, &p[n << 6], length);
+        context.length = length;
+        context.total += (n + 1) << 6;
+      }
+      n = 1 + (55 < (context.length % 64));
+      length = (context.total + context.length) << 3;
+      l = n << 6;
+      memset(context.buf + context.length, 0, l - context.length);
+      context.buf[context.length] = FAST_SHA2_PAD_MARK;
+      FAST_SHA2_UNPACK32(length, context.buf + l - 4);
+
+      if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_SHA256))
+        fast_sha2_256_process_hardware_hash(&context, context.buf, n);
+      else
+        fast_sha2_256_process_software_hash(&context, context.buf, n);
+
+      for(i = 0; i < 8; i++)
+        FAST_SHA2_UNPACK32(context.hash[i], &digest[i << 2]);
+      return(digest);
+    }
+
+    uc8 *fast_sha2_256(uc8 *string, b8 software_only)
+    {
+      if(string == NULL)
+        return(fast_sha2_256_hash(string, 0, software_only));
+      else
+        return(fast_sha2_256_hash(string, (u32)strlen((c8 *)string), software_only));
+    }
+
+    c8 *fast_sha2_256_digest(uc8 *hash)
+    {
+      c8 *digest = NULL;
+
+      digest = calloc((size_t)sizeof(c8), (size_t)65);
+/*
+      i32 i = 0;
+      for(i = 0; i < 32; i++)
+        sprintf((c8 *)(digest + (i * 2)), "%02x", hash[i]);
+*/
+      sprintf(digest, "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x",
+           hash[0], hash[1], hash[2], hash[3], hash[4], hash[5], hash[6], hash[7],
+           hash[8], hash[9], hash[10], hash[11], hash[12], hash[13], hash[14], hash[15],
+           hash[16], hash[17], hash[18], hash[19], hash[20], hash[21], hash[22], hash[23],
+           hash[24], hash[25], hash[26], hash[27], hash[28], hash[29], hash[30], hash[31]);
+      digest[64] = '\0';
+
+      return(digest);
+    }
+
+    void fast_sha2_256_show_hash(uc8 *hash)
+    {
+      printf("%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x\n",
+         hash[0], hash[1], hash[2], hash[3], hash[4], hash[5], hash[6], hash[7],
+         hash[8], hash[9], hash[10], hash[11], hash[12], hash[13], hash[14], hash[15],
+         hash[16], hash[17], hash[18], hash[19], hash[20], hash[21], hash[22], hash[23],
+         hash[24], hash[25], hash[26], hash[27], hash[28], hash[29], hash[30], hash[31]);
+/*
+      i32 i = 0;
+
+      for(i = 0; i < 32; i++)
+        printf("%02x", hash[i]);
+      printf("\n");
+*/
+    }
+
+
+
+
+
+
+
+
+
+	/* 512 */    
+
+
+
+
+
+
+    /*
+       Warning: unused function - if FAST_SHA2_NI and FAST_SHA2_ARM hardware support isn't
+       available, this function is empty. In this case, the function
+       fast_sha2_supported_by_cpu will return false, and so in this case the empty
+       function should never be called.
+
+       However, this *may* cause compiler warnings.
+    */
+  #if defined(FAST_SHA2_ATTRIBUTES)
+    FAST_SHA2_ATTRIBUTES_512
+  #endif
+    void fast_sha2_512_process_hardware_hash(fast_sha2_hash_context512 *context,
+        uc8 *message, u64 n, b32 hardware_support)
+    {
+    #if defined(FAST_SHA2_NI)
+      v256 state0, state1, save0, save1, keys;
+      v256 msg, tmp, tmsg0, tmsg1, tmsg2, tmsg3;
+    #elif defined(FAST_SHA2_ARM)
+      v128_64 state0, state1, state2, state3, save0, save1, save2, save3, keys;
+      v128_64 msg, tmp, tmsg0, tmsg1, tmsg2, tmsg3;
+    #endif
+    #if defined(FAST_SHA2_NI)
+      const v256 shuffle_mask = _mm256_set_epi8(8, 9, 10, 11, 12, 13, 14, 15,
+          0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3,
+          4, 5, 6, 7);
+    #endif
+    #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM)
+      u64 s0[16] = {0}, s1[16] = {0}, i = 0;
+      uc8 *p = NULL;
+    #endif
+
+    /* Initialize state from context */
+    #if defined(FAST_SHA2_NI)
+      state0 = _mm256_set_epi64x((i64)context->hash[4], (i64)context->hash[5],
+          (i64)context->hash[0], (i64)context->hash[1]);		/* EFAB */
+      state1 = _mm256_set_epi64x((i64)context->hash[6], (i64)context->hash[7],
+          (i64)context->hash[2], (i64)context->hash[3]);		/* GHCD */
+    #elif defined(FAST_SHA2_ARM)
+      state0 = vld1q_u64((const u64 *)&context->hash[0]);	/* AB */
+      state1 = vld1q_u64((const u64 *)&context->hash[2]);	/* CD */
+      state2 = vld1q_u64((const u64 *)&context->hash[4]);	/* EF */
+      state3 = vld1q_u64((const u64 *)&context->hash[6]);	/* GH */
+    #endif
+
+    #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM)
+      for(i = 0; i < n; i++) {
+        p = message + (i << 7);
+
+        save0 = state0;	/* Save for next round */
+        save1 = state1;
+      #if defined(FAST_SHA2_ARM)
+        save2 = state2;
+        save3 = state3;
+      #endif
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_SHA512)) {
+          /* Rounds 0-3 */
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[1], (i64)fast_sha2_512_k_table[0],
+              (i64)fast_sha2_512_k_table[1], (i64)fast_sha2_512_k_table[0]);
+          msg = _mm256_loadu_si256((v256 *)p);
+          tmsg0 = _mm256_shuffle_epi8(msg, shuffle_mask);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[3], (i64)fast_sha2_512_k_table[2],
+              (i64)fast_sha2_512_k_table[3], (i64)fast_sha2_512_k_table[2]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* Rounds 4-7 */
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[5], (i64)fast_sha2_512_k_table[4],
+              (i64)fast_sha2_512_k_table[5], (i64)fast_sha2_512_k_table[4]);
+          msg = _mm256_loadu_si256((v256 *)(p + 32));
+          tmsg1 = _mm256_shuffle_epi8(msg, shuffle_mask);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[7], (i64)fast_sha2_512_k_table[6],
+              (i64)fast_sha2_512_k_table[7], (i64)fast_sha2_512_k_table[6]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* Rounds 8-11 */
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[9], (i64)fast_sha2_512_k_table[8],
+              (i64)fast_sha2_512_k_table[9], (i64)fast_sha2_512_k_table[8]);
+          msg = _mm256_loadu_si256((v256 *)(p + 64));
+          tmsg2 = _mm256_shuffle_epi8(msg, shuffle_mask);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[11], (i64)fast_sha2_512_k_table[10],
+              (i64)fast_sha2_512_k_table[11], (i64)fast_sha2_512_k_table[10]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* Rounds 12-15 */
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[13], (i64)fast_sha2_512_k_table[12],
+              (i64)fast_sha2_512_k_table[13], (i64)fast_sha2_512_k_table[12]);
+          msg = _mm256_loadu_si256((v256 *)(p + 96));
+          tmsg3 = _mm256_shuffle_epi8(msg, shuffle_mask);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[15], (i64)fast_sha2_512_k_table[14],
+              (i64)fast_sha2_512_k_table[15], (i64)fast_sha2_512_k_table[14]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* Rounds 16-19 */
+          tmsg0 = _mm256_sha512msg1_epi64(tmsg0, _mm256_extracti128_si256(tmsg1, 0));
+          tmsg0 = _mm256_sha512msg2_epi64(tmsg0, tmsg3);
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[17], (i64)fast_sha2_512_k_table[16],
+              (i64)fast_sha2_512_k_table[17], (i64)fast_sha2_512_k_table[16]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[19], (i64)fast_sha2_512_k_table[18],
+              (i64)fast_sha2_512_k_table[19], (i64)fast_sha2_512_k_table[18]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 20-23 --- */
+          tmsg1 = _mm256_sha512msg1_epi64(tmsg1, _mm256_extracti128_si256(tmsg2, 0));
+          tmsg1 = _mm256_sha512msg2_epi64(tmsg1, tmsg0);
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[21], (i64)fast_sha2_512_k_table[20],
+              (i64)fast_sha2_512_k_table[21], (i64)fast_sha2_512_k_table[20]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[23], (i64)fast_sha2_512_k_table[22],
+              (i64)fast_sha2_512_k_table[23], (i64)fast_sha2_512_k_table[22]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 24-27 --- */
+          tmsg2 = _mm256_sha512msg1_epi64(tmsg2, _mm256_extracti128_si256(tmsg3, 0));
+          tmsg2 = _mm256_sha512msg2_epi64(tmsg2, tmsg1);
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[25], (i64)fast_sha2_512_k_table[24],
+              (i64)fast_sha2_512_k_table[25], (i64)fast_sha2_512_k_table[24]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[27], (i64)fast_sha2_512_k_table[26],
+              (i64)fast_sha2_512_k_table[27], (i64)fast_sha2_512_k_table[26]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 28-31 --- */
+          tmsg3 = _mm256_sha512msg1_epi64(tmsg3, _mm256_extracti128_si256(tmsg0, 0));
+          tmsg3 = _mm256_sha512msg2_epi64(tmsg3, tmsg2);
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[29], (i64)fast_sha2_512_k_table[28],
+              (i64)fast_sha2_512_k_table[29], (i64)fast_sha2_512_k_table[28]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[31], (i64)fast_sha2_512_k_table[30],
+              (i64)fast_sha2_512_k_table[31], (i64)fast_sha2_512_k_table[30]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 32-35 --- */
+          tmsg0 = _mm256_sha512msg1_epi64(tmsg0, _mm256_extracti128_si256(tmsg1, 0));
+          tmsg0 = _mm256_sha512msg2_epi64(tmsg0, tmsg3);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[33], (i64)fast_sha2_512_k_table[32],
+              (i64)fast_sha2_512_k_table[33], (i64)fast_sha2_512_k_table[32]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[35], (i64)fast_sha2_512_k_table[34],
+              (i64)fast_sha2_512_k_table[35], (i64)fast_sha2_512_k_table[34]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 36-39 --- */
+          tmsg1 = _mm256_sha512msg1_epi64(tmsg1, _mm256_extracti128_si256(tmsg2, 0));
+          tmsg1 = _mm256_sha512msg2_epi64(tmsg1, tmsg0);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[37], (i64)fast_sha2_512_k_table[36],
+              (i64)fast_sha2_512_k_table[37], (i64)fast_sha2_512_k_table[36]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[39], (i64)fast_sha2_512_k_table[38],
+              (i64)fast_sha2_512_k_table[39], (i64)fast_sha2_512_k_table[38]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 40-43 --- */
+          tmsg2 = _mm256_sha512msg1_epi64(tmsg2, _mm256_extracti128_si256(tmsg3, 0));
+          tmsg2 = _mm256_sha512msg2_epi64(tmsg2, tmsg1);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[41], (i64)fast_sha2_512_k_table[40],
+              (i64)fast_sha2_512_k_table[41], (i64)fast_sha2_512_k_table[40]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[43], (i64)fast_sha2_512_k_table[42],
+              (i64)fast_sha2_512_k_table[43], (i64)fast_sha2_512_k_table[42]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 44-47 --- */
+          tmsg3 = _mm256_sha512msg1_epi64(tmsg3, _mm256_extracti128_si256(tmsg0, 0));
+          tmsg3 = _mm256_sha512msg2_epi64(tmsg3, tmsg2);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[45], (i64)fast_sha2_512_k_table[44],
+              (i64)fast_sha2_512_k_table[45], (i64)fast_sha2_512_k_table[44]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[47], (i64)fast_sha2_512_k_table[46],
+              (i64)fast_sha2_512_k_table[47], (i64)fast_sha2_512_k_table[46]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 48-51 --- */
+          tmsg0 = _mm256_sha512msg1_epi64(tmsg0, _mm256_extracti128_si256(tmsg1, 0));
+          tmsg0 = _mm256_sha512msg2_epi64(tmsg0, tmsg3);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[49], (i64)fast_sha2_512_k_table[48],
+              (i64)fast_sha2_512_k_table[49], (i64)fast_sha2_512_k_table[48]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[51], (i64)fast_sha2_512_k_table[50],
+              (i64)fast_sha2_512_k_table[51], (i64)fast_sha2_512_k_table[50]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 52-55 --- */
+          tmsg1 = _mm256_sha512msg1_epi64(tmsg1, _mm256_extracti128_si256(tmsg2, 0));
+          tmsg1 = _mm256_sha512msg2_epi64(tmsg1, tmsg0);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[53], (i64)fast_sha2_512_k_table[52],
+              (i64)fast_sha2_512_k_table[53], (i64)fast_sha2_512_k_table[52]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[55], (i64)fast_sha2_512_k_table[54],
+              (i64)fast_sha2_512_k_table[55], (i64)fast_sha2_512_k_table[54]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 56-59 --- */
+          tmsg2 = _mm256_sha512msg1_epi64(tmsg2, _mm256_extracti128_si256(tmsg3, 0));
+          tmsg2 = _mm256_sha512msg2_epi64(tmsg2, tmsg1);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[57], (i64)fast_sha2_512_k_table[56],
+              (i64)fast_sha2_512_k_table[57], (i64)fast_sha2_512_k_table[56]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[59], (i64)fast_sha2_512_k_table[58],
+              (i64)fast_sha2_512_k_table[59], (i64)fast_sha2_512_k_table[58]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 60-63 --- */
+          tmsg3 = _mm256_sha512msg1_epi64(tmsg3, _mm256_extracti128_si256(tmsg0, 0));
+          tmsg3 = _mm256_sha512msg2_epi64(tmsg3, tmsg2);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[61], (i64)fast_sha2_512_k_table[60],
+              (i64)fast_sha2_512_k_table[61], (i64)fast_sha2_512_k_table[60]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[63], (i64)fast_sha2_512_k_table[62],
+              (i64)fast_sha2_512_k_table[63], (i64)fast_sha2_512_k_table[62]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 64-67 --- */
+          tmsg0 = _mm256_sha512msg1_epi64(tmsg0, _mm256_extracti128_si256(tmsg1, 0));
+          tmsg0 = _mm256_sha512msg2_epi64(tmsg0, tmsg3);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[65], (i64)fast_sha2_512_k_table[64],
+              (i64)fast_sha2_512_k_table[65], (i64)fast_sha2_512_k_table[64]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[67], (i64)fast_sha2_512_k_table[66],
+              (i64)fast_sha2_512_k_table[67], (i64)fast_sha2_512_k_table[66]);
+          msg = _mm256_add_epi64(tmsg0, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 68-71 --- */
+          tmsg1 = _mm256_sha512msg1_epi64(tmsg1, _mm256_extracti128_si256(tmsg2, 0));
+          tmsg1 = _mm256_sha512msg2_epi64(tmsg1, tmsg0);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[69], (i64)fast_sha2_512_k_table[68],
+              (i64)fast_sha2_512_k_table[69], (i64)fast_sha2_512_k_table[68]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[71], (i64)fast_sha2_512_k_table[70],
+              (i64)fast_sha2_512_k_table[71], (i64)fast_sha2_512_k_table[70]);
+          msg = _mm256_add_epi64(tmsg1, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 72-75 --- */
+          tmsg2 = _mm256_sha512msg1_epi64(tmsg2, _mm256_extracti128_si256(tmsg3, 0));
+          tmsg2 = _mm256_sha512msg2_epi64(tmsg2, tmsg1);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[73], (i64)fast_sha2_512_k_table[72],
+              (i64)fast_sha2_512_k_table[73], (i64)fast_sha2_512_k_table[72]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[75], (i64)fast_sha2_512_k_table[74],
+              (i64)fast_sha2_512_k_table[75], (i64)fast_sha2_512_k_table[74]);
+          msg = _mm256_add_epi64(tmsg2, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+
+          /* --- ROUNDS 76-79 --- */
+          tmsg3 = _mm256_sha512msg1_epi64(tmsg3, _mm256_extracti128_si256(tmsg0, 0));
+          tmsg3 = _mm256_sha512msg2_epi64(tmsg3, tmsg2);
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[77], (i64)fast_sha2_512_k_table[76],
+              (i64)fast_sha2_512_k_table[77], (i64)fast_sha2_512_k_table[76]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state0 = _mm256_sha512rnds2_epi64(state0, state1, _mm256_extracti128_si256(msg, 0));
+          keys = _mm256_set_epi64x((i64)fast_sha2_512_k_table[79], (i64)fast_sha2_512_k_table[78],
+              (i64)fast_sha2_512_k_table[79], (i64)fast_sha2_512_k_table[78]);
+          msg = _mm256_add_epi64(tmsg3, keys);
+          state1 = _mm256_sha512rnds2_epi64(state1, state0, _mm256_extracti128_si256(msg, 1));
+        } else if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_AVX512)) {
+        } else if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_AVX2)) {
+        }
+
+
+    #elif defined(FAST_SHA2_ARM)
+
+/*
+    v128_64 ab = vld1q_u64(&fast_sha2_512_initial_states[0]); // a, b  state0
+    v128_64 cd = vld1q_u64(&fast_sha2_512_initial_states[2]); // c, d  state1
+    v128_64 ef = vld1q_u64(&fast_sha2_512_initial_states[4]); // e, f  state2
+    v128_64 gh = vld1q_u64(&fast_sha2_512_initial_states[6]); // g, h  state3
+*/
+
+    /* --- Rounds 0 & 1 --- */
+      keys = vld1q_u64((const u64 *)&fast_sha2_512_k_table[0]);
+      msg = vld1q_u64((const u64 *)p);
+      tmsg0 = (v128_64)vrev64q_u8((uint8x16_t)msg);
+
+      msg = vaddq_u64(tmsg0, keys);
+
+      tmp = vsha512hq_u64(state0, state2, msg);
+      state2 = vsha512h2q_u64(state2, state3, state0);
+      state0 = tmp;
+
+    /* --- Rounds 2 & 3 --- */
+      keys = vld1q_u64((const u64 *)&fast_sha2_512_k_table[2]);
+      msg = vld1q_u64((const u64 *)p + 16);
+      tmsg1 = (v128_64)vrev64q_u8((uint8x16_t)msg);
+      msg = vaddq_u64(tmsg1, keys);
+
+      tmp = vsha512hq_u64(state0, state2, msg);
+      state2 = vsha512h2q_u64(state2, state3, state0);
+      state0 = tmp;
+
+      printf("State 'a' after round 3: %016lx\n", vgetq_lane_u64(state0, 0));
+
+
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+    #elif defined(FAST_SHA2_ARM)
+    #endif
+
+
+    #ifdef FAST_SHA2_DEBUG
+      #if defined(FAST_SHA2_NI)
+        _mm256_storeu_si256((v256 *)&s0, state0);
+        _mm256_storeu_si256((v256 *)&s1, state1);
+      #elif defined(FAST_SHA2_ARM)
+        vst1q_u64((u64 *)&s0, state0);
+        vst1q_u64((u64 *)&s1, state1);
+      #endif
+
+      #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM)
+        context->hash[0] = s0[0];
+        context->hash[1] = s0[1];
+        context->hash[2] = s0[2];
+        context->hash[3] = s0[3];
+        context->hash[4] = s1[0];
+        context->hash[5] = s1[1];
+        context->hash[6] = s1[2];
+        context->hash[7] = s1[3];
+        printf("t60-63 = %016lx %016lx %016lx %016lx\n"
+               "         %016lx %016lx %016lx %016lx\n",
+           context->hash[0], context->hash[1], context->hash[2],
+           context->hash[3], context->hash[4], context->hash[5],
+           context->hash[6], context->hash[7]);
+      #endif
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+        state0 = _mm256_add_epi64(state0, save0);
+        state1 = _mm256_add_epi64(state1, save1);
+    #elif defined(FAST_SHA2_ARM)
+        state0 = vaddq_u64(state0, save0);
+        state1 = vaddq_u64(state1, save1);
+    #endif
+
+    #ifdef FAST_SHA2_DEBUG
+      #if defined(FAST_SHA2_NI)
+        printf("s0     = %032llx %032llx\n", state0[0], state0[1]);
+        printf("s1     = %032llx %032llx\n", state1[0], state1[1]);
+      #elif defined(FAST_SHA2_ARM)
+        printf("s0     = %016lx %016lx %016lx %016lx\n",
+            state0[0], state0[1], state1[0], state1[1]);
+        printf("s1     = %016lx %016lx %016lx %016lx\n",
+            state2[0], state2[1], state3[0], state3[1]);
+      #endif
+    #endif
+
+    #if defined(FAST_SHA2_NI) || defined(FAST_SHA2_ARM)
+      }
+    #endif
+
+    #if defined(FAST_SHA2_NI)
+      _mm256_storeu_si256((v256 *)&s0, state0);
+      _mm256_storeu_si256((v256 *)&s1, state1);
+      context->hash[0] = s0[3];
+      context->hash[1] = s0[2];
+      context->hash[2] = s1[3];
+      context->hash[3] = s1[2];
+      context->hash[4] = s0[1];
+      context->hash[5] = s0[0];
+      context->hash[6] = s1[1];
+      context->hash[7] = s1[0];
+    #elif defined(FAST_SHA2_ARM)
+      vst1q_u64((u64 *)&s0, state0);
+      vst1q_u64((u64 *)&s1, state1);
+      context->hash[0] = s0[0];
+      context->hash[1] = s0[1];
+      context->hash[2] = s0[2];
+      context->hash[3] = s0[3];
+      context->hash[4] = s1[0];
+      context->hash[5] = s1[1];
+      context->hash[6] = s1[2];
+      context->hash[7] = s1[3];
+    #endif
+      return;
+    }
+
+    void fast_sha2_512_process_software_hash(fast_sha2_hash_context512 *context,
+        uc8 *message, u64 n)
+    {
+/*
+#if defined(FAST_SHA2_ARM)
+      v128_64 tmsg = {0};
+#endif
+*/
+      u64 a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, t1 = 0, t2 = 0, w[80];
+      uc8 *p = NULL;
+
+      for(i = 0; i < n; i++) {
+        p = message + (i << 7);
+/*
+#if defined(FAST_SHA2_ARM)
+        for(j = 0; j < 16; j += 2) {
+          tmsg = (v128_64)vrev64q_u8(vld1q_u8(p + (j << 3)));
+          vst1q_u64(&w[j], tmsg);
+        }
+#else
+        for(j = 0; j < 16; j++) {
+          FAST_SHA2_PACK64(&w[j], &p[j << 3]);
+        }
+#endif
+*/
+
+        for(j = 0; j < 16; j++) {
+          FAST_SHA2_PACK64(&w[j], &p[j << 3]);
+        }
+        a = context->hash[0];
+        b = context->hash[1];
+        c = context->hash[2];
+        d = context->hash[3];
+        e = context->hash[4];
+        f = context->hash[5];
+        g = context->hash[6];
+        h = context->hash[7];
+
+        for(j = 0; j < 80; j++) {
+          if(j >= 16)
+            w[j] = FAST_SHA2_G1_64(w[j - 2]) + w[j - 7] + FAST_SHA2_G0_64(w[j - 15]) + w[j - 16];
+          t1 = h + FAST_SHA2_S1_64(e) + FAST_SHA2_CH(e, f, g) + fast_sha2_512_k_table[j] + w[j];
+          t2 = FAST_SHA2_S0_64(a) + FAST_SHA2_MAJ(a, b, c);
+          h = g;
+          g = f;
+          f = e;
+          e = d + t1;
+          d = c;
+          c = b;
+          b = a;
+          a = t1 + t2;
+    #ifdef FAST_SHA2_DEBUG
+          printf("t = %2ld %16.16lx %16.16lx %16.16lx %16.16lx\n"
+                 "       %16.16lx %16.16lx %16.16lx %16.16lx, "
+                 "k = %16.16lx, w = %16.16lx\n", j, a, b, c, d, e, f, g, h,
+              fast_sha2_512_k_table[j], w[j]);
+    #endif
+        }
+        context->hash[0] += a;
+        context->hash[1] += b;
+        context->hash[2] += c;
+        context->hash[3] += d;
+        context->hash[4] += e;
+        context->hash[5] += f;
+        context->hash[6] += g;
+        context->hash[7] += h;
+      }
+    }
+
+    void fast_sha2_512_create_hash(fast_sha2_hash_context512 *context, uc8 *message,
+        uc8 *digest, u64 length, b8 software_only)
+    {
+      u64 i = 0, l = 0, n = 0;
+      uc8 *p = NULL;
+      u32 hardware_support = fast_sha2_supported_by_cpu();
+
+      if(software_only)
+        hardware_support = FALSE;
+      l = 128 - context->length;
+      if(length < l)
+        l = length;
+      memcpy(&context->buf[context->length], message, l);
+      if(context->length + length < 128)
+        context->length += length;
+      else {
+        length -= l;
+        n = length / 128;
+        p = (uc8 *)message + l;
+        if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_SHA512))
+          fast_sha2_512_process_hardware_hash(context, context->buf, 1, hardware_support);
+        else
+          fast_sha2_512_process_software_hash(context, context->buf, 1);
+        if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_SHA512))
+          fast_sha2_512_process_hardware_hash(context, p, n, hardware_support);
+        else
+          fast_sha2_512_process_software_hash(context, p, n);
+        length = length % 128;
+        memcpy(context->buf, &p[n << 7], length);
+        context->length = length;
+        context->total += (n + 1) << 7;
+      }
+      n = 1 + (111 < (context->length % 128));
+      length = (context->total + context->length) << 3;
+      l = n << 7;
+      memset(context->buf + context->length, 0, l - context->length);
+      context->buf[context->length] = FAST_SHA2_PAD_MARK;
+      FAST_SHA2_UNPACK64(length, (context->buf + l - 8));
+      if(FAST_SHA2_BIT_IS_SET(hardware_support, FAST_SHA2_CPU_SUPPORTS_SHA512))
+        fast_sha2_512_process_hardware_hash(context, context->buf, n, hardware_support);
+      else
+        fast_sha2_512_process_software_hash(context, context->buf, n);
+      for(i = 0; i < 8; i++)
+        FAST_SHA2_UNPACK64(context->hash[i], &digest[i << 3]);
+    }
+
+    uc8 *fast_sha2_512_hash(uc8 *message, u64 length, b8 software_only)
+    {
+      fast_sha2_hash_context512 context;
+      uc8 *digest = NULL;
+
+      memcpy(context.hash, fast_sha2_512_initial_states, (size_t)64);
+      memset(context.buf, 0, (size_t)256);
+      context.length = 0;
+      context.total = 0;
+      digest = calloc((size_t)sizeof(c8), (size_t)65);
+    #ifdef FAST_SHA2_DEBUG
+      printf("init    %16.16lx  %16.16lx  %16.16lx  %16.16lx\r\n"
+             "        %16.16lx  %16.16lx  %16.16lx  %16.16lx\r\n",
+        context.hash[0], context.hash[1], context.hash[2], context.hash[3],
+        context.hash[4], context.hash[5], context.hash[6], context.hash[7]);
+    #endif
+      fast_sha2_512_create_hash(&context, message, digest, length, software_only);
+
+      return(digest);
+    }
+
+    uc8 *fast_sha2_512(uc8 *string, b8 software_only)
+    {
+      if(string == NULL)
+        return(fast_sha2_512_hash(string, 0, software_only));
+      else
+        return(fast_sha2_512_hash(string, (u32)strlen((c8 *)string), software_only));
+    }
+
+    c8 *fast_sha2_512_digest(uc8 *hash)
+    {
+      c8 *digest = NULL;
+
+      digest = calloc((size_t)sizeof(c8), (size_t)129);
+/*
+      i32 i = 0;
+      for(i = 0; i < 32; i++)
+        sprintf((c8 *)(digest + (i * 2)), "%02x", hash[i]);
+*/
+      sprintf(digest, "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x"
+                      "%02x%02x%02x%02x%02x%02x%02x%02x",
+           hash[0], hash[1], hash[2], hash[3], hash[4], hash[5], hash[6], hash[7],
+           hash[8], hash[9], hash[10], hash[11], hash[12], hash[13], hash[14], hash[15],
+           hash[16], hash[17], hash[18], hash[19], hash[20], hash[21], hash[22], hash[23],
+           hash[24], hash[25], hash[26], hash[27], hash[28], hash[29], hash[30], hash[31],
+           hash[32], hash[33], hash[34], hash[35], hash[36], hash[37], hash[38], hash[39],
+           hash[40], hash[41], hash[42], hash[43], hash[44], hash[45], hash[46], hash[47],
+           hash[48], hash[49], hash[50], hash[51], hash[52], hash[53], hash[54], hash[55],
+           hash[56], hash[57], hash[58], hash[59], hash[60], hash[61], hash[62], hash[63]);
+      digest[128] = '\0';
+
+      return(digest);
+    }
+
+    void fast_sha2_512_show_hash(uc8 *hash)
+    {
+      printf("%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x"
+             "%02x%02x%02x%02x%02x%02x%02x%02x\n",
+         hash[0], hash[1], hash[2], hash[3], hash[4], hash[5], hash[6], hash[7],
+         hash[8], hash[9], hash[10], hash[11], hash[12], hash[13], hash[14], hash[15],
+         hash[16], hash[17], hash[18], hash[19], hash[20], hash[21], hash[22], hash[23],
+         hash[24], hash[25], hash[26], hash[27], hash[28], hash[29], hash[30], hash[31],
+         hash[32], hash[33], hash[34], hash[35], hash[36], hash[37], hash[38], hash[39],
+         hash[40], hash[41], hash[42], hash[43], hash[44], hash[45], hash[46], hash[47],
+         hash[48], hash[49], hash[50], hash[51], hash[52], hash[53], hash[54], hash[55],
+         hash[56], hash[57], hash[58], hash[59], hash[60], hash[61], hash[62], hash[63]);
+/*
+      i32 i = 0;
+      for(i = 0; i < 64; i++)
+        printf("%02x", hash[i]);
+      printf("\n");
+*/
+    }
+
+  #endif	/* FAST_SHA2_IMPLEMENTATION */
+#endif		/* FAST_SHA2_H_Minaswan */