v3.5.9.1

algo/groestl/sse2/brg_endian.h

@@ -0,0 +1,133 @@
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved.
+
+ LICENSE TERMS
+
+ The redistribution and use of this software (with or without changes)
+ is allowed without the payment of fees or royalties provided that:
+
+  1. source code distributions include the above copyright notice, this
+     list of conditions and the following disclaimer;
+
+  2. binary distributions include the above copyright notice, this list
+     of conditions and the following disclaimer in their documentation;
+
+  3. the name of the copyright holder is not used to endorse products
+     built using this software without specific written permission.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 20/12/2007
+*/
+
+#ifndef _BRG_ENDIAN_H
+#define _BRG_ENDIAN_H
+
+#define IS_BIG_ENDIAN      4321 /* byte 0 is most significant (mc68k) */
+#define IS_LITTLE_ENDIAN   1234 /* byte 0 is least significant (i386) */
+
+/* Include files where endian defines and byteswap functions may reside */
+#if defined( __sun )
+#  include <sys/isa_defs.h>
+#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ )
+#  include <sys/endian.h>
+#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \
+      defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ )
+#  include <machine/endian.h>
+#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ )
+#  if !defined( __MINGW32__ ) && !defined( _AIX )
+#    include <endian.h>
+#    if !defined( __BEOS__ )
+#      include <byteswap.h>
+#    endif
+#  endif
+#endif
+
+/* Now attempt to set the define for platform byte order using any  */
+/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which  */
+/* seem to encompass most endian symbol definitions                 */
+
+#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN )
+#  if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN )
+#  if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( _BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( _LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN )
+#  if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ )
+#  if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+/*  if the platform byte order could not be determined, then try to */
+/*  set this define using common machine defines                    */
+#if !defined(PLATFORM_BYTE_ORDER)
+
+#if   defined( __alpha__ ) || defined( __alpha ) || defined( i386 )       || \
+      defined( __i386__ )  || defined( _M_I86 )  || defined( _M_IX86 )    || \
+      defined( __OS2__ )   || defined( sun386 )  || defined( __TURBOC__ ) || \
+      defined( vax )       || defined( vms )     || defined( VMS )        || \
+      defined( __VMS )     || defined( _M_X64 )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+
+#elif defined( AMIGA )   || defined( applec )    || defined( __AS400__ )  || \
+      defined( _CRAY )   || defined( __hppa )    || defined( __hp9000 )   || \
+      defined( ibm370 )  || defined( mc68000 )   || defined( m68k )       || \
+      defined( __MRC__ ) || defined( __MVS__ )   || defined( __MWERKS__ ) || \
+      defined( sparc )   || defined( __sparc)    || defined( SYMANTEC_C ) || \
+      defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM )   || \
+      defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+
+#elif 0     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#elif 0     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#else
+#  error Please edit lines 126 or 128 in brg_endian.h to set the platform byte order
+#endif
+
+#endif
+
+#endif

algo/groestl/sse2/brg_types.h

@@ -0,0 +1,231 @@
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved.
+
+ (a few lines added by Soeren S. Thomsen, October 2008)
+
+ LICENSE TERMS
+
+ The redistribution and use of this software (with or without changes)
+ is allowed without the payment of fees or royalties provided that:
+
+  1. source code distributions include the above copyright notice, this
+     list of conditions and the following disclaimer;
+
+  2. binary distributions include the above copyright notice, this list
+     of conditions and the following disclaimer in their documentation;
+
+  3. the name of the copyright holder is not used to endorse products
+     built using this software without specific written permission.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 20/12/2007
+
+ The unsigned integer types defined here are of the form uint_<nn>t where
+ <nn> is the length of the type; for example, the unsigned 32-bit type is
+ 'uint_32t'.  These are NOT the same as the 'C99 integer types' that are
+ defined in the inttypes.h and stdint.h headers since attempts to use these
+ types have shown that support for them is still highly variable.  However,
+ since the latter are of the form uint<nn>_t, a regular expression search
+ and replace (in VC++ search on 'uint_{:z}t' and replace with 'uint\1_t')
+ can be used to convert the types used here to the C99 standard types.
+*/
+
+#ifndef _BRG_TYPES_H
+#define _BRG_TYPES_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include <limits.h>
+
+#if defined( _MSC_VER ) && ( _MSC_VER >= 1300 )
+#  include <stddef.h>
+#  define ptrint_t intptr_t
+#elif defined( __GNUC__ ) && ( __GNUC__ >= 3 )
+#  include <stdint.h>
+#  define ptrint_t intptr_t
+#else
+#  define ptrint_t int
+#endif
+
+#ifndef BRG_UI8
+#  define BRG_UI8
+#  if UCHAR_MAX == 255u
+     typedef unsigned char uint_8t;
+#  else
+#    error Please define uint_8t as an 8-bit unsigned integer type in brg_types.h
+#  endif
+#endif
+
+#ifndef BRG_UI16
+#  define BRG_UI16
+#  if USHRT_MAX == 65535u
+     typedef unsigned short uint_16t;
+#  else
+#    error Please define uint_16t as a 16-bit unsigned short type in brg_types.h
+#  endif
+#endif
+
+#ifndef BRG_UI32
+#  define BRG_UI32
+#  if UINT_MAX == 4294967295u
+#    define li_32(h) 0x##h##u
+     typedef unsigned int uint_32t;
+#  elif ULONG_MAX == 4294967295u
+#    define li_32(h) 0x##h##ul
+     typedef unsigned long uint_32t;
+#  elif defined( _CRAY )
+#    error This code needs 32-bit data types, which Cray machines do not provide
+#  else
+#    error Please define uint_32t as a 32-bit unsigned integer type in brg_types.h
+#  endif
+#endif
+
+#ifndef BRG_UI64
+#  if defined( __BORLANDC__ ) && !defined( __MSDOS__ )
+#    define BRG_UI64
+#    define li_64(h) 0x##h##ui64
+     typedef unsigned __int64 uint_64t;
+#  elif defined( _MSC_VER ) && ( _MSC_VER < 1300 )    /* 1300 == VC++ 7.0 */
+#    define BRG_UI64
+#    define li_64(h) 0x##h##ui64
+     typedef unsigned __int64 uint_64t;
+#  elif defined( __sun ) && defined( ULONG_MAX ) && ULONG_MAX == 0xfffffffful
+#    define BRG_UI64
+#    define li_64(h) 0x##h##ull
+     typedef unsigned long long uint_64t;
+#  elif defined( __MVS__ )
+#    define BRG_UI64
+#    define li_64(h) 0x##h##ull
+     typedef unsigned int long long uint_64t;
+#  elif defined( UINT_MAX ) && UINT_MAX > 4294967295u
+#    if UINT_MAX == 18446744073709551615u
+#      define BRG_UI64
+#      define li_64(h) 0x##h##u
+       typedef unsigned int uint_64t;
+#    endif
+#  elif defined( ULONG_MAX ) && ULONG_MAX > 4294967295u
+#    if ULONG_MAX == 18446744073709551615ul
+#      define BRG_UI64
+#      define li_64(h) 0x##h##ul
+       typedef unsigned long uint_64t;
+#    endif
+#  elif defined( ULLONG_MAX ) && ULLONG_MAX > 4294967295u
+#    if ULLONG_MAX == 18446744073709551615ull
+#      define BRG_UI64
+#      define li_64(h) 0x##h##ull
+       typedef unsigned long long uint_64t;
+#    endif
+#  elif defined( ULONG_LONG_MAX ) && ULONG_LONG_MAX > 4294967295u
+#    if ULONG_LONG_MAX == 18446744073709551615ull
+#      define BRG_UI64
+#      define li_64(h) 0x##h##ull
+       typedef unsigned long long uint_64t;
+#    endif
+#  endif
+#endif
+
+#if !defined( BRG_UI64 )
+#  if defined( NEED_UINT_64T )
+#    error Please define uint_64t as an unsigned 64 bit type in brg_types.h
+#  endif
+#endif
+
+#ifndef RETURN_VALUES
+#  define RETURN_VALUES
+#  if defined( DLL_EXPORT )
+#    if defined( _MSC_VER ) || defined ( __INTEL_COMPILER )
+#      define VOID_RETURN    __declspec( dllexport ) void __stdcall
+#      define INT_RETURN     __declspec( dllexport ) int  __stdcall
+#    elif defined( __GNUC__ )
+#      define VOID_RETURN    __declspec( __dllexport__ ) void
+#      define INT_RETURN     __declspec( __dllexport__ ) int
+#    else
+#      error Use of the DLL is only available on the Microsoft, Intel and GCC compilers
+#    endif
+#  elif defined( DLL_IMPORT )
+#    if defined( _MSC_VER ) || defined ( __INTEL_COMPILER )
+#      define VOID_RETURN    __declspec( dllimport ) void __stdcall
+#      define INT_RETURN     __declspec( dllimport ) int  __stdcall
+#    elif defined( __GNUC__ )
+#      define VOID_RETURN    __declspec( __dllimport__ ) void
+#      define INT_RETURN     __declspec( __dllimport__ ) int
+#    else
+#      error Use of the DLL is only available on the Microsoft, Intel and GCC compilers
+#    endif
+#  elif defined( __WATCOMC__ )
+#    define VOID_RETURN  void __cdecl
+#    define INT_RETURN   int  __cdecl
+#  else
+#    define VOID_RETURN  void
+#    define INT_RETURN   int
+#  endif
+#endif
+
+/*	These defines are used to detect and set the memory alignment of pointers.
+    Note that offsets are in bytes.
+
+	ALIGN_OFFSET(x,n)			return the positive or zero offset of 
+								the memory addressed by the pointer 'x' 
+								from an address that is aligned on an 
+								'n' byte boundary ('n' is a power of 2)
+
+	ALIGN_FLOOR(x,n)			return a pointer that points to memory
+								that is aligned on an 'n' byte boundary 
+								and is not higher than the memory address
+								pointed to by 'x' ('n' is a power of 2)
+
+	ALIGN_CEIL(x,n)				return a pointer that points to memory
+								that is aligned on an 'n' byte boundary 
+								and is not lower than the memory address
+								pointed to by 'x' ('n' is a power of 2)
+*/
+
+#define ALIGN_OFFSET(x,n)	(((ptrint_t)(x)) & ((n) - 1))
+#define ALIGN_FLOOR(x,n)	((uint_8t*)(x) - ( ((ptrint_t)(x)) & ((n) - 1)))
+#define ALIGN_CEIL(x,n)		((uint_8t*)(x) + (-((ptrint_t)(x)) & ((n) - 1)))
+
+/*  These defines are used to declare buffers in a way that allows
+    faster operations on longer variables to be used.  In all these
+    defines 'size' must be a power of 2 and >= 8. NOTE that the 
+    buffer size is in bytes but the type length is in bits
+
+    UNIT_TYPEDEF(x,size)        declares a variable 'x' of length 
+                                'size' bits
+
+    BUFR_TYPEDEF(x,size,bsize)  declares a buffer 'x' of length 'bsize' 
+                                bytes defined as an array of variables
+                                each of 'size' bits (bsize must be a 
+                                multiple of size / 8)
+
+    UNIT_CAST(x,size)           casts a variable to a type of 
+                                length 'size' bits
+
+    UPTR_CAST(x,size)           casts a pointer to a pointer to a 
+                                varaiable of length 'size' bits
+*/
+
+#define UI_TYPE(size)               uint_##size##t
+#define UNIT_TYPEDEF(x,size)        typedef UI_TYPE(size) x
+#define BUFR_TYPEDEF(x,size,bsize)  typedef UI_TYPE(size) x[bsize / (size >> 3)]
+#define UNIT_CAST(x,size)           ((UI_TYPE(size) )(x))  
+#define UPTR_CAST(x,size)           ((UI_TYPE(size)*)(x))
+
+  /* Added by Soeren S. Thomsen (begin) */
+#define u8 uint_8t
+#define u32 uint_32t
+#define u64 uint_64t
+  /* (end) */
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

algo/groestl/sse2/grso-asm.h

@@ -0,0 +1,10 @@
+#ifndef GRSOASM_H
+#define GRSOASM_H
+
+#include "grso.h"
+
+void grsoP1024ASM (u64 *x) ;
+
+void grsoQ1024ASM (u64 *x) ;
+
+#endif 

algo/groestl/sse2/grso-asm2.h

@@ -0,0 +1,11 @@
+#ifndef GRSOASM_H
+#define GRSOASM_H
+/* really same as the mmx asm.h */
+/* made just in case something must be changed */
+#include "grso.h"
+
+void grsoP1024ASM (u64 *x) ;
+
+void grsoQ1024ASM (u64 *x) ;
+
+#endif 

algo/groestl/sse2/grso-macro.c

@@ -0,0 +1,110 @@
+/* hash.c     January 2011
+ *
+ * Groestl-512 implementation with inline assembly containing mmx and
+ * sse instructions. Optimized for Opteron.
+ * Authors: Krystian Matusiewicz and Soeren S. Thomsen
+ *
+ * This code is placed in the public domain
+ */
+
+//#include "grso.h"
+//#include "grso-asm.h"
+// #include "grsotab.h"
+
+#define DECL_GRS
+
+/* load initial constants */
+#define GRS_I \
+do { \
+  int i; \
+  /* set initial value */ \
+  for (i = 0; i < grsoCOLS-1; i++) sts_grs.grsstate[i] = 0; \
+  sts_grs.grsstate[grsoCOLS-1] = grsoU64BIG((u64)(8*grsoDIGESTSIZE)); \
+ \
+  /* set other variables */ \
+  sts_grs.grsbuf_ptr = 0; \
+  sts_grs.grsblock_counter = 0; \
+} while (0); \
+
+/* load hash */
+#define GRS_U \
+do { \
+    unsigned char* in = hash; \
+  unsigned long long index = 0; \
+ \
+  /* if the buffer contains data that has not yet been digested, first \
+     add data to buffer until full */ \
+  if (sts_grs.grsbuf_ptr) { \
+    while (sts_grs.grsbuf_ptr < grsoSIZE && index < 64) { \
+      hashbuf[(int)sts_grs.grsbuf_ptr++] = in[index++]; \
+    } \
+    if (sts_grs.grsbuf_ptr < grsoSIZE) continue; \
+ \
+    /* digest buffer */ \
+    sts_grs.grsbuf_ptr = 0; \
+    grsoTransform(&sts_grs, hashbuf, grsoSIZE); \
+  } \
+ \
+  /* digest bulk of message */ \
+  grsoTransform(&sts_grs, in+index, 64-index); \
+  index += ((64-index)/grsoSIZE)*grsoSIZE; \
+ \
+  /* store remaining data in buffer */ \
+  while (index < 64) { \
+    hashbuf[(int)sts_grs.grsbuf_ptr++] = in[index++]; \
+  } \
+ \
+} while (0);
+
+/* groestl512 hash loaded */
+/* hash = groestl512(loaded) */
+#define GRS_C \
+do { \
+    char *out = hash; \
+  int i, j = 0; \
+  unsigned char *s = (unsigned char*)sts_grs.grsstate; \
+ \
+  hashbuf[sts_grs.grsbuf_ptr++] = 0x80; \
+ \
+  /* pad with '0'-bits */ \
+  if (sts_grs.grsbuf_ptr > grsoSIZE-grsoLENGTHFIELDLEN) { \
+    /* padding requires two blocks */ \
+    while (sts_grs.grsbuf_ptr < grsoSIZE) { \
+      hashbuf[sts_grs.grsbuf_ptr++] = 0; \
+    } \
+    /* digest first padding block */ \
+    grsoTransform(&sts_grs, hashbuf, grsoSIZE); \
+    sts_grs.grsbuf_ptr = 0; \
+  } \
+  while (sts_grs.grsbuf_ptr < grsoSIZE-grsoLENGTHFIELDLEN) { \
+    hashbuf[sts_grs.grsbuf_ptr++] = 0; \
+  } \
+ \
+  /* length padding */ \
+  sts_grs.grsblock_counter++; \
+  sts_grs.grsbuf_ptr = grsoSIZE; \
+  while (sts_grs.grsbuf_ptr > grsoSIZE-grsoLENGTHFIELDLEN) { \
+    hashbuf[--sts_grs.grsbuf_ptr] = (unsigned char)sts_grs.grsblock_counter; \
+    sts_grs.grsblock_counter >>= 8; \
+  } \
+ \
+  /* digest final padding block */ \
+  grsoTransform(&sts_grs, hashbuf, grsoSIZE); \
+  /* perform output transformation */ \
+  grsoOutputTransformation(&sts_grs); \
+ \
+  /* store hash result in output */ \
+  for (i = grsoSIZE-grsoDIGESTSIZE; i < grsoSIZE; i++,j++) { \
+    out[j] = s[i]; \
+  } \
+ \
+  /* zeroise relevant variables and deallocate memory */ \
+  for (i = 0; i < grsoCOLS; i++) { \
+    sts_grs.grsstate[i] = 0; \
+  } \
+  for (i = 0; i < grsoSIZE; i++) { \
+    hashbuf[i] = 0; \
+  } \
+} while (0); 
+ 
+

algo/groestl/sse2/grso.c

@@ -0,0 +1,57 @@
+/* hash.c     January 2011
+ *
+ * Groestl-512 implementation with inline assembly containing mmx and
+ * sse instructions. Optimized for Opteron.
+ * Authors: Krystian Matusiewicz and Soeren S. Thomsen
+ *
+ * This code is placed in the public domain
+ */
+
+#include "algo/groestl/sse2/grso-asm.h"
+#include "algo/groestl/sse2/grso.h"
+#include "algo/groestl/sse2/grsotab.h"
+
+/* digest up to len bytes of input (full blocks only) */
+void grsoTransform(grsoState *ctx, 
+	       const unsigned char *in, 
+	       unsigned long long len) {
+  u64 y[grsoCOLS+2] __attribute__ ((aligned (16)));
+  u64 z[grsoCOLS+2] __attribute__ ((aligned (16)));
+  u64 *m, *h = (u64*)ctx->grsstate;
+  int i;
+  
+  /* increment block counter */
+  ctx->grsblock_counter += len/grsoSIZE;
+  
+  /* digest message, one block at a time */
+  for (; len >= grsoSIZE; len -= grsoSIZE, in += grsoSIZE) {
+    m = (u64*)in;
+    for (i = 0; i < grsoCOLS; i++) {
+      y[i] = m[i];
+      z[i] = m[i] ^ h[i];
+    }
+
+    grsoQ1024ASM(y);
+    grsoP1024ASM(z);
+
+    /* h' == h + Q(m) + P(h+m) */
+    for (i = 0; i < grsoCOLS; i++) {
+      h[i] ^= z[i] ^ y[i];
+    }
+  }
+}
+
+/* given state h, do h <- P(h)+h */
+void grsoOutputTransformation(grsoState *ctx) {
+  u64 z[grsoCOLS] __attribute__ ((aligned (16)));
+  int j;
+
+  for (j = 0; j < grsoCOLS; j++) {
+    z[j] = ctx->grsstate[j];
+  }
+  grsoP1024ASM(z);
+  for (j = 0; j < grsoCOLS; j++) {
+    ctx->grsstate[j] ^= z[j];
+  }
+}
+

algo/groestl/sse2/grso.h

@@ -0,0 +1,62 @@
+#ifndef __hash_h
+#define __hash_h
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "brg_endian.h"
+#include "brg_types.h"
+
+/* some sizes (number of bytes) */
+#define grsoROWS 8
+#define grsoLENGTHFIELDLEN grsoROWS
+#define grsoCOLS 16
+#define grsoSIZE (grsoROWS*grsoCOLS)
+#define grsoDIGESTSIZE 64
+
+#define grsoROUNDS 14
+
+#define grsoROTL64(a,n) ((((a)<<(n))|((a)>>(64-(n))))&((u64)0xffffffffffffffffULL))
+
+#if (PLATFORM_BYTE_ORDER == IS_BIG_ENDIAN)
+#error
+#endif /* IS_BIG_ENDIAN */
+
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+#define EXT_BYTE(var,n) ((u8)((u64)(var) >> (8*n)))
+#define grsoU64BIG(a)				\
+  ((grsoROTL64(a, 8) & ((u64)0x000000ff000000ffULL)) |	\
+   (grsoROTL64(a,24) & ((u64)0x0000ff000000ff00ULL)) |	\
+   (grsoROTL64(a,40) & ((u64)0x00ff000000ff0000ULL)) |	\
+   (grsoROTL64(a,56) & ((u64)0xff000000ff000000ULL)))
+#endif /* IS_LITTLE_ENDIAN */
+
+typedef struct {
+  u64 grsstate[grsoCOLS];             /* actual state */
+  u64 grsblock_counter;           /* message block counter */
+  int grsbuf_ptr;                 /* data buffer pointer */
+} grsoState;
+
+//extern int grsoInit(grsoState* ctx); 
+//extern int grsoUpdate(grsoState* ctx, const unsigned char* in,
+//	   unsigned long long len);
+//extern int grsoUpdateq(grsoState* ctx, const unsigned char* in);
+//extern int grsoFinal(grsoState* ctx,
+//	  unsigned char* out); 
+//
+//extern int grsohash(unsigned char *out,
+//		const unsigned char *in,
+//		unsigned long long len);
+
+/* digest up to len bytes of input (full blocks only) */
+void grsoTransform( grsoState *ctx, const unsigned char *in,
+                            unsigned long long len );
+
+/* given state h, do h <- P(h)+h */
+void grsoOutputTransformation( grsoState *ctx );
+
+int grso_init ( grsoState* sts_grs );
+int grso_update ( grsoState* sts_grs, char* hashbuf, char* hash );
+int grso_close ( grsoState *sts_grs, char* hashbuf, char* hash );
+
+
+#endif /* __hash_h */