github.com/onflow/flow-go@v0.35.7-crescendo-preview.23-atree-inlining/ledger/common/hash/keccak.s (about)

     1  // The functions below were copied from golang.org/x/crypto/sha3.
     2  //
     3  // Copyright (c) 2009 The Go Authors. All rights reserved.
     4  
     5  // Redistribution and use in source and binary forms, with or without
     6  // modification, are permitted provided that the following conditions are
     7  // met:
     8  
     9  //    * Redistributions of source code must retain the above copyright
    10  // notice, this list of conditions and the following disclaimer.
    11  //    * Redistributions in binary form must reproduce the above
    12  // copyright notice, this list of conditions and the following disclaimer
    13  // in the documentation and/or other materials provided with the
    14  // distribution.
    15  //    * Neither the name of Google Inc. nor the names of its
    16  // contributors may be used to endorse or promote products derived from
    17  // this software without specific prior written permission.
    18  
    19  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    20  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    21  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    22  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    23  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    24  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    25  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    26  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    27  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    28  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    29  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    30  
    31  
    32  // +build amd64,!purego,gc
    33  
    34  // This code was translated into a form compatible with 6a from the public
    35  // domain sources at https://github.com/gvanas/KeccakCodePackage
    36  
    37  // Offsets in state
    38  #define _ba  (0*8)
    39  #define _be  (1*8)
    40  #define _bi  (2*8)
    41  #define _bo  (3*8)
    42  #define _bu  (4*8)
    43  #define _ga  (5*8)
    44  #define _ge  (6*8)
    45  #define _gi  (7*8)
    46  #define _go  (8*8)
    47  #define _gu  (9*8)
    48  #define _ka (10*8)
    49  #define _ke (11*8)
    50  #define _ki (12*8)
    51  #define _ko (13*8)
    52  #define _ku (14*8)
    53  #define _ma (15*8)
    54  #define _me (16*8)
    55  #define _mi (17*8)
    56  #define _mo (18*8)
    57  #define _mu (19*8)
    58  #define _sa (20*8)
    59  #define _se (21*8)
    60  #define _si (22*8)
    61  #define _so (23*8)
    62  #define _su (24*8)
    63  
    64  // Temporary registers
    65  #define rT1  AX
    66  
    67  // Round vars
    68  #define rpState DI
    69  #define rpStack SP
    70  
    71  #define rDa BX
    72  #define rDe CX
    73  #define rDi DX
    74  #define rDo R8
    75  #define rDu R9
    76  
    77  #define rBa R10
    78  #define rBe R11
    79  #define rBi R12
    80  #define rBo R13
    81  #define rBu R14
    82  
    83  #define rCa SI
    84  #define rCe BP
    85  #define rCi rBi
    86  #define rCo rBo
    87  #define rCu R15
    88  
    89  #define MOVQ_RBI_RCE MOVQ rBi, rCe
    90  #define XORQ_RT1_RCA XORQ rT1, rCa
    91  #define XORQ_RT1_RCE XORQ rT1, rCe
    92  #define XORQ_RBA_RCU XORQ rBa, rCu
    93  #define XORQ_RBE_RCU XORQ rBe, rCu
    94  #define XORQ_RDU_RCU XORQ rDu, rCu
    95  #define XORQ_RDA_RCA XORQ rDa, rCa
    96  #define XORQ_RDE_RCE XORQ rDe, rCe
    97  
    98  #define mKeccakRound(iState, oState, rc, B_RBI_RCE, G_RT1_RCA, G_RT1_RCE, G_RBA_RCU, K_RT1_RCA, K_RT1_RCE, K_RBA_RCU, M_RT1_RCA, M_RT1_RCE, M_RBE_RCU, S_RDU_RCU, S_RDA_RCA, S_RDE_RCE) \
    99  	/* Prepare round */    \
   100  	MOVQ rCe, rDa;         \
   101  	ROLQ $1, rDa;          \
   102  	                       \
   103  	MOVQ _bi(iState), rCi; \
   104  	XORQ _gi(iState), rDi; \
   105  	XORQ rCu, rDa;         \
   106  	XORQ _ki(iState), rCi; \
   107  	XORQ _mi(iState), rDi; \
   108  	XORQ rDi, rCi;         \
   109  	                       \
   110  	MOVQ rCi, rDe;         \
   111  	ROLQ $1, rDe;          \
   112  	                       \
   113  	MOVQ _bo(iState), rCo; \
   114  	XORQ _go(iState), rDo; \
   115  	XORQ rCa, rDe;         \
   116  	XORQ _ko(iState), rCo; \
   117  	XORQ _mo(iState), rDo; \
   118  	XORQ rDo, rCo;         \
   119  	                       \
   120  	MOVQ rCo, rDi;         \
   121  	ROLQ $1, rDi;          \
   122  	                       \
   123  	MOVQ rCu, rDo;         \
   124  	XORQ rCe, rDi;         \
   125  	ROLQ $1, rDo;          \
   126  	                       \
   127  	MOVQ rCa, rDu;         \
   128  	XORQ rCi, rDo;         \
   129  	ROLQ $1, rDu;          \
   130  	                       \
   131  	/* Result b */         \
   132  	MOVQ _ba(iState), rBa; \
   133  	MOVQ _ge(iState), rBe; \
   134  	XORQ rCo, rDu;         \
   135  	MOVQ _ki(iState), rBi; \
   136  	MOVQ _mo(iState), rBo; \
   137  	MOVQ _su(iState), rBu; \
   138  	XORQ rDe, rBe;         \
   139  	ROLQ $44, rBe;         \
   140  	XORQ rDi, rBi;         \
   141  	XORQ rDa, rBa;         \
   142  	ROLQ $43, rBi;         \
   143  	                       \
   144  	MOVQ rBe, rCa;         \
   145  	MOVQ rc, rT1;          \
   146  	ORQ  rBi, rCa;         \
   147  	XORQ rBa, rT1;         \
   148  	XORQ rT1, rCa;         \
   149  	MOVQ rCa, _ba(oState); \
   150  	                       \
   151  	XORQ rDu, rBu;         \
   152  	ROLQ $14, rBu;         \
   153  	MOVQ rBa, rCu;         \
   154  	ANDQ rBe, rCu;         \
   155  	XORQ rBu, rCu;         \
   156  	MOVQ rCu, _bu(oState); \
   157  	                       \
   158  	XORQ rDo, rBo;         \
   159  	ROLQ $21, rBo;         \
   160  	MOVQ rBo, rT1;         \
   161  	ANDQ rBu, rT1;         \
   162  	XORQ rBi, rT1;         \
   163  	MOVQ rT1, _bi(oState); \
   164  	                       \
   165  	NOTQ rBi;              \
   166  	ORQ  rBa, rBu;         \
   167  	ORQ  rBo, rBi;         \
   168  	XORQ rBo, rBu;         \
   169  	XORQ rBe, rBi;         \
   170  	MOVQ rBu, _bo(oState); \
   171  	MOVQ rBi, _be(oState); \
   172  	B_RBI_RCE;             \
   173  	                       \
   174  	/* Result g */         \
   175  	MOVQ _gu(iState), rBe; \
   176  	XORQ rDu, rBe;         \
   177  	MOVQ _ka(iState), rBi; \
   178  	ROLQ $20, rBe;         \
   179  	XORQ rDa, rBi;         \
   180  	ROLQ $3, rBi;          \
   181  	MOVQ _bo(iState), rBa; \
   182  	MOVQ rBe, rT1;         \
   183  	ORQ  rBi, rT1;         \
   184  	XORQ rDo, rBa;         \
   185  	MOVQ _me(iState), rBo; \
   186  	MOVQ _si(iState), rBu; \
   187  	ROLQ $28, rBa;         \
   188  	XORQ rBa, rT1;         \
   189  	MOVQ rT1, _ga(oState); \
   190  	G_RT1_RCA;             \
   191  	                       \
   192  	XORQ rDe, rBo;         \
   193  	ROLQ $45, rBo;         \
   194  	MOVQ rBi, rT1;         \
   195  	ANDQ rBo, rT1;         \
   196  	XORQ rBe, rT1;         \
   197  	MOVQ rT1, _ge(oState); \
   198  	G_RT1_RCE;             \
   199  	                       \
   200  	XORQ rDi, rBu;         \
   201  	ROLQ $61, rBu;         \
   202  	MOVQ rBu, rT1;         \
   203  	ORQ  rBa, rT1;         \
   204  	XORQ rBo, rT1;         \
   205  	MOVQ rT1, _go(oState); \
   206  	                       \
   207  	ANDQ rBe, rBa;         \
   208  	XORQ rBu, rBa;         \
   209  	MOVQ rBa, _gu(oState); \
   210  	NOTQ rBu;              \
   211  	G_RBA_RCU;             \
   212  	                       \
   213  	ORQ  rBu, rBo;         \
   214  	XORQ rBi, rBo;         \
   215  	MOVQ rBo, _gi(oState); \
   216  	                       \
   217  	/* Result k */         \
   218  	MOVQ _be(iState), rBa; \
   219  	MOVQ _gi(iState), rBe; \
   220  	MOVQ _ko(iState), rBi; \
   221  	MOVQ _mu(iState), rBo; \
   222  	MOVQ _sa(iState), rBu; \
   223  	XORQ rDi, rBe;         \
   224  	ROLQ $6, rBe;          \
   225  	XORQ rDo, rBi;         \
   226  	ROLQ $25, rBi;         \
   227  	MOVQ rBe, rT1;         \
   228  	ORQ  rBi, rT1;         \
   229  	XORQ rDe, rBa;         \
   230  	ROLQ $1, rBa;          \
   231  	XORQ rBa, rT1;         \
   232  	MOVQ rT1, _ka(oState); \
   233  	K_RT1_RCA;             \
   234  	                       \
   235  	XORQ rDu, rBo;         \
   236  	ROLQ $8, rBo;          \
   237  	MOVQ rBi, rT1;         \
   238  	ANDQ rBo, rT1;         \
   239  	XORQ rBe, rT1;         \
   240  	MOVQ rT1, _ke(oState); \
   241  	K_RT1_RCE;             \
   242  	                       \
   243  	XORQ rDa, rBu;         \
   244  	ROLQ $18, rBu;         \
   245  	NOTQ rBo;              \
   246  	MOVQ rBo, rT1;         \
   247  	ANDQ rBu, rT1;         \
   248  	XORQ rBi, rT1;         \
   249  	MOVQ rT1, _ki(oState); \
   250  	                       \
   251  	MOVQ rBu, rT1;         \
   252  	ORQ  rBa, rT1;         \
   253  	XORQ rBo, rT1;         \
   254  	MOVQ rT1, _ko(oState); \
   255  	                       \
   256  	ANDQ rBe, rBa;         \
   257  	XORQ rBu, rBa;         \
   258  	MOVQ rBa, _ku(oState); \
   259  	K_RBA_RCU;             \
   260  	                       \
   261  	/* Result m */         \
   262  	MOVQ _ga(iState), rBe; \
   263  	XORQ rDa, rBe;         \
   264  	MOVQ _ke(iState), rBi; \
   265  	ROLQ $36, rBe;         \
   266  	XORQ rDe, rBi;         \
   267  	MOVQ _bu(iState), rBa; \
   268  	ROLQ $10, rBi;         \
   269  	MOVQ rBe, rT1;         \
   270  	MOVQ _mi(iState), rBo; \
   271  	ANDQ rBi, rT1;         \
   272  	XORQ rDu, rBa;         \
   273  	MOVQ _so(iState), rBu; \
   274  	ROLQ $27, rBa;         \
   275  	XORQ rBa, rT1;         \
   276  	MOVQ rT1, _ma(oState); \
   277  	M_RT1_RCA;             \
   278  	                       \
   279  	XORQ rDi, rBo;         \
   280  	ROLQ $15, rBo;         \
   281  	MOVQ rBi, rT1;         \
   282  	ORQ  rBo, rT1;         \
   283  	XORQ rBe, rT1;         \
   284  	MOVQ rT1, _me(oState); \
   285  	M_RT1_RCE;             \
   286  	                       \
   287  	XORQ rDo, rBu;         \
   288  	ROLQ $56, rBu;         \
   289  	NOTQ rBo;              \
   290  	MOVQ rBo, rT1;         \
   291  	ORQ  rBu, rT1;         \
   292  	XORQ rBi, rT1;         \
   293  	MOVQ rT1, _mi(oState); \
   294  	                       \
   295  	ORQ  rBa, rBe;         \
   296  	XORQ rBu, rBe;         \
   297  	MOVQ rBe, _mu(oState); \
   298  	                       \
   299  	ANDQ rBa, rBu;         \
   300  	XORQ rBo, rBu;         \
   301  	MOVQ rBu, _mo(oState); \
   302  	M_RBE_RCU;             \
   303  	                       \
   304  	/* Result s */         \
   305  	MOVQ _bi(iState), rBa; \
   306  	MOVQ _go(iState), rBe; \
   307  	MOVQ _ku(iState), rBi; \
   308  	XORQ rDi, rBa;         \
   309  	MOVQ _ma(iState), rBo; \
   310  	ROLQ $62, rBa;         \
   311  	XORQ rDo, rBe;         \
   312  	MOVQ _se(iState), rBu; \
   313  	ROLQ $55, rBe;         \
   314  	                       \
   315  	XORQ rDu, rBi;         \
   316  	MOVQ rBa, rDu;         \
   317  	XORQ rDe, rBu;         \
   318  	ROLQ $2, rBu;          \
   319  	ANDQ rBe, rDu;         \
   320  	XORQ rBu, rDu;         \
   321  	MOVQ rDu, _su(oState); \
   322  	                       \
   323  	ROLQ $39, rBi;         \
   324  	S_RDU_RCU;             \
   325  	NOTQ rBe;              \
   326  	XORQ rDa, rBo;         \
   327  	MOVQ rBe, rDa;         \
   328  	ANDQ rBi, rDa;         \
   329  	XORQ rBa, rDa;         \
   330  	MOVQ rDa, _sa(oState); \
   331  	S_RDA_RCA;             \
   332  	                       \
   333  	ROLQ $41, rBo;         \
   334  	MOVQ rBi, rDe;         \
   335  	ORQ  rBo, rDe;         \
   336  	XORQ rBe, rDe;         \
   337  	MOVQ rDe, _se(oState); \
   338  	S_RDE_RCE;             \
   339  	                       \
   340  	MOVQ rBo, rDi;         \
   341  	MOVQ rBu, rDo;         \
   342  	ANDQ rBu, rDi;         \
   343  	ORQ  rBa, rDo;         \
   344  	XORQ rBi, rDi;         \
   345  	XORQ rBo, rDo;         \
   346  	MOVQ rDi, _si(oState); \
   347  	MOVQ rDo, _so(oState)  \
   348  
   349  // func keccakF1600(state *[25]uint64)
   350  TEXT ·keccakF1600(SB), 0, $200-8
   351  	MOVQ state+0(FP), rpState
   352  
   353  	// Convert the user state into an internal state
   354  	NOTQ _be(rpState)
   355  	NOTQ _bi(rpState)
   356  	NOTQ _go(rpState)
   357  	NOTQ _ki(rpState)
   358  	NOTQ _mi(rpState)
   359  	NOTQ _sa(rpState)
   360  
   361  	// Execute the KeccakF permutation
   362  	MOVQ _ba(rpState), rCa
   363  	MOVQ _be(rpState), rCe
   364  	MOVQ _bu(rpState), rCu
   365  
   366  	XORQ _ga(rpState), rCa
   367  	XORQ _ge(rpState), rCe
   368  	XORQ _gu(rpState), rCu
   369  
   370  	XORQ _ka(rpState), rCa
   371  	XORQ _ke(rpState), rCe
   372  	XORQ _ku(rpState), rCu
   373  
   374  	XORQ _ma(rpState), rCa
   375  	XORQ _me(rpState), rCe
   376  	XORQ _mu(rpState), rCu
   377  
   378  	XORQ _sa(rpState), rCa
   379  	XORQ _se(rpState), rCe
   380  	MOVQ _si(rpState), rDi
   381  	MOVQ _so(rpState), rDo
   382  	XORQ _su(rpState), rCu
   383  
   384  	mKeccakRound(rpState, rpStack, $0x0000000000000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   385  	mKeccakRound(rpStack, rpState, $0x0000000000008082, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   386  	mKeccakRound(rpState, rpStack, $0x800000000000808a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   387  	mKeccakRound(rpStack, rpState, $0x8000000080008000, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   388  	mKeccakRound(rpState, rpStack, $0x000000000000808b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   389  	mKeccakRound(rpStack, rpState, $0x0000000080000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   390  	mKeccakRound(rpState, rpStack, $0x8000000080008081, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   391  	mKeccakRound(rpStack, rpState, $0x8000000000008009, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   392  	mKeccakRound(rpState, rpStack, $0x000000000000008a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   393  	mKeccakRound(rpStack, rpState, $0x0000000000000088, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   394  	mKeccakRound(rpState, rpStack, $0x0000000080008009, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   395  	mKeccakRound(rpStack, rpState, $0x000000008000000a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   396  	mKeccakRound(rpState, rpStack, $0x000000008000808b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   397  	mKeccakRound(rpStack, rpState, $0x800000000000008b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   398  	mKeccakRound(rpState, rpStack, $0x8000000000008089, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   399  	mKeccakRound(rpStack, rpState, $0x8000000000008003, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   400  	mKeccakRound(rpState, rpStack, $0x8000000000008002, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   401  	mKeccakRound(rpStack, rpState, $0x8000000000000080, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   402  	mKeccakRound(rpState, rpStack, $0x000000000000800a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   403  	mKeccakRound(rpStack, rpState, $0x800000008000000a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   404  	mKeccakRound(rpState, rpStack, $0x8000000080008081, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   405  	mKeccakRound(rpStack, rpState, $0x8000000000008080, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   406  	mKeccakRound(rpState, rpStack, $0x0000000080000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
   407  	mKeccakRound(rpStack, rpState, $0x8000000080008008, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP)
   408  
   409  	// Revert the internal state to the user state
   410  	NOTQ _be(rpState)
   411  	NOTQ _bi(rpState)
   412  	NOTQ _go(rpState)
   413  	NOTQ _ki(rpState)
   414  	NOTQ _mi(rpState)
   415  	NOTQ _sa(rpState)
   416  
   417  	RET
   418