vendor/golang.org/x/crypto/sha3/keccakf_amd64.s

   1 // Copyright 2015 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build amd64,!appengine,!gccgo
   6
   7 // This code was translated into a form compatible with 6a from the public
   8 // domain sources at https://github.com/gvanas/KeccakCodePackage
   9
  10 // Offsets in state
  11 #define _ba  (0*8)
  12 #define _be  (1*8)
  13 #define _bi  (2*8)
  14 #define _bo  (3*8)
  15 #define _bu  (4*8)
  16 #define _ga  (5*8)
  17 #define _ge  (6*8)
  18 #define _gi  (7*8)
  19 #define _go  (8*8)
  20 #define _gu  (9*8)
  21 #define _ka (10*8)
  22 #define _ke (11*8)
  23 #define _ki (12*8)
  24 #define _ko (13*8)
  25 #define _ku (14*8)
  26 #define _ma (15*8)
  27 #define _me (16*8)
  28 #define _mi (17*8)
  29 #define _mo (18*8)
  30 #define _mu (19*8)
  31 #define _sa (20*8)
  32 #define _se (21*8)
  33 #define _si (22*8)
  34 #define _so (23*8)
  35 #define _su (24*8)
  36
  37 // Temporary registers
  38 #define rT1  AX
  39
  40 // Round vars
  41 #define rpState DI
  42 #define rpStack SP
  43
  44 #define rDa BX
  45 #define rDe CX
  46 #define rDi DX
  47 #define rDo R8
  48 #define rDu R9
  49
  50 #define rBa R10
  51 #define rBe R11
  52 #define rBi R12
  53 #define rBo R13
  54 #define rBu R14
  55
  56 #define rCa SI
  57 #define rCe BP
  58 #define rCi rBi
  59 #define rCo rBo
  60 #define rCu R15
  61
  62 #define MOVQ_RBI_RCE MOVQ rBi, rCe
  63 #define XORQ_RT1_RCA XORQ rT1, rCa
  64 #define XORQ_RT1_RCE XORQ rT1, rCe
  65 #define XORQ_RBA_RCU XORQ rBa, rCu
  66 #define XORQ_RBE_RCU XORQ rBe, rCu
  67 #define XORQ_RDU_RCU XORQ rDu, rCu
  68 #define XORQ_RDA_RCA XORQ rDa, rCa
  69 #define XORQ_RDE_RCE XORQ rDe, rCe
  70
  71 #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) \
  72         /* Prepare round */    \
  73         MOVQ rCe, rDa;         \
  74         ROLQ $1, rDa;          \
  75                                \
  76         MOVQ _bi(iState), rCi; \
  77         XORQ _gi(iState), rDi; \
  78         XORQ rCu, rDa;         \
  79         XORQ _ki(iState), rCi; \
  80         XORQ _mi(iState), rDi; \
  81         XORQ rDi, rCi;         \
  82                                \
  83         MOVQ rCi, rDe;         \
  84         ROLQ $1, rDe;          \
  85                                \
  86         MOVQ _bo(iState), rCo; \
  87         XORQ _go(iState), rDo; \
  88         XORQ rCa, rDe;         \
  89         XORQ _ko(iState), rCo; \
  90         XORQ _mo(iState), rDo; \
  91         XORQ rDo, rCo;         \
  92                                \
  93         MOVQ rCo, rDi;         \
  94         ROLQ $1, rDi;          \
  95                                \
  96         MOVQ rCu, rDo;         \
  97         XORQ rCe, rDi;         \
  98         ROLQ $1, rDo;          \
  99                                \
 100         MOVQ rCa, rDu;         \
 101         XORQ rCi, rDo;         \
 102         ROLQ $1, rDu;          \
 103                                \
 104         /* Result b */         \
 105         MOVQ _ba(iState), rBa; \
 106         MOVQ _ge(iState), rBe; \
 107         XORQ rCo, rDu;         \
 108         MOVQ _ki(iState), rBi; \
 109         MOVQ _mo(iState), rBo; \
 110         MOVQ _su(iState), rBu; \
 111         XORQ rDe, rBe;         \
 112         ROLQ $44, rBe;         \
 113         XORQ rDi, rBi;         \
 114         XORQ rDa, rBa;         \
 115         ROLQ $43, rBi;         \
 116                                \
 117         MOVQ rBe, rCa;         \
 118         MOVQ rc, rT1;          \
 119         ORQ  rBi, rCa;         \
 120         XORQ rBa, rT1;         \
 121         XORQ rT1, rCa;         \
 122         MOVQ rCa, _ba(oState); \
 123                                \
 124         XORQ rDu, rBu;         \
 125         ROLQ $14, rBu;         \
 126         MOVQ rBa, rCu;         \
 127         ANDQ rBe, rCu;         \
 128         XORQ rBu, rCu;         \
 129         MOVQ rCu, _bu(oState); \
 130                                \
 131         XORQ rDo, rBo;         \
 132         ROLQ $21, rBo;         \
 133         MOVQ rBo, rT1;         \
 134         ANDQ rBu, rT1;         \
 135         XORQ rBi, rT1;         \
 136         MOVQ rT1, _bi(oState); \
 137                                \
 138         NOTQ rBi;              \
 139         ORQ  rBa, rBu;         \
 140         ORQ  rBo, rBi;         \
 141         XORQ rBo, rBu;         \
 142         XORQ rBe, rBi;         \
 143         MOVQ rBu, _bo(oState); \
 144         MOVQ rBi, _be(oState); \
 145         B_RBI_RCE;             \
 146                                \
 147         /* Result g */         \
 148         MOVQ _gu(iState), rBe; \
 149         XORQ rDu, rBe;         \
 150         MOVQ _ka(iState), rBi; \
 151         ROLQ $20, rBe;         \
 152         XORQ rDa, rBi;         \
 153         ROLQ $3, rBi;          \
 154         MOVQ _bo(iState), rBa; \
 155         MOVQ rBe, rT1;         \
 156         ORQ  rBi, rT1;         \
 157         XORQ rDo, rBa;         \
 158         MOVQ _me(iState), rBo; \
 159         MOVQ _si(iState), rBu; \
 160         ROLQ $28, rBa;         \
 161         XORQ rBa, rT1;         \
 162         MOVQ rT1, _ga(oState); \
 163         G_RT1_RCA;             \
 164                                \
 165         XORQ rDe, rBo;         \
 166         ROLQ $45, rBo;         \
 167         MOVQ rBi, rT1;         \
 168         ANDQ rBo, rT1;         \
 169         XORQ rBe, rT1;         \
 170         MOVQ rT1, _ge(oState); \
 171         G_RT1_RCE;             \
 172                                \
 173         XORQ rDi, rBu;         \
 174         ROLQ $61, rBu;         \
 175         MOVQ rBu, rT1;         \
 176         ORQ  rBa, rT1;         \
 177         XORQ rBo, rT1;         \
 178         MOVQ rT1, _go(oState); \
 179                                \
 180         ANDQ rBe, rBa;         \
 181         XORQ rBu, rBa;         \
 182         MOVQ rBa, _gu(oState); \
 183         NOTQ rBu;              \
 184         G_RBA_RCU;             \
 185                                \
 186         ORQ  rBu, rBo;         \
 187         XORQ rBi, rBo;         \
 188         MOVQ rBo, _gi(oState); \
 189                                \
 190         /* Result k */         \
 191         MOVQ _be(iState), rBa; \
 192         MOVQ _gi(iState), rBe; \
 193         MOVQ _ko(iState), rBi; \
 194         MOVQ _mu(iState), rBo; \
 195         MOVQ _sa(iState), rBu; \
 196         XORQ rDi, rBe;         \
 197         ROLQ $6, rBe;          \
 198         XORQ rDo, rBi;         \
 199         ROLQ $25, rBi;         \
 200         MOVQ rBe, rT1;         \
 201         ORQ  rBi, rT1;         \
 202         XORQ rDe, rBa;         \
 203         ROLQ $1, rBa;          \
 204         XORQ rBa, rT1;         \
 205         MOVQ rT1, _ka(oState); \
 206         K_RT1_RCA;             \
 207                                \
 208         XORQ rDu, rBo;         \
 209         ROLQ $8, rBo;          \
 210         MOVQ rBi, rT1;         \
 211         ANDQ rBo, rT1;         \
 212         XORQ rBe, rT1;         \
 213         MOVQ rT1, _ke(oState); \
 214         K_RT1_RCE;             \
 215                                \
 216         XORQ rDa, rBu;         \
 217         ROLQ $18, rBu;         \
 218         NOTQ rBo;              \
 219         MOVQ rBo, rT1;         \
 220         ANDQ rBu, rT1;         \
 221         XORQ rBi, rT1;         \
 222         MOVQ rT1, _ki(oState); \
 223                                \
 224         MOVQ rBu, rT1;         \
 225         ORQ  rBa, rT1;         \
 226         XORQ rBo, rT1;         \
 227         MOVQ rT1, _ko(oState); \
 228                                \
 229         ANDQ rBe, rBa;         \
 230         XORQ rBu, rBa;         \
 231         MOVQ rBa, _ku(oState); \
 232         K_RBA_RCU;             \
 233                                \
 234         /* Result m */         \
 235         MOVQ _ga(iState), rBe; \
 236         XORQ rDa, rBe;         \
 237         MOVQ _ke(iState), rBi; \
 238         ROLQ $36, rBe;         \
 239         XORQ rDe, rBi;         \
 240         MOVQ _bu(iState), rBa; \
 241         ROLQ $10, rBi;         \
 242         MOVQ rBe, rT1;         \
 243         MOVQ _mi(iState), rBo; \
 244         ANDQ rBi, rT1;         \
 245         XORQ rDu, rBa;         \
 246         MOVQ _so(iState), rBu; \
 247         ROLQ $27, rBa;         \
 248         XORQ rBa, rT1;         \
 249         MOVQ rT1, _ma(oState); \
 250         M_RT1_RCA;             \
 251                                \
 252         XORQ rDi, rBo;         \
 253         ROLQ $15, rBo;         \
 254         MOVQ rBi, rT1;         \
 255         ORQ  rBo, rT1;         \
 256         XORQ rBe, rT1;         \
 257         MOVQ rT1, _me(oState); \
 258         M_RT1_RCE;             \
 259                                \
 260         XORQ rDo, rBu;         \
 261         ROLQ $56, rBu;         \
 262         NOTQ rBo;              \
 263         MOVQ rBo, rT1;         \
 264         ORQ  rBu, rT1;         \
 265         XORQ rBi, rT1;         \
 266         MOVQ rT1, _mi(oState); \
 267                                \
 268         ORQ  rBa, rBe;         \
 269         XORQ rBu, rBe;         \
 270         MOVQ rBe, _mu(oState); \
 271                                \
 272         ANDQ rBa, rBu;         \
 273         XORQ rBo, rBu;         \
 274         MOVQ rBu, _mo(oState); \
 275         M_RBE_RCU;             \
 276                                \
 277         /* Result s */         \
 278         MOVQ _bi(iState), rBa; \
 279         MOVQ _go(iState), rBe; \
 280         MOVQ _ku(iState), rBi; \
 281         XORQ rDi, rBa;         \
 282         MOVQ _ma(iState), rBo; \
 283         ROLQ $62, rBa;         \
 284         XORQ rDo, rBe;         \
 285         MOVQ _se(iState), rBu; \
 286         ROLQ $55, rBe;         \
 287                                \
 288         XORQ rDu, rBi;         \
 289         MOVQ rBa, rDu;         \
 290         XORQ rDe, rBu;         \
 291         ROLQ $2, rBu;          \
 292         ANDQ rBe, rDu;         \
 293         XORQ rBu, rDu;         \
 294         MOVQ rDu, _su(oState); \
 295                                \
 296         ROLQ $39, rBi;         \
 297         S_RDU_RCU;             \
 298         NOTQ rBe;              \
 299         XORQ rDa, rBo;         \
 300         MOVQ rBe, rDa;         \
 301         ANDQ rBi, rDa;         \
 302         XORQ rBa, rDa;         \
 303         MOVQ rDa, _sa(oState); \
 304         S_RDA_RCA;             \
 305                                \
 306         ROLQ $41, rBo;         \
 307         MOVQ rBi, rDe;         \
 308         ORQ  rBo, rDe;         \
 309         XORQ rBe, rDe;         \
 310         MOVQ rDe, _se(oState); \
 311         S_RDE_RCE;             \
 312                                \
 313         MOVQ rBo, rDi;         \
 314         MOVQ rBu, rDo;         \
 315         ANDQ rBu, rDi;         \
 316         ORQ  rBa, rDo;         \
 317         XORQ rBi, rDi;         \
 318         XORQ rBo, rDo;         \
 319         MOVQ rDi, _si(oState); \
 320         MOVQ rDo, _so(oState)  \
 321
 322 // func keccakF1600(state *[25]uint64)
 323 TEXT ·keccakF1600(SB), 0, $200-8
 324         MOVQ state+0(FP), rpState
 325
 326         // Convert the user state into an internal state
 327         NOTQ _be(rpState)
 328         NOTQ _bi(rpState)
 329         NOTQ _go(rpState)
 330         NOTQ _ki(rpState)
 331         NOTQ _mi(rpState)
 332         NOTQ _sa(rpState)
 333
 334         // Execute the KeccakF permutation
 335         MOVQ _ba(rpState), rCa
 336         MOVQ _be(rpState), rCe
 337         MOVQ _bu(rpState), rCu
 338
 339         XORQ _ga(rpState), rCa
 340         XORQ _ge(rpState), rCe
 341         XORQ _gu(rpState), rCu
 342
 343         XORQ _ka(rpState), rCa
 344         XORQ _ke(rpState), rCe
 345         XORQ _ku(rpState), rCu
 346
 347         XORQ _ma(rpState), rCa
 348         XORQ _me(rpState), rCe
 349         XORQ _mu(rpState), rCu
 350
 351         XORQ _sa(rpState), rCa
 352         XORQ _se(rpState), rCe
 353         MOVQ _si(rpState), rDi
 354         MOVQ _so(rpState), rDo
 355         XORQ _su(rpState), rCu
 356
 357         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)
 358         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)
 359         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)
 360         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)
 361         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)
 362         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)
 363         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)
 364         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)
 365         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)
 366         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)
 367         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)
 368         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)
 369         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)
 370         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)
 371         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)
 372         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)
 373         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)
 374         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)
 375         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)
 376         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)
 377         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)
 378         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)
 379         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)
 380         mKeccakRound(rpStack, rpState, $0x8000000080008008, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP)
 381
 382         // Revert the internal state to the user state
 383         NOTQ _be(rpState)
 384         NOTQ _bi(rpState)
 385         NOTQ _go(rpState)
 386         NOTQ _ki(rpState)
 387         NOTQ _mi(rpState)
 388         NOTQ _sa(rpState)
 389
 390         RET