← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/golang.org/x/crypto/sha3/keccakf_amd64.s

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/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
        SUBQ $(8*25), SP
 
326
 
 
327
        // Convert the user state into an internal state
 
328
        NOTQ _be(rpState)
 
329
        NOTQ _bi(rpState)
 
330
        NOTQ _go(rpState)
 
331
        NOTQ _ki(rpState)
 
332
        NOTQ _mi(rpState)
 
333
        NOTQ _sa(rpState)
 
334
 
 
335
        // Execute the KeccakF permutation
 
336
        MOVQ _ba(rpState), rCa
 
337
        MOVQ _be(rpState), rCe
 
338
        MOVQ _bu(rpState), rCu
 
339
 
 
340
        XORQ _ga(rpState), rCa
 
341
        XORQ _ge(rpState), rCe
 
342
        XORQ _gu(rpState), rCu
 
343
 
 
344
        XORQ _ka(rpState), rCa
 
345
        XORQ _ke(rpState), rCe
 
346
        XORQ _ku(rpState), rCu
 
347
 
 
348
        XORQ _ma(rpState), rCa
 
349
        XORQ _me(rpState), rCe
 
350
        XORQ _mu(rpState), rCu
 
351
 
 
352
        XORQ _sa(rpState), rCa
 
353
        XORQ _se(rpState), rCe
 
354
        MOVQ _si(rpState), rDi
 
355
        MOVQ _so(rpState), rDo
 
356
        XORQ _su(rpState), rCu
 
357
 
 
358
        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)
 
359
        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)
 
360
        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)
 
361
        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)
 
362
        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)
 
363
        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)
 
364
        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)
 
365
        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)
 
366
        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)
 
367
        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)
 
368
        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)
 
369
        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)
 
370
        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)
 
371
        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)
 
372
        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)
 
373
        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)
 
374
        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)
 
375
        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)
 
376
        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)
 
377
        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)
 
378
        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)
 
379
        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)
 
380
        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)
 
381
        mKeccakRound(rpStack, rpState, $0x8000000080008008, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP)
 
382
 
 
383
        // Revert the internal state to the user state
 
384
        NOTQ _be(rpState)
 
385
        NOTQ _bi(rpState)
 
386
        NOTQ _go(rpState)
 
387
        NOTQ _ki(rpState)
 
388
        NOTQ _mi(rpState)
 
389
        NOTQ _sa(rpState)
 
390
 
 
391
        ADDQ $(8*25), SP
 
392
        RET