sleeping_kangaroo12 0.0.1 → 0.0.5

data/ext/{xkcp/lib/low/KeccakP-1600/common/KeccakP-1600-64.macros → k12/lib/Optimized64/KeccakP-1600-opt64.c}

@@ -1,5 +1,5 @@
 /*
-The eXtended Keccak Code Package (XKCP)
+K12 based on the eXtended Keccak Code Package (XKCP)
 https://github.com/XKCP/XKCP
 
 The Keccak-p permutations, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche.
@@ -12,8 +12,241 @@ 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/
+
+---
+
+Please refer to the XKCP for more details.
 */
 
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "brg_endian.h"
+#include <KeccakP-1600-SnP.h>
+
+#define KeccakP1600_opt64_implementation_config "all rounds unrolled"
+#define KeccakP1600_opt64_fullUnrolling
+/* Or */
+/*
+#define KeccakP1600_opt64_implementation_config "6 rounds unrolled"
+#define KeccakP1600_opt64_unrolling 6
+*/
+/* Or */
+/*
+#define KeccakP1600_opt64_implementation_config "lane complementing, 6 rounds unrolled"
+#define KeccakP1600_opt64_unrolling 6
+#define KeccakP1600_opt64_useLaneComplementing
+*/
+/* Or */
+/*
+#define KeccakP1600_opt64_implementation_config "lane complementing, all rounds unrolled"
+#define KeccakP1600_opt64_fullUnrolling
+#define KeccakP1600_opt64_useLaneComplementing
+*/
+/* Or */
+/*
+#define KeccakP1600_opt64_implementation_config "lane complementing, all rounds unrolled, using SHLD for rotations"
+#define KeccakP1600_opt64_fullUnrolling
+#define KeccakP1600_opt64_useLaneComplementing
+#define KeccakP1600_opt64_useSHLD
+*/
+
+#if defined(KeccakP1600_opt64_useLaneComplementing)
+#define UseBebigokimisa
+#endif
+
+#if defined(_MSC_VER)
+#define ROL64(a, offset) _rotl64(a, offset)
+#elif defined(KeccakP1600_opt64_useSHLD)
+    #define ROL64(x,N) ({ \
+    register uint64_t __out; \
+    register uint64_t __in = x; \
+    __asm__ ("shld %2,%0,%0" : "=r"(__out) : "0"(__in), "i"(N)); \
+    __out; \
+    })
+#else
+#define ROL64(a, offset) ((((uint64_t)a) << offset) ^ (((uint64_t)a) >> (64-offset)))
+#endif
+
+#ifdef KeccakP1600_opt64_fullUnrolling
+#define FullUnrolling
+#else
+#define Unrolling KeccakP1600_opt64_unrolling
+#endif
+
+static const uint64_t KeccakF1600RoundConstants[24] = {
+    0x0000000000000001ULL,
+    0x0000000000008082ULL,
+    0x800000000000808aULL,
+    0x8000000080008000ULL,
+    0x000000000000808bULL,
+    0x0000000080000001ULL,
+    0x8000000080008081ULL,
+    0x8000000000008009ULL,
+    0x000000000000008aULL,
+    0x0000000000000088ULL,
+    0x0000000080008009ULL,
+    0x000000008000000aULL,
+    0x000000008000808bULL,
+    0x800000000000008bULL,
+    0x8000000000008089ULL,
+    0x8000000000008003ULL,
+    0x8000000000008002ULL,
+    0x8000000000000080ULL,
+    0x000000000000800aULL,
+    0x800000008000000aULL,
+    0x8000000080008081ULL,
+    0x8000000000008080ULL,
+    0x0000000080000001ULL,
+    0x8000000080008008ULL };
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_Initialize(void *state)
+{
+    memset(state, 0, 200);
+#ifdef KeccakP1600_opt64_useLaneComplementing
+    ((uint64_t*)state)[ 1] = ~(uint64_t)0;
+    ((uint64_t*)state)[ 2] = ~(uint64_t)0;
+    ((uint64_t*)state)[ 8] = ~(uint64_t)0;
+    ((uint64_t*)state)[12] = ~(uint64_t)0;
+    ((uint64_t*)state)[17] = ~(uint64_t)0;
+    ((uint64_t*)state)[20] = ~(uint64_t)0;
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+    uint64_t lane;
+    if (length == 0)
+        return;
+    if (length == 1)
+        lane = data[0];
+    else {
+        lane = 0;
+        memcpy(&lane, data, length);
+    }
+    lane <<= offset*8;
+#else
+    uint64_t lane = 0;
+    unsigned int i;
+    for(i=0; i<length; i++)
+        lane |= ((uint64_t)data[i]) << ((i+offset)*8);
+#endif
+    ((uint64_t*)state)[lanePosition] ^= lane;
+}
+
+/* ---------------------------------------------------------------- */
+
+static void KeccakP1600_opt64_AddLanes(void *state, const unsigned char *data, unsigned int laneCount)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+    unsigned int i = 0;
+#ifdef NO_MISALIGNED_ACCESSES
+    /* If either pointer is misaligned, fall back to byte-wise xor. */
+    if (((((uintptr_t)state) & 7) != 0) || ((((uintptr_t)data) & 7) != 0)) {
+      for (i = 0; i < laneCount * 8; i++) {
+        ((unsigned char*)state)[i] ^= data[i];
+      }
+    }
+    else
+#endif
+    {
+      /* Otherwise... */
+      for( ; (i+8)<=laneCount; i+=8) {
+          ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+          ((uint64_t*)state)[i+1] ^= ((uint64_t*)data)[i+1];
+          ((uint64_t*)state)[i+2] ^= ((uint64_t*)data)[i+2];
+          ((uint64_t*)state)[i+3] ^= ((uint64_t*)data)[i+3];
+          ((uint64_t*)state)[i+4] ^= ((uint64_t*)data)[i+4];
+          ((uint64_t*)state)[i+5] ^= ((uint64_t*)data)[i+5];
+          ((uint64_t*)state)[i+6] ^= ((uint64_t*)data)[i+6];
+          ((uint64_t*)state)[i+7] ^= ((uint64_t*)data)[i+7];
+      }
+      for( ; (i+4)<=laneCount; i+=4) {
+          ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+          ((uint64_t*)state)[i+1] ^= ((uint64_t*)data)[i+1];
+          ((uint64_t*)state)[i+2] ^= ((uint64_t*)data)[i+2];
+          ((uint64_t*)state)[i+3] ^= ((uint64_t*)data)[i+3];
+      }
+      for( ; (i+2)<=laneCount; i+=2) {
+          ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+          ((uint64_t*)state)[i+1] ^= ((uint64_t*)data)[i+1];
+      }
+      if (i<laneCount) {
+          ((uint64_t*)state)[i+0] ^= ((uint64_t*)data)[i+0];
+      }
+    }
+#else
+    unsigned int i;
+    const uint8_t *curData = data;
+    for(i=0; i<laneCount; i++, curData+=8) {
+        uint64_t lane = (uint64_t)curData[0]
+            | ((uint64_t)curData[1] <<  8)
+            | ((uint64_t)curData[2] << 16)
+            | ((uint64_t)curData[3] << 24)
+            | ((uint64_t)curData[4] << 32)
+            | ((uint64_t)curData[5] << 40)
+            | ((uint64_t)curData[6] << 48)
+            | ((uint64_t)curData[7] << 56);
+        ((uint64_t*)state)[i] ^= lane;
+    }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_AddByte(void *state, unsigned char byte, unsigned int offset)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+    ((unsigned char*)(state))[offset] ^= byte;
+#else
+    uint64_t lane = byte;
+    lane <<= (offset%8)*8;
+    ((uint64_t*)state)[offset/8] ^= lane;
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+#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; \
+            } \
+        } \
+    }
+
+void KeccakP1600_opt64_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+    SnP_AddBytes(state, data, offset, length, KeccakP1600_opt64_AddLanes, KeccakP1600_opt64_AddBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
 #define declareABCDE \
     uint64_t Aba, Abe, Abi, Abo, Abu; \
     uint64_t Aga, Age, Agi, Ago, Agu; \
@@ -539,6 +772,193 @@ http://creativecommons.org/publicdomain/zero/1.0/
     X##so = Y##so; \
     X##su = Y##su; \
 
+#if ((defined(FullUnrolling)) || (Unrolling == 12))
+#define rounds12 \
+    prepareTheta \
+    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) \
+
+#elif (Unrolling == 6)
+#define rounds12 \
+    prepareTheta \
+    for(i=12; 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) \
+    } \
+
+#elif (Unrolling == 4)
+#define rounds12 \
+    prepareTheta \
+    for(i=12; i<24; i+=4) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+    } \
+
+#elif (Unrolling == 3)
+#define rounds12 \
+    prepareTheta \
+    for(i=12; i<24; i+=3) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+        thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+        copyStateVariables(A, E) \
+    } \
+
+#elif (Unrolling == 2)
+#define rounds12 \
+    prepareTheta \
+    for(i=12; i<24; i+=2) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+    } \
+
+#elif (Unrolling == 1)
+#define rounds12 \
+    prepareTheta \
+    for(i=12; i<24; i++) { \
+        thetaRhoPiChiIotaPrepareTheta(i  , A, E) \
+        copyStateVariables(A, E) \
+    } \
+
+#else
+#error "Unrolling is not correctly specified!"
+#endif
+
+void KeccakP1600_opt64_Permute_12rounds(void *state)
+{
+    declareABCDE
+    #ifndef KeccakP1600_opt64_fullUnrolling
+    unsigned int i;
+    #endif
+    uint64_t *stateAsLanes = (uint64_t*)state;
+
+    copyFromState(A, stateAsLanes)
+    rounds12
+    copyToState(stateAsLanes, A)
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_opt64_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length)
+{
+    uint64_t lane = ((uint64_t*)state)[lanePosition];
+#ifdef KeccakP1600_opt64_useLaneComplementing
+    if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
+        lane = ~lane;
+#endif
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+    {
+        uint64_t lane1[1];
+        lane1[0] = lane;
+        memcpy(data, (uint8_t*)lane1+offset, length);
+    }
+#else
+    unsigned int i;
+    lane >>= offset*8;
+    for(i=0; i<length; i++) {
+        data[i] = lane & 0xFF;
+        lane >>= 8;
+    }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
+static void fromWordToBytes(uint8_t *bytes, const uint64_t word)
+{
+    unsigned int i;
+
+    for(i=0; i<(64/8); i++)
+        bytes[i] = (word >> (8*i)) & 0xFF;
+}
+#endif
+
+void KeccakP1600_opt64_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+    memcpy(data, state, laneCount*8);
+#else
+    unsigned int i;
+
+    for(i=0; i<laneCount; i++)
+        fromWordToBytes(data+(i*8), ((const uint64_t*)state)[i]);
+#endif
+#ifdef KeccakP1600_opt64_useLaneComplementing
+    if (laneCount > 1) {
+        ((uint64_t*)data)[ 1] = ~((uint64_t*)data)[ 1];
+        if (laneCount > 2) {
+            ((uint64_t*)data)[ 2] = ~((uint64_t*)data)[ 2];
+            if (laneCount > 8) {
+                ((uint64_t*)data)[ 8] = ~((uint64_t*)data)[ 8];
+                if (laneCount > 12) {
+                    ((uint64_t*)data)[12] = ~((uint64_t*)data)[12];
+                    if (laneCount > 17) {
+                        ((uint64_t*)data)[17] = ~((uint64_t*)data)[17];
+                        if (laneCount > 20) {
+                            ((uint64_t*)data)[20] = ~((uint64_t*)data)[20];
+                        }
+                    }
+                }
+            }
+        }
+    }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+#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; \
+            } \
+        } \
+    }
+
+void KeccakP1600_opt64_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+{
+    SnP_ExtractBytes(state, data, offset, length, KeccakP1600_opt64_ExtractLanes, KeccakP1600_opt64_ExtractBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
 #define HTOLE64(x) (x)
 #else
@@ -577,172 +997,30 @@ http://creativecommons.org/publicdomain/zero/1.0/
         X##mu ^= HTOLE64(input[19]); \
         X##sa ^= HTOLE64(input[20]); \
     } \
-    else if (laneCount < 16) { \
-        if (laneCount < 8) { \
-            if (laneCount < 4) { \
-                if (laneCount < 2) { \
-                    if (laneCount < 1) { \
-                    } \
-                    else { \
-                        X##ba ^= HTOLE64(input[ 0]); \
-                    } \
-                } \
-                else { \
-                    X##ba ^= HTOLE64(input[ 0]); \
-                    X##be ^= HTOLE64(input[ 1]); \
-                    if (laneCount < 3) { \
-                    } \
-                    else { \
-                        X##bi ^= HTOLE64(input[ 2]); \
-                    } \
-                } \
-            } \
-            else { \
-                X##ba ^= HTOLE64(input[ 0]); \
-                X##be ^= HTOLE64(input[ 1]); \
-                X##bi ^= HTOLE64(input[ 2]); \
-                X##bo ^= HTOLE64(input[ 3]); \
-                if (laneCount < 6) { \
-                    if (laneCount < 5) { \
-                    } \
-                    else { \
-                        X##bu ^= HTOLE64(input[ 4]); \
-                    } \
-                } \
-                else { \
-                    X##bu ^= HTOLE64(input[ 4]); \
-                    X##ga ^= HTOLE64(input[ 5]); \
-                    if (laneCount < 7) { \
-                    } \
-                    else { \
-                        X##ge ^= HTOLE64(input[ 6]); \
-                    } \
-                } \
-            } \
-        } \
-        else { \
-            X##ba ^= HTOLE64(input[ 0]); \
-            X##be ^= HTOLE64(input[ 1]); \
-            X##bi ^= HTOLE64(input[ 2]); \
-            X##bo ^= HTOLE64(input[ 3]); \
-            X##bu ^= HTOLE64(input[ 4]); \
-            X##ga ^= HTOLE64(input[ 5]); \
-            X##ge ^= HTOLE64(input[ 6]); \
-            X##gi ^= HTOLE64(input[ 7]); \
-            if (laneCount < 12) { \
-                if (laneCount < 10) { \
-                    if (laneCount < 9) { \
-                    } \
-                    else { \
-                        X##go ^= HTOLE64(input[ 8]); \
-                    } \
-                } \
-                else { \
-                    X##go ^= HTOLE64(input[ 8]); \
-                    X##gu ^= HTOLE64(input[ 9]); \
-                    if (laneCount < 11) { \
-                    } \
-                    else { \
-                        X##ka ^= HTOLE64(input[10]); \
-                    } \
-                } \
-            } \
-            else { \
-                X##go ^= HTOLE64(input[ 8]); \
-                X##gu ^= HTOLE64(input[ 9]); \
-                X##ka ^= HTOLE64(input[10]); \
-                X##ke ^= HTOLE64(input[11]); \
-                if (laneCount < 14) { \
-                    if (laneCount < 13) { \
-                    } \
-                    else { \
-                        X##ki ^= HTOLE64(input[12]); \
-                    } \
-                } \
-                else { \
-                    X##ki ^= HTOLE64(input[12]); \
-                    X##ko ^= HTOLE64(input[13]); \
-                    if (laneCount < 15) { \
-                    } \
-                    else { \
-                        X##ku ^= HTOLE64(input[14]); \
-                    } \
-                } \
-            } \
-        } \
-    } \
-    else { \
-        X##ba ^= HTOLE64(input[ 0]); \
-        X##be ^= HTOLE64(input[ 1]); \
-        X##bi ^= HTOLE64(input[ 2]); \
-        X##bo ^= HTOLE64(input[ 3]); \
-        X##bu ^= HTOLE64(input[ 4]); \
-        X##ga ^= HTOLE64(input[ 5]); \
-        X##ge ^= HTOLE64(input[ 6]); \
-        X##gi ^= HTOLE64(input[ 7]); \
-        X##go ^= HTOLE64(input[ 8]); \
-        X##gu ^= HTOLE64(input[ 9]); \
-        X##ka ^= HTOLE64(input[10]); \
-        X##ke ^= HTOLE64(input[11]); \
-        X##ki ^= HTOLE64(input[12]); \
-        X##ko ^= HTOLE64(input[13]); \
-        X##ku ^= HTOLE64(input[14]); \
-        X##ma ^= HTOLE64(input[15]); \
-        if (laneCount < 24) { \
-            if (laneCount < 20) { \
-                if (laneCount < 18) { \
-                    if (laneCount < 17) { \
-                    } \
-                    else { \
-                        X##me ^= HTOLE64(input[16]); \
-                    } \
-                } \
-                else { \
-                    X##me ^= HTOLE64(input[16]); \
-                    X##mi ^= HTOLE64(input[17]); \
-                    if (laneCount < 19) { \
-                    } \
-                    else { \
-                        X##mo ^= HTOLE64(input[18]); \
-                    } \
-                } \
-            } \
-            else { \
-                X##me ^= HTOLE64(input[16]); \
-                X##mi ^= HTOLE64(input[17]); \
-                X##mo ^= HTOLE64(input[18]); \
-                X##mu ^= HTOLE64(input[19]); \
-                if (laneCount < 22) { \
-                    if (laneCount < 21) { \
-                    } \
-                    else { \
-                        X##sa ^= HTOLE64(input[20]); \
-                    } \
-                } \
-                else { \
-                    X##sa ^= HTOLE64(input[20]); \
-                    X##se ^= HTOLE64(input[21]); \
-                    if (laneCount < 23) { \
-                    } \
-                    else { \
-                        X##si ^= HTOLE64(input[22]); \
-                    } \
-                } \
-            } \
-        } \
-        else { \
-            X##me ^= HTOLE64(input[16]); \
-            X##mi ^= HTOLE64(input[17]); \
-            X##mo ^= HTOLE64(input[18]); \
-            X##mu ^= HTOLE64(input[19]); \
-            X##sa ^= HTOLE64(input[20]); \
-            X##se ^= HTOLE64(input[21]); \
-            X##si ^= HTOLE64(input[22]); \
-            X##so ^= HTOLE64(input[23]); \
-            if (laneCount < 25) { \
-            } \
-            else { \
-                X##su ^= HTOLE64(input[24]); \
-            } \
-        } \
+
+#include <assert.h>
+
+size_t KeccakP1600_opt64_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen)
+{
+    size_t originalDataByteLen = dataByteLen;
+    declareABCDE
+    #ifndef KeccakP1600_opt64_fullUnrolling
+    unsigned int i;
+    #endif
+    uint64_t *stateAsLanes = (uint64_t*)state;
+    uint64_t *inDataAsLanes = (uint64_t*)data;
+
+    assert(laneCount == 21);
+
+    #define laneCount 21
+    copyFromState(A, stateAsLanes)
+    while(dataByteLen >= laneCount*8) {
+        addInput(A, inDataAsLanes, laneCount)
+        rounds12
+        inDataAsLanes += laneCount;
+        dataByteLen -= laneCount*8;
     }
+    #undef laneCount
+    copyToState(stateAsLanes, A)
+    return originalDataByteLen - dataByteLen;
+}