digest-kangarootwelve 0.3.2 → 0.4.5

data/ext/digest/kangarootwelve/keccak/bulldozer/PlSnP-Fallback.inc

@@ -1,287 +0,0 @@
-/*
-Implementation by Gilles Van Assche, hereby denoted as "the implementer".
-
-For more information, feedback or questions, please refer to our website:
-https://keccak.team/
-
-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/
-
----
-
-This file contains macros that help make a PlSnP-compatible implementation by
-serially falling back on a SnP-compatible implementation or on a PlSnP-compatible
-implementation of lower parallism degree.
-
-Please refer to PlSnP-documentation.h for more details.
-*/
-
-/* expect PlSnP_baseParallelism, PlSnP_targetParallelism */
-/* expect SnP_stateSizeInBytes, SnP_stateAlignment */
-/* expect prefix */
-/* expect SnP_* */
-
-#define JOIN0(a, b)                     a ## b
-#define JOIN(a, b)                      JOIN0(a, b)
-
-#define PlSnP_StaticInitialize          JOIN(prefix, _StaticInitialize)
-#define PlSnP_InitializeAll             JOIN(prefix, _InitializeAll)
-#define PlSnP_AddByte                   JOIN(prefix, _AddByte)
-#define PlSnP_AddBytes                  JOIN(prefix, _AddBytes)
-#define PlSnP_AddLanesAll               JOIN(prefix, _AddLanesAll)
-#define PlSnP_OverwriteBytes            JOIN(prefix, _OverwriteBytes)
-#define PlSnP_OverwriteLanesAll         JOIN(prefix, _OverwriteLanesAll)
-#define PlSnP_OverwriteWithZeroes       JOIN(prefix, _OverwriteWithZeroes)
-#define PlSnP_ExtractBytes              JOIN(prefix, _ExtractBytes)
-#define PlSnP_ExtractLanesAll           JOIN(prefix, _ExtractLanesAll)
-#define PlSnP_ExtractAndAddBytes        JOIN(prefix, _ExtractAndAddBytes)
-#define PlSnP_ExtractAndAddLanesAll     JOIN(prefix, _ExtractAndAddLanesAll)
-
-#if (PlSnP_baseParallelism == 1)
-    #define SnP_stateSizeInBytes            JOIN(SnP, _stateSizeInBytes)
-    #define SnP_stateAlignment              JOIN(SnP, _stateAlignment)
-#else
-    #define SnP_stateSizeInBytes            JOIN(SnP, _statesSizeInBytes)
-    #define SnP_stateAlignment              JOIN(SnP, _statesAlignment)
-#endif
-#define PlSnP_factor ((PlSnP_targetParallelism)/(PlSnP_baseParallelism))
-#define SnP_stateOffset (((SnP_stateSizeInBytes+(SnP_stateAlignment-1))/SnP_stateAlignment)*SnP_stateAlignment)
-#define stateWithIndex(i) ((unsigned char *)states+((i)*SnP_stateOffset))
-
-#define SnP_StaticInitialize            JOIN(SnP, _StaticInitialize)
-#define SnP_Initialize                  JOIN(SnP, _Initialize)
-#define SnP_InitializeAll               JOIN(SnP, _InitializeAll)
-#define SnP_AddByte                     JOIN(SnP, _AddByte)
-#define SnP_AddBytes                    JOIN(SnP, _AddBytes)
-#define SnP_AddLanesAll                 JOIN(SnP, _AddLanesAll)
-#define SnP_OverwriteBytes              JOIN(SnP, _OverwriteBytes)
-#define SnP_OverwriteLanesAll           JOIN(SnP, _OverwriteLanesAll)
-#define SnP_OverwriteWithZeroes         JOIN(SnP, _OverwriteWithZeroes)
-#define SnP_ExtractBytes                JOIN(SnP, _ExtractBytes)
-#define SnP_ExtractLanesAll             JOIN(SnP, _ExtractLanesAll)
-#define SnP_ExtractAndAddBytes          JOIN(SnP, _ExtractAndAddBytes)
-#define SnP_ExtractAndAddLanesAll       JOIN(SnP, _ExtractAndAddLanesAll)
-
-void PlSnP_StaticInitialize( void )
-{
-    SnP_StaticInitialize();
-}
-
-void PlSnP_InitializeAll(void *states)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++)
-    #if (PlSnP_baseParallelism == 1)
-        SnP_Initialize(stateWithIndex(i));
-    #else
-        SnP_InitializeAll(stateWithIndex(i));
-    #endif
-}
-
-void PlSnP_AddByte(void *states, unsigned int instanceIndex, unsigned char byte, unsigned int offset)
-{
-    #if (PlSnP_baseParallelism == 1)
-        SnP_AddByte(stateWithIndex(instanceIndex), byte, offset);
-    #else
-        SnP_AddByte(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanceIndex%PlSnP_baseParallelism, byte, offset);
-    #endif
-}
-
-void PlSnP_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    #if (PlSnP_baseParallelism == 1)
-        SnP_AddBytes(stateWithIndex(instanceIndex), data, offset, length);
-    #else
-        SnP_AddBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanceIndex%PlSnP_baseParallelism, data, offset, length);
-    #endif
-}
-
-void PlSnP_AddLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_AddBytes(stateWithIndex(i), data, 0, laneCount*SnP_laneLengthInBytes);
-        #else
-            SnP_AddLanesAll(stateWithIndex(i), data, laneCount, laneOffset);
-        #endif
-        data += PlSnP_baseParallelism*laneOffset*SnP_laneLengthInBytes;
-    }
-}
-
-void PlSnP_OverwriteBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length)
-{
-    #if (PlSnP_baseParallelism == 1)
-        SnP_OverwriteBytes(stateWithIndex(instanceIndex), data, offset, length);
-    #else
-        SnP_OverwriteBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanceIndex%PlSnP_baseParallelism, data, offset, length);
-    #endif
-}
-
-void PlSnP_OverwriteLanesAll(void *states, const unsigned char *data, unsigned int laneCount, unsigned int laneOffset)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_OverwriteBytes(stateWithIndex(i), data, 0, laneCount*SnP_laneLengthInBytes);
-        #else
-            SnP_OverwriteLanesAll(stateWithIndex(i), data, laneCount, laneOffset);
-        #endif
-        data += PlSnP_baseParallelism*laneOffset*SnP_laneLengthInBytes;
-    }
-}
-
-void PlSnP_OverwriteWithZeroes(void *states, unsigned int instanceIndex, unsigned int byteCount)
-{
-    #if (PlSnP_baseParallelism == 1)
-        SnP_OverwriteWithZeroes(stateWithIndex(instanceIndex), byteCount);
-    #else
-        SnP_OverwriteWithZeroes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanceIndex%PlSnP_baseParallelism, byteCount);
-    #endif
-}
-
-void PlSnP_PermuteAll(void *states)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_Permute(stateWithIndex(i));
-        #else
-            SnP_PermuteAll(stateWithIndex(i));
-        #endif
-    }
-}
-
-#if (defined(SnP_Permute_12rounds) || defined(SnP_PermuteAll_12rounds))
-void PlSnP_PermuteAll_12rounds(void *states)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_Permute_12rounds(stateWithIndex(i));
-        #else
-            SnP_PermuteAll_12rounds(stateWithIndex(i));
-        #endif
-    }
-}
-#endif
-
-#if (defined(SnP_Permute_Nrounds) || defined(SnP_PermuteAll_6rounds))
-void PlSnP_PermuteAll_6rounds(void *states)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_Permute_Nrounds(stateWithIndex(i), 6);
-        #else
-            SnP_PermuteAll_6rounds(stateWithIndex(i));
-        #endif
-    }
-}
-#endif
-
-#if (defined(SnP_Permute_Nrounds) || defined(SnP_PermuteAll_4rounds))
-void PlSnP_PermuteAll_4rounds(void *states)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_Permute_Nrounds(stateWithIndex(i), 4);
-        #else
-            SnP_PermuteAll_4rounds(stateWithIndex(i));
-        #endif
-    }
-}
-#endif
-
-void PlSnP_ExtractBytes(void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length)
-{
-    #if (PlSnP_baseParallelism == 1)
-        SnP_ExtractBytes(stateWithIndex(instanceIndex), data, offset, length);
-    #else
-        SnP_ExtractBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanceIndex%PlSnP_baseParallelism, data, offset, length);
-    #endif
-}
-
-void PlSnP_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_ExtractBytes(stateWithIndex(i), data, 0, laneCount*SnP_laneLengthInBytes);
-        #else
-            SnP_ExtractLanesAll(stateWithIndex(i), data, laneCount, laneOffset);
-        #endif
-        data += laneOffset*SnP_laneLengthInBytes*PlSnP_baseParallelism;
-    }
-}
-
-void PlSnP_ExtractAndAddBytes(void *states, unsigned int instanceIndex, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
-{
-    #if (PlSnP_baseParallelism == 1)
-        SnP_ExtractAndAddBytes(stateWithIndex(instanceIndex), input, output, offset, length);
-    #else
-        SnP_ExtractAndAddBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanceIndex%PlSnP_baseParallelism, input, output, offset, length);
-    #endif
-}
-
-void PlSnP_ExtractAndAddLanesAll(const void *states, const unsigned char *input, unsigned char *output, unsigned int laneCount, unsigned int laneOffset)
-{
-    unsigned int i;
-
-    for(i=0; i<PlSnP_factor; i++) {
-        #if (PlSnP_baseParallelism == 1)
-            SnP_ExtractAndAddBytes(stateWithIndex(i), input, output, 0, laneCount*SnP_laneLengthInBytes);
-        #else
-            SnP_ExtractAndAddLanesAll(stateWithIndex(i), input, output, laneCount, laneOffset);
-        #endif
-        input += laneOffset*SnP_laneLengthInBytes*PlSnP_baseParallelism;
-        output += laneOffset*SnP_laneLengthInBytes*PlSnP_baseParallelism;
-    }
-}
-
-#undef PlSnP_factor
-#undef SnP_stateOffset
-#undef stateWithIndex
-#undef JOIN0
-#undef JOIN
-#undef PlSnP_StaticInitialize
-#undef PlSnP_InitializeAll
-#undef PlSnP_AddByte
-#undef PlSnP_AddBytes
-#undef PlSnP_AddLanesAll
-#undef PlSnP_OverwriteBytes
-#undef PlSnP_OverwriteLanesAll
-#undef PlSnP_OverwriteWithZeroes
-#undef PlSnP_PermuteAll
-#undef PlSnP_ExtractBytes
-#undef PlSnP_ExtractLanesAll
-#undef PlSnP_ExtractAndAddBytes
-#undef PlSnP_ExtractAndAddLanesAll
-#undef SnP_stateAlignment
-#undef SnP_stateSizeInBytes
-#undef PlSnP_factor
-#undef SnP_stateOffset
-#undef stateWithIndex
-#undef SnP_StaticInitialize
-#undef SnP_Initialize
-#undef SnP_InitializeAll
-#undef SnP_AddByte
-#undef SnP_AddBytes
-#undef SnP_AddLanesAll
-#undef SnP_OverwriteBytes
-#undef SnP_OverwriteWithZeroes
-#undef SnP_OverwriteLanesAll
-#undef SnP_ExtractBytes
-#undef SnP_ExtractLanesAll
-#undef SnP_ExtractAndAddBytes
-#undef SnP_ExtractAndAddLanesAll

data/ext/digest/kangarootwelve/keccak/bulldozer/SnP-Relaned.h

@@ -1,140 +0,0 @@
-/*
-Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
-Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
-hereby denoted as "the implementer".
-
-For more information, feedback or questions, please refer to our website:
-https://keccak.team/
-
-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/
-
----
-
-This file contains macros that help implement a permutation in a SnP-compatible way.
-It converts an implementation that implement state input/output functions
-in a lane-oriented fashion (i.e., using SnP_AddLanes() and SnP_AddBytesInLane,
-and similarly for Overwite, Extract and ExtractAndAdd) to the byte-oriented SnP.
-Please refer to SnP-documentation.h for more details.
-*/
-
-#ifndef _SnP_Relaned_h_
-#define _SnP_Relaned_h_
-
-#define SnP_AddBytes(state, data, offset, length, SnP_AddLanes, SnP_AddBytesInLane, SnP_laneLengthInBytes) \
-    { \
-        if ((offset) == 0) { \
-            SnP_AddLanes(state, data, (length)/SnP_laneLengthInBytes); \
-            SnP_AddBytesInLane(state, \
-                (length)/SnP_laneLengthInBytes, \
-                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
-                0, \
-                (length)%SnP_laneLengthInBytes); \
-        } \
-        else { \
-            unsigned int _sizeLeft = (length); \
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
-            const unsigned char *_curData = (data); \
-            while(_sizeLeft > 0) { \
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
-                if (_bytesInLane > _sizeLeft) \
-                    _bytesInLane = _sizeLeft; \
-                SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
-                _sizeLeft -= _bytesInLane; \
-                _lanePosition++; \
-                _offsetInLane = 0; \
-                _curData += _bytesInLane; \
-            } \
-        } \
-    }
-
-#define SnP_OverwriteBytes(state, data, offset, length, SnP_OverwriteLanes, SnP_OverwriteBytesInLane, SnP_laneLengthInBytes) \
-    { \
-        if ((offset) == 0) { \
-            SnP_OverwriteLanes(state, data, (length)/SnP_laneLengthInBytes); \
-            SnP_OverwriteBytesInLane(state, \
-                (length)/SnP_laneLengthInBytes, \
-                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
-                0, \
-                (length)%SnP_laneLengthInBytes); \
-        } \
-        else { \
-            unsigned int _sizeLeft = (length); \
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
-            const unsigned char *_curData = (data); \
-            while(_sizeLeft > 0) { \
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
-                if (_bytesInLane > _sizeLeft) \
-                    _bytesInLane = _sizeLeft; \
-                SnP_OverwriteBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
-                _sizeLeft -= _bytesInLane; \
-                _lanePosition++; \
-                _offsetInLane = 0; \
-                _curData += _bytesInLane; \
-            } \
-        } \
-    }
-
-#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \
-    { \
-        if ((offset) == 0) { \
-            SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \
-            SnP_ExtractBytesInLane(state, \
-                (length)/SnP_laneLengthInBytes, \
-                (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
-                0, \
-                (length)%SnP_laneLengthInBytes); \
-        } \
-        else { \
-            unsigned int _sizeLeft = (length); \
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
-            unsigned char *_curData = (data); \
-            while(_sizeLeft > 0) { \
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
-                if (_bytesInLane > _sizeLeft) \
-                    _bytesInLane = _sizeLeft; \
-                SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
-                _sizeLeft -= _bytesInLane; \
-                _lanePosition++; \
-                _offsetInLane = 0; \
-                _curData += _bytesInLane; \
-            } \
-        } \
-    }
-
-#define SnP_ExtractAndAddBytes(state, input, output, offset, length, SnP_ExtractAndAddLanes, SnP_ExtractAndAddBytesInLane, SnP_laneLengthInBytes) \
-    { \
-        if ((offset) == 0) { \
-            SnP_ExtractAndAddLanes(state, input, output, (length)/SnP_laneLengthInBytes); \
-            SnP_ExtractAndAddBytesInLane(state, \
-                (length)/SnP_laneLengthInBytes, \
-                (input)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
-                (output)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
-                0, \
-                (length)%SnP_laneLengthInBytes); \
-        } \
-        else { \
-            unsigned int _sizeLeft = (length); \
-            unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
-            unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
-            const unsigned char *_curInput = (input); \
-            unsigned char *_curOutput = (output); \
-            while(_sizeLeft > 0) { \
-                unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
-                if (_bytesInLane > _sizeLeft) \
-                    _bytesInLane = _sizeLeft; \
-                SnP_ExtractAndAddBytesInLane(state, _lanePosition, _curInput, _curOutput, _offsetInLane, _bytesInLane); \
-                _sizeLeft -= _bytesInLane; \
-                _lanePosition++; \
-                _offsetInLane = 0; \
-                _curInput += _bytesInLane; \
-                _curOutput += _bytesInLane; \
-            } \
-        } \
-    }
-
-#endif

data/ext/digest/kangarootwelve/keccak/common/KangarooTwelve.c

@@ -1,271 +0,0 @@
-/*
-Implementation by Ronny Van Keer, hereby denoted as "the implementer".
-
-For more information, feedback or questions, please refer to our website:
-https://keccak.team/
-
-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 "KangarooTwelve.h"
-#ifndef KeccakP1600timesN_excluded
-    #include "KeccakP-1600-times2-SnP.h"
-    #include "KeccakP-1600-times4-SnP.h"
-    #include "KeccakP-1600-times8-SnP.h"
-#endif
-
-#define chunkSize       8192
-#define laneSize        8
-#define suffixLeaf      0x0B /* '110': message hop, simple padding, inner node */
-
-#define security        128
-#define capacity        (2*security)
-#define capacityInBytes (capacity/8)
-#define capacityInLanes (capacityInBytes/laneSize)
-#define rate            (1600-capacity)
-#define rateInBytes     (rate/8)
-#define rateInLanes     (rateInBytes/laneSize)
-
-#define ParallelSpongeFastLoop( Parallellism ) \
-    while ( inLen >= Parallellism * chunkSize ) { \
-        ALIGN(KeccakP1600times##Parallellism##_statesAlignment) unsigned char states[KeccakP1600times##Parallellism##_statesSizeInBytes]; \
-        unsigned char intermediate[Parallellism*capacityInBytes]; \
-        unsigned int localBlockLen = chunkSize; \
-        const unsigned char * localInput = input; \
-        unsigned int i; \
-        unsigned int fastLoopOffset; \
-        \
-        KeccakP1600times##Parallellism##_StaticInitialize(); \
-        KeccakP1600times##Parallellism##_InitializeAll(states); \
-        fastLoopOffset = KeccakP1600times##Parallellism##_12rounds_FastLoop_Absorb(states, rateInLanes, chunkSize / laneSize, rateInLanes, localInput, Parallellism * chunkSize); \
-        localBlockLen -= fastLoopOffset; \
-        localInput += fastLoopOffset; \
-        for ( i = 0; i < Parallellism; ++i, localInput += chunkSize ) { \
-            KeccakP1600times##Parallellism##_AddBytes(states, i, localInput, 0, localBlockLen); \
-            KeccakP1600times##Parallellism##_AddByte(states, i, suffixLeaf, localBlockLen); \
-            KeccakP1600times##Parallellism##_AddByte(states, i, 0x80, rateInBytes-1); \
-        } \
-        KeccakP1600times##Parallellism##_PermuteAll_12rounds(states); \
-        input += Parallellism * chunkSize; \
-        inLen -= Parallellism * chunkSize; \
-        ktInstance->blockNumber += Parallellism; \
-        KeccakP1600times##Parallellism##_ExtractLanesAll(states, intermediate, capacityInLanes, capacityInLanes ); \
-        if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, Parallellism * capacityInBytes) != 0) return 1; \
-    }
-
-#define ParallelSpongeLoop( Parallellism ) \
-    while ( inLen >= Parallellism * chunkSize ) { \
-        ALIGN(KeccakP1600times##Parallellism##_statesAlignment) unsigned char states[KeccakP1600times##Parallellism##_statesSizeInBytes]; \
-        unsigned char intermediate[Parallellism*capacityInBytes]; \
-        unsigned int localBlockLen = chunkSize; \
-        const unsigned char * localInput = input; \
-        unsigned int i; \
-        \
-        KeccakP1600times##Parallellism##_StaticInitialize(); \
-        KeccakP1600times##Parallellism##_InitializeAll(states); \
-        while(localBlockLen >= rateInBytes) { \
-            KeccakP1600times##Parallellism##_AddLanesAll(states, localInput, rateInLanes, chunkSize / laneSize); \
-            KeccakP1600times##Parallellism##_PermuteAll_12rounds(states); \
-            localBlockLen -= rateInBytes; \
-            localInput += rateInBytes; \
-           } \
-        for ( i = 0; i < Parallellism; ++i, localInput += chunkSize ) { \
-            KeccakP1600times##Parallellism##_AddBytes(states, i, localInput, 0, localBlockLen); \
-            KeccakP1600times##Parallellism##_AddByte(states, i, suffixLeaf, localBlockLen); \
-            KeccakP1600times##Parallellism##_AddByte(states, i, 0x80, rateInBytes-1); \
-        } \
-        KeccakP1600times##Parallellism##_PermuteAll_12rounds(states); \
-        input += Parallellism * chunkSize; \
-        inLen -= Parallellism * chunkSize; \
-        ktInstance->blockNumber += Parallellism; \
-        KeccakP1600times##Parallellism##_ExtractLanesAll(states, intermediate, capacityInLanes, capacityInLanes ); \
-        if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, Parallellism * capacityInBytes) != 0) return 1; \
-    }
-
-static unsigned int right_encode( unsigned char * encbuf, size_t value )
-{
-    unsigned int n, i;
-    size_t v;
-
-    for ( v = value, n = 0; v && (n < sizeof(size_t)); ++n, v >>= 8 )
-        ; /* empty */
-    for ( i = 1; i <= n; ++i )
-        encbuf[i-1] = (unsigned char)(value >> (8 * (n-i)));
-    encbuf[n] = (unsigned char)n;
-    return n + 1;
-}
-
-int KangarooTwelve_Initialize(KangarooTwelve_Instance *ktInstance, size_t outputLen)
-{
-    ktInstance->fixedOutputLength = outputLen;
-    ktInstance->queueAbsorbedLen = 0;
-    ktInstance->blockNumber = 0;
-    ktInstance->phase = ABSORBING;
-    return KeccakWidth1600_12rounds_SpongeInitialize(&ktInstance->finalNode, rate, capacity);
-}
-
-int KangarooTwelve_Update(KangarooTwelve_Instance *ktInstance, const unsigned char *input, size_t inLen)
-{
-    if (ktInstance->phase != ABSORBING)
-        return 1;
-
-    if ( ktInstance->blockNumber == 0 ) {
-        /* First block, absorb in final node */
-        unsigned int len = (inLen < (chunkSize - ktInstance->queueAbsorbedLen)) ? inLen : (chunkSize - ktInstance->queueAbsorbedLen);
-        if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, input, len) != 0)
-            return 1;
-        input += len;
-        inLen -= len;
-        ktInstance->queueAbsorbedLen += len;
-        if ( (ktInstance->queueAbsorbedLen == chunkSize) && (inLen != 0) ) {
-            /* First block complete and more input data available, finalize it */
-            const unsigned char padding = 0x03; /* '110^6': message hop, simple padding */
-            ktInstance->queueAbsorbedLen = 0;
-            ktInstance->blockNumber = 1;
-            if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, &padding, 1) != 0)
-                return 1;
-            ktInstance->finalNode.byteIOIndex = (ktInstance->finalNode.byteIOIndex + 7) & ~7; /* Zero padding up to 64 bits */
-        }
-    }
-    else if ( ktInstance->queueAbsorbedLen != 0 ) {
-        /* There is data in the queue, absorb further in queue until block complete */
-        unsigned int len = (inLen < (chunkSize - ktInstance->queueAbsorbedLen)) ? inLen : (chunkSize - ktInstance->queueAbsorbedLen);
-        if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->queueNode, input, len) != 0)
-            return 1;
-        input += len;
-        inLen -= len;
-        ktInstance->queueAbsorbedLen += len;
-        if ( ktInstance->queueAbsorbedLen == chunkSize ) {
-            unsigned char intermediate[capacityInBytes];
-            ktInstance->queueAbsorbedLen = 0;
-            ++ktInstance->blockNumber;
-            if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->queueNode, suffixLeaf) != 0)
-                return 1;
-            if (KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->queueNode, intermediate, capacityInBytes) != 0)
-                return 1;
-            if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, capacityInBytes) != 0)
-                return 1;
-        }
-    }
-
-    #if defined(KeccakP1600times8_implementation) && !defined(KeccakP1600times8_isFallback)
-    #if defined(KeccakP1600times8_12rounds_FastLoop_supported)
-    ParallelSpongeFastLoop( 8 )
-    #else
-    ParallelSpongeLoop( 8 )
-    #endif
-    #endif
-
-    #if defined(KeccakP1600times4_implementation) && !defined(KeccakP1600times4_isFallback)
-    #if defined(KeccakP1600times4_12rounds_FastLoop_supported)
-    ParallelSpongeFastLoop( 4 )
-    #else
-    ParallelSpongeLoop( 4 )
-    #endif
-    #endif
-
-    #if defined(KeccakP1600times2_implementation) && !defined(KeccakP1600times2_isFallback)
-    #if defined(KeccakP1600times2_12rounds_FastLoop_supported)
-    ParallelSpongeFastLoop( 2 )
-    #else
-    ParallelSpongeLoop( 2 )
-    #endif
-    #endif
-
-    while ( inLen > 0 ) {
-        unsigned int len = (inLen < chunkSize) ? inLen : chunkSize;
-        if (KeccakWidth1600_12rounds_SpongeInitialize(&ktInstance->queueNode, rate, capacity) != 0)
-            return 1;
-        if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->queueNode, input, len) != 0)
-            return 1;
-        input += len;
-        inLen -= len;
-        if ( len == chunkSize ) {
-            unsigned char intermediate[capacityInBytes];
-            ++ktInstance->blockNumber;
-            if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->queueNode, suffixLeaf) != 0)
-                return 1;
-            if (KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->queueNode, intermediate, capacityInBytes) != 0)
-                return 1;
-            if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, capacityInBytes) != 0)
-                return 1;
-        }
-        else
-            ktInstance->queueAbsorbedLen = len;
-    }
-
-    return 0;
-}
-
-int KangarooTwelve_Final(KangarooTwelve_Instance *ktInstance, unsigned char * output, const unsigned char * customization, size_t customLen)
-{
-    unsigned char encbuf[sizeof(size_t)+1+2];
-    unsigned char padding;
-
-    if (ktInstance->phase != ABSORBING)
-        return 1;
-
-    /* Absorb customization | right_encode(customLen) */
-    if ((customLen != 0) && (KangarooTwelve_Update(ktInstance, customization, customLen) != 0))
-        return 1;
-    if (KangarooTwelve_Update(ktInstance, encbuf, right_encode(encbuf, customLen)) != 0)
-        return 1;
-
-    if ( ktInstance->blockNumber == 0 ) {
-        /* Non complete first block in final node, pad it */
-        padding = 0x07; /*  '11': message hop, final node */
-    }
-    else {
-        unsigned int n;
-
-        if ( ktInstance->queueAbsorbedLen != 0 ) {
-            /* There is data in the queue node */
-            unsigned char intermediate[capacityInBytes];
-            ++ktInstance->blockNumber;
-            if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->queueNode, suffixLeaf) != 0)
-                return 1;
-            if (KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->queueNode, intermediate, capacityInBytes) != 0)
-                return 1;
-            if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, intermediate, capacityInBytes) != 0)
-                return 1;
-        }
-        --ktInstance->blockNumber; /* Absorb right_encode(number of Chaining Values) || 0xFF || 0xFF */
-        n = right_encode(encbuf, ktInstance->blockNumber);
-        encbuf[n++] = 0xFF;
-        encbuf[n++] = 0xFF;
-        if (KeccakWidth1600_12rounds_SpongeAbsorb(&ktInstance->finalNode, encbuf, n) != 0)
-            return 1;
-        padding = 0x06; /* '01': chaining hop, final node */
-    }
-    if (KeccakWidth1600_12rounds_SpongeAbsorbLastFewBits(&ktInstance->finalNode, padding) != 0)
-        return 1;
-    if ( ktInstance->fixedOutputLength != 0 ) {
-        ktInstance->phase = FINAL;
-        return KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->finalNode, output, ktInstance->fixedOutputLength);
-    }
-    ktInstance->phase = SQUEEZING;
-    return 0;
-}
-
-int KangarooTwelve_Squeeze(KangarooTwelve_Instance *ktInstance, unsigned char * output, size_t outputLen)
-{
-    if (ktInstance->phase != SQUEEZING)
-        return 1;
-    return KeccakWidth1600_12rounds_SpongeSqueeze(&ktInstance->finalNode, output, outputLen);
-}
-
-int KangarooTwelve( const unsigned char * input, size_t inLen, unsigned char * output, size_t outLen, const unsigned char * customization, size_t customLen )
-{
-    KangarooTwelve_Instance ktInstance;
-
-    if (outLen == 0)
-        return 1;
-    if (KangarooTwelve_Initialize(&ktInstance, outLen) != 0)
-        return 1;
-    if (KangarooTwelve_Update(&ktInstance, input, inLen) != 0)
-        return 1;
-    return KangarooTwelve_Final(&ktInstance, output, customization, customLen);
-}