mirror
/
oragono
mirror of https://github.com/oragono/oragono
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 67 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5229 Commits
19 Branches
Tree: 6be1ec3ad6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6be1ec3ad6'
${ noResults }
oragono/vendor/golang.org/x/crypto/sha3/keccakf_amd64.s

keccakf_amd64.s 14KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390 
  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. //go:build amd64 && !purego && gc

  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(a *[25]uint64)

  323. TEXT ·keccakF1600(SB), 0, $200-8

  324. 	MOVQ a+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