sha3-ruby 0.0.1

data/ext/sha3/KeccakReferenceAndOptimized/Sources/KeccakF-1600-unrolling.macros

@@ -0,0 +1,124 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by the designers,
+hereby denoted as "the implementer".
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#if (Unrolling == 24)
+#define rounds \
+    prepareTheta \
+    thetaRhoPiChiIotaPrepareTheta( 0, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 1, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 2, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 3, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 4, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 5, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 6, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 7, E, A) \
+    thetaRhoPiChiIotaPrepareTheta( 8, A, E) \
+    thetaRhoPiChiIotaPrepareTheta( 9, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(10, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(11, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(12, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(13, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(14, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(15, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(16, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(17, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+    thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+    thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+    thetaRhoPiChiIota(23, E, A) \
+    copyToState(state, A)
+#elif (Unrolling == 12)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=12) { \
+        thetaRhoPiChiIotaPrepareTheta(i   , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 3, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 4, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 5, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 6, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 7, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 8, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+ 9, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+10, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+11, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 8)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=8) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+6, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+7, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 6)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=6) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 4)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=4) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 3)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=3) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        copyStateVariables(A, E) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 2)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i+=2) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+    } \
+    copyToState(state, A)
+#elif (Unrolling == 1)
+#define rounds \
+    prepareTheta \
+    for(i=0; i<24; i++) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        copyStateVariables(A, E) \
+    } \
+    copyToState(state, A)
+#else
+#error "Unrolling is not correctly specified!"
+#endif

data/ext/sha3/KeccakReferenceAndOptimized/Sources/KeccakF-1600-x86-64-asm.c

@@ -0,0 +1,62 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by Ronny Van Keer,
+hereby denoted as "the implementer".
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include <string.h>
+#include "KeccakF-1600-interface.h"
+
+#define	UseBebigokimisa
+
+typedef unsigned char UINT8;
+typedef unsigned long long int UINT64;
+
+void KeccakInitialize()
+{
+}
+
+void KeccakExtract(const unsigned char *state, unsigned char *data, unsigned int laneCount)
+{
+    memcpy(data, state, laneCount*8);
+#ifdef UseBebigokimisa
+    if (laneCount > 8) 
+    {
+        ((UINT64*)data)[ 1] = ~((UINT64*)data)[ 1];
+        ((UINT64*)data)[ 2] = ~((UINT64*)data)[ 2];
+        ((UINT64*)data)[ 8] = ~((UINT64*)data)[ 8];
+
+        if (laneCount > 12) 
+        {
+            ((UINT64*)data)[12] = ~((UINT64*)data)[12];
+            if (laneCount > 17) 
+            {
+                ((UINT64*)data)[17] = ~((UINT64*)data)[17];
+                if (laneCount > 20) 
+                {
+                    ((UINT64*)data)[20] = ~((UINT64*)data)[20];
+                }
+            }
+        }
+    }
+    else
+    {
+		if (laneCount > 1) 
+		{
+			((UINT64*)data)[ 1] = ~((UINT64*)data)[ 1];
+			if (laneCount > 2) 
+			{
+				((UINT64*)data)[ 2] = ~((UINT64*)data)[ 2];
+            }
+        }
+    }
+
+#endif
+}

data/ext/sha3/KeccakReferenceAndOptimized/Sources/KeccakF-1600-x86-64-gas.s

@@ -0,0 +1,766 @@
+#
+# The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+# Michaël Peeters and Gilles Van Assche. For more information, feedback or
+# questions, please refer to our website: http://keccak.noekeon.org/
+#
+# Implementation by Ronny Van Keer,
+# hereby denoted as "the implementer".
+# 
+# To the extent possible under law, the implementer has waived all copyright
+# and related or neighboring rights to the source code in this file.
+# http://creativecommons.org/publicdomain/zero/1.0/
+#
+
+	.text
+
+
+#// --- defines
+
+.equ UseSIMD, 1
+
+
+.equ _ba,  0*8
+.equ _be,  1*8
+.equ _bi,  2*8
+.equ _bo,  3*8
+.equ _bu,  4*8
+.equ _ga,  5*8
+.equ _ge,  6*8
+.equ _gi,  7*8
+.equ _go,  8*8
+.equ _gu,  9*8
+.equ _ka, 10*8
+.equ _ke, 11*8
+.equ _ki, 12*8
+.equ _ko, 13*8
+.equ _ku, 14*8
+.equ _ma, 15*8
+.equ _me, 16*8
+.equ _mi, 17*8
+.equ _mo, 18*8
+.equ _mu, 19*8
+.equ _sa, 20*8
+.equ _se, 21*8
+.equ _si, 22*8
+.equ _so, 23*8
+.equ _su, 24*8
+
+
+#	arguments
+.equ apState,		%rdi
+.equ apInput,		%rsi
+.equ aNbrWords,		%rdx
+
+#	xor input into state section
+.equ xpState,		%r9
+
+# round vars
+.equ rT1,		%rax
+.equ rpState,		%rdi
+.equ rpStack,		%rsp
+
+.equ rDa,		%rbx
+.equ rDe,		%rcx
+.equ rDi,		%rdx
+.equ rDo,		%r8
+.equ rDu,		%r9
+
+.equ rBa,		%r10 
+.equ rBe,		%r11
+.equ rBi,		%r12
+.equ rBo,		%r13
+.equ rBu,		%r14
+
+.equ rCa,		%rsi
+.equ rCe,		%rbp
+.equ rCi,		rBi
+.equ rCo,		rBo
+.equ rCu,		%r15
+
+.macro	mKeccakRound	iState, oState, rc, lastRound
+
+		movq		rCe, rDa
+		rolq		rDa
+
+		movq		_bi(\iState), rCi
+		xorq		_gi(\iState), rDi
+		xorq		rCu, rDa
+		xorq		_ki(\iState), rCi
+		xorq		_mi(\iState), rDi
+		xorq		rDi, rCi
+
+		movq		rCi, rDe
+		rolq		rDe
+
+		movq		_bo(\iState), rCo
+		xorq		_go(\iState), rDo
+		xorq		rCa, rDe
+		xorq		_ko(\iState), rCo
+		xorq		_mo(\iState), rDo
+		xorq		rDo, rCo
+
+		movq		rCo, rDi
+		rolq		rDi
+
+		movq		rCu, rDo
+		xorq		rCe, rDi
+		rolq		rDo
+
+		movq		rCa, rDu
+		xorq		rCi, rDo
+		rolq		rDu
+
+		movq		_ba(\iState), rBa
+		movq		_ge(\iState), rBe
+		xorq		rCo, rDu
+		movq		_ki(\iState), rBi
+		movq		_mo(\iState), rBo
+		movq		_su(\iState), rBu
+		xorq		rDe, rBe
+		rolq		$44, rBe
+		xorq		rDi, rBi
+		xorq		rDa, rBa
+		rolq		$43, rBi
+
+		movq		rBe, rCa
+		movq		$\rc, rT1
+		orq		rBi, rCa
+		xorq		rBa, rT1
+		xorq		rT1, rCa
+		movq		rCa, _ba(\oState)
+
+		xorq		rDu, rBu
+		rolq		$14, rBu
+		movq		rBa, rCu
+		andq		rBe, rCu
+		xorq		rBu, rCu
+		movq		rCu, _bu(\oState)
+
+		xorq		rDo, rBo
+		rolq		$21, rBo
+		movq		rBo, rT1
+		andq		rBu, rT1
+		xorq		rBi, rT1
+		movq		rT1, _bi(\oState)
+
+		notq		rBi
+		orq		rBa, rBu
+		orq		rBo, rBi
+		xorq		rBo, rBu
+		xorq		rBe, rBi
+		movq		rBu, _bo(\oState)
+		movq		rBi, _be(\oState)
+		.if		\lastRound == 0
+		movq		rBi, rCe
+		.endif
+
+
+		movq		_gu(\iState), rBe
+		xorq		rDu, rBe
+		movq		_ka(\iState), rBi
+		rolq		$20, rBe
+		xorq		rDa, rBi
+		rolq		$3,  rBi
+		movq		_bo(\iState), rBa
+		movq		rBe, rT1
+		orq		rBi, rT1
+		xorq		rDo, rBa
+		movq		_me(\iState), rBo
+		movq		_si(\iState), rBu
+		rolq		$28, rBa
+		xorq		rBa, rT1
+		movq		rT1, _ga(\oState)
+		.if		\lastRound == 0
+		xor 		rT1, rCa
+		.endif
+
+		xorq		rDe, rBo
+		rolq		$45, rBo
+		movq		rBi, rT1
+		andq		rBo, rT1
+		xorq		rBe, rT1
+		movq		rT1, _ge(\oState)
+		.if		\lastRound == 0
+		xorq		rT1, rCe
+		.endif
+
+		xorq		rDi, rBu
+		rolq		$61, rBu
+		movq		rBu, rT1
+		orq		rBa, rT1
+		xorq		rBo, rT1
+		movq		rT1, _go(\oState)
+
+		andq		rBe, rBa
+		xorq		rBu, rBa
+		movq		rBa, _gu(\oState)
+		notq		rBu
+		.if		\lastRound == 0
+		xorq		rBa, rCu
+		.endif
+
+		orq		rBu, rBo
+		xorq		rBi, rBo
+		movq		rBo, _gi(\oState)
+
+
+		movq		_be(\iState), rBa
+		movq		_gi(\iState), rBe
+		movq		_ko(\iState), rBi
+		movq		_mu(\iState), rBo
+		movq		_sa(\iState), rBu
+		xorq		rDi, rBe
+		rolq		$6,  rBe
+		xorq		rDo, rBi
+		rolq		$25, rBi
+		movq		rBe, rT1
+		orq		rBi, rT1
+		xorq		rDe, rBa
+		rolq		$1,  rBa
+		xorq		rBa, rT1
+		movq		rT1, _ka(\oState)
+		.if		\lastRound == 0
+		xor 		rT1, rCa
+		.endif
+
+		xorq		rDu, rBo
+		rolq		$8,  rBo
+		movq		rBi, rT1
+		andq		rBo, rT1
+		xorq		rBe, rT1
+		movq		rT1, _ke(\oState)
+		.if		\lastRound == 0
+		xorq		rT1, rCe
+		.endif
+
+		xorq		rDa, rBu
+		rolq		$18, rBu
+		notq		rBo
+		movq		rBo, rT1
+		andq		rBu, rT1
+		xorq		rBi, rT1
+		movq		rT1, _ki(\oState)
+
+		movq		rBu, rT1
+		orq		rBa, rT1
+		xorq		rBo, rT1
+		movq		rT1, _ko(\oState)
+
+		andq		rBe, rBa
+		xorq		rBu, rBa
+		movq		rBa, _ku(\oState)
+		.if		\lastRound == 0
+		xorq		rBa, rCu
+		.endif
+
+		movq		_ga(\iState), rBe
+		xorq		rDa, rBe
+		movq		_ke(\iState), rBi
+		rolq		$36, rBe
+		xorq		rDe, rBi
+		movq		_bu(\iState), rBa
+		rolq		$10, rBi
+		movq		rBe, rT1
+		movq		_mi(\iState), rBo
+		andq		rBi, rT1
+		xorq		rDu, rBa
+		movq		_so(\iState), rBu
+		rolq		$27, rBa
+		xorq		rBa, rT1
+		movq		rT1, _ma(\oState)
+		.if		\lastRound == 0
+		xor 		rT1, rCa
+		.endif
+
+		xorq		rDi, rBo
+		rolq		$15, rBo
+		movq		rBi, rT1
+		orq		rBo, rT1
+		xorq		rBe, rT1
+		movq		rT1, _me(\oState)
+		.if		\lastRound == 0
+		xorq		rT1, rCe
+		.endif
+
+		xorq		rDo, rBu
+		rolq		$56, rBu
+		notq		rBo
+		movq		rBo, rT1
+		orq		rBu, rT1
+		xorq		rBi, rT1
+		movq		rT1, _mi(\oState)
+
+		orq		rBa, rBe
+		xorq		rBu, rBe
+		movq		rBe, _mu(\oState)
+
+		andq		rBa, rBu
+		xorq		rBo, rBu
+		movq		rBu, _mo(\oState)
+		.if		\lastRound == 0
+		xorq		rBe, rCu
+		.endif
+
+
+		movq		_bi(\iState), rBa
+		movq		_go(\iState), rBe
+		movq		_ku(\iState), rBi
+		xorq		rDi, rBa
+		movq		_ma(\iState), rBo
+		rolq		$62, rBa
+		xorq		rDo, rBe
+		movq		_se(\iState), rBu
+		rolq		$55, rBe
+
+		xorq		rDu, rBi
+		movq		rBa, rDu
+		xorq		rDe, rBu
+		rolq		$2,  rBu
+		andq		rBe, rDu
+		xorq		rBu, rDu
+		movq		rDu, _su(\oState)
+
+		rolq		$39, rBi
+		.if		\lastRound == 0
+		xorq		rDu, rCu
+		.endif
+		notq		rBe
+		xorq		rDa, rBo
+		movq		rBe, rDa
+		andq		rBi, rDa
+		xorq		rBa, rDa
+		movq		rDa, _sa(\oState)
+		.if		\lastRound == 0
+		xor 		rDa, rCa
+		.endif
+
+		rolq		$41, rBo
+		movq		rBi, rDe
+		orq		rBo, rDe
+		xorq		rBe, rDe
+		movq		rDe, _se(\oState)
+		.if		\lastRound == 0
+		xorq		rDe, rCe
+		.endif
+
+		movq		rBo, rDi
+		movq		rBu, rDo
+		andq		rBu, rDi
+		orq		rBa, rDo
+		xorq		rBi, rDi
+		xorq		rBo, rDo
+		movq		rDi, _si(\oState)
+		movq		rDo, _so(\oState)
+
+		.endm
+
+.macro	mKeccakPermutation	
+
+		subq		$8*25, %rsp
+
+		movq		_ba(rpState), rCa             
+		movq		_be(rpState), rCe
+		movq		_bu(rpState), rCu
+
+		xorq		_ga(rpState), rCa             
+		xorq		_ge(rpState), rCe
+		xorq		_gu(rpState), rCu             
+
+		xorq		_ka(rpState), rCa             
+		xorq		_ke(rpState), rCe
+		xorq		_ku(rpState), rCu             
+
+		xorq		_ma(rpState), rCa             
+		xorq		_me(rpState), rCe
+		xorq		_mu(rpState), rCu             
+
+		xorq		_sa(rpState), rCa
+		xorq		_se(rpState), rCe
+		movq		_si(rpState), rDi
+		movq		_so(rpState), rDo
+		xorq		_su(rpState), rCu             
+
+
+		mKeccakRound	rpState, rpStack, 0x0000000000000001, 0
+		mKeccakRound	rpStack, rpState, 0x0000000000008082, 0
+		mKeccakRound	rpState, rpStack, 0x800000000000808a, 0
+		mKeccakRound	rpStack, rpState, 0x8000000080008000, 0
+		mKeccakRound	rpState, rpStack, 0x000000000000808b, 0
+		mKeccakRound	rpStack, rpState, 0x0000000080000001, 0
+
+		mKeccakRound	rpState, rpStack, 0x8000000080008081, 0
+		mKeccakRound	rpStack, rpState, 0x8000000000008009, 0
+		mKeccakRound	rpState, rpStack, 0x000000000000008a, 0
+		mKeccakRound	rpStack, rpState, 0x0000000000000088, 0
+		mKeccakRound	rpState, rpStack, 0x0000000080008009, 0
+		mKeccakRound	rpStack, rpState, 0x000000008000000a, 0
+
+		mKeccakRound	rpState, rpStack, 0x000000008000808b, 0
+		mKeccakRound	rpStack, rpState, 0x800000000000008b, 0
+		mKeccakRound	rpState, rpStack, 0x8000000000008089, 0
+		mKeccakRound	rpStack, rpState, 0x8000000000008003, 0
+		mKeccakRound	rpState, rpStack, 0x8000000000008002, 0
+		mKeccakRound	rpStack, rpState, 0x8000000000000080, 0
+
+		mKeccakRound	rpState, rpStack, 0x000000000000800a, 0
+		mKeccakRound	rpStack, rpState, 0x800000008000000a, 0
+		mKeccakRound	rpState, rpStack, 0x8000000080008081, 0
+		mKeccakRound	rpStack, rpState, 0x8000000000008080, 0
+		mKeccakRound	rpState, rpStack, 0x0000000080000001, 0
+		mKeccakRound	rpStack, rpState, 0x8000000080008008, 1
+
+		addq		$8*25, %rsp
+
+		.endm
+
+.macro	mPushRegs	
+
+	pushq		%rbx
+	pushq		%rbp
+	pushq		%r12
+	pushq		%r13
+	pushq		%r14
+	pushq		%r15
+
+	.endm
+
+
+.macro	mPopRegs	
+
+	popq		%r15
+	popq		%r14
+	popq		%r13
+	popq		%r12
+	popq		%rbp
+	popq		%rbx
+
+	.endm
+
+
+.macro	mXorState128	input, state, offset
+	.if 		UseSIMD == 0
+	movq		\offset(\input), %rax
+	movq		\offset+8(\input), %rcx
+	xorq		%rax, \offset(\state)
+	xorq		%rcx, \offset+8(\state)
+	.else
+	movdqu		\offset(\input), %xmm0
+	pxor		\offset(\state), %xmm0
+	movdqu		%xmm0, \offset(\state)
+	.endif
+	.endm
+
+.macro	mXorState256	input, state, offset
+	.if 		UseSIMD == 0
+	movq		\offset(\input), %rax
+	movq		\offset+8(\input), %r10
+	movq		\offset+16(\input), %rcx
+	movq		\offset+24(\input), %r8
+	xorq		%rax, \offset(\state)
+	xorq		%r10, \offset+8(\state)
+	xorq		%rcx, \offset+16(\state)
+	xorq		%r8,  \offset+24(\state)
+	.else
+	movdqu		\offset(\input), %xmm0
+	pxor		\offset(\state), %xmm0
+	movdqu		\offset+16(\input), %xmm1
+	pxor		\offset+16(\state), %xmm1
+	movdqu		%xmm0, \offset(\state)
+	movdqu		%xmm1, \offset+16(\state)
+	.endif
+	.endm
+
+.macro	mXorState512	input, state, offset
+	.if 		UseSIMD == 0
+	mXorState256	\input, \state, \offset
+	mXorState256	\input, \state, \offset+32
+	.else
+	movdqu		\offset(\input), %xmm0
+	movdqu		\offset+16(\input), %xmm1
+	pxor		\offset(\state), %xmm0
+	movdqu		\offset+32(\input), %xmm2
+	pxor		\offset+16(\state), %xmm1
+	movdqu		%xmm0, \offset(\state)
+	movdqu		\offset+48(\input), %xmm3
+	pxor		\offset+32(\state), %xmm2
+	movdqu		%xmm1, \offset+16(\state)
+	pxor		\offset+48(\state), %xmm3
+	movdqu		%xmm2, \offset+32(\state)
+	movdqu		%xmm3, \offset+48(\state)
+	.endif
+	.endm
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakPermutation, .-KeccakPermutation
+	.align	2
+	.global	KeccakPermutation
+	.type	KeccakPermutation, %function
+KeccakPermutation:
+
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakAbsorb576bits, .-KeccakAbsorb576bits
+	.align	2
+	.global	KeccakAbsorb576bits
+	.type	KeccakAbsorb576bits, %function
+KeccakAbsorb576bits:
+
+	mXorState512	apInput, apState, 0
+	movq		64(apInput), %rax
+	xorq		%rax, 64(apState)
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakAbsorb832bits, .-KeccakAbsorb832bits
+	.align	2
+	.global	KeccakAbsorb832bits
+	.type	KeccakAbsorb832bits, %function
+KeccakAbsorb832bits:
+
+	mXorState512	apInput, apState, 0
+	mXorState256	apInput, apState, 64
+	movq		96(apInput), %rax
+	xorq		%rax, 96(apState)
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakAbsorb1024bits, .-KeccakAbsorb1024bits
+	.align	2
+	.global	KeccakAbsorb1024bits
+	.type	KeccakAbsorb1024bits, %function
+KeccakAbsorb1024bits:
+
+	mXorState512	apInput, apState, 0
+	mXorState512	apInput, apState, 64
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakAbsorb1088bits, .-KeccakAbsorb1088bits
+	.align	2
+	.global	KeccakAbsorb1088bits
+	.type	KeccakAbsorb1088bits, %function
+KeccakAbsorb1088bits:
+
+	mXorState512	apInput, apState, 0
+	mXorState512	apInput, apState, 64
+	movq		128(apInput), %rax
+	xorq		%rax, 128(apState)
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakAbsorb1152bits, .-KeccakAbsorb1152bits
+	.align	2
+	.global	KeccakAbsorb1152bits
+	.type	KeccakAbsorb1152bits, %function
+KeccakAbsorb1152bits:
+
+	mXorState512	apInput, apState, 0
+	mXorState512	apInput, apState, 64
+	mXorState128	apInput, apState, 128
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakAbsorb1344bits, .-KeccakAbsorb1344bits
+	.align	2
+	.global	KeccakAbsorb1344bits
+	.type	KeccakAbsorb1344bits, %function
+KeccakAbsorb1344bits:
+
+	mXorState512	apInput, apState, 0
+	mXorState512	apInput, apState, 64
+	mXorState256	apInput, apState, 128
+	movq		160(apInput), %rax
+	xorq		%rax, 160(apState)
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakAbsorb, .-KeccakAbsorb
+	.align	2
+	.global	KeccakAbsorb
+	.type	KeccakAbsorb, %function
+KeccakAbsorb:
+
+	movq		apState, xpState
+
+	test		$16, aNbrWords
+	jz		xorInputToState8
+	mXorState512	apInput, xpState, 0
+	mXorState512	apInput, xpState, 64
+	addq		$128, apInput
+	addq		$128, xpState
+
+xorInputToState8:
+	test		$8, aNbrWords
+	jz		xorInputToState4
+	mXorState512	apInput, xpState, 0
+	addq		$64, apInput
+	addq		$64, xpState
+
+xorInputToState4:
+	test		$4, aNbrWords
+	jz		xorInputToState2
+	mXorState256	apInput, xpState, 0
+	addq		$32, apInput
+	addq		$32, xpState
+
+xorInputToState2:
+	test		$2, aNbrWords
+	jz		xorInputToState1
+	mXorState128	apInput, xpState, 0
+	addq		$16, apInput
+	addq		$16, xpState
+
+xorInputToState1:
+	test		$1, aNbrWords
+	jz		xorInputToStateDone
+	movq		(apInput), %rax
+	xorq		%rax, (xpState)
+
+xorInputToStateDone:
+
+	mPushRegs
+	mKeccakPermutation
+	mPopRegs
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakInitializeState, .-KeccakInitializeState
+	.align	2
+	.global	KeccakInitializeState
+	.type	KeccakInitializeState, %function
+KeccakInitializeState:
+	xorq		%rax, %rax
+	xorq		%rcx, %rcx
+	notq		%rcx
+
+	.if 		UseSIMD == 0
+	movq		%rax,   0*8(apState)
+	movq		%rcx,   1*8(apState)
+	movq		%rcx,   2*8(apState)
+	movq		%rax,   3*8(apState)
+	movq		%rax,   4*8(apState)
+	movq		%rax,   5*8(apState)
+	movq		%rax,   6*8(apState)
+	movq		%rax,   7*8(apState)
+	movq		%rcx,   8*8(apState)
+	movq		%rax,   9*8(apState)
+	movq		%rax,  10*8(apState)
+	movq		%rax,  11*8(apState)
+	movq		%rcx,  12*8(apState)
+	movq		%rax,  13*8(apState)
+	movq		%rax,  14*8(apState)
+	movq		%rax,  15*8(apState)
+	movq		%rax,  16*8(apState)
+	movq		%rcx,  17*8(apState)
+	movq		%rax,  18*8(apState)
+	movq		%rax,  19*8(apState)
+	movq		%rcx,  20*8(apState)
+	movq		%rax,  21*8(apState)
+	movq		%rax,  22*8(apState)
+	movq		%rax,  23*8(apState)
+	movq		%rax,  24*8(apState)
+	.else
+	pxor		%xmm0, %xmm0
+
+	movq		%rax,   0*8(apState)
+	movq		%rcx,   1*8(apState)
+	movq		%rcx,   2*8(apState)
+	movq		%rax,   3*8(apState)
+	movdqu		%xmm0,  4*8(apState)
+	movdqu		%xmm0,  6*8(apState)
+	movq		%rcx,   8*8(apState)
+	movq		%rax,   9*8(apState)
+	movdqu		%xmm0, 10*8(apState)
+	movq		%rcx,  12*8(apState)
+	movq		%rax,  13*8(apState)
+	movdqu		%xmm0, 14*8(apState)
+	movq		%rax,  16*8(apState)
+	movq		%rcx,  17*8(apState)
+	movdqu		%xmm0, 18*8(apState)
+	movq		%rcx,  20*8(apState)
+	movq		%rax,  21*8(apState)
+	movdqu		%xmm0, 22*8(apState)
+	movq		%rax,  24*8(apState)
+	.endif
+	ret
+
+# -------------------------------------------------------------------------
+
+	.size	KeccakExtract1024bits, .-KeccakExtract1024bits
+	.align	2
+	.global	KeccakExtract1024bits
+	.type	KeccakExtract1024bits, %function
+KeccakExtract1024bits:
+
+	movq		0*8(apState), %rax
+	movq		1*8(apState), %rcx
+	movq		2*8(apState), %rdx
+	movq		3*8(apState), %r8
+	notq		%rcx
+	notq		%rdx
+	movq		%rax, 0*8(%rsi)
+	movq		%rcx, 1*8(%rsi)
+	movq		%rdx, 2*8(%rsi)
+	movq		%r8,  3*8(%rsi)
+
+	movq		4*8(apState), %rax
+	movq		5*8(apState), %rcx
+	movq		6*8(apState), %rdx
+	movq		7*8(apState), %r8
+	movq		%rax, 4*8(%rsi)
+	movq		%rcx, 5*8(%rsi)
+	movq		%rdx, 6*8(%rsi)
+	movq		%r8,  7*8(%rsi)
+
+	movq		 8*8(apState), %rax
+	movq		 9*8(apState), %rcx
+	movq		10*8(apState), %rdx
+	movq		11*8(apState), %r8
+	notq		%rax
+	movq		%rax,  8*8(%rsi)
+	movq		%rcx,  9*8(%rsi)
+	movq		%rdx, 10*8(%rsi)
+	movq		%r8,  11*8(%rsi)
+
+	movq		12*8(apState), %rax
+	movq		13*8(apState), %rcx
+	movq		14*8(apState), %rdx
+	movq		15*8(apState), %r8
+	notq		%rax
+	movq		%rax, 12*8(%rsi)
+	movq		%rcx, 13*8(%rsi)
+	movq		%rdx, 14*8(%rsi)
+	movq		%r8,  15*8(%rsi)
+	ret
+