sha3 0.2.6 → 1.0.1

data/ext/sha3/KeccakF-1600-reference.c-arch

@@ -1,300 +0,0 @@
-/*
-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/
-*/
-
-#include <stdio.h>
-#include <string.h>
-#include "brg_endian.h"
-#include "displayIntermediateValues.h"
-#include "KeccakNISTInterface.h"
-#include "KeccakF-1600-interface.h"
-
-typedef unsigned char UINT8;
-typedef unsigned long long int UINT64;
-
-#define nrRounds 24
-UINT64 KeccakRoundConstants[nrRounds];
-#define nrLanes 25
-unsigned int KeccakRhoOffsets[nrLanes];
-
-void KeccakPermutationOnWords(UINT64 *state);
-void theta(UINT64 *A);
-void rho(UINT64 *A);
-void pi(UINT64 *A);
-void chi(UINT64 *A);
-void iota(UINT64 *A, unsigned int indexRound);
-
-void fromBytesToWords(UINT64 *stateAsWords, const unsigned char *state)
-{
-    unsigned int i, j;
-
-    for(i=0; i<(KeccakPermutationSize/64); i++) {
-        stateAsWords[i] = 0;
-        for(j=0; j<(64/8); j++)
-            stateAsWords[i] |= (UINT64)(state[i*(64/8)+j]) << (8*j);
-    }
-}
-
-void fromWordsToBytes(unsigned char *state, const UINT64 *stateAsWords)
-{
-    unsigned int i, j;
-
-    for(i=0; i<(KeccakPermutationSize/64); i++)
-        for(j=0; j<(64/8); j++)
-            state[i*(64/8)+j] = (stateAsWords[i] >> (8*j)) & 0xFF;
-}
-
-void KeccakPermutation(unsigned char *state)
-{
-#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
-    UINT64 stateAsWords[KeccakPermutationSize/64];
-#endif
-
-    displayStateAsBytes(1, "Input of permutation", state);
-#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
-    KeccakPermutationOnWords((UINT64*)state);
-#else
-    fromBytesToWords(stateAsWords, state);
-    KeccakPermutationOnWords(stateAsWords);
-    fromWordsToBytes(state, stateAsWords);
-#endif
-    displayStateAsBytes(1, "State after permutation", state);
-}
-
-void KeccakPermutationAfterXor(unsigned char *state, const unsigned char *data, unsigned int dataLengthInBytes)
-{
-    unsigned int i;
-
-    for(i=0; i<dataLengthInBytes; i++)
-        state[i] ^= data[i];
-    KeccakPermutation(state);
-}
-
-void KeccakPermutationOnWords(UINT64 *state)
-{
-    unsigned int i;
-
-    displayStateAs64bitWords(3, "Same, with lanes as 64-bit words", state);
-
-    for(i=0; i<nrRounds; i++) {
-        displayRoundNumber(3, i);
-
-        theta(state);
-        displayStateAs64bitWords(3, "After theta", state);
-
-        rho(state);
-        displayStateAs64bitWords(3, "After rho", state);
-
-        pi(state);
-        displayStateAs64bitWords(3, "After pi", state);
-
-        chi(state);
-        displayStateAs64bitWords(3, "After chi", state);
-
-        iota(state, i);
-        displayStateAs64bitWords(3, "After iota", state);
-    }
-}
-
-#define index(x, y) (((x)%5)+5*((y)%5))
-#define ROL64(a, offset) ((offset != 0) ? ((((UINT64)a) << offset) ^ (((UINT64)a) >> (64-offset))) : a)
-
-void theta(UINT64 *A)
-{
-    unsigned int x, y;
-    UINT64 C[5], D[5];
-
-    for(x=0; x<5; x++) {
-        C[x] = 0; 
-        for(y=0; y<5; y++) 
-            C[x] ^= A[index(x, y)];
-    }
-    for(x=0; x<5; x++)
-        D[x] = ROL64(C[(x+1)%5], 1) ^ C[(x+4)%5];
-    for(x=0; x<5; x++)
-        for(y=0; y<5; y++)
-            A[index(x, y)] ^= D[x];
-}
-
-void rho(UINT64 *A)
-{
-    unsigned int x, y;
-
-    for(x=0; x<5; x++) for(y=0; y<5; y++)
-        A[index(x, y)] = ROL64(A[index(x, y)], KeccakRhoOffsets[index(x, y)]);
-}
-
-void pi(UINT64 *A)
-{
-    unsigned int x, y;
-    UINT64 tempA[25];
-
-    for(x=0; x<5; x++) for(y=0; y<5; y++)
-        tempA[index(x, y)] = A[index(x, y)];
-    for(x=0; x<5; x++) for(y=0; y<5; y++)
-        A[index(0*x+1*y, 2*x+3*y)] = tempA[index(x, y)];
-}
-
-void chi(UINT64 *A)
-{
-    unsigned int x, y;
-    UINT64 C[5];
-
-    for(y=0; y<5; y++) { 
-        for(x=0; x<5; x++)
-            C[x] = A[index(x, y)] ^ ((~A[index(x+1, y)]) & A[index(x+2, y)]);
-        for(x=0; x<5; x++)
-            A[index(x, y)] = C[x];
-    }
-}
-
-void iota(UINT64 *A, unsigned int indexRound)
-{
-    A[index(0, 0)] ^= KeccakRoundConstants[indexRound];
-}
-
-int LFSR86540(UINT8 *LFSR)
-{
-    int result = ((*LFSR) & 0x01) != 0;
-    if (((*LFSR) & 0x80) != 0)
-        // Primitive polynomial over GF(2): x^8+x^6+x^5+x^4+1
-        (*LFSR) = ((*LFSR) << 1) ^ 0x71;
-    else
-        (*LFSR) <<= 1;
-    return result;
-}
-
-void KeccakInitializeRoundConstants()
-{
-    UINT8 LFSRstate = 0x01;
-    unsigned int i, j, bitPosition;
-
-    for(i=0; i<nrRounds; i++) {
-        KeccakRoundConstants[i] = 0;
-        for(j=0; j<7; j++) {
-            bitPosition = (1<<j)-1; //2^j-1
-            if (LFSR86540(&LFSRstate))
-                KeccakRoundConstants[i] ^= (UINT64)1<<bitPosition;
-        }
-    }
-}
-
-void KeccakInitializeRhoOffsets()
-{
-    unsigned int x, y, t, newX, newY;
-
-    KeccakRhoOffsets[index(0, 0)] = 0;
-    x = 1;
-    y = 0;
-    for(t=0; t<24; t++) {
-        KeccakRhoOffsets[index(x, y)] = ((t+1)*(t+2)/2) % 64;
-        newX = (0*x+1*y) % 5;
-        newY = (2*x+3*y) % 5;
-        x = newX;
-        y = newY;
-    }
-}
-
-void KeccakInitialize()
-{
-    KeccakInitializeRoundConstants();
-    KeccakInitializeRhoOffsets();
-}
-
-void displayRoundConstants(FILE *f)
-{
-    unsigned int i;
-
-    for(i=0; i<nrRounds; i++) {
-        fprintf(f, "RC[%02i][0][0] = ", i);
-        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] >> 32));
-        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] & 0xFFFFFFFFULL));
-        fprintf(f, "\n");
-    }
-    fprintf(f, "\n");
-}
-
-void displayRhoOffsets(FILE *f)
-{
-    unsigned int x, y;
-
-    for(y=0; y<5; y++) for(x=0; x<5; x++) {
-        fprintf(f, "RhoOffset[%i][%i] = ", x, y);
-        fprintf(f, "%2i", KeccakRhoOffsets[index(x, y)]);
-        fprintf(f, "\n");
-    }
-    fprintf(f, "\n");
-}
-
-void KeccakInitializeState(unsigned char *state)
-{
-    memset(state, 0, KeccakPermutationSizeInBytes);
-}
-
-#ifdef ProvideFast576
-void KeccakAbsorb576bits(unsigned char *state, const unsigned char *data)
-{
-    KeccakPermutationAfterXor(state, data, 72);
-}
-#endif
-
-#ifdef ProvideFast832
-void KeccakAbsorb832bits(unsigned char *state, const unsigned char *data)
-{
-    KeccakPermutationAfterXor(state, data, 104);
-}
-#endif
-
-#ifdef ProvideFast1024
-void KeccakAbsorb1024bits(unsigned char *state, const unsigned char *data)
-{
-    KeccakPermutationAfterXor(state, data, 128);
-}
-#endif
-
-#ifdef ProvideFast1088
-void KeccakAbsorb1088bits(unsigned char *state, const unsigned char *data)
-{
-    KeccakPermutationAfterXor(state, data, 136);
-}
-#endif
-
-#ifdef ProvideFast1152
-void KeccakAbsorb1152bits(unsigned char *state, const unsigned char *data)
-{
-    KeccakPermutationAfterXor(state, data, 144);
-}
-#endif
-
-#ifdef ProvideFast1344
-void KeccakAbsorb1344bits(unsigned char *state, const unsigned char *data)
-{
-    KeccakPermutationAfterXor(state, data, 168);
-}
-#endif
-
-void KeccakAbsorb(unsigned char *state, const unsigned char *data, unsigned int laneCount)
-{
-    KeccakPermutationAfterXor(state, data, laneCount*8);
-}
-
-#ifdef ProvideFast1024
-void KeccakExtract1024bits(const unsigned char *state, unsigned char *data)
-{
-    memcpy(data, state, 128);
-}
-#endif
-
-void KeccakExtract(const unsigned char *state, unsigned char *data, unsigned int laneCount)
-{
-    memcpy(data, state, laneCount*8);
-}

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

@@ -1,766 +0,0 @@
-#
-# 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
-