sleeping_kangaroo12 0.0.3 → 0.0.4

data/ext/k12/lib/Optimized64/KeccakP-1600-timesN-AVX512.c

@@ -0,0 +1,458 @@
+/*
+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.
+
+Implementation by Gilles Van Assche and Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team 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/
+
+---
+
+Please refer to the XKCP for more details.
+*/
+
+#include <stdint.h>
+#include <emmintrin.h>
+#include <immintrin.h>
+#include "KeccakP-1600-SnP.h"
+#include "align.h"
+
+#define AVX512alignment 64
+
+#define LOAD4_32(a,b,c,d)           _mm_set_epi32((uint64_t)(a), (uint32_t)(b), (uint32_t)(c), (uint32_t)(d))
+#define LOAD8_32(a,b,c,d,e,f,g,h)   _mm256_set_epi32((uint64_t)(a), (uint32_t)(b), (uint32_t)(c), (uint32_t)(d), (uint32_t)(e), (uint32_t)(f), (uint32_t)(g), (uint32_t)(h))
+#define LOAD_GATHER2_64(idx,p)      _mm_i32gather_epi64( (const void*)(p), idx, 8)
+#define LOAD_GATHER4_64(idx,p)      _mm256_i32gather_epi64( (const void*)(p), idx, 8)
+#define LOAD_GATHER8_64(idx,p)      _mm512_i32gather_epi64( idx, (const void*)(p), 8)
+#define STORE_SCATTER8_64(p,idx, v) _mm512_i32scatter_epi64( (void*)(p), idx, v, 8)
+
+
+/* Keccak-p[1600]×2 */
+
+#define XOR(a,b)                    _mm_xor_si128(a,b)
+#define XOReq(a, b)                 a = _mm_xor_si128(a, b)
+#define XOR3(a,b,c)                 _mm_ternarylogic_epi64(a,b,c,0x96)
+#define XOR5(a,b,c,d,e)             XOR3(XOR3(a,b,c),d,e)
+#define ROL(a,offset)               _mm_rol_epi64(a,offset)
+#define Chi(a,b,c)                  _mm_ternarylogic_epi64(a,b,c,0xD2)
+#define CONST_64(a)                 _mm_set1_epi64x(a)
+#define LOAD6464(a, b)              _mm_set_epi64x(a, b)
+#define STORE128u(a, b)             _mm_storeu_si128((__m128i *)&(a), b)
+#define UNPACKL( a, b )             _mm_unpacklo_epi64((a), (b))
+#define UNPACKH( a, b )             _mm_unpackhi_epi64((a), (b))
+#define ZERO()              _mm_setzero_si128()
+
+static ALIGN(AVX512alignment) const uint64_t KeccakP1600RoundConstants[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};
+
+#define KeccakP_DeclareVars(type) \
+    type    _Ba, _Be, _Bi, _Bo, _Bu; \
+    type    _Da, _De, _Di, _Do, _Du; \
+    type    _ba, _be, _bi, _bo, _bu; \
+    type    _ga, _ge, _gi, _go, _gu; \
+    type    _ka, _ke, _ki, _ko, _ku; \
+    type    _ma, _me, _mi, _mo, _mu; \
+    type    _sa, _se, _si, _so, _su
+
+#define KeccakP_ThetaRhoPiChi( _L1, _L2, _L3, _L4, _L5, _Bb1, _Bb2, _Bb3, _Bb4, _Bb5, _Rr1, _Rr2, _Rr3, _Rr4, _Rr5 ) \
+    _Bb1 = XOR(_L1, _Da); \
+    _Bb2 = XOR(_L2, _De); \
+    _Bb3 = XOR(_L3, _Di); \
+    _Bb4 = XOR(_L4, _Do); \
+    _Bb5 = XOR(_L5, _Du); \
+    if (_Rr1 != 0) _Bb1 = ROL(_Bb1, _Rr1); \
+    _Bb2 = ROL(_Bb2, _Rr2); \
+    _Bb3 = ROL(_Bb3, _Rr3); \
+    _Bb4 = ROL(_Bb4, _Rr4); \
+    _Bb5 = ROL(_Bb5, _Rr5); \
+    _L1 = Chi( _Ba, _Be, _Bi); \
+    _L2 = Chi( _Be, _Bi, _Bo); \
+    _L3 = Chi( _Bi, _Bo, _Bu); \
+    _L4 = Chi( _Bo, _Bu, _Ba); \
+    _L5 = Chi( _Bu, _Ba, _Be);
+
+#define KeccakP_ThetaRhoPiChiIota0( _L1, _L2, _L3, _L4, _L5, _rc ) \
+    _Ba = XOR5( _ba, _ga, _ka, _ma, _sa ); /* Theta effect */ \
+    _Be = XOR5( _be, _ge, _ke, _me, _se ); \
+    _Bi = XOR5( _bi, _gi, _ki, _mi, _si ); \
+    _Bo = XOR5( _bo, _go, _ko, _mo, _so ); \
+    _Bu = XOR5( _bu, _gu, _ku, _mu, _su ); \
+    _Da = ROL( _Be, 1 ); \
+    _De = ROL( _Bi, 1 ); \
+    _Di = ROL( _Bo, 1 ); \
+    _Do = ROL( _Bu, 1 ); \
+    _Du = ROL( _Ba, 1 ); \
+    _Da = XOR( _Da, _Bu ); \
+    _De = XOR( _De, _Ba ); \
+    _Di = XOR( _Di, _Be ); \
+    _Do = XOR( _Do, _Bi ); \
+    _Du = XOR( _Du, _Bo ); \
+    KeccakP_ThetaRhoPiChi( _L1, _L2, _L3, _L4, _L5, _Ba, _Be, _Bi, _Bo, _Bu,  0, 44, 43, 21, 14 ); \
+    _L1 = XOR(_L1, _rc) /* Iota */
+
+#define KeccakP_ThetaRhoPiChi1( _L1, _L2, _L3, _L4, _L5 ) \
+    KeccakP_ThetaRhoPiChi( _L1, _L2, _L3, _L4, _L5, _Bi, _Bo, _Bu, _Ba, _Be,  3, 45, 61, 28, 20 )
+
+#define KeccakP_ThetaRhoPiChi2( _L1, _L2, _L3, _L4, _L5 ) \
+    KeccakP_ThetaRhoPiChi( _L1, _L2, _L3, _L4, _L5, _Bu, _Ba, _Be, _Bi, _Bo, 18,  1,  6, 25,  8 )
+
+#define KeccakP_ThetaRhoPiChi3( _L1, _L2, _L3, _L4, _L5 ) \
+    KeccakP_ThetaRhoPiChi( _L1, _L2, _L3, _L4, _L5, _Be, _Bi, _Bo, _Bu, _Ba, 36, 10, 15, 56, 27 )
+
+#define KeccakP_ThetaRhoPiChi4( _L1, _L2, _L3, _L4, _L5 ) \
+    KeccakP_ThetaRhoPiChi( _L1, _L2, _L3, _L4, _L5, _Bo, _Bu, _Ba, _Be, _Bi, 41,  2, 62, 55, 39 )
+
+#define KeccakP_4rounds( i ) \
+    KeccakP_ThetaRhoPiChiIota0(_ba, _ge, _ki, _mo, _su, CONST_64(KeccakP1600RoundConstants[i]) ); \
+    KeccakP_ThetaRhoPiChi1(    _ka, _me, _si, _bo, _gu ); \
+    KeccakP_ThetaRhoPiChi2(    _sa, _be, _gi, _ko, _mu ); \
+    KeccakP_ThetaRhoPiChi3(    _ga, _ke, _mi, _so, _bu ); \
+    KeccakP_ThetaRhoPiChi4(    _ma, _se, _bi, _go, _ku ); \
+\
+    KeccakP_ThetaRhoPiChiIota0(_ba, _me, _gi, _so, _ku, CONST_64(KeccakP1600RoundConstants[i+1]) ); \
+    KeccakP_ThetaRhoPiChi1(    _sa, _ke, _bi, _mo, _gu ); \
+    KeccakP_ThetaRhoPiChi2(    _ma, _ge, _si, _ko, _bu ); \
+    KeccakP_ThetaRhoPiChi3(    _ka, _be, _mi, _go, _su ); \
+    KeccakP_ThetaRhoPiChi4(    _ga, _se, _ki, _bo, _mu ); \
+\
+    KeccakP_ThetaRhoPiChiIota0(_ba, _ke, _si, _go, _mu, CONST_64(KeccakP1600RoundConstants[i+2]) ); \
+    KeccakP_ThetaRhoPiChi1(    _ma, _be, _ki, _so, _gu ); \
+    KeccakP_ThetaRhoPiChi2(    _ga, _me, _bi, _ko, _su ); \
+    KeccakP_ThetaRhoPiChi3(    _sa, _ge, _mi, _bo, _ku ); \
+    KeccakP_ThetaRhoPiChi4(    _ka, _se, _gi, _mo, _bu ); \
+\
+    KeccakP_ThetaRhoPiChiIota0(_ba, _be, _bi, _bo, _bu, CONST_64(KeccakP1600RoundConstants[i+3]) ); \
+    KeccakP_ThetaRhoPiChi1(    _ga, _ge, _gi, _go, _gu ); \
+    KeccakP_ThetaRhoPiChi2(    _ka, _ke, _ki, _ko, _ku ); \
+    KeccakP_ThetaRhoPiChi3(    _ma, _me, _mi, _mo, _mu ); \
+    KeccakP_ThetaRhoPiChi4(    _sa, _se, _si, _so, _su )
+
+#define rounds12 \
+    KeccakP_4rounds( 12 ); \
+    KeccakP_4rounds( 16 ); \
+    KeccakP_4rounds( 20 )
+
+#define initializeState(X) \
+    X##ba = ZERO(); \
+    X##be = ZERO(); \
+    X##bi = ZERO(); \
+    X##bo = ZERO(); \
+    X##bu = ZERO(); \
+    X##ga = ZERO(); \
+    X##ge = ZERO(); \
+    X##gi = ZERO(); \
+    X##go = ZERO(); \
+    X##gu = ZERO(); \
+    X##ka = ZERO(); \
+    X##ke = ZERO(); \
+    X##ki = ZERO(); \
+    X##ko = ZERO(); \
+    X##ku = ZERO(); \
+    X##ma = ZERO(); \
+    X##me = ZERO(); \
+    X##mi = ZERO(); \
+    X##mo = ZERO(); \
+    X##mu = ZERO(); \
+    X##sa = ZERO(); \
+    X##se = ZERO(); \
+    X##si = ZERO(); \
+    X##so = ZERO(); \
+    X##su = ZERO(); \
+
+#define XORdata16(X, data0, data1) \
+    XOReq(X##ba, LOAD6464((data1)[ 0], (data0)[ 0])); \
+    XOReq(X##be, LOAD6464((data1)[ 1], (data0)[ 1])); \
+    XOReq(X##bi, LOAD6464((data1)[ 2], (data0)[ 2])); \
+    XOReq(X##bo, LOAD6464((data1)[ 3], (data0)[ 3])); \
+    XOReq(X##bu, LOAD6464((data1)[ 4], (data0)[ 4])); \
+    XOReq(X##ga, LOAD6464((data1)[ 5], (data0)[ 5])); \
+    XOReq(X##ge, LOAD6464((data1)[ 6], (data0)[ 6])); \
+    XOReq(X##gi, LOAD6464((data1)[ 7], (data0)[ 7])); \
+    XOReq(X##go, LOAD6464((data1)[ 8], (data0)[ 8])); \
+    XOReq(X##gu, LOAD6464((data1)[ 9], (data0)[ 9])); \
+    XOReq(X##ka, LOAD6464((data1)[10], (data0)[10])); \
+    XOReq(X##ke, LOAD6464((data1)[11], (data0)[11])); \
+    XOReq(X##ki, LOAD6464((data1)[12], (data0)[12])); \
+    XOReq(X##ko, LOAD6464((data1)[13], (data0)[13])); \
+    XOReq(X##ku, LOAD6464((data1)[14], (data0)[14])); \
+    XOReq(X##ma, LOAD6464((data1)[15], (data0)[15])); \
+
+#define XORdata21(X, data0, data1) \
+    XORdata16(X, data0, data1) \
+    XOReq(X##me, LOAD6464((data1)[16], (data0)[16])); \
+    XOReq(X##mi, LOAD6464((data1)[17], (data0)[17])); \
+    XOReq(X##mo, LOAD6464((data1)[18], (data0)[18])); \
+    XOReq(X##mu, LOAD6464((data1)[19], (data0)[19])); \
+    XOReq(X##sa, LOAD6464((data1)[20], (data0)[20])); \
+
+#define chunkSize 8192
+#define rateInBytes (21*8)
+
+void KangarooTwelve_AVX512_Process2Leaves(const unsigned char *input, unsigned char *output)
+{
+    KeccakP_DeclareVars(__m128i);
+    unsigned int j;
+
+    initializeState(_);
+
+    for(j = 0; j < (chunkSize - rateInBytes); j += rateInBytes) {
+        XORdata21(_, (const uint64_t *)input, (const uint64_t *)(input+chunkSize));
+        rounds12
+        input += rateInBytes;
+    }
+
+    XORdata16(_, (const uint64_t *)input, (const uint64_t *)(input+chunkSize));
+    XOReq(_me, CONST_64(0x0BULL));
+    XOReq(_sa, CONST_64(0x8000000000000000ULL));
+    rounds12
+
+    STORE128u( *(__m128i*)&(output[ 0]), UNPACKL( _ba, _be ) );
+    STORE128u( *(__m128i*)&(output[16]), UNPACKL( _bi, _bo ) );
+    STORE128u( *(__m128i*)&(output[32]), UNPACKH( _ba, _be ) );
+    STORE128u( *(__m128i*)&(output[48]), UNPACKH( _bi, _bo ) );
+}
+
+#undef XOR
+#undef XOReq
+#undef XOR3
+#undef XOR5
+#undef ROL
+#undef Chi
+#undef CONST_64
+#undef LOAD6464
+#undef STORE128u
+#undef UNPACKL
+#undef UNPACKH
+#undef ZERO
+#undef XORdata16
+#undef XORdata21
+
+
+/* Keccak-p[1600]×4 */
+
+#define XOR(a,b)                    _mm256_xor_si256(a,b)
+#define XOReq(a,b)                  a = _mm256_xor_si256(a,b)
+#define XOR3(a,b,c)                 _mm256_ternarylogic_epi64(a,b,c,0x96)
+#define XOR5(a,b,c,d,e)             XOR3(XOR3(a,b,c),d,e)
+#define XOR512(a,b)                 _mm512_xor_si512(a,b)
+#define ROL(a,offset)               _mm256_rol_epi64(a,offset)
+#define Chi(a,b,c)                  _mm256_ternarylogic_epi64(a,b,c,0xD2)
+#define CONST_64(a)                 _mm256_set1_epi64x(a)
+#define ZERO()                      _mm256_setzero_si256()
+#define LOAD4_64(a, b, c, d)    _mm256_set_epi64x((uint64_t)(a), (uint64_t)(b), (uint64_t)(c), (uint64_t)(d))
+
+#define XORdata16(X, data0, data1, data2, data3) \
+    XOReq(X##ba, LOAD4_64((data3)[ 0], (data2)[ 0], (data1)[ 0], (data0)[ 0])); \
+    XOReq(X##be, LOAD4_64((data3)[ 1], (data2)[ 1], (data1)[ 1], (data0)[ 1])); \
+    XOReq(X##bi, LOAD4_64((data3)[ 2], (data2)[ 2], (data1)[ 2], (data0)[ 2])); \
+    XOReq(X##bo, LOAD4_64((data3)[ 3], (data2)[ 3], (data1)[ 3], (data0)[ 3])); \
+    XOReq(X##bu, LOAD4_64((data3)[ 4], (data2)[ 4], (data1)[ 4], (data0)[ 4])); \
+    XOReq(X##ga, LOAD4_64((data3)[ 5], (data2)[ 5], (data1)[ 5], (data0)[ 5])); \
+    XOReq(X##ge, LOAD4_64((data3)[ 6], (data2)[ 6], (data1)[ 6], (data0)[ 6])); \
+    XOReq(X##gi, LOAD4_64((data3)[ 7], (data2)[ 7], (data1)[ 7], (data0)[ 7])); \
+    XOReq(X##go, LOAD4_64((data3)[ 8], (data2)[ 8], (data1)[ 8], (data0)[ 8])); \
+    XOReq(X##gu, LOAD4_64((data3)[ 9], (data2)[ 9], (data1)[ 9], (data0)[ 9])); \
+    XOReq(X##ka, LOAD4_64((data3)[10], (data2)[10], (data1)[10], (data0)[10])); \
+    XOReq(X##ke, LOAD4_64((data3)[11], (data2)[11], (data1)[11], (data0)[11])); \
+    XOReq(X##ki, LOAD4_64((data3)[12], (data2)[12], (data1)[12], (data0)[12])); \
+    XOReq(X##ko, LOAD4_64((data3)[13], (data2)[13], (data1)[13], (data0)[13])); \
+    XOReq(X##ku, LOAD4_64((data3)[14], (data2)[14], (data1)[14], (data0)[14])); \
+    XOReq(X##ma, LOAD4_64((data3)[15], (data2)[15], (data1)[15], (data0)[15])); \
+
+#define XORdata21(X, data0, data1, data2, data3) \
+    XORdata16(X, data0, data1, data2, data3) \
+    XOReq(X##me, LOAD4_64((data3)[16], (data2)[16], (data1)[16], (data0)[16])); \
+    XOReq(X##mi, LOAD4_64((data3)[17], (data2)[17], (data1)[17], (data0)[17])); \
+    XOReq(X##mo, LOAD4_64((data3)[18], (data2)[18], (data1)[18], (data0)[18])); \
+    XOReq(X##mu, LOAD4_64((data3)[19], (data2)[19], (data1)[19], (data0)[19])); \
+    XOReq(X##sa, LOAD4_64((data3)[20], (data2)[20], (data1)[20], (data0)[20])); \
+
+void KangarooTwelve_AVX512_Process4Leaves(const unsigned char *input, unsigned char *output)
+{
+    KeccakP_DeclareVars(__m256i);
+    unsigned int j;
+
+    initializeState(_);
+
+    for(j = 0; j < (chunkSize - rateInBytes); j += rateInBytes) {
+        XORdata21(_, (const uint64_t *)input, (const uint64_t *)(input+chunkSize), (const uint64_t *)(input+2*chunkSize), (const uint64_t *)(input+3*chunkSize));
+        rounds12
+        input += rateInBytes;
+    }
+
+    XORdata16(_, (const uint64_t *)input, (const uint64_t *)(input+chunkSize), (const uint64_t *)(input+2*chunkSize), (const uint64_t *)(input+3*chunkSize));
+    XOReq(_me, CONST_64(0x0BULL));
+    XOReq(_sa, CONST_64(0x8000000000000000ULL));
+    rounds12
+
+#define STORE256u(a, b)         _mm256_storeu_si256((__m256i *)&(a), b)
+#define UNPACKL( a, b )         _mm256_unpacklo_epi64((a), (b))
+#define UNPACKH( a, b )         _mm256_unpackhi_epi64((a), (b))
+#define PERM128( a, b, c )      _mm256_permute2f128_si256(a, b, c)
+    {
+        __m256i lanesL01, lanesL23, lanesH01, lanesH23;
+
+        lanesL01 = UNPACKL( _ba, _be );
+        lanesH01 = UNPACKH( _ba, _be );
+        lanesL23 = UNPACKL( _bi, _bo );
+        lanesH23 = UNPACKH( _bi, _bo );
+        STORE256u( output[ 0], PERM128( lanesL01, lanesL23, 0x20 ) );
+        STORE256u( output[32], PERM128( lanesH01, lanesH23, 0x20 ) );
+        STORE256u( output[64], PERM128( lanesL01, lanesL23, 0x31 ) );
+        STORE256u( output[96], PERM128( lanesH01, lanesH23, 0x31 ) );
+    }
+/* TODO: check if something like this would be better:
+    index512 = LOAD8_32(3*laneOffset+1, 2*laneOffset+1, 1*laneOffset+1, 0*laneOffset+1, 3*laneOffset, 2*laneOffset, 1*laneOffset, 0*laneOffset);
+    STORE_SCATTER8_64(dataAsLanes+0, index512, stateAsLanes512[0/2]);
+    STORE_SCATTER8_64(dataAsLanes+2, index512, stateAsLanes512[2/2]);
+*/
+}
+
+#undef XOR
+#undef XOReq
+#undef XOR3
+#undef XOR5
+#undef XOR512
+#undef ROL
+#undef Chi
+#undef CONST_64
+#undef ZERO
+#undef LOAD4_64
+#undef XORdata16
+#undef XORdata21
+
+
+/* Keccak-p[1600]×8 */
+
+#define XOR(a,b)                    _mm512_xor_si512(a,b)
+#define XOReq(a,b)                  a = _mm512_xor_si512(a,b)
+#define XOR3(a,b,c)                 _mm512_ternarylogic_epi64(a,b,c,0x96)
+#define XOR5(a,b,c,d,e)             XOR3(XOR3(a,b,c),d,e)
+#define XOReq512(a, b)              a = XOR(a,b)
+#define ROL(a,offset)               _mm512_rol_epi64(a,offset)
+#define Chi(a,b,c)                  _mm512_ternarylogic_epi64(a,b,c,0xD2)
+#define CONST_64(a)                 _mm512_set1_epi64(a)
+#define ZERO()                      _mm512_setzero_si512()
+#define LOAD(p)                     _mm512_loadu_si512(p)
+
+#define LoadAndTranspose8(dataAsLanes, offset) \
+    t0 = LOAD((dataAsLanes) + (offset) + 0*chunkSize/8); \
+    t1 = LOAD((dataAsLanes) + (offset) + 1*chunkSize/8); \
+    t2 = LOAD((dataAsLanes) + (offset) + 2*chunkSize/8); \
+    t3 = LOAD((dataAsLanes) + (offset) + 3*chunkSize/8); \
+    t4 = LOAD((dataAsLanes) + (offset) + 4*chunkSize/8); \
+    t5 = LOAD((dataAsLanes) + (offset) + 5*chunkSize/8); \
+    t6 = LOAD((dataAsLanes) + (offset) + 6*chunkSize/8); \
+    t7 = LOAD((dataAsLanes) + (offset) + 7*chunkSize/8); \
+    r0 = _mm512_unpacklo_epi64(t0, t1); \
+    r1 = _mm512_unpackhi_epi64(t0, t1); \
+    r2 = _mm512_unpacklo_epi64(t2, t3); \
+    r3 = _mm512_unpackhi_epi64(t2, t3); \
+    r4 = _mm512_unpacklo_epi64(t4, t5); \
+    r5 = _mm512_unpackhi_epi64(t4, t5); \
+    r6 = _mm512_unpacklo_epi64(t6, t7); \
+    r7 = _mm512_unpackhi_epi64(t6, t7); \
+    t0 = _mm512_shuffle_i32x4(r0, r2, 0x88); \
+    t1 = _mm512_shuffle_i32x4(r1, r3, 0x88); \
+    t2 = _mm512_shuffle_i32x4(r0, r2, 0xdd); \
+    t3 = _mm512_shuffle_i32x4(r1, r3, 0xdd); \
+    t4 = _mm512_shuffle_i32x4(r4, r6, 0x88); \
+    t5 = _mm512_shuffle_i32x4(r5, r7, 0x88); \
+    t6 = _mm512_shuffle_i32x4(r4, r6, 0xdd); \
+    t7 = _mm512_shuffle_i32x4(r5, r7, 0xdd); \
+    r0 = _mm512_shuffle_i32x4(t0, t4, 0x88); \
+    r1 = _mm512_shuffle_i32x4(t1, t5, 0x88); \
+    r2 = _mm512_shuffle_i32x4(t2, t6, 0x88); \
+    r3 = _mm512_shuffle_i32x4(t3, t7, 0x88); \
+    r4 = _mm512_shuffle_i32x4(t0, t4, 0xdd); \
+    r5 = _mm512_shuffle_i32x4(t1, t5, 0xdd); \
+    r6 = _mm512_shuffle_i32x4(t2, t6, 0xdd); \
+    r7 = _mm512_shuffle_i32x4(t3, t7, 0xdd); \
+
+#define XORdata16(X, index, dataAsLanes) \
+    LoadAndTranspose8(dataAsLanes, 0) \
+    XOReq(X##ba, r0); \
+    XOReq(X##be, r1); \
+    XOReq(X##bi, r2); \
+    XOReq(X##bo, r3); \
+    XOReq(X##bu, r4); \
+    XOReq(X##ga, r5); \
+    XOReq(X##ge, r6); \
+    XOReq(X##gi, r7); \
+    LoadAndTranspose8(dataAsLanes, 8) \
+    XOReq(X##go, r0); \
+    XOReq(X##gu, r1); \
+    XOReq(X##ka, r2); \
+    XOReq(X##ke, r3); \
+    XOReq(X##ki, r4); \
+    XOReq(X##ko, r5); \
+    XOReq(X##ku, r6); \
+    XOReq(X##ma, r7); \
+
+#define XORdata21(X, index, dataAsLanes) \
+    XORdata16(X, index, dataAsLanes) \
+    XOReq(X##me, LOAD_GATHER8_64(index, (dataAsLanes) + 16)); \
+    XOReq(X##mi, LOAD_GATHER8_64(index, (dataAsLanes) + 17)); \
+    XOReq(X##mo, LOAD_GATHER8_64(index, (dataAsLanes) + 18)); \
+    XOReq(X##mu, LOAD_GATHER8_64(index, (dataAsLanes) + 19)); \
+    XOReq(X##sa, LOAD_GATHER8_64(index, (dataAsLanes) + 20)); \
+
+void KangarooTwelve_AVX512_Process8Leaves(const unsigned char *input, unsigned char *output)
+{
+    KeccakP_DeclareVars(__m512i);
+    unsigned int j;
+    const uint64_t *outputAsLanes = (const uint64_t *)output;
+    __m256i index;
+    __m512i t0, t1, t2, t3, t4, t5, t6, t7;
+    __m512i r0, r1, r2, r3, r4, r5, r6, r7;
+
+    initializeState(_);
+
+    index = LOAD8_32(7*(chunkSize / 8), 6*(chunkSize / 8), 5*(chunkSize / 8), 4*(chunkSize / 8), 3*(chunkSize / 8), 2*(chunkSize / 8), 1*(chunkSize / 8), 0*(chunkSize / 8));
+    for(j = 0; j < (chunkSize - rateInBytes); j += rateInBytes) {
+        XORdata21(_, index, (const uint64_t *)input);
+        rounds12
+        input += rateInBytes;
+    }
+
+    XORdata16(_, index, (const uint64_t *)input);
+    XOReq(_me, CONST_64(0x0BULL));
+    XOReq(_sa, CONST_64(0x8000000000000000ULL));
+    rounds12
+
+    index = LOAD8_32(7*4, 6*4, 5*4, 4*4, 3*4, 2*4, 1*4, 0*4);
+    STORE_SCATTER8_64(outputAsLanes+0, index, _ba);
+    STORE_SCATTER8_64(outputAsLanes+1, index, _be);
+    STORE_SCATTER8_64(outputAsLanes+2, index, _bi);
+    STORE_SCATTER8_64(outputAsLanes+3, index, _bo);
+}