p521_fiat64.mx raw
1 // Code generated by Fiat Cryptography. DO NOT EDIT.
2 //
3 // Autogenerated: word_by_word_montgomery --lang Go --no-wide-int --cmovznz-by-mul --relax-primitive-carry-to-bitwidth 32,64 --internal-static --public-function-case camelCase --public-type-case camelCase --private-function-case camelCase --private-type-case camelCase --doc-text-before-function-name '' --doc-newline-before-package-declaration --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --package-name fiat --no-prefix-fiat p521 64 '2^521 - 1' mul square add sub one from_montgomery to_montgomery selectznz to_bytes from_bytes
4 //
5 // curve description: p521
6 //
7 // machine_wordsize = 64 (from "64")
8 //
9 // requested operations: mul, square, add, sub, one, from_montgomery, to_montgomery, selectznz, to_bytes, from_bytes
10 //
11 // m = 0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff (from "2^521 - 1")
12 //
13 //
14 //
15 // NOTE: In addition to the bounds specified above each function, all
16 //
17 // functions synthesized for this Montgomery arithmetic require the
18 //
19 // input to be strictly less than the prime modulus (m), and also
20 //
21 // require the input to be in the unique saturated representation.
22 //
23 // All functions also ensure that these two properties are true of
24 //
25 // return values.
26 //
27 //
28 //
29 // Computed values:
30 //
31 // eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) + (z[6] << 0x180) + (z[7] << 0x1c0) + (z[8] << 2^9)
32 //
33 // bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) + (z[48] << 0x180) + (z[49] << 0x188) + (z[50] << 0x190) + (z[51] << 0x198) + (z[52] << 0x1a0) + (z[53] << 0x1a8) + (z[54] << 0x1b0) + (z[55] << 0x1b8) + (z[56] << 0x1c0) + (z[57] << 0x1c8) + (z[58] << 0x1d0) + (z[59] << 0x1d8) + (z[60] << 0x1e0) + (z[61] << 0x1e8) + (z[62] << 0x1f0) + (z[63] << 0x1f8) + (z[64] << 2^9) + (z[65] << 0x208)
34 //
35 // twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) + (z[6] << 0x180) + (z[7] << 0x1c0) + (z[8] << 2^9) in
36 //
37 // if x1 & (2^576-1) < 2^575 then x1 & (2^576-1) else (x1 & (2^576-1)) - 2^576
38
39 package fiat
40
41 import "math/bits"
42
43 type p521Uint1 uint64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927
44 type p521Int1 int64 // We use uint64 instead of a more narrow type for performance reasons; see https://github.com/mit-plv/fiat-crypto/pull/1006#issuecomment-892625927
45
46 // The type p521MontgomeryDomainFieldElement is a field element in the Montgomery domain.
47 //
48 // Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
49 type p521MontgomeryDomainFieldElement [9]uint64
50
51 // The type p521NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain.
52 //
53 // Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
54 type p521NonMontgomeryDomainFieldElement [9]uint64
55
56 // p521CmovznzU64 is a single-word conditional move.
57 //
58 // Postconditions:
59 //
60 // out1 = (if arg1 = 0 then arg2 else arg3)
61 //
62 // Input Bounds:
63 //
64 // arg1: [0x0 ~> 0x1]
65 // arg2: [0x0 ~> 0xffffffffffffffff]
66 // arg3: [0x0 ~> 0xffffffffffffffff]
67 //
68 // Output Bounds:
69 //
70 // out1: [0x0 ~> 0xffffffffffffffff]
71 func p521CmovznzU64(out1 *uint64, arg1 p521Uint1, arg2 uint64, arg3 uint64) {
72 x1 := (uint64(arg1) * 0xffffffffffffffff)
73 x2 := ((x1 & arg3) | ((^x1) & arg2))
74 *out1 = x2
75 }
76
77 // p521Mul multiplies two field elements in the Montgomery domain.
78 //
79 // Preconditions:
80 //
81 // 0 ≤ eval arg1 < m
82 // 0 ≤ eval arg2 < m
83 //
84 // Postconditions:
85 //
86 // eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m
87 // 0 ≤ eval out1 < m
88 func p521Mul(out1 *p521MontgomeryDomainFieldElement, arg1 *p521MontgomeryDomainFieldElement, arg2 *p521MontgomeryDomainFieldElement) {
89 x1 := arg1[1]
90 x2 := arg1[2]
91 x3 := arg1[3]
92 x4 := arg1[4]
93 x5 := arg1[5]
94 x6 := arg1[6]
95 x7 := arg1[7]
96 x8 := arg1[8]
97 x9 := arg1[0]
98 var x10 uint64
99 var x11 uint64
100 x11, x10 = bits.Mul64(x9, arg2[8])
101 var x12 uint64
102 var x13 uint64
103 x13, x12 = bits.Mul64(x9, arg2[7])
104 var x14 uint64
105 var x15 uint64
106 x15, x14 = bits.Mul64(x9, arg2[6])
107 var x16 uint64
108 var x17 uint64
109 x17, x16 = bits.Mul64(x9, arg2[5])
110 var x18 uint64
111 var x19 uint64
112 x19, x18 = bits.Mul64(x9, arg2[4])
113 var x20 uint64
114 var x21 uint64
115 x21, x20 = bits.Mul64(x9, arg2[3])
116 var x22 uint64
117 var x23 uint64
118 x23, x22 = bits.Mul64(x9, arg2[2])
119 var x24 uint64
120 var x25 uint64
121 x25, x24 = bits.Mul64(x9, arg2[1])
122 var x26 uint64
123 var x27 uint64
124 x27, x26 = bits.Mul64(x9, arg2[0])
125 var x28 uint64
126 var x29 uint64
127 x28, x29 = bits.Add64(x27, x24, uint64(0x0))
128 var x30 uint64
129 var x31 uint64
130 x30, x31 = bits.Add64(x25, x22, uint64(p521Uint1(x29)))
131 var x32 uint64
132 var x33 uint64
133 x32, x33 = bits.Add64(x23, x20, uint64(p521Uint1(x31)))
134 var x34 uint64
135 var x35 uint64
136 x34, x35 = bits.Add64(x21, x18, uint64(p521Uint1(x33)))
137 var x36 uint64
138 var x37 uint64
139 x36, x37 = bits.Add64(x19, x16, uint64(p521Uint1(x35)))
140 var x38 uint64
141 var x39 uint64
142 x38, x39 = bits.Add64(x17, x14, uint64(p521Uint1(x37)))
143 var x40 uint64
144 var x41 uint64
145 x40, x41 = bits.Add64(x15, x12, uint64(p521Uint1(x39)))
146 var x42 uint64
147 var x43 uint64
148 x42, x43 = bits.Add64(x13, x10, uint64(p521Uint1(x41)))
149 x44 := (uint64(p521Uint1(x43)) + x11)
150 var x45 uint64
151 var x46 uint64
152 x46, x45 = bits.Mul64(x26, 0x1ff)
153 var x47 uint64
154 var x48 uint64
155 x48, x47 = bits.Mul64(x26, 0xffffffffffffffff)
156 var x49 uint64
157 var x50 uint64
158 x50, x49 = bits.Mul64(x26, 0xffffffffffffffff)
159 var x51 uint64
160 var x52 uint64
161 x52, x51 = bits.Mul64(x26, 0xffffffffffffffff)
162 var x53 uint64
163 var x54 uint64
164 x54, x53 = bits.Mul64(x26, 0xffffffffffffffff)
165 var x55 uint64
166 var x56 uint64
167 x56, x55 = bits.Mul64(x26, 0xffffffffffffffff)
168 var x57 uint64
169 var x58 uint64
170 x58, x57 = bits.Mul64(x26, 0xffffffffffffffff)
171 var x59 uint64
172 var x60 uint64
173 x60, x59 = bits.Mul64(x26, 0xffffffffffffffff)
174 var x61 uint64
175 var x62 uint64
176 x62, x61 = bits.Mul64(x26, 0xffffffffffffffff)
177 var x63 uint64
178 var x64 uint64
179 x63, x64 = bits.Add64(x62, x59, uint64(0x0))
180 var x65 uint64
181 var x66 uint64
182 x65, x66 = bits.Add64(x60, x57, uint64(p521Uint1(x64)))
183 var x67 uint64
184 var x68 uint64
185 x67, x68 = bits.Add64(x58, x55, uint64(p521Uint1(x66)))
186 var x69 uint64
187 var x70 uint64
188 x69, x70 = bits.Add64(x56, x53, uint64(p521Uint1(x68)))
189 var x71 uint64
190 var x72 uint64
191 x71, x72 = bits.Add64(x54, x51, uint64(p521Uint1(x70)))
192 var x73 uint64
193 var x74 uint64
194 x73, x74 = bits.Add64(x52, x49, uint64(p521Uint1(x72)))
195 var x75 uint64
196 var x76 uint64
197 x75, x76 = bits.Add64(x50, x47, uint64(p521Uint1(x74)))
198 var x77 uint64
199 var x78 uint64
200 x77, x78 = bits.Add64(x48, x45, uint64(p521Uint1(x76)))
201 x79 := (uint64(p521Uint1(x78)) + x46)
202 var x81 uint64
203 _, x81 = bits.Add64(x26, x61, uint64(0x0))
204 var x82 uint64
205 var x83 uint64
206 x82, x83 = bits.Add64(x28, x63, uint64(p521Uint1(x81)))
207 var x84 uint64
208 var x85 uint64
209 x84, x85 = bits.Add64(x30, x65, uint64(p521Uint1(x83)))
210 var x86 uint64
211 var x87 uint64
212 x86, x87 = bits.Add64(x32, x67, uint64(p521Uint1(x85)))
213 var x88 uint64
214 var x89 uint64
215 x88, x89 = bits.Add64(x34, x69, uint64(p521Uint1(x87)))
216 var x90 uint64
217 var x91 uint64
218 x90, x91 = bits.Add64(x36, x71, uint64(p521Uint1(x89)))
219 var x92 uint64
220 var x93 uint64
221 x92, x93 = bits.Add64(x38, x73, uint64(p521Uint1(x91)))
222 var x94 uint64
223 var x95 uint64
224 x94, x95 = bits.Add64(x40, x75, uint64(p521Uint1(x93)))
225 var x96 uint64
226 var x97 uint64
227 x96, x97 = bits.Add64(x42, x77, uint64(p521Uint1(x95)))
228 var x98 uint64
229 var x99 uint64
230 x98, x99 = bits.Add64(x44, x79, uint64(p521Uint1(x97)))
231 var x100 uint64
232 var x101 uint64
233 x101, x100 = bits.Mul64(x1, arg2[8])
234 var x102 uint64
235 var x103 uint64
236 x103, x102 = bits.Mul64(x1, arg2[7])
237 var x104 uint64
238 var x105 uint64
239 x105, x104 = bits.Mul64(x1, arg2[6])
240 var x106 uint64
241 var x107 uint64
242 x107, x106 = bits.Mul64(x1, arg2[5])
243 var x108 uint64
244 var x109 uint64
245 x109, x108 = bits.Mul64(x1, arg2[4])
246 var x110 uint64
247 var x111 uint64
248 x111, x110 = bits.Mul64(x1, arg2[3])
249 var x112 uint64
250 var x113 uint64
251 x113, x112 = bits.Mul64(x1, arg2[2])
252 var x114 uint64
253 var x115 uint64
254 x115, x114 = bits.Mul64(x1, arg2[1])
255 var x116 uint64
256 var x117 uint64
257 x117, x116 = bits.Mul64(x1, arg2[0])
258 var x118 uint64
259 var x119 uint64
260 x118, x119 = bits.Add64(x117, x114, uint64(0x0))
261 var x120 uint64
262 var x121 uint64
263 x120, x121 = bits.Add64(x115, x112, uint64(p521Uint1(x119)))
264 var x122 uint64
265 var x123 uint64
266 x122, x123 = bits.Add64(x113, x110, uint64(p521Uint1(x121)))
267 var x124 uint64
268 var x125 uint64
269 x124, x125 = bits.Add64(x111, x108, uint64(p521Uint1(x123)))
270 var x126 uint64
271 var x127 uint64
272 x126, x127 = bits.Add64(x109, x106, uint64(p521Uint1(x125)))
273 var x128 uint64
274 var x129 uint64
275 x128, x129 = bits.Add64(x107, x104, uint64(p521Uint1(x127)))
276 var x130 uint64
277 var x131 uint64
278 x130, x131 = bits.Add64(x105, x102, uint64(p521Uint1(x129)))
279 var x132 uint64
280 var x133 uint64
281 x132, x133 = bits.Add64(x103, x100, uint64(p521Uint1(x131)))
282 x134 := (uint64(p521Uint1(x133)) + x101)
283 var x135 uint64
284 var x136 uint64
285 x135, x136 = bits.Add64(x82, x116, uint64(0x0))
286 var x137 uint64
287 var x138 uint64
288 x137, x138 = bits.Add64(x84, x118, uint64(p521Uint1(x136)))
289 var x139 uint64
290 var x140 uint64
291 x139, x140 = bits.Add64(x86, x120, uint64(p521Uint1(x138)))
292 var x141 uint64
293 var x142 uint64
294 x141, x142 = bits.Add64(x88, x122, uint64(p521Uint1(x140)))
295 var x143 uint64
296 var x144 uint64
297 x143, x144 = bits.Add64(x90, x124, uint64(p521Uint1(x142)))
298 var x145 uint64
299 var x146 uint64
300 x145, x146 = bits.Add64(x92, x126, uint64(p521Uint1(x144)))
301 var x147 uint64
302 var x148 uint64
303 x147, x148 = bits.Add64(x94, x128, uint64(p521Uint1(x146)))
304 var x149 uint64
305 var x150 uint64
306 x149, x150 = bits.Add64(x96, x130, uint64(p521Uint1(x148)))
307 var x151 uint64
308 var x152 uint64
309 x151, x152 = bits.Add64(x98, x132, uint64(p521Uint1(x150)))
310 var x153 uint64
311 var x154 uint64
312 x153, x154 = bits.Add64(uint64(p521Uint1(x99)), x134, uint64(p521Uint1(x152)))
313 var x155 uint64
314 var x156 uint64
315 x156, x155 = bits.Mul64(x135, 0x1ff)
316 var x157 uint64
317 var x158 uint64
318 x158, x157 = bits.Mul64(x135, 0xffffffffffffffff)
319 var x159 uint64
320 var x160 uint64
321 x160, x159 = bits.Mul64(x135, 0xffffffffffffffff)
322 var x161 uint64
323 var x162 uint64
324 x162, x161 = bits.Mul64(x135, 0xffffffffffffffff)
325 var x163 uint64
326 var x164 uint64
327 x164, x163 = bits.Mul64(x135, 0xffffffffffffffff)
328 var x165 uint64
329 var x166 uint64
330 x166, x165 = bits.Mul64(x135, 0xffffffffffffffff)
331 var x167 uint64
332 var x168 uint64
333 x168, x167 = bits.Mul64(x135, 0xffffffffffffffff)
334 var x169 uint64
335 var x170 uint64
336 x170, x169 = bits.Mul64(x135, 0xffffffffffffffff)
337 var x171 uint64
338 var x172 uint64
339 x172, x171 = bits.Mul64(x135, 0xffffffffffffffff)
340 var x173 uint64
341 var x174 uint64
342 x173, x174 = bits.Add64(x172, x169, uint64(0x0))
343 var x175 uint64
344 var x176 uint64
345 x175, x176 = bits.Add64(x170, x167, uint64(p521Uint1(x174)))
346 var x177 uint64
347 var x178 uint64
348 x177, x178 = bits.Add64(x168, x165, uint64(p521Uint1(x176)))
349 var x179 uint64
350 var x180 uint64
351 x179, x180 = bits.Add64(x166, x163, uint64(p521Uint1(x178)))
352 var x181 uint64
353 var x182 uint64
354 x181, x182 = bits.Add64(x164, x161, uint64(p521Uint1(x180)))
355 var x183 uint64
356 var x184 uint64
357 x183, x184 = bits.Add64(x162, x159, uint64(p521Uint1(x182)))
358 var x185 uint64
359 var x186 uint64
360 x185, x186 = bits.Add64(x160, x157, uint64(p521Uint1(x184)))
361 var x187 uint64
362 var x188 uint64
363 x187, x188 = bits.Add64(x158, x155, uint64(p521Uint1(x186)))
364 x189 := (uint64(p521Uint1(x188)) + x156)
365 var x191 uint64
366 _, x191 = bits.Add64(x135, x171, uint64(0x0))
367 var x192 uint64
368 var x193 uint64
369 x192, x193 = bits.Add64(x137, x173, uint64(p521Uint1(x191)))
370 var x194 uint64
371 var x195 uint64
372 x194, x195 = bits.Add64(x139, x175, uint64(p521Uint1(x193)))
373 var x196 uint64
374 var x197 uint64
375 x196, x197 = bits.Add64(x141, x177, uint64(p521Uint1(x195)))
376 var x198 uint64
377 var x199 uint64
378 x198, x199 = bits.Add64(x143, x179, uint64(p521Uint1(x197)))
379 var x200 uint64
380 var x201 uint64
381 x200, x201 = bits.Add64(x145, x181, uint64(p521Uint1(x199)))
382 var x202 uint64
383 var x203 uint64
384 x202, x203 = bits.Add64(x147, x183, uint64(p521Uint1(x201)))
385 var x204 uint64
386 var x205 uint64
387 x204, x205 = bits.Add64(x149, x185, uint64(p521Uint1(x203)))
388 var x206 uint64
389 var x207 uint64
390 x206, x207 = bits.Add64(x151, x187, uint64(p521Uint1(x205)))
391 var x208 uint64
392 var x209 uint64
393 x208, x209 = bits.Add64(x153, x189, uint64(p521Uint1(x207)))
394 x210 := (uint64(p521Uint1(x209)) + uint64(p521Uint1(x154)))
395 var x211 uint64
396 var x212 uint64
397 x212, x211 = bits.Mul64(x2, arg2[8])
398 var x213 uint64
399 var x214 uint64
400 x214, x213 = bits.Mul64(x2, arg2[7])
401 var x215 uint64
402 var x216 uint64
403 x216, x215 = bits.Mul64(x2, arg2[6])
404 var x217 uint64
405 var x218 uint64
406 x218, x217 = bits.Mul64(x2, arg2[5])
407 var x219 uint64
408 var x220 uint64
409 x220, x219 = bits.Mul64(x2, arg2[4])
410 var x221 uint64
411 var x222 uint64
412 x222, x221 = bits.Mul64(x2, arg2[3])
413 var x223 uint64
414 var x224 uint64
415 x224, x223 = bits.Mul64(x2, arg2[2])
416 var x225 uint64
417 var x226 uint64
418 x226, x225 = bits.Mul64(x2, arg2[1])
419 var x227 uint64
420 var x228 uint64
421 x228, x227 = bits.Mul64(x2, arg2[0])
422 var x229 uint64
423 var x230 uint64
424 x229, x230 = bits.Add64(x228, x225, uint64(0x0))
425 var x231 uint64
426 var x232 uint64
427 x231, x232 = bits.Add64(x226, x223, uint64(p521Uint1(x230)))
428 var x233 uint64
429 var x234 uint64
430 x233, x234 = bits.Add64(x224, x221, uint64(p521Uint1(x232)))
431 var x235 uint64
432 var x236 uint64
433 x235, x236 = bits.Add64(x222, x219, uint64(p521Uint1(x234)))
434 var x237 uint64
435 var x238 uint64
436 x237, x238 = bits.Add64(x220, x217, uint64(p521Uint1(x236)))
437 var x239 uint64
438 var x240 uint64
439 x239, x240 = bits.Add64(x218, x215, uint64(p521Uint1(x238)))
440 var x241 uint64
441 var x242 uint64
442 x241, x242 = bits.Add64(x216, x213, uint64(p521Uint1(x240)))
443 var x243 uint64
444 var x244 uint64
445 x243, x244 = bits.Add64(x214, x211, uint64(p521Uint1(x242)))
446 x245 := (uint64(p521Uint1(x244)) + x212)
447 var x246 uint64
448 var x247 uint64
449 x246, x247 = bits.Add64(x192, x227, uint64(0x0))
450 var x248 uint64
451 var x249 uint64
452 x248, x249 = bits.Add64(x194, x229, uint64(p521Uint1(x247)))
453 var x250 uint64
454 var x251 uint64
455 x250, x251 = bits.Add64(x196, x231, uint64(p521Uint1(x249)))
456 var x252 uint64
457 var x253 uint64
458 x252, x253 = bits.Add64(x198, x233, uint64(p521Uint1(x251)))
459 var x254 uint64
460 var x255 uint64
461 x254, x255 = bits.Add64(x200, x235, uint64(p521Uint1(x253)))
462 var x256 uint64
463 var x257 uint64
464 x256, x257 = bits.Add64(x202, x237, uint64(p521Uint1(x255)))
465 var x258 uint64
466 var x259 uint64
467 x258, x259 = bits.Add64(x204, x239, uint64(p521Uint1(x257)))
468 var x260 uint64
469 var x261 uint64
470 x260, x261 = bits.Add64(x206, x241, uint64(p521Uint1(x259)))
471 var x262 uint64
472 var x263 uint64
473 x262, x263 = bits.Add64(x208, x243, uint64(p521Uint1(x261)))
474 var x264 uint64
475 var x265 uint64
476 x264, x265 = bits.Add64(x210, x245, uint64(p521Uint1(x263)))
477 var x266 uint64
478 var x267 uint64
479 x267, x266 = bits.Mul64(x246, 0x1ff)
480 var x268 uint64
481 var x269 uint64
482 x269, x268 = bits.Mul64(x246, 0xffffffffffffffff)
483 var x270 uint64
484 var x271 uint64
485 x271, x270 = bits.Mul64(x246, 0xffffffffffffffff)
486 var x272 uint64
487 var x273 uint64
488 x273, x272 = bits.Mul64(x246, 0xffffffffffffffff)
489 var x274 uint64
490 var x275 uint64
491 x275, x274 = bits.Mul64(x246, 0xffffffffffffffff)
492 var x276 uint64
493 var x277 uint64
494 x277, x276 = bits.Mul64(x246, 0xffffffffffffffff)
495 var x278 uint64
496 var x279 uint64
497 x279, x278 = bits.Mul64(x246, 0xffffffffffffffff)
498 var x280 uint64
499 var x281 uint64
500 x281, x280 = bits.Mul64(x246, 0xffffffffffffffff)
501 var x282 uint64
502 var x283 uint64
503 x283, x282 = bits.Mul64(x246, 0xffffffffffffffff)
504 var x284 uint64
505 var x285 uint64
506 x284, x285 = bits.Add64(x283, x280, uint64(0x0))
507 var x286 uint64
508 var x287 uint64
509 x286, x287 = bits.Add64(x281, x278, uint64(p521Uint1(x285)))
510 var x288 uint64
511 var x289 uint64
512 x288, x289 = bits.Add64(x279, x276, uint64(p521Uint1(x287)))
513 var x290 uint64
514 var x291 uint64
515 x290, x291 = bits.Add64(x277, x274, uint64(p521Uint1(x289)))
516 var x292 uint64
517 var x293 uint64
518 x292, x293 = bits.Add64(x275, x272, uint64(p521Uint1(x291)))
519 var x294 uint64
520 var x295 uint64
521 x294, x295 = bits.Add64(x273, x270, uint64(p521Uint1(x293)))
522 var x296 uint64
523 var x297 uint64
524 x296, x297 = bits.Add64(x271, x268, uint64(p521Uint1(x295)))
525 var x298 uint64
526 var x299 uint64
527 x298, x299 = bits.Add64(x269, x266, uint64(p521Uint1(x297)))
528 x300 := (uint64(p521Uint1(x299)) + x267)
529 var x302 uint64
530 _, x302 = bits.Add64(x246, x282, uint64(0x0))
531 var x303 uint64
532 var x304 uint64
533 x303, x304 = bits.Add64(x248, x284, uint64(p521Uint1(x302)))
534 var x305 uint64
535 var x306 uint64
536 x305, x306 = bits.Add64(x250, x286, uint64(p521Uint1(x304)))
537 var x307 uint64
538 var x308 uint64
539 x307, x308 = bits.Add64(x252, x288, uint64(p521Uint1(x306)))
540 var x309 uint64
541 var x310 uint64
542 x309, x310 = bits.Add64(x254, x290, uint64(p521Uint1(x308)))
543 var x311 uint64
544 var x312 uint64
545 x311, x312 = bits.Add64(x256, x292, uint64(p521Uint1(x310)))
546 var x313 uint64
547 var x314 uint64
548 x313, x314 = bits.Add64(x258, x294, uint64(p521Uint1(x312)))
549 var x315 uint64
550 var x316 uint64
551 x315, x316 = bits.Add64(x260, x296, uint64(p521Uint1(x314)))
552 var x317 uint64
553 var x318 uint64
554 x317, x318 = bits.Add64(x262, x298, uint64(p521Uint1(x316)))
555 var x319 uint64
556 var x320 uint64
557 x319, x320 = bits.Add64(x264, x300, uint64(p521Uint1(x318)))
558 x321 := (uint64(p521Uint1(x320)) + uint64(p521Uint1(x265)))
559 var x322 uint64
560 var x323 uint64
561 x323, x322 = bits.Mul64(x3, arg2[8])
562 var x324 uint64
563 var x325 uint64
564 x325, x324 = bits.Mul64(x3, arg2[7])
565 var x326 uint64
566 var x327 uint64
567 x327, x326 = bits.Mul64(x3, arg2[6])
568 var x328 uint64
569 var x329 uint64
570 x329, x328 = bits.Mul64(x3, arg2[5])
571 var x330 uint64
572 var x331 uint64
573 x331, x330 = bits.Mul64(x3, arg2[4])
574 var x332 uint64
575 var x333 uint64
576 x333, x332 = bits.Mul64(x3, arg2[3])
577 var x334 uint64
578 var x335 uint64
579 x335, x334 = bits.Mul64(x3, arg2[2])
580 var x336 uint64
581 var x337 uint64
582 x337, x336 = bits.Mul64(x3, arg2[1])
583 var x338 uint64
584 var x339 uint64
585 x339, x338 = bits.Mul64(x3, arg2[0])
586 var x340 uint64
587 var x341 uint64
588 x340, x341 = bits.Add64(x339, x336, uint64(0x0))
589 var x342 uint64
590 var x343 uint64
591 x342, x343 = bits.Add64(x337, x334, uint64(p521Uint1(x341)))
592 var x344 uint64
593 var x345 uint64
594 x344, x345 = bits.Add64(x335, x332, uint64(p521Uint1(x343)))
595 var x346 uint64
596 var x347 uint64
597 x346, x347 = bits.Add64(x333, x330, uint64(p521Uint1(x345)))
598 var x348 uint64
599 var x349 uint64
600 x348, x349 = bits.Add64(x331, x328, uint64(p521Uint1(x347)))
601 var x350 uint64
602 var x351 uint64
603 x350, x351 = bits.Add64(x329, x326, uint64(p521Uint1(x349)))
604 var x352 uint64
605 var x353 uint64
606 x352, x353 = bits.Add64(x327, x324, uint64(p521Uint1(x351)))
607 var x354 uint64
608 var x355 uint64
609 x354, x355 = bits.Add64(x325, x322, uint64(p521Uint1(x353)))
610 x356 := (uint64(p521Uint1(x355)) + x323)
611 var x357 uint64
612 var x358 uint64
613 x357, x358 = bits.Add64(x303, x338, uint64(0x0))
614 var x359 uint64
615 var x360 uint64
616 x359, x360 = bits.Add64(x305, x340, uint64(p521Uint1(x358)))
617 var x361 uint64
618 var x362 uint64
619 x361, x362 = bits.Add64(x307, x342, uint64(p521Uint1(x360)))
620 var x363 uint64
621 var x364 uint64
622 x363, x364 = bits.Add64(x309, x344, uint64(p521Uint1(x362)))
623 var x365 uint64
624 var x366 uint64
625 x365, x366 = bits.Add64(x311, x346, uint64(p521Uint1(x364)))
626 var x367 uint64
627 var x368 uint64
628 x367, x368 = bits.Add64(x313, x348, uint64(p521Uint1(x366)))
629 var x369 uint64
630 var x370 uint64
631 x369, x370 = bits.Add64(x315, x350, uint64(p521Uint1(x368)))
632 var x371 uint64
633 var x372 uint64
634 x371, x372 = bits.Add64(x317, x352, uint64(p521Uint1(x370)))
635 var x373 uint64
636 var x374 uint64
637 x373, x374 = bits.Add64(x319, x354, uint64(p521Uint1(x372)))
638 var x375 uint64
639 var x376 uint64
640 x375, x376 = bits.Add64(x321, x356, uint64(p521Uint1(x374)))
641 var x377 uint64
642 var x378 uint64
643 x378, x377 = bits.Mul64(x357, 0x1ff)
644 var x379 uint64
645 var x380 uint64
646 x380, x379 = bits.Mul64(x357, 0xffffffffffffffff)
647 var x381 uint64
648 var x382 uint64
649 x382, x381 = bits.Mul64(x357, 0xffffffffffffffff)
650 var x383 uint64
651 var x384 uint64
652 x384, x383 = bits.Mul64(x357, 0xffffffffffffffff)
653 var x385 uint64
654 var x386 uint64
655 x386, x385 = bits.Mul64(x357, 0xffffffffffffffff)
656 var x387 uint64
657 var x388 uint64
658 x388, x387 = bits.Mul64(x357, 0xffffffffffffffff)
659 var x389 uint64
660 var x390 uint64
661 x390, x389 = bits.Mul64(x357, 0xffffffffffffffff)
662 var x391 uint64
663 var x392 uint64
664 x392, x391 = bits.Mul64(x357, 0xffffffffffffffff)
665 var x393 uint64
666 var x394 uint64
667 x394, x393 = bits.Mul64(x357, 0xffffffffffffffff)
668 var x395 uint64
669 var x396 uint64
670 x395, x396 = bits.Add64(x394, x391, uint64(0x0))
671 var x397 uint64
672 var x398 uint64
673 x397, x398 = bits.Add64(x392, x389, uint64(p521Uint1(x396)))
674 var x399 uint64
675 var x400 uint64
676 x399, x400 = bits.Add64(x390, x387, uint64(p521Uint1(x398)))
677 var x401 uint64
678 var x402 uint64
679 x401, x402 = bits.Add64(x388, x385, uint64(p521Uint1(x400)))
680 var x403 uint64
681 var x404 uint64
682 x403, x404 = bits.Add64(x386, x383, uint64(p521Uint1(x402)))
683 var x405 uint64
684 var x406 uint64
685 x405, x406 = bits.Add64(x384, x381, uint64(p521Uint1(x404)))
686 var x407 uint64
687 var x408 uint64
688 x407, x408 = bits.Add64(x382, x379, uint64(p521Uint1(x406)))
689 var x409 uint64
690 var x410 uint64
691 x409, x410 = bits.Add64(x380, x377, uint64(p521Uint1(x408)))
692 x411 := (uint64(p521Uint1(x410)) + x378)
693 var x413 uint64
694 _, x413 = bits.Add64(x357, x393, uint64(0x0))
695 var x414 uint64
696 var x415 uint64
697 x414, x415 = bits.Add64(x359, x395, uint64(p521Uint1(x413)))
698 var x416 uint64
699 var x417 uint64
700 x416, x417 = bits.Add64(x361, x397, uint64(p521Uint1(x415)))
701 var x418 uint64
702 var x419 uint64
703 x418, x419 = bits.Add64(x363, x399, uint64(p521Uint1(x417)))
704 var x420 uint64
705 var x421 uint64
706 x420, x421 = bits.Add64(x365, x401, uint64(p521Uint1(x419)))
707 var x422 uint64
708 var x423 uint64
709 x422, x423 = bits.Add64(x367, x403, uint64(p521Uint1(x421)))
710 var x424 uint64
711 var x425 uint64
712 x424, x425 = bits.Add64(x369, x405, uint64(p521Uint1(x423)))
713 var x426 uint64
714 var x427 uint64
715 x426, x427 = bits.Add64(x371, x407, uint64(p521Uint1(x425)))
716 var x428 uint64
717 var x429 uint64
718 x428, x429 = bits.Add64(x373, x409, uint64(p521Uint1(x427)))
719 var x430 uint64
720 var x431 uint64
721 x430, x431 = bits.Add64(x375, x411, uint64(p521Uint1(x429)))
722 x432 := (uint64(p521Uint1(x431)) + uint64(p521Uint1(x376)))
723 var x433 uint64
724 var x434 uint64
725 x434, x433 = bits.Mul64(x4, arg2[8])
726 var x435 uint64
727 var x436 uint64
728 x436, x435 = bits.Mul64(x4, arg2[7])
729 var x437 uint64
730 var x438 uint64
731 x438, x437 = bits.Mul64(x4, arg2[6])
732 var x439 uint64
733 var x440 uint64
734 x440, x439 = bits.Mul64(x4, arg2[5])
735 var x441 uint64
736 var x442 uint64
737 x442, x441 = bits.Mul64(x4, arg2[4])
738 var x443 uint64
739 var x444 uint64
740 x444, x443 = bits.Mul64(x4, arg2[3])
741 var x445 uint64
742 var x446 uint64
743 x446, x445 = bits.Mul64(x4, arg2[2])
744 var x447 uint64
745 var x448 uint64
746 x448, x447 = bits.Mul64(x4, arg2[1])
747 var x449 uint64
748 var x450 uint64
749 x450, x449 = bits.Mul64(x4, arg2[0])
750 var x451 uint64
751 var x452 uint64
752 x451, x452 = bits.Add64(x450, x447, uint64(0x0))
753 var x453 uint64
754 var x454 uint64
755 x453, x454 = bits.Add64(x448, x445, uint64(p521Uint1(x452)))
756 var x455 uint64
757 var x456 uint64
758 x455, x456 = bits.Add64(x446, x443, uint64(p521Uint1(x454)))
759 var x457 uint64
760 var x458 uint64
761 x457, x458 = bits.Add64(x444, x441, uint64(p521Uint1(x456)))
762 var x459 uint64
763 var x460 uint64
764 x459, x460 = bits.Add64(x442, x439, uint64(p521Uint1(x458)))
765 var x461 uint64
766 var x462 uint64
767 x461, x462 = bits.Add64(x440, x437, uint64(p521Uint1(x460)))
768 var x463 uint64
769 var x464 uint64
770 x463, x464 = bits.Add64(x438, x435, uint64(p521Uint1(x462)))
771 var x465 uint64
772 var x466 uint64
773 x465, x466 = bits.Add64(x436, x433, uint64(p521Uint1(x464)))
774 x467 := (uint64(p521Uint1(x466)) + x434)
775 var x468 uint64
776 var x469 uint64
777 x468, x469 = bits.Add64(x414, x449, uint64(0x0))
778 var x470 uint64
779 var x471 uint64
780 x470, x471 = bits.Add64(x416, x451, uint64(p521Uint1(x469)))
781 var x472 uint64
782 var x473 uint64
783 x472, x473 = bits.Add64(x418, x453, uint64(p521Uint1(x471)))
784 var x474 uint64
785 var x475 uint64
786 x474, x475 = bits.Add64(x420, x455, uint64(p521Uint1(x473)))
787 var x476 uint64
788 var x477 uint64
789 x476, x477 = bits.Add64(x422, x457, uint64(p521Uint1(x475)))
790 var x478 uint64
791 var x479 uint64
792 x478, x479 = bits.Add64(x424, x459, uint64(p521Uint1(x477)))
793 var x480 uint64
794 var x481 uint64
795 x480, x481 = bits.Add64(x426, x461, uint64(p521Uint1(x479)))
796 var x482 uint64
797 var x483 uint64
798 x482, x483 = bits.Add64(x428, x463, uint64(p521Uint1(x481)))
799 var x484 uint64
800 var x485 uint64
801 x484, x485 = bits.Add64(x430, x465, uint64(p521Uint1(x483)))
802 var x486 uint64
803 var x487 uint64
804 x486, x487 = bits.Add64(x432, x467, uint64(p521Uint1(x485)))
805 var x488 uint64
806 var x489 uint64
807 x489, x488 = bits.Mul64(x468, 0x1ff)
808 var x490 uint64
809 var x491 uint64
810 x491, x490 = bits.Mul64(x468, 0xffffffffffffffff)
811 var x492 uint64
812 var x493 uint64
813 x493, x492 = bits.Mul64(x468, 0xffffffffffffffff)
814 var x494 uint64
815 var x495 uint64
816 x495, x494 = bits.Mul64(x468, 0xffffffffffffffff)
817 var x496 uint64
818 var x497 uint64
819 x497, x496 = bits.Mul64(x468, 0xffffffffffffffff)
820 var x498 uint64
821 var x499 uint64
822 x499, x498 = bits.Mul64(x468, 0xffffffffffffffff)
823 var x500 uint64
824 var x501 uint64
825 x501, x500 = bits.Mul64(x468, 0xffffffffffffffff)
826 var x502 uint64
827 var x503 uint64
828 x503, x502 = bits.Mul64(x468, 0xffffffffffffffff)
829 var x504 uint64
830 var x505 uint64
831 x505, x504 = bits.Mul64(x468, 0xffffffffffffffff)
832 var x506 uint64
833 var x507 uint64
834 x506, x507 = bits.Add64(x505, x502, uint64(0x0))
835 var x508 uint64
836 var x509 uint64
837 x508, x509 = bits.Add64(x503, x500, uint64(p521Uint1(x507)))
838 var x510 uint64
839 var x511 uint64
840 x510, x511 = bits.Add64(x501, x498, uint64(p521Uint1(x509)))
841 var x512 uint64
842 var x513 uint64
843 x512, x513 = bits.Add64(x499, x496, uint64(p521Uint1(x511)))
844 var x514 uint64
845 var x515 uint64
846 x514, x515 = bits.Add64(x497, x494, uint64(p521Uint1(x513)))
847 var x516 uint64
848 var x517 uint64
849 x516, x517 = bits.Add64(x495, x492, uint64(p521Uint1(x515)))
850 var x518 uint64
851 var x519 uint64
852 x518, x519 = bits.Add64(x493, x490, uint64(p521Uint1(x517)))
853 var x520 uint64
854 var x521 uint64
855 x520, x521 = bits.Add64(x491, x488, uint64(p521Uint1(x519)))
856 x522 := (uint64(p521Uint1(x521)) + x489)
857 var x524 uint64
858 _, x524 = bits.Add64(x468, x504, uint64(0x0))
859 var x525 uint64
860 var x526 uint64
861 x525, x526 = bits.Add64(x470, x506, uint64(p521Uint1(x524)))
862 var x527 uint64
863 var x528 uint64
864 x527, x528 = bits.Add64(x472, x508, uint64(p521Uint1(x526)))
865 var x529 uint64
866 var x530 uint64
867 x529, x530 = bits.Add64(x474, x510, uint64(p521Uint1(x528)))
868 var x531 uint64
869 var x532 uint64
870 x531, x532 = bits.Add64(x476, x512, uint64(p521Uint1(x530)))
871 var x533 uint64
872 var x534 uint64
873 x533, x534 = bits.Add64(x478, x514, uint64(p521Uint1(x532)))
874 var x535 uint64
875 var x536 uint64
876 x535, x536 = bits.Add64(x480, x516, uint64(p521Uint1(x534)))
877 var x537 uint64
878 var x538 uint64
879 x537, x538 = bits.Add64(x482, x518, uint64(p521Uint1(x536)))
880 var x539 uint64
881 var x540 uint64
882 x539, x540 = bits.Add64(x484, x520, uint64(p521Uint1(x538)))
883 var x541 uint64
884 var x542 uint64
885 x541, x542 = bits.Add64(x486, x522, uint64(p521Uint1(x540)))
886 x543 := (uint64(p521Uint1(x542)) + uint64(p521Uint1(x487)))
887 var x544 uint64
888 var x545 uint64
889 x545, x544 = bits.Mul64(x5, arg2[8])
890 var x546 uint64
891 var x547 uint64
892 x547, x546 = bits.Mul64(x5, arg2[7])
893 var x548 uint64
894 var x549 uint64
895 x549, x548 = bits.Mul64(x5, arg2[6])
896 var x550 uint64
897 var x551 uint64
898 x551, x550 = bits.Mul64(x5, arg2[5])
899 var x552 uint64
900 var x553 uint64
901 x553, x552 = bits.Mul64(x5, arg2[4])
902 var x554 uint64
903 var x555 uint64
904 x555, x554 = bits.Mul64(x5, arg2[3])
905 var x556 uint64
906 var x557 uint64
907 x557, x556 = bits.Mul64(x5, arg2[2])
908 var x558 uint64
909 var x559 uint64
910 x559, x558 = bits.Mul64(x5, arg2[1])
911 var x560 uint64
912 var x561 uint64
913 x561, x560 = bits.Mul64(x5, arg2[0])
914 var x562 uint64
915 var x563 uint64
916 x562, x563 = bits.Add64(x561, x558, uint64(0x0))
917 var x564 uint64
918 var x565 uint64
919 x564, x565 = bits.Add64(x559, x556, uint64(p521Uint1(x563)))
920 var x566 uint64
921 var x567 uint64
922 x566, x567 = bits.Add64(x557, x554, uint64(p521Uint1(x565)))
923 var x568 uint64
924 var x569 uint64
925 x568, x569 = bits.Add64(x555, x552, uint64(p521Uint1(x567)))
926 var x570 uint64
927 var x571 uint64
928 x570, x571 = bits.Add64(x553, x550, uint64(p521Uint1(x569)))
929 var x572 uint64
930 var x573 uint64
931 x572, x573 = bits.Add64(x551, x548, uint64(p521Uint1(x571)))
932 var x574 uint64
933 var x575 uint64
934 x574, x575 = bits.Add64(x549, x546, uint64(p521Uint1(x573)))
935 var x576 uint64
936 var x577 uint64
937 x576, x577 = bits.Add64(x547, x544, uint64(p521Uint1(x575)))
938 x578 := (uint64(p521Uint1(x577)) + x545)
939 var x579 uint64
940 var x580 uint64
941 x579, x580 = bits.Add64(x525, x560, uint64(0x0))
942 var x581 uint64
943 var x582 uint64
944 x581, x582 = bits.Add64(x527, x562, uint64(p521Uint1(x580)))
945 var x583 uint64
946 var x584 uint64
947 x583, x584 = bits.Add64(x529, x564, uint64(p521Uint1(x582)))
948 var x585 uint64
949 var x586 uint64
950 x585, x586 = bits.Add64(x531, x566, uint64(p521Uint1(x584)))
951 var x587 uint64
952 var x588 uint64
953 x587, x588 = bits.Add64(x533, x568, uint64(p521Uint1(x586)))
954 var x589 uint64
955 var x590 uint64
956 x589, x590 = bits.Add64(x535, x570, uint64(p521Uint1(x588)))
957 var x591 uint64
958 var x592 uint64
959 x591, x592 = bits.Add64(x537, x572, uint64(p521Uint1(x590)))
960 var x593 uint64
961 var x594 uint64
962 x593, x594 = bits.Add64(x539, x574, uint64(p521Uint1(x592)))
963 var x595 uint64
964 var x596 uint64
965 x595, x596 = bits.Add64(x541, x576, uint64(p521Uint1(x594)))
966 var x597 uint64
967 var x598 uint64
968 x597, x598 = bits.Add64(x543, x578, uint64(p521Uint1(x596)))
969 var x599 uint64
970 var x600 uint64
971 x600, x599 = bits.Mul64(x579, 0x1ff)
972 var x601 uint64
973 var x602 uint64
974 x602, x601 = bits.Mul64(x579, 0xffffffffffffffff)
975 var x603 uint64
976 var x604 uint64
977 x604, x603 = bits.Mul64(x579, 0xffffffffffffffff)
978 var x605 uint64
979 var x606 uint64
980 x606, x605 = bits.Mul64(x579, 0xffffffffffffffff)
981 var x607 uint64
982 var x608 uint64
983 x608, x607 = bits.Mul64(x579, 0xffffffffffffffff)
984 var x609 uint64
985 var x610 uint64
986 x610, x609 = bits.Mul64(x579, 0xffffffffffffffff)
987 var x611 uint64
988 var x612 uint64
989 x612, x611 = bits.Mul64(x579, 0xffffffffffffffff)
990 var x613 uint64
991 var x614 uint64
992 x614, x613 = bits.Mul64(x579, 0xffffffffffffffff)
993 var x615 uint64
994 var x616 uint64
995 x616, x615 = bits.Mul64(x579, 0xffffffffffffffff)
996 var x617 uint64
997 var x618 uint64
998 x617, x618 = bits.Add64(x616, x613, uint64(0x0))
999 var x619 uint64
1000 var x620 uint64
1001 x619, x620 = bits.Add64(x614, x611, uint64(p521Uint1(x618)))
1002 var x621 uint64
1003 var x622 uint64
1004 x621, x622 = bits.Add64(x612, x609, uint64(p521Uint1(x620)))
1005 var x623 uint64
1006 var x624 uint64
1007 x623, x624 = bits.Add64(x610, x607, uint64(p521Uint1(x622)))
1008 var x625 uint64
1009 var x626 uint64
1010 x625, x626 = bits.Add64(x608, x605, uint64(p521Uint1(x624)))
1011 var x627 uint64
1012 var x628 uint64
1013 x627, x628 = bits.Add64(x606, x603, uint64(p521Uint1(x626)))
1014 var x629 uint64
1015 var x630 uint64
1016 x629, x630 = bits.Add64(x604, x601, uint64(p521Uint1(x628)))
1017 var x631 uint64
1018 var x632 uint64
1019 x631, x632 = bits.Add64(x602, x599, uint64(p521Uint1(x630)))
1020 x633 := (uint64(p521Uint1(x632)) + x600)
1021 var x635 uint64
1022 _, x635 = bits.Add64(x579, x615, uint64(0x0))
1023 var x636 uint64
1024 var x637 uint64
1025 x636, x637 = bits.Add64(x581, x617, uint64(p521Uint1(x635)))
1026 var x638 uint64
1027 var x639 uint64
1028 x638, x639 = bits.Add64(x583, x619, uint64(p521Uint1(x637)))
1029 var x640 uint64
1030 var x641 uint64
1031 x640, x641 = bits.Add64(x585, x621, uint64(p521Uint1(x639)))
1032 var x642 uint64
1033 var x643 uint64
1034 x642, x643 = bits.Add64(x587, x623, uint64(p521Uint1(x641)))
1035 var x644 uint64
1036 var x645 uint64
1037 x644, x645 = bits.Add64(x589, x625, uint64(p521Uint1(x643)))
1038 var x646 uint64
1039 var x647 uint64
1040 x646, x647 = bits.Add64(x591, x627, uint64(p521Uint1(x645)))
1041 var x648 uint64
1042 var x649 uint64
1043 x648, x649 = bits.Add64(x593, x629, uint64(p521Uint1(x647)))
1044 var x650 uint64
1045 var x651 uint64
1046 x650, x651 = bits.Add64(x595, x631, uint64(p521Uint1(x649)))
1047 var x652 uint64
1048 var x653 uint64
1049 x652, x653 = bits.Add64(x597, x633, uint64(p521Uint1(x651)))
1050 x654 := (uint64(p521Uint1(x653)) + uint64(p521Uint1(x598)))
1051 var x655 uint64
1052 var x656 uint64
1053 x656, x655 = bits.Mul64(x6, arg2[8])
1054 var x657 uint64
1055 var x658 uint64
1056 x658, x657 = bits.Mul64(x6, arg2[7])
1057 var x659 uint64
1058 var x660 uint64
1059 x660, x659 = bits.Mul64(x6, arg2[6])
1060 var x661 uint64
1061 var x662 uint64
1062 x662, x661 = bits.Mul64(x6, arg2[5])
1063 var x663 uint64
1064 var x664 uint64
1065 x664, x663 = bits.Mul64(x6, arg2[4])
1066 var x665 uint64
1067 var x666 uint64
1068 x666, x665 = bits.Mul64(x6, arg2[3])
1069 var x667 uint64
1070 var x668 uint64
1071 x668, x667 = bits.Mul64(x6, arg2[2])
1072 var x669 uint64
1073 var x670 uint64
1074 x670, x669 = bits.Mul64(x6, arg2[1])
1075 var x671 uint64
1076 var x672 uint64
1077 x672, x671 = bits.Mul64(x6, arg2[0])
1078 var x673 uint64
1079 var x674 uint64
1080 x673, x674 = bits.Add64(x672, x669, uint64(0x0))
1081 var x675 uint64
1082 var x676 uint64
1083 x675, x676 = bits.Add64(x670, x667, uint64(p521Uint1(x674)))
1084 var x677 uint64
1085 var x678 uint64
1086 x677, x678 = bits.Add64(x668, x665, uint64(p521Uint1(x676)))
1087 var x679 uint64
1088 var x680 uint64
1089 x679, x680 = bits.Add64(x666, x663, uint64(p521Uint1(x678)))
1090 var x681 uint64
1091 var x682 uint64
1092 x681, x682 = bits.Add64(x664, x661, uint64(p521Uint1(x680)))
1093 var x683 uint64
1094 var x684 uint64
1095 x683, x684 = bits.Add64(x662, x659, uint64(p521Uint1(x682)))
1096 var x685 uint64
1097 var x686 uint64
1098 x685, x686 = bits.Add64(x660, x657, uint64(p521Uint1(x684)))
1099 var x687 uint64
1100 var x688 uint64
1101 x687, x688 = bits.Add64(x658, x655, uint64(p521Uint1(x686)))
1102 x689 := (uint64(p521Uint1(x688)) + x656)
1103 var x690 uint64
1104 var x691 uint64
1105 x690, x691 = bits.Add64(x636, x671, uint64(0x0))
1106 var x692 uint64
1107 var x693 uint64
1108 x692, x693 = bits.Add64(x638, x673, uint64(p521Uint1(x691)))
1109 var x694 uint64
1110 var x695 uint64
1111 x694, x695 = bits.Add64(x640, x675, uint64(p521Uint1(x693)))
1112 var x696 uint64
1113 var x697 uint64
1114 x696, x697 = bits.Add64(x642, x677, uint64(p521Uint1(x695)))
1115 var x698 uint64
1116 var x699 uint64
1117 x698, x699 = bits.Add64(x644, x679, uint64(p521Uint1(x697)))
1118 var x700 uint64
1119 var x701 uint64
1120 x700, x701 = bits.Add64(x646, x681, uint64(p521Uint1(x699)))
1121 var x702 uint64
1122 var x703 uint64
1123 x702, x703 = bits.Add64(x648, x683, uint64(p521Uint1(x701)))
1124 var x704 uint64
1125 var x705 uint64
1126 x704, x705 = bits.Add64(x650, x685, uint64(p521Uint1(x703)))
1127 var x706 uint64
1128 var x707 uint64
1129 x706, x707 = bits.Add64(x652, x687, uint64(p521Uint1(x705)))
1130 var x708 uint64
1131 var x709 uint64
1132 x708, x709 = bits.Add64(x654, x689, uint64(p521Uint1(x707)))
1133 var x710 uint64
1134 var x711 uint64
1135 x711, x710 = bits.Mul64(x690, 0x1ff)
1136 var x712 uint64
1137 var x713 uint64
1138 x713, x712 = bits.Mul64(x690, 0xffffffffffffffff)
1139 var x714 uint64
1140 var x715 uint64
1141 x715, x714 = bits.Mul64(x690, 0xffffffffffffffff)
1142 var x716 uint64
1143 var x717 uint64
1144 x717, x716 = bits.Mul64(x690, 0xffffffffffffffff)
1145 var x718 uint64
1146 var x719 uint64
1147 x719, x718 = bits.Mul64(x690, 0xffffffffffffffff)
1148 var x720 uint64
1149 var x721 uint64
1150 x721, x720 = bits.Mul64(x690, 0xffffffffffffffff)
1151 var x722 uint64
1152 var x723 uint64
1153 x723, x722 = bits.Mul64(x690, 0xffffffffffffffff)
1154 var x724 uint64
1155 var x725 uint64
1156 x725, x724 = bits.Mul64(x690, 0xffffffffffffffff)
1157 var x726 uint64
1158 var x727 uint64
1159 x727, x726 = bits.Mul64(x690, 0xffffffffffffffff)
1160 var x728 uint64
1161 var x729 uint64
1162 x728, x729 = bits.Add64(x727, x724, uint64(0x0))
1163 var x730 uint64
1164 var x731 uint64
1165 x730, x731 = bits.Add64(x725, x722, uint64(p521Uint1(x729)))
1166 var x732 uint64
1167 var x733 uint64
1168 x732, x733 = bits.Add64(x723, x720, uint64(p521Uint1(x731)))
1169 var x734 uint64
1170 var x735 uint64
1171 x734, x735 = bits.Add64(x721, x718, uint64(p521Uint1(x733)))
1172 var x736 uint64
1173 var x737 uint64
1174 x736, x737 = bits.Add64(x719, x716, uint64(p521Uint1(x735)))
1175 var x738 uint64
1176 var x739 uint64
1177 x738, x739 = bits.Add64(x717, x714, uint64(p521Uint1(x737)))
1178 var x740 uint64
1179 var x741 uint64
1180 x740, x741 = bits.Add64(x715, x712, uint64(p521Uint1(x739)))
1181 var x742 uint64
1182 var x743 uint64
1183 x742, x743 = bits.Add64(x713, x710, uint64(p521Uint1(x741)))
1184 x744 := (uint64(p521Uint1(x743)) + x711)
1185 var x746 uint64
1186 _, x746 = bits.Add64(x690, x726, uint64(0x0))
1187 var x747 uint64
1188 var x748 uint64
1189 x747, x748 = bits.Add64(x692, x728, uint64(p521Uint1(x746)))
1190 var x749 uint64
1191 var x750 uint64
1192 x749, x750 = bits.Add64(x694, x730, uint64(p521Uint1(x748)))
1193 var x751 uint64
1194 var x752 uint64
1195 x751, x752 = bits.Add64(x696, x732, uint64(p521Uint1(x750)))
1196 var x753 uint64
1197 var x754 uint64
1198 x753, x754 = bits.Add64(x698, x734, uint64(p521Uint1(x752)))
1199 var x755 uint64
1200 var x756 uint64
1201 x755, x756 = bits.Add64(x700, x736, uint64(p521Uint1(x754)))
1202 var x757 uint64
1203 var x758 uint64
1204 x757, x758 = bits.Add64(x702, x738, uint64(p521Uint1(x756)))
1205 var x759 uint64
1206 var x760 uint64
1207 x759, x760 = bits.Add64(x704, x740, uint64(p521Uint1(x758)))
1208 var x761 uint64
1209 var x762 uint64
1210 x761, x762 = bits.Add64(x706, x742, uint64(p521Uint1(x760)))
1211 var x763 uint64
1212 var x764 uint64
1213 x763, x764 = bits.Add64(x708, x744, uint64(p521Uint1(x762)))
1214 x765 := (uint64(p521Uint1(x764)) + uint64(p521Uint1(x709)))
1215 var x766 uint64
1216 var x767 uint64
1217 x767, x766 = bits.Mul64(x7, arg2[8])
1218 var x768 uint64
1219 var x769 uint64
1220 x769, x768 = bits.Mul64(x7, arg2[7])
1221 var x770 uint64
1222 var x771 uint64
1223 x771, x770 = bits.Mul64(x7, arg2[6])
1224 var x772 uint64
1225 var x773 uint64
1226 x773, x772 = bits.Mul64(x7, arg2[5])
1227 var x774 uint64
1228 var x775 uint64
1229 x775, x774 = bits.Mul64(x7, arg2[4])
1230 var x776 uint64
1231 var x777 uint64
1232 x777, x776 = bits.Mul64(x7, arg2[3])
1233 var x778 uint64
1234 var x779 uint64
1235 x779, x778 = bits.Mul64(x7, arg2[2])
1236 var x780 uint64
1237 var x781 uint64
1238 x781, x780 = bits.Mul64(x7, arg2[1])
1239 var x782 uint64
1240 var x783 uint64
1241 x783, x782 = bits.Mul64(x7, arg2[0])
1242 var x784 uint64
1243 var x785 uint64
1244 x784, x785 = bits.Add64(x783, x780, uint64(0x0))
1245 var x786 uint64
1246 var x787 uint64
1247 x786, x787 = bits.Add64(x781, x778, uint64(p521Uint1(x785)))
1248 var x788 uint64
1249 var x789 uint64
1250 x788, x789 = bits.Add64(x779, x776, uint64(p521Uint1(x787)))
1251 var x790 uint64
1252 var x791 uint64
1253 x790, x791 = bits.Add64(x777, x774, uint64(p521Uint1(x789)))
1254 var x792 uint64
1255 var x793 uint64
1256 x792, x793 = bits.Add64(x775, x772, uint64(p521Uint1(x791)))
1257 var x794 uint64
1258 var x795 uint64
1259 x794, x795 = bits.Add64(x773, x770, uint64(p521Uint1(x793)))
1260 var x796 uint64
1261 var x797 uint64
1262 x796, x797 = bits.Add64(x771, x768, uint64(p521Uint1(x795)))
1263 var x798 uint64
1264 var x799 uint64
1265 x798, x799 = bits.Add64(x769, x766, uint64(p521Uint1(x797)))
1266 x800 := (uint64(p521Uint1(x799)) + x767)
1267 var x801 uint64
1268 var x802 uint64
1269 x801, x802 = bits.Add64(x747, x782, uint64(0x0))
1270 var x803 uint64
1271 var x804 uint64
1272 x803, x804 = bits.Add64(x749, x784, uint64(p521Uint1(x802)))
1273 var x805 uint64
1274 var x806 uint64
1275 x805, x806 = bits.Add64(x751, x786, uint64(p521Uint1(x804)))
1276 var x807 uint64
1277 var x808 uint64
1278 x807, x808 = bits.Add64(x753, x788, uint64(p521Uint1(x806)))
1279 var x809 uint64
1280 var x810 uint64
1281 x809, x810 = bits.Add64(x755, x790, uint64(p521Uint1(x808)))
1282 var x811 uint64
1283 var x812 uint64
1284 x811, x812 = bits.Add64(x757, x792, uint64(p521Uint1(x810)))
1285 var x813 uint64
1286 var x814 uint64
1287 x813, x814 = bits.Add64(x759, x794, uint64(p521Uint1(x812)))
1288 var x815 uint64
1289 var x816 uint64
1290 x815, x816 = bits.Add64(x761, x796, uint64(p521Uint1(x814)))
1291 var x817 uint64
1292 var x818 uint64
1293 x817, x818 = bits.Add64(x763, x798, uint64(p521Uint1(x816)))
1294 var x819 uint64
1295 var x820 uint64
1296 x819, x820 = bits.Add64(x765, x800, uint64(p521Uint1(x818)))
1297 var x821 uint64
1298 var x822 uint64
1299 x822, x821 = bits.Mul64(x801, 0x1ff)
1300 var x823 uint64
1301 var x824 uint64
1302 x824, x823 = bits.Mul64(x801, 0xffffffffffffffff)
1303 var x825 uint64
1304 var x826 uint64
1305 x826, x825 = bits.Mul64(x801, 0xffffffffffffffff)
1306 var x827 uint64
1307 var x828 uint64
1308 x828, x827 = bits.Mul64(x801, 0xffffffffffffffff)
1309 var x829 uint64
1310 var x830 uint64
1311 x830, x829 = bits.Mul64(x801, 0xffffffffffffffff)
1312 var x831 uint64
1313 var x832 uint64
1314 x832, x831 = bits.Mul64(x801, 0xffffffffffffffff)
1315 var x833 uint64
1316 var x834 uint64
1317 x834, x833 = bits.Mul64(x801, 0xffffffffffffffff)
1318 var x835 uint64
1319 var x836 uint64
1320 x836, x835 = bits.Mul64(x801, 0xffffffffffffffff)
1321 var x837 uint64
1322 var x838 uint64
1323 x838, x837 = bits.Mul64(x801, 0xffffffffffffffff)
1324 var x839 uint64
1325 var x840 uint64
1326 x839, x840 = bits.Add64(x838, x835, uint64(0x0))
1327 var x841 uint64
1328 var x842 uint64
1329 x841, x842 = bits.Add64(x836, x833, uint64(p521Uint1(x840)))
1330 var x843 uint64
1331 var x844 uint64
1332 x843, x844 = bits.Add64(x834, x831, uint64(p521Uint1(x842)))
1333 var x845 uint64
1334 var x846 uint64
1335 x845, x846 = bits.Add64(x832, x829, uint64(p521Uint1(x844)))
1336 var x847 uint64
1337 var x848 uint64
1338 x847, x848 = bits.Add64(x830, x827, uint64(p521Uint1(x846)))
1339 var x849 uint64
1340 var x850 uint64
1341 x849, x850 = bits.Add64(x828, x825, uint64(p521Uint1(x848)))
1342 var x851 uint64
1343 var x852 uint64
1344 x851, x852 = bits.Add64(x826, x823, uint64(p521Uint1(x850)))
1345 var x853 uint64
1346 var x854 uint64
1347 x853, x854 = bits.Add64(x824, x821, uint64(p521Uint1(x852)))
1348 x855 := (uint64(p521Uint1(x854)) + x822)
1349 var x857 uint64
1350 _, x857 = bits.Add64(x801, x837, uint64(0x0))
1351 var x858 uint64
1352 var x859 uint64
1353 x858, x859 = bits.Add64(x803, x839, uint64(p521Uint1(x857)))
1354 var x860 uint64
1355 var x861 uint64
1356 x860, x861 = bits.Add64(x805, x841, uint64(p521Uint1(x859)))
1357 var x862 uint64
1358 var x863 uint64
1359 x862, x863 = bits.Add64(x807, x843, uint64(p521Uint1(x861)))
1360 var x864 uint64
1361 var x865 uint64
1362 x864, x865 = bits.Add64(x809, x845, uint64(p521Uint1(x863)))
1363 var x866 uint64
1364 var x867 uint64
1365 x866, x867 = bits.Add64(x811, x847, uint64(p521Uint1(x865)))
1366 var x868 uint64
1367 var x869 uint64
1368 x868, x869 = bits.Add64(x813, x849, uint64(p521Uint1(x867)))
1369 var x870 uint64
1370 var x871 uint64
1371 x870, x871 = bits.Add64(x815, x851, uint64(p521Uint1(x869)))
1372 var x872 uint64
1373 var x873 uint64
1374 x872, x873 = bits.Add64(x817, x853, uint64(p521Uint1(x871)))
1375 var x874 uint64
1376 var x875 uint64
1377 x874, x875 = bits.Add64(x819, x855, uint64(p521Uint1(x873)))
1378 x876 := (uint64(p521Uint1(x875)) + uint64(p521Uint1(x820)))
1379 var x877 uint64
1380 var x878 uint64
1381 x878, x877 = bits.Mul64(x8, arg2[8])
1382 var x879 uint64
1383 var x880 uint64
1384 x880, x879 = bits.Mul64(x8, arg2[7])
1385 var x881 uint64
1386 var x882 uint64
1387 x882, x881 = bits.Mul64(x8, arg2[6])
1388 var x883 uint64
1389 var x884 uint64
1390 x884, x883 = bits.Mul64(x8, arg2[5])
1391 var x885 uint64
1392 var x886 uint64
1393 x886, x885 = bits.Mul64(x8, arg2[4])
1394 var x887 uint64
1395 var x888 uint64
1396 x888, x887 = bits.Mul64(x8, arg2[3])
1397 var x889 uint64
1398 var x890 uint64
1399 x890, x889 = bits.Mul64(x8, arg2[2])
1400 var x891 uint64
1401 var x892 uint64
1402 x892, x891 = bits.Mul64(x8, arg2[1])
1403 var x893 uint64
1404 var x894 uint64
1405 x894, x893 = bits.Mul64(x8, arg2[0])
1406 var x895 uint64
1407 var x896 uint64
1408 x895, x896 = bits.Add64(x894, x891, uint64(0x0))
1409 var x897 uint64
1410 var x898 uint64
1411 x897, x898 = bits.Add64(x892, x889, uint64(p521Uint1(x896)))
1412 var x899 uint64
1413 var x900 uint64
1414 x899, x900 = bits.Add64(x890, x887, uint64(p521Uint1(x898)))
1415 var x901 uint64
1416 var x902 uint64
1417 x901, x902 = bits.Add64(x888, x885, uint64(p521Uint1(x900)))
1418 var x903 uint64
1419 var x904 uint64
1420 x903, x904 = bits.Add64(x886, x883, uint64(p521Uint1(x902)))
1421 var x905 uint64
1422 var x906 uint64
1423 x905, x906 = bits.Add64(x884, x881, uint64(p521Uint1(x904)))
1424 var x907 uint64
1425 var x908 uint64
1426 x907, x908 = bits.Add64(x882, x879, uint64(p521Uint1(x906)))
1427 var x909 uint64
1428 var x910 uint64
1429 x909, x910 = bits.Add64(x880, x877, uint64(p521Uint1(x908)))
1430 x911 := (uint64(p521Uint1(x910)) + x878)
1431 var x912 uint64
1432 var x913 uint64
1433 x912, x913 = bits.Add64(x858, x893, uint64(0x0))
1434 var x914 uint64
1435 var x915 uint64
1436 x914, x915 = bits.Add64(x860, x895, uint64(p521Uint1(x913)))
1437 var x916 uint64
1438 var x917 uint64
1439 x916, x917 = bits.Add64(x862, x897, uint64(p521Uint1(x915)))
1440 var x918 uint64
1441 var x919 uint64
1442 x918, x919 = bits.Add64(x864, x899, uint64(p521Uint1(x917)))
1443 var x920 uint64
1444 var x921 uint64
1445 x920, x921 = bits.Add64(x866, x901, uint64(p521Uint1(x919)))
1446 var x922 uint64
1447 var x923 uint64
1448 x922, x923 = bits.Add64(x868, x903, uint64(p521Uint1(x921)))
1449 var x924 uint64
1450 var x925 uint64
1451 x924, x925 = bits.Add64(x870, x905, uint64(p521Uint1(x923)))
1452 var x926 uint64
1453 var x927 uint64
1454 x926, x927 = bits.Add64(x872, x907, uint64(p521Uint1(x925)))
1455 var x928 uint64
1456 var x929 uint64
1457 x928, x929 = bits.Add64(x874, x909, uint64(p521Uint1(x927)))
1458 var x930 uint64
1459 var x931 uint64
1460 x930, x931 = bits.Add64(x876, x911, uint64(p521Uint1(x929)))
1461 var x932 uint64
1462 var x933 uint64
1463 x933, x932 = bits.Mul64(x912, 0x1ff)
1464 var x934 uint64
1465 var x935 uint64
1466 x935, x934 = bits.Mul64(x912, 0xffffffffffffffff)
1467 var x936 uint64
1468 var x937 uint64
1469 x937, x936 = bits.Mul64(x912, 0xffffffffffffffff)
1470 var x938 uint64
1471 var x939 uint64
1472 x939, x938 = bits.Mul64(x912, 0xffffffffffffffff)
1473 var x940 uint64
1474 var x941 uint64
1475 x941, x940 = bits.Mul64(x912, 0xffffffffffffffff)
1476 var x942 uint64
1477 var x943 uint64
1478 x943, x942 = bits.Mul64(x912, 0xffffffffffffffff)
1479 var x944 uint64
1480 var x945 uint64
1481 x945, x944 = bits.Mul64(x912, 0xffffffffffffffff)
1482 var x946 uint64
1483 var x947 uint64
1484 x947, x946 = bits.Mul64(x912, 0xffffffffffffffff)
1485 var x948 uint64
1486 var x949 uint64
1487 x949, x948 = bits.Mul64(x912, 0xffffffffffffffff)
1488 var x950 uint64
1489 var x951 uint64
1490 x950, x951 = bits.Add64(x949, x946, uint64(0x0))
1491 var x952 uint64
1492 var x953 uint64
1493 x952, x953 = bits.Add64(x947, x944, uint64(p521Uint1(x951)))
1494 var x954 uint64
1495 var x955 uint64
1496 x954, x955 = bits.Add64(x945, x942, uint64(p521Uint1(x953)))
1497 var x956 uint64
1498 var x957 uint64
1499 x956, x957 = bits.Add64(x943, x940, uint64(p521Uint1(x955)))
1500 var x958 uint64
1501 var x959 uint64
1502 x958, x959 = bits.Add64(x941, x938, uint64(p521Uint1(x957)))
1503 var x960 uint64
1504 var x961 uint64
1505 x960, x961 = bits.Add64(x939, x936, uint64(p521Uint1(x959)))
1506 var x962 uint64
1507 var x963 uint64
1508 x962, x963 = bits.Add64(x937, x934, uint64(p521Uint1(x961)))
1509 var x964 uint64
1510 var x965 uint64
1511 x964, x965 = bits.Add64(x935, x932, uint64(p521Uint1(x963)))
1512 x966 := (uint64(p521Uint1(x965)) + x933)
1513 var x968 uint64
1514 _, x968 = bits.Add64(x912, x948, uint64(0x0))
1515 var x969 uint64
1516 var x970 uint64
1517 x969, x970 = bits.Add64(x914, x950, uint64(p521Uint1(x968)))
1518 var x971 uint64
1519 var x972 uint64
1520 x971, x972 = bits.Add64(x916, x952, uint64(p521Uint1(x970)))
1521 var x973 uint64
1522 var x974 uint64
1523 x973, x974 = bits.Add64(x918, x954, uint64(p521Uint1(x972)))
1524 var x975 uint64
1525 var x976 uint64
1526 x975, x976 = bits.Add64(x920, x956, uint64(p521Uint1(x974)))
1527 var x977 uint64
1528 var x978 uint64
1529 x977, x978 = bits.Add64(x922, x958, uint64(p521Uint1(x976)))
1530 var x979 uint64
1531 var x980 uint64
1532 x979, x980 = bits.Add64(x924, x960, uint64(p521Uint1(x978)))
1533 var x981 uint64
1534 var x982 uint64
1535 x981, x982 = bits.Add64(x926, x962, uint64(p521Uint1(x980)))
1536 var x983 uint64
1537 var x984 uint64
1538 x983, x984 = bits.Add64(x928, x964, uint64(p521Uint1(x982)))
1539 var x985 uint64
1540 var x986 uint64
1541 x985, x986 = bits.Add64(x930, x966, uint64(p521Uint1(x984)))
1542 x987 := (uint64(p521Uint1(x986)) + uint64(p521Uint1(x931)))
1543 var x988 uint64
1544 var x989 uint64
1545 x988, x989 = bits.Sub64(x969, 0xffffffffffffffff, uint64(0x0))
1546 var x990 uint64
1547 var x991 uint64
1548 x990, x991 = bits.Sub64(x971, 0xffffffffffffffff, uint64(p521Uint1(x989)))
1549 var x992 uint64
1550 var x993 uint64
1551 x992, x993 = bits.Sub64(x973, 0xffffffffffffffff, uint64(p521Uint1(x991)))
1552 var x994 uint64
1553 var x995 uint64
1554 x994, x995 = bits.Sub64(x975, 0xffffffffffffffff, uint64(p521Uint1(x993)))
1555 var x996 uint64
1556 var x997 uint64
1557 x996, x997 = bits.Sub64(x977, 0xffffffffffffffff, uint64(p521Uint1(x995)))
1558 var x998 uint64
1559 var x999 uint64
1560 x998, x999 = bits.Sub64(x979, 0xffffffffffffffff, uint64(p521Uint1(x997)))
1561 var x1000 uint64
1562 var x1001 uint64
1563 x1000, x1001 = bits.Sub64(x981, 0xffffffffffffffff, uint64(p521Uint1(x999)))
1564 var x1002 uint64
1565 var x1003 uint64
1566 x1002, x1003 = bits.Sub64(x983, 0xffffffffffffffff, uint64(p521Uint1(x1001)))
1567 var x1004 uint64
1568 var x1005 uint64
1569 x1004, x1005 = bits.Sub64(x985, 0x1ff, uint64(p521Uint1(x1003)))
1570 var x1007 uint64
1571 _, x1007 = bits.Sub64(x987, uint64(0x0), uint64(p521Uint1(x1005)))
1572 var x1008 uint64
1573 p521CmovznzU64(&x1008, p521Uint1(x1007), x988, x969)
1574 var x1009 uint64
1575 p521CmovznzU64(&x1009, p521Uint1(x1007), x990, x971)
1576 var x1010 uint64
1577 p521CmovznzU64(&x1010, p521Uint1(x1007), x992, x973)
1578 var x1011 uint64
1579 p521CmovznzU64(&x1011, p521Uint1(x1007), x994, x975)
1580 var x1012 uint64
1581 p521CmovznzU64(&x1012, p521Uint1(x1007), x996, x977)
1582 var x1013 uint64
1583 p521CmovznzU64(&x1013, p521Uint1(x1007), x998, x979)
1584 var x1014 uint64
1585 p521CmovznzU64(&x1014, p521Uint1(x1007), x1000, x981)
1586 var x1015 uint64
1587 p521CmovznzU64(&x1015, p521Uint1(x1007), x1002, x983)
1588 var x1016 uint64
1589 p521CmovznzU64(&x1016, p521Uint1(x1007), x1004, x985)
1590 out1[0] = x1008
1591 out1[1] = x1009
1592 out1[2] = x1010
1593 out1[3] = x1011
1594 out1[4] = x1012
1595 out1[5] = x1013
1596 out1[6] = x1014
1597 out1[7] = x1015
1598 out1[8] = x1016
1599 }
1600
1601 // p521Square squares a field element in the Montgomery domain.
1602 //
1603 // Preconditions:
1604 //
1605 // 0 ≤ eval arg1 < m
1606 //
1607 // Postconditions:
1608 //
1609 // eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m
1610 // 0 ≤ eval out1 < m
1611 func p521Square(out1 *p521MontgomeryDomainFieldElement, arg1 *p521MontgomeryDomainFieldElement) {
1612 x1 := arg1[1]
1613 x2 := arg1[2]
1614 x3 := arg1[3]
1615 x4 := arg1[4]
1616 x5 := arg1[5]
1617 x6 := arg1[6]
1618 x7 := arg1[7]
1619 x8 := arg1[8]
1620 x9 := arg1[0]
1621 var x10 uint64
1622 var x11 uint64
1623 x11, x10 = bits.Mul64(x9, arg1[8])
1624 var x12 uint64
1625 var x13 uint64
1626 x13, x12 = bits.Mul64(x9, arg1[7])
1627 var x14 uint64
1628 var x15 uint64
1629 x15, x14 = bits.Mul64(x9, arg1[6])
1630 var x16 uint64
1631 var x17 uint64
1632 x17, x16 = bits.Mul64(x9, arg1[5])
1633 var x18 uint64
1634 var x19 uint64
1635 x19, x18 = bits.Mul64(x9, arg1[4])
1636 var x20 uint64
1637 var x21 uint64
1638 x21, x20 = bits.Mul64(x9, arg1[3])
1639 var x22 uint64
1640 var x23 uint64
1641 x23, x22 = bits.Mul64(x9, arg1[2])
1642 var x24 uint64
1643 var x25 uint64
1644 x25, x24 = bits.Mul64(x9, arg1[1])
1645 var x26 uint64
1646 var x27 uint64
1647 x27, x26 = bits.Mul64(x9, arg1[0])
1648 var x28 uint64
1649 var x29 uint64
1650 x28, x29 = bits.Add64(x27, x24, uint64(0x0))
1651 var x30 uint64
1652 var x31 uint64
1653 x30, x31 = bits.Add64(x25, x22, uint64(p521Uint1(x29)))
1654 var x32 uint64
1655 var x33 uint64
1656 x32, x33 = bits.Add64(x23, x20, uint64(p521Uint1(x31)))
1657 var x34 uint64
1658 var x35 uint64
1659 x34, x35 = bits.Add64(x21, x18, uint64(p521Uint1(x33)))
1660 var x36 uint64
1661 var x37 uint64
1662 x36, x37 = bits.Add64(x19, x16, uint64(p521Uint1(x35)))
1663 var x38 uint64
1664 var x39 uint64
1665 x38, x39 = bits.Add64(x17, x14, uint64(p521Uint1(x37)))
1666 var x40 uint64
1667 var x41 uint64
1668 x40, x41 = bits.Add64(x15, x12, uint64(p521Uint1(x39)))
1669 var x42 uint64
1670 var x43 uint64
1671 x42, x43 = bits.Add64(x13, x10, uint64(p521Uint1(x41)))
1672 x44 := (uint64(p521Uint1(x43)) + x11)
1673 var x45 uint64
1674 var x46 uint64
1675 x46, x45 = bits.Mul64(x26, 0x1ff)
1676 var x47 uint64
1677 var x48 uint64
1678 x48, x47 = bits.Mul64(x26, 0xffffffffffffffff)
1679 var x49 uint64
1680 var x50 uint64
1681 x50, x49 = bits.Mul64(x26, 0xffffffffffffffff)
1682 var x51 uint64
1683 var x52 uint64
1684 x52, x51 = bits.Mul64(x26, 0xffffffffffffffff)
1685 var x53 uint64
1686 var x54 uint64
1687 x54, x53 = bits.Mul64(x26, 0xffffffffffffffff)
1688 var x55 uint64
1689 var x56 uint64
1690 x56, x55 = bits.Mul64(x26, 0xffffffffffffffff)
1691 var x57 uint64
1692 var x58 uint64
1693 x58, x57 = bits.Mul64(x26, 0xffffffffffffffff)
1694 var x59 uint64
1695 var x60 uint64
1696 x60, x59 = bits.Mul64(x26, 0xffffffffffffffff)
1697 var x61 uint64
1698 var x62 uint64
1699 x62, x61 = bits.Mul64(x26, 0xffffffffffffffff)
1700 var x63 uint64
1701 var x64 uint64
1702 x63, x64 = bits.Add64(x62, x59, uint64(0x0))
1703 var x65 uint64
1704 var x66 uint64
1705 x65, x66 = bits.Add64(x60, x57, uint64(p521Uint1(x64)))
1706 var x67 uint64
1707 var x68 uint64
1708 x67, x68 = bits.Add64(x58, x55, uint64(p521Uint1(x66)))
1709 var x69 uint64
1710 var x70 uint64
1711 x69, x70 = bits.Add64(x56, x53, uint64(p521Uint1(x68)))
1712 var x71 uint64
1713 var x72 uint64
1714 x71, x72 = bits.Add64(x54, x51, uint64(p521Uint1(x70)))
1715 var x73 uint64
1716 var x74 uint64
1717 x73, x74 = bits.Add64(x52, x49, uint64(p521Uint1(x72)))
1718 var x75 uint64
1719 var x76 uint64
1720 x75, x76 = bits.Add64(x50, x47, uint64(p521Uint1(x74)))
1721 var x77 uint64
1722 var x78 uint64
1723 x77, x78 = bits.Add64(x48, x45, uint64(p521Uint1(x76)))
1724 x79 := (uint64(p521Uint1(x78)) + x46)
1725 var x81 uint64
1726 _, x81 = bits.Add64(x26, x61, uint64(0x0))
1727 var x82 uint64
1728 var x83 uint64
1729 x82, x83 = bits.Add64(x28, x63, uint64(p521Uint1(x81)))
1730 var x84 uint64
1731 var x85 uint64
1732 x84, x85 = bits.Add64(x30, x65, uint64(p521Uint1(x83)))
1733 var x86 uint64
1734 var x87 uint64
1735 x86, x87 = bits.Add64(x32, x67, uint64(p521Uint1(x85)))
1736 var x88 uint64
1737 var x89 uint64
1738 x88, x89 = bits.Add64(x34, x69, uint64(p521Uint1(x87)))
1739 var x90 uint64
1740 var x91 uint64
1741 x90, x91 = bits.Add64(x36, x71, uint64(p521Uint1(x89)))
1742 var x92 uint64
1743 var x93 uint64
1744 x92, x93 = bits.Add64(x38, x73, uint64(p521Uint1(x91)))
1745 var x94 uint64
1746 var x95 uint64
1747 x94, x95 = bits.Add64(x40, x75, uint64(p521Uint1(x93)))
1748 var x96 uint64
1749 var x97 uint64
1750 x96, x97 = bits.Add64(x42, x77, uint64(p521Uint1(x95)))
1751 var x98 uint64
1752 var x99 uint64
1753 x98, x99 = bits.Add64(x44, x79, uint64(p521Uint1(x97)))
1754 var x100 uint64
1755 var x101 uint64
1756 x101, x100 = bits.Mul64(x1, arg1[8])
1757 var x102 uint64
1758 var x103 uint64
1759 x103, x102 = bits.Mul64(x1, arg1[7])
1760 var x104 uint64
1761 var x105 uint64
1762 x105, x104 = bits.Mul64(x1, arg1[6])
1763 var x106 uint64
1764 var x107 uint64
1765 x107, x106 = bits.Mul64(x1, arg1[5])
1766 var x108 uint64
1767 var x109 uint64
1768 x109, x108 = bits.Mul64(x1, arg1[4])
1769 var x110 uint64
1770 var x111 uint64
1771 x111, x110 = bits.Mul64(x1, arg1[3])
1772 var x112 uint64
1773 var x113 uint64
1774 x113, x112 = bits.Mul64(x1, arg1[2])
1775 var x114 uint64
1776 var x115 uint64
1777 x115, x114 = bits.Mul64(x1, arg1[1])
1778 var x116 uint64
1779 var x117 uint64
1780 x117, x116 = bits.Mul64(x1, arg1[0])
1781 var x118 uint64
1782 var x119 uint64
1783 x118, x119 = bits.Add64(x117, x114, uint64(0x0))
1784 var x120 uint64
1785 var x121 uint64
1786 x120, x121 = bits.Add64(x115, x112, uint64(p521Uint1(x119)))
1787 var x122 uint64
1788 var x123 uint64
1789 x122, x123 = bits.Add64(x113, x110, uint64(p521Uint1(x121)))
1790 var x124 uint64
1791 var x125 uint64
1792 x124, x125 = bits.Add64(x111, x108, uint64(p521Uint1(x123)))
1793 var x126 uint64
1794 var x127 uint64
1795 x126, x127 = bits.Add64(x109, x106, uint64(p521Uint1(x125)))
1796 var x128 uint64
1797 var x129 uint64
1798 x128, x129 = bits.Add64(x107, x104, uint64(p521Uint1(x127)))
1799 var x130 uint64
1800 var x131 uint64
1801 x130, x131 = bits.Add64(x105, x102, uint64(p521Uint1(x129)))
1802 var x132 uint64
1803 var x133 uint64
1804 x132, x133 = bits.Add64(x103, x100, uint64(p521Uint1(x131)))
1805 x134 := (uint64(p521Uint1(x133)) + x101)
1806 var x135 uint64
1807 var x136 uint64
1808 x135, x136 = bits.Add64(x82, x116, uint64(0x0))
1809 var x137 uint64
1810 var x138 uint64
1811 x137, x138 = bits.Add64(x84, x118, uint64(p521Uint1(x136)))
1812 var x139 uint64
1813 var x140 uint64
1814 x139, x140 = bits.Add64(x86, x120, uint64(p521Uint1(x138)))
1815 var x141 uint64
1816 var x142 uint64
1817 x141, x142 = bits.Add64(x88, x122, uint64(p521Uint1(x140)))
1818 var x143 uint64
1819 var x144 uint64
1820 x143, x144 = bits.Add64(x90, x124, uint64(p521Uint1(x142)))
1821 var x145 uint64
1822 var x146 uint64
1823 x145, x146 = bits.Add64(x92, x126, uint64(p521Uint1(x144)))
1824 var x147 uint64
1825 var x148 uint64
1826 x147, x148 = bits.Add64(x94, x128, uint64(p521Uint1(x146)))
1827 var x149 uint64
1828 var x150 uint64
1829 x149, x150 = bits.Add64(x96, x130, uint64(p521Uint1(x148)))
1830 var x151 uint64
1831 var x152 uint64
1832 x151, x152 = bits.Add64(x98, x132, uint64(p521Uint1(x150)))
1833 var x153 uint64
1834 var x154 uint64
1835 x153, x154 = bits.Add64(uint64(p521Uint1(x99)), x134, uint64(p521Uint1(x152)))
1836 var x155 uint64
1837 var x156 uint64
1838 x156, x155 = bits.Mul64(x135, 0x1ff)
1839 var x157 uint64
1840 var x158 uint64
1841 x158, x157 = bits.Mul64(x135, 0xffffffffffffffff)
1842 var x159 uint64
1843 var x160 uint64
1844 x160, x159 = bits.Mul64(x135, 0xffffffffffffffff)
1845 var x161 uint64
1846 var x162 uint64
1847 x162, x161 = bits.Mul64(x135, 0xffffffffffffffff)
1848 var x163 uint64
1849 var x164 uint64
1850 x164, x163 = bits.Mul64(x135, 0xffffffffffffffff)
1851 var x165 uint64
1852 var x166 uint64
1853 x166, x165 = bits.Mul64(x135, 0xffffffffffffffff)
1854 var x167 uint64
1855 var x168 uint64
1856 x168, x167 = bits.Mul64(x135, 0xffffffffffffffff)
1857 var x169 uint64
1858 var x170 uint64
1859 x170, x169 = bits.Mul64(x135, 0xffffffffffffffff)
1860 var x171 uint64
1861 var x172 uint64
1862 x172, x171 = bits.Mul64(x135, 0xffffffffffffffff)
1863 var x173 uint64
1864 var x174 uint64
1865 x173, x174 = bits.Add64(x172, x169, uint64(0x0))
1866 var x175 uint64
1867 var x176 uint64
1868 x175, x176 = bits.Add64(x170, x167, uint64(p521Uint1(x174)))
1869 var x177 uint64
1870 var x178 uint64
1871 x177, x178 = bits.Add64(x168, x165, uint64(p521Uint1(x176)))
1872 var x179 uint64
1873 var x180 uint64
1874 x179, x180 = bits.Add64(x166, x163, uint64(p521Uint1(x178)))
1875 var x181 uint64
1876 var x182 uint64
1877 x181, x182 = bits.Add64(x164, x161, uint64(p521Uint1(x180)))
1878 var x183 uint64
1879 var x184 uint64
1880 x183, x184 = bits.Add64(x162, x159, uint64(p521Uint1(x182)))
1881 var x185 uint64
1882 var x186 uint64
1883 x185, x186 = bits.Add64(x160, x157, uint64(p521Uint1(x184)))
1884 var x187 uint64
1885 var x188 uint64
1886 x187, x188 = bits.Add64(x158, x155, uint64(p521Uint1(x186)))
1887 x189 := (uint64(p521Uint1(x188)) + x156)
1888 var x191 uint64
1889 _, x191 = bits.Add64(x135, x171, uint64(0x0))
1890 var x192 uint64
1891 var x193 uint64
1892 x192, x193 = bits.Add64(x137, x173, uint64(p521Uint1(x191)))
1893 var x194 uint64
1894 var x195 uint64
1895 x194, x195 = bits.Add64(x139, x175, uint64(p521Uint1(x193)))
1896 var x196 uint64
1897 var x197 uint64
1898 x196, x197 = bits.Add64(x141, x177, uint64(p521Uint1(x195)))
1899 var x198 uint64
1900 var x199 uint64
1901 x198, x199 = bits.Add64(x143, x179, uint64(p521Uint1(x197)))
1902 var x200 uint64
1903 var x201 uint64
1904 x200, x201 = bits.Add64(x145, x181, uint64(p521Uint1(x199)))
1905 var x202 uint64
1906 var x203 uint64
1907 x202, x203 = bits.Add64(x147, x183, uint64(p521Uint1(x201)))
1908 var x204 uint64
1909 var x205 uint64
1910 x204, x205 = bits.Add64(x149, x185, uint64(p521Uint1(x203)))
1911 var x206 uint64
1912 var x207 uint64
1913 x206, x207 = bits.Add64(x151, x187, uint64(p521Uint1(x205)))
1914 var x208 uint64
1915 var x209 uint64
1916 x208, x209 = bits.Add64(x153, x189, uint64(p521Uint1(x207)))
1917 x210 := (uint64(p521Uint1(x209)) + uint64(p521Uint1(x154)))
1918 var x211 uint64
1919 var x212 uint64
1920 x212, x211 = bits.Mul64(x2, arg1[8])
1921 var x213 uint64
1922 var x214 uint64
1923 x214, x213 = bits.Mul64(x2, arg1[7])
1924 var x215 uint64
1925 var x216 uint64
1926 x216, x215 = bits.Mul64(x2, arg1[6])
1927 var x217 uint64
1928 var x218 uint64
1929 x218, x217 = bits.Mul64(x2, arg1[5])
1930 var x219 uint64
1931 var x220 uint64
1932 x220, x219 = bits.Mul64(x2, arg1[4])
1933 var x221 uint64
1934 var x222 uint64
1935 x222, x221 = bits.Mul64(x2, arg1[3])
1936 var x223 uint64
1937 var x224 uint64
1938 x224, x223 = bits.Mul64(x2, arg1[2])
1939 var x225 uint64
1940 var x226 uint64
1941 x226, x225 = bits.Mul64(x2, arg1[1])
1942 var x227 uint64
1943 var x228 uint64
1944 x228, x227 = bits.Mul64(x2, arg1[0])
1945 var x229 uint64
1946 var x230 uint64
1947 x229, x230 = bits.Add64(x228, x225, uint64(0x0))
1948 var x231 uint64
1949 var x232 uint64
1950 x231, x232 = bits.Add64(x226, x223, uint64(p521Uint1(x230)))
1951 var x233 uint64
1952 var x234 uint64
1953 x233, x234 = bits.Add64(x224, x221, uint64(p521Uint1(x232)))
1954 var x235 uint64
1955 var x236 uint64
1956 x235, x236 = bits.Add64(x222, x219, uint64(p521Uint1(x234)))
1957 var x237 uint64
1958 var x238 uint64
1959 x237, x238 = bits.Add64(x220, x217, uint64(p521Uint1(x236)))
1960 var x239 uint64
1961 var x240 uint64
1962 x239, x240 = bits.Add64(x218, x215, uint64(p521Uint1(x238)))
1963 var x241 uint64
1964 var x242 uint64
1965 x241, x242 = bits.Add64(x216, x213, uint64(p521Uint1(x240)))
1966 var x243 uint64
1967 var x244 uint64
1968 x243, x244 = bits.Add64(x214, x211, uint64(p521Uint1(x242)))
1969 x245 := (uint64(p521Uint1(x244)) + x212)
1970 var x246 uint64
1971 var x247 uint64
1972 x246, x247 = bits.Add64(x192, x227, uint64(0x0))
1973 var x248 uint64
1974 var x249 uint64
1975 x248, x249 = bits.Add64(x194, x229, uint64(p521Uint1(x247)))
1976 var x250 uint64
1977 var x251 uint64
1978 x250, x251 = bits.Add64(x196, x231, uint64(p521Uint1(x249)))
1979 var x252 uint64
1980 var x253 uint64
1981 x252, x253 = bits.Add64(x198, x233, uint64(p521Uint1(x251)))
1982 var x254 uint64
1983 var x255 uint64
1984 x254, x255 = bits.Add64(x200, x235, uint64(p521Uint1(x253)))
1985 var x256 uint64
1986 var x257 uint64
1987 x256, x257 = bits.Add64(x202, x237, uint64(p521Uint1(x255)))
1988 var x258 uint64
1989 var x259 uint64
1990 x258, x259 = bits.Add64(x204, x239, uint64(p521Uint1(x257)))
1991 var x260 uint64
1992 var x261 uint64
1993 x260, x261 = bits.Add64(x206, x241, uint64(p521Uint1(x259)))
1994 var x262 uint64
1995 var x263 uint64
1996 x262, x263 = bits.Add64(x208, x243, uint64(p521Uint1(x261)))
1997 var x264 uint64
1998 var x265 uint64
1999 x264, x265 = bits.Add64(x210, x245, uint64(p521Uint1(x263)))
2000 var x266 uint64
2001 var x267 uint64
2002 x267, x266 = bits.Mul64(x246, 0x1ff)
2003 var x268 uint64
2004 var x269 uint64
2005 x269, x268 = bits.Mul64(x246, 0xffffffffffffffff)
2006 var x270 uint64
2007 var x271 uint64
2008 x271, x270 = bits.Mul64(x246, 0xffffffffffffffff)
2009 var x272 uint64
2010 var x273 uint64
2011 x273, x272 = bits.Mul64(x246, 0xffffffffffffffff)
2012 var x274 uint64
2013 var x275 uint64
2014 x275, x274 = bits.Mul64(x246, 0xffffffffffffffff)
2015 var x276 uint64
2016 var x277 uint64
2017 x277, x276 = bits.Mul64(x246, 0xffffffffffffffff)
2018 var x278 uint64
2019 var x279 uint64
2020 x279, x278 = bits.Mul64(x246, 0xffffffffffffffff)
2021 var x280 uint64
2022 var x281 uint64
2023 x281, x280 = bits.Mul64(x246, 0xffffffffffffffff)
2024 var x282 uint64
2025 var x283 uint64
2026 x283, x282 = bits.Mul64(x246, 0xffffffffffffffff)
2027 var x284 uint64
2028 var x285 uint64
2029 x284, x285 = bits.Add64(x283, x280, uint64(0x0))
2030 var x286 uint64
2031 var x287 uint64
2032 x286, x287 = bits.Add64(x281, x278, uint64(p521Uint1(x285)))
2033 var x288 uint64
2034 var x289 uint64
2035 x288, x289 = bits.Add64(x279, x276, uint64(p521Uint1(x287)))
2036 var x290 uint64
2037 var x291 uint64
2038 x290, x291 = bits.Add64(x277, x274, uint64(p521Uint1(x289)))
2039 var x292 uint64
2040 var x293 uint64
2041 x292, x293 = bits.Add64(x275, x272, uint64(p521Uint1(x291)))
2042 var x294 uint64
2043 var x295 uint64
2044 x294, x295 = bits.Add64(x273, x270, uint64(p521Uint1(x293)))
2045 var x296 uint64
2046 var x297 uint64
2047 x296, x297 = bits.Add64(x271, x268, uint64(p521Uint1(x295)))
2048 var x298 uint64
2049 var x299 uint64
2050 x298, x299 = bits.Add64(x269, x266, uint64(p521Uint1(x297)))
2051 x300 := (uint64(p521Uint1(x299)) + x267)
2052 var x302 uint64
2053 _, x302 = bits.Add64(x246, x282, uint64(0x0))
2054 var x303 uint64
2055 var x304 uint64
2056 x303, x304 = bits.Add64(x248, x284, uint64(p521Uint1(x302)))
2057 var x305 uint64
2058 var x306 uint64
2059 x305, x306 = bits.Add64(x250, x286, uint64(p521Uint1(x304)))
2060 var x307 uint64
2061 var x308 uint64
2062 x307, x308 = bits.Add64(x252, x288, uint64(p521Uint1(x306)))
2063 var x309 uint64
2064 var x310 uint64
2065 x309, x310 = bits.Add64(x254, x290, uint64(p521Uint1(x308)))
2066 var x311 uint64
2067 var x312 uint64
2068 x311, x312 = bits.Add64(x256, x292, uint64(p521Uint1(x310)))
2069 var x313 uint64
2070 var x314 uint64
2071 x313, x314 = bits.Add64(x258, x294, uint64(p521Uint1(x312)))
2072 var x315 uint64
2073 var x316 uint64
2074 x315, x316 = bits.Add64(x260, x296, uint64(p521Uint1(x314)))
2075 var x317 uint64
2076 var x318 uint64
2077 x317, x318 = bits.Add64(x262, x298, uint64(p521Uint1(x316)))
2078 var x319 uint64
2079 var x320 uint64
2080 x319, x320 = bits.Add64(x264, x300, uint64(p521Uint1(x318)))
2081 x321 := (uint64(p521Uint1(x320)) + uint64(p521Uint1(x265)))
2082 var x322 uint64
2083 var x323 uint64
2084 x323, x322 = bits.Mul64(x3, arg1[8])
2085 var x324 uint64
2086 var x325 uint64
2087 x325, x324 = bits.Mul64(x3, arg1[7])
2088 var x326 uint64
2089 var x327 uint64
2090 x327, x326 = bits.Mul64(x3, arg1[6])
2091 var x328 uint64
2092 var x329 uint64
2093 x329, x328 = bits.Mul64(x3, arg1[5])
2094 var x330 uint64
2095 var x331 uint64
2096 x331, x330 = bits.Mul64(x3, arg1[4])
2097 var x332 uint64
2098 var x333 uint64
2099 x333, x332 = bits.Mul64(x3, arg1[3])
2100 var x334 uint64
2101 var x335 uint64
2102 x335, x334 = bits.Mul64(x3, arg1[2])
2103 var x336 uint64
2104 var x337 uint64
2105 x337, x336 = bits.Mul64(x3, arg1[1])
2106 var x338 uint64
2107 var x339 uint64
2108 x339, x338 = bits.Mul64(x3, arg1[0])
2109 var x340 uint64
2110 var x341 uint64
2111 x340, x341 = bits.Add64(x339, x336, uint64(0x0))
2112 var x342 uint64
2113 var x343 uint64
2114 x342, x343 = bits.Add64(x337, x334, uint64(p521Uint1(x341)))
2115 var x344 uint64
2116 var x345 uint64
2117 x344, x345 = bits.Add64(x335, x332, uint64(p521Uint1(x343)))
2118 var x346 uint64
2119 var x347 uint64
2120 x346, x347 = bits.Add64(x333, x330, uint64(p521Uint1(x345)))
2121 var x348 uint64
2122 var x349 uint64
2123 x348, x349 = bits.Add64(x331, x328, uint64(p521Uint1(x347)))
2124 var x350 uint64
2125 var x351 uint64
2126 x350, x351 = bits.Add64(x329, x326, uint64(p521Uint1(x349)))
2127 var x352 uint64
2128 var x353 uint64
2129 x352, x353 = bits.Add64(x327, x324, uint64(p521Uint1(x351)))
2130 var x354 uint64
2131 var x355 uint64
2132 x354, x355 = bits.Add64(x325, x322, uint64(p521Uint1(x353)))
2133 x356 := (uint64(p521Uint1(x355)) + x323)
2134 var x357 uint64
2135 var x358 uint64
2136 x357, x358 = bits.Add64(x303, x338, uint64(0x0))
2137 var x359 uint64
2138 var x360 uint64
2139 x359, x360 = bits.Add64(x305, x340, uint64(p521Uint1(x358)))
2140 var x361 uint64
2141 var x362 uint64
2142 x361, x362 = bits.Add64(x307, x342, uint64(p521Uint1(x360)))
2143 var x363 uint64
2144 var x364 uint64
2145 x363, x364 = bits.Add64(x309, x344, uint64(p521Uint1(x362)))
2146 var x365 uint64
2147 var x366 uint64
2148 x365, x366 = bits.Add64(x311, x346, uint64(p521Uint1(x364)))
2149 var x367 uint64
2150 var x368 uint64
2151 x367, x368 = bits.Add64(x313, x348, uint64(p521Uint1(x366)))
2152 var x369 uint64
2153 var x370 uint64
2154 x369, x370 = bits.Add64(x315, x350, uint64(p521Uint1(x368)))
2155 var x371 uint64
2156 var x372 uint64
2157 x371, x372 = bits.Add64(x317, x352, uint64(p521Uint1(x370)))
2158 var x373 uint64
2159 var x374 uint64
2160 x373, x374 = bits.Add64(x319, x354, uint64(p521Uint1(x372)))
2161 var x375 uint64
2162 var x376 uint64
2163 x375, x376 = bits.Add64(x321, x356, uint64(p521Uint1(x374)))
2164 var x377 uint64
2165 var x378 uint64
2166 x378, x377 = bits.Mul64(x357, 0x1ff)
2167 var x379 uint64
2168 var x380 uint64
2169 x380, x379 = bits.Mul64(x357, 0xffffffffffffffff)
2170 var x381 uint64
2171 var x382 uint64
2172 x382, x381 = bits.Mul64(x357, 0xffffffffffffffff)
2173 var x383 uint64
2174 var x384 uint64
2175 x384, x383 = bits.Mul64(x357, 0xffffffffffffffff)
2176 var x385 uint64
2177 var x386 uint64
2178 x386, x385 = bits.Mul64(x357, 0xffffffffffffffff)
2179 var x387 uint64
2180 var x388 uint64
2181 x388, x387 = bits.Mul64(x357, 0xffffffffffffffff)
2182 var x389 uint64
2183 var x390 uint64
2184 x390, x389 = bits.Mul64(x357, 0xffffffffffffffff)
2185 var x391 uint64
2186 var x392 uint64
2187 x392, x391 = bits.Mul64(x357, 0xffffffffffffffff)
2188 var x393 uint64
2189 var x394 uint64
2190 x394, x393 = bits.Mul64(x357, 0xffffffffffffffff)
2191 var x395 uint64
2192 var x396 uint64
2193 x395, x396 = bits.Add64(x394, x391, uint64(0x0))
2194 var x397 uint64
2195 var x398 uint64
2196 x397, x398 = bits.Add64(x392, x389, uint64(p521Uint1(x396)))
2197 var x399 uint64
2198 var x400 uint64
2199 x399, x400 = bits.Add64(x390, x387, uint64(p521Uint1(x398)))
2200 var x401 uint64
2201 var x402 uint64
2202 x401, x402 = bits.Add64(x388, x385, uint64(p521Uint1(x400)))
2203 var x403 uint64
2204 var x404 uint64
2205 x403, x404 = bits.Add64(x386, x383, uint64(p521Uint1(x402)))
2206 var x405 uint64
2207 var x406 uint64
2208 x405, x406 = bits.Add64(x384, x381, uint64(p521Uint1(x404)))
2209 var x407 uint64
2210 var x408 uint64
2211 x407, x408 = bits.Add64(x382, x379, uint64(p521Uint1(x406)))
2212 var x409 uint64
2213 var x410 uint64
2214 x409, x410 = bits.Add64(x380, x377, uint64(p521Uint1(x408)))
2215 x411 := (uint64(p521Uint1(x410)) + x378)
2216 var x413 uint64
2217 _, x413 = bits.Add64(x357, x393, uint64(0x0))
2218 var x414 uint64
2219 var x415 uint64
2220 x414, x415 = bits.Add64(x359, x395, uint64(p521Uint1(x413)))
2221 var x416 uint64
2222 var x417 uint64
2223 x416, x417 = bits.Add64(x361, x397, uint64(p521Uint1(x415)))
2224 var x418 uint64
2225 var x419 uint64
2226 x418, x419 = bits.Add64(x363, x399, uint64(p521Uint1(x417)))
2227 var x420 uint64
2228 var x421 uint64
2229 x420, x421 = bits.Add64(x365, x401, uint64(p521Uint1(x419)))
2230 var x422 uint64
2231 var x423 uint64
2232 x422, x423 = bits.Add64(x367, x403, uint64(p521Uint1(x421)))
2233 var x424 uint64
2234 var x425 uint64
2235 x424, x425 = bits.Add64(x369, x405, uint64(p521Uint1(x423)))
2236 var x426 uint64
2237 var x427 uint64
2238 x426, x427 = bits.Add64(x371, x407, uint64(p521Uint1(x425)))
2239 var x428 uint64
2240 var x429 uint64
2241 x428, x429 = bits.Add64(x373, x409, uint64(p521Uint1(x427)))
2242 var x430 uint64
2243 var x431 uint64
2244 x430, x431 = bits.Add64(x375, x411, uint64(p521Uint1(x429)))
2245 x432 := (uint64(p521Uint1(x431)) + uint64(p521Uint1(x376)))
2246 var x433 uint64
2247 var x434 uint64
2248 x434, x433 = bits.Mul64(x4, arg1[8])
2249 var x435 uint64
2250 var x436 uint64
2251 x436, x435 = bits.Mul64(x4, arg1[7])
2252 var x437 uint64
2253 var x438 uint64
2254 x438, x437 = bits.Mul64(x4, arg1[6])
2255 var x439 uint64
2256 var x440 uint64
2257 x440, x439 = bits.Mul64(x4, arg1[5])
2258 var x441 uint64
2259 var x442 uint64
2260 x442, x441 = bits.Mul64(x4, arg1[4])
2261 var x443 uint64
2262 var x444 uint64
2263 x444, x443 = bits.Mul64(x4, arg1[3])
2264 var x445 uint64
2265 var x446 uint64
2266 x446, x445 = bits.Mul64(x4, arg1[2])
2267 var x447 uint64
2268 var x448 uint64
2269 x448, x447 = bits.Mul64(x4, arg1[1])
2270 var x449 uint64
2271 var x450 uint64
2272 x450, x449 = bits.Mul64(x4, arg1[0])
2273 var x451 uint64
2274 var x452 uint64
2275 x451, x452 = bits.Add64(x450, x447, uint64(0x0))
2276 var x453 uint64
2277 var x454 uint64
2278 x453, x454 = bits.Add64(x448, x445, uint64(p521Uint1(x452)))
2279 var x455 uint64
2280 var x456 uint64
2281 x455, x456 = bits.Add64(x446, x443, uint64(p521Uint1(x454)))
2282 var x457 uint64
2283 var x458 uint64
2284 x457, x458 = bits.Add64(x444, x441, uint64(p521Uint1(x456)))
2285 var x459 uint64
2286 var x460 uint64
2287 x459, x460 = bits.Add64(x442, x439, uint64(p521Uint1(x458)))
2288 var x461 uint64
2289 var x462 uint64
2290 x461, x462 = bits.Add64(x440, x437, uint64(p521Uint1(x460)))
2291 var x463 uint64
2292 var x464 uint64
2293 x463, x464 = bits.Add64(x438, x435, uint64(p521Uint1(x462)))
2294 var x465 uint64
2295 var x466 uint64
2296 x465, x466 = bits.Add64(x436, x433, uint64(p521Uint1(x464)))
2297 x467 := (uint64(p521Uint1(x466)) + x434)
2298 var x468 uint64
2299 var x469 uint64
2300 x468, x469 = bits.Add64(x414, x449, uint64(0x0))
2301 var x470 uint64
2302 var x471 uint64
2303 x470, x471 = bits.Add64(x416, x451, uint64(p521Uint1(x469)))
2304 var x472 uint64
2305 var x473 uint64
2306 x472, x473 = bits.Add64(x418, x453, uint64(p521Uint1(x471)))
2307 var x474 uint64
2308 var x475 uint64
2309 x474, x475 = bits.Add64(x420, x455, uint64(p521Uint1(x473)))
2310 var x476 uint64
2311 var x477 uint64
2312 x476, x477 = bits.Add64(x422, x457, uint64(p521Uint1(x475)))
2313 var x478 uint64
2314 var x479 uint64
2315 x478, x479 = bits.Add64(x424, x459, uint64(p521Uint1(x477)))
2316 var x480 uint64
2317 var x481 uint64
2318 x480, x481 = bits.Add64(x426, x461, uint64(p521Uint1(x479)))
2319 var x482 uint64
2320 var x483 uint64
2321 x482, x483 = bits.Add64(x428, x463, uint64(p521Uint1(x481)))
2322 var x484 uint64
2323 var x485 uint64
2324 x484, x485 = bits.Add64(x430, x465, uint64(p521Uint1(x483)))
2325 var x486 uint64
2326 var x487 uint64
2327 x486, x487 = bits.Add64(x432, x467, uint64(p521Uint1(x485)))
2328 var x488 uint64
2329 var x489 uint64
2330 x489, x488 = bits.Mul64(x468, 0x1ff)
2331 var x490 uint64
2332 var x491 uint64
2333 x491, x490 = bits.Mul64(x468, 0xffffffffffffffff)
2334 var x492 uint64
2335 var x493 uint64
2336 x493, x492 = bits.Mul64(x468, 0xffffffffffffffff)
2337 var x494 uint64
2338 var x495 uint64
2339 x495, x494 = bits.Mul64(x468, 0xffffffffffffffff)
2340 var x496 uint64
2341 var x497 uint64
2342 x497, x496 = bits.Mul64(x468, 0xffffffffffffffff)
2343 var x498 uint64
2344 var x499 uint64
2345 x499, x498 = bits.Mul64(x468, 0xffffffffffffffff)
2346 var x500 uint64
2347 var x501 uint64
2348 x501, x500 = bits.Mul64(x468, 0xffffffffffffffff)
2349 var x502 uint64
2350 var x503 uint64
2351 x503, x502 = bits.Mul64(x468, 0xffffffffffffffff)
2352 var x504 uint64
2353 var x505 uint64
2354 x505, x504 = bits.Mul64(x468, 0xffffffffffffffff)
2355 var x506 uint64
2356 var x507 uint64
2357 x506, x507 = bits.Add64(x505, x502, uint64(0x0))
2358 var x508 uint64
2359 var x509 uint64
2360 x508, x509 = bits.Add64(x503, x500, uint64(p521Uint1(x507)))
2361 var x510 uint64
2362 var x511 uint64
2363 x510, x511 = bits.Add64(x501, x498, uint64(p521Uint1(x509)))
2364 var x512 uint64
2365 var x513 uint64
2366 x512, x513 = bits.Add64(x499, x496, uint64(p521Uint1(x511)))
2367 var x514 uint64
2368 var x515 uint64
2369 x514, x515 = bits.Add64(x497, x494, uint64(p521Uint1(x513)))
2370 var x516 uint64
2371 var x517 uint64
2372 x516, x517 = bits.Add64(x495, x492, uint64(p521Uint1(x515)))
2373 var x518 uint64
2374 var x519 uint64
2375 x518, x519 = bits.Add64(x493, x490, uint64(p521Uint1(x517)))
2376 var x520 uint64
2377 var x521 uint64
2378 x520, x521 = bits.Add64(x491, x488, uint64(p521Uint1(x519)))
2379 x522 := (uint64(p521Uint1(x521)) + x489)
2380 var x524 uint64
2381 _, x524 = bits.Add64(x468, x504, uint64(0x0))
2382 var x525 uint64
2383 var x526 uint64
2384 x525, x526 = bits.Add64(x470, x506, uint64(p521Uint1(x524)))
2385 var x527 uint64
2386 var x528 uint64
2387 x527, x528 = bits.Add64(x472, x508, uint64(p521Uint1(x526)))
2388 var x529 uint64
2389 var x530 uint64
2390 x529, x530 = bits.Add64(x474, x510, uint64(p521Uint1(x528)))
2391 var x531 uint64
2392 var x532 uint64
2393 x531, x532 = bits.Add64(x476, x512, uint64(p521Uint1(x530)))
2394 var x533 uint64
2395 var x534 uint64
2396 x533, x534 = bits.Add64(x478, x514, uint64(p521Uint1(x532)))
2397 var x535 uint64
2398 var x536 uint64
2399 x535, x536 = bits.Add64(x480, x516, uint64(p521Uint1(x534)))
2400 var x537 uint64
2401 var x538 uint64
2402 x537, x538 = bits.Add64(x482, x518, uint64(p521Uint1(x536)))
2403 var x539 uint64
2404 var x540 uint64
2405 x539, x540 = bits.Add64(x484, x520, uint64(p521Uint1(x538)))
2406 var x541 uint64
2407 var x542 uint64
2408 x541, x542 = bits.Add64(x486, x522, uint64(p521Uint1(x540)))
2409 x543 := (uint64(p521Uint1(x542)) + uint64(p521Uint1(x487)))
2410 var x544 uint64
2411 var x545 uint64
2412 x545, x544 = bits.Mul64(x5, arg1[8])
2413 var x546 uint64
2414 var x547 uint64
2415 x547, x546 = bits.Mul64(x5, arg1[7])
2416 var x548 uint64
2417 var x549 uint64
2418 x549, x548 = bits.Mul64(x5, arg1[6])
2419 var x550 uint64
2420 var x551 uint64
2421 x551, x550 = bits.Mul64(x5, arg1[5])
2422 var x552 uint64
2423 var x553 uint64
2424 x553, x552 = bits.Mul64(x5, arg1[4])
2425 var x554 uint64
2426 var x555 uint64
2427 x555, x554 = bits.Mul64(x5, arg1[3])
2428 var x556 uint64
2429 var x557 uint64
2430 x557, x556 = bits.Mul64(x5, arg1[2])
2431 var x558 uint64
2432 var x559 uint64
2433 x559, x558 = bits.Mul64(x5, arg1[1])
2434 var x560 uint64
2435 var x561 uint64
2436 x561, x560 = bits.Mul64(x5, arg1[0])
2437 var x562 uint64
2438 var x563 uint64
2439 x562, x563 = bits.Add64(x561, x558, uint64(0x0))
2440 var x564 uint64
2441 var x565 uint64
2442 x564, x565 = bits.Add64(x559, x556, uint64(p521Uint1(x563)))
2443 var x566 uint64
2444 var x567 uint64
2445 x566, x567 = bits.Add64(x557, x554, uint64(p521Uint1(x565)))
2446 var x568 uint64
2447 var x569 uint64
2448 x568, x569 = bits.Add64(x555, x552, uint64(p521Uint1(x567)))
2449 var x570 uint64
2450 var x571 uint64
2451 x570, x571 = bits.Add64(x553, x550, uint64(p521Uint1(x569)))
2452 var x572 uint64
2453 var x573 uint64
2454 x572, x573 = bits.Add64(x551, x548, uint64(p521Uint1(x571)))
2455 var x574 uint64
2456 var x575 uint64
2457 x574, x575 = bits.Add64(x549, x546, uint64(p521Uint1(x573)))
2458 var x576 uint64
2459 var x577 uint64
2460 x576, x577 = bits.Add64(x547, x544, uint64(p521Uint1(x575)))
2461 x578 := (uint64(p521Uint1(x577)) + x545)
2462 var x579 uint64
2463 var x580 uint64
2464 x579, x580 = bits.Add64(x525, x560, uint64(0x0))
2465 var x581 uint64
2466 var x582 uint64
2467 x581, x582 = bits.Add64(x527, x562, uint64(p521Uint1(x580)))
2468 var x583 uint64
2469 var x584 uint64
2470 x583, x584 = bits.Add64(x529, x564, uint64(p521Uint1(x582)))
2471 var x585 uint64
2472 var x586 uint64
2473 x585, x586 = bits.Add64(x531, x566, uint64(p521Uint1(x584)))
2474 var x587 uint64
2475 var x588 uint64
2476 x587, x588 = bits.Add64(x533, x568, uint64(p521Uint1(x586)))
2477 var x589 uint64
2478 var x590 uint64
2479 x589, x590 = bits.Add64(x535, x570, uint64(p521Uint1(x588)))
2480 var x591 uint64
2481 var x592 uint64
2482 x591, x592 = bits.Add64(x537, x572, uint64(p521Uint1(x590)))
2483 var x593 uint64
2484 var x594 uint64
2485 x593, x594 = bits.Add64(x539, x574, uint64(p521Uint1(x592)))
2486 var x595 uint64
2487 var x596 uint64
2488 x595, x596 = bits.Add64(x541, x576, uint64(p521Uint1(x594)))
2489 var x597 uint64
2490 var x598 uint64
2491 x597, x598 = bits.Add64(x543, x578, uint64(p521Uint1(x596)))
2492 var x599 uint64
2493 var x600 uint64
2494 x600, x599 = bits.Mul64(x579, 0x1ff)
2495 var x601 uint64
2496 var x602 uint64
2497 x602, x601 = bits.Mul64(x579, 0xffffffffffffffff)
2498 var x603 uint64
2499 var x604 uint64
2500 x604, x603 = bits.Mul64(x579, 0xffffffffffffffff)
2501 var x605 uint64
2502 var x606 uint64
2503 x606, x605 = bits.Mul64(x579, 0xffffffffffffffff)
2504 var x607 uint64
2505 var x608 uint64
2506 x608, x607 = bits.Mul64(x579, 0xffffffffffffffff)
2507 var x609 uint64
2508 var x610 uint64
2509 x610, x609 = bits.Mul64(x579, 0xffffffffffffffff)
2510 var x611 uint64
2511 var x612 uint64
2512 x612, x611 = bits.Mul64(x579, 0xffffffffffffffff)
2513 var x613 uint64
2514 var x614 uint64
2515 x614, x613 = bits.Mul64(x579, 0xffffffffffffffff)
2516 var x615 uint64
2517 var x616 uint64
2518 x616, x615 = bits.Mul64(x579, 0xffffffffffffffff)
2519 var x617 uint64
2520 var x618 uint64
2521 x617, x618 = bits.Add64(x616, x613, uint64(0x0))
2522 var x619 uint64
2523 var x620 uint64
2524 x619, x620 = bits.Add64(x614, x611, uint64(p521Uint1(x618)))
2525 var x621 uint64
2526 var x622 uint64
2527 x621, x622 = bits.Add64(x612, x609, uint64(p521Uint1(x620)))
2528 var x623 uint64
2529 var x624 uint64
2530 x623, x624 = bits.Add64(x610, x607, uint64(p521Uint1(x622)))
2531 var x625 uint64
2532 var x626 uint64
2533 x625, x626 = bits.Add64(x608, x605, uint64(p521Uint1(x624)))
2534 var x627 uint64
2535 var x628 uint64
2536 x627, x628 = bits.Add64(x606, x603, uint64(p521Uint1(x626)))
2537 var x629 uint64
2538 var x630 uint64
2539 x629, x630 = bits.Add64(x604, x601, uint64(p521Uint1(x628)))
2540 var x631 uint64
2541 var x632 uint64
2542 x631, x632 = bits.Add64(x602, x599, uint64(p521Uint1(x630)))
2543 x633 := (uint64(p521Uint1(x632)) + x600)
2544 var x635 uint64
2545 _, x635 = bits.Add64(x579, x615, uint64(0x0))
2546 var x636 uint64
2547 var x637 uint64
2548 x636, x637 = bits.Add64(x581, x617, uint64(p521Uint1(x635)))
2549 var x638 uint64
2550 var x639 uint64
2551 x638, x639 = bits.Add64(x583, x619, uint64(p521Uint1(x637)))
2552 var x640 uint64
2553 var x641 uint64
2554 x640, x641 = bits.Add64(x585, x621, uint64(p521Uint1(x639)))
2555 var x642 uint64
2556 var x643 uint64
2557 x642, x643 = bits.Add64(x587, x623, uint64(p521Uint1(x641)))
2558 var x644 uint64
2559 var x645 uint64
2560 x644, x645 = bits.Add64(x589, x625, uint64(p521Uint1(x643)))
2561 var x646 uint64
2562 var x647 uint64
2563 x646, x647 = bits.Add64(x591, x627, uint64(p521Uint1(x645)))
2564 var x648 uint64
2565 var x649 uint64
2566 x648, x649 = bits.Add64(x593, x629, uint64(p521Uint1(x647)))
2567 var x650 uint64
2568 var x651 uint64
2569 x650, x651 = bits.Add64(x595, x631, uint64(p521Uint1(x649)))
2570 var x652 uint64
2571 var x653 uint64
2572 x652, x653 = bits.Add64(x597, x633, uint64(p521Uint1(x651)))
2573 x654 := (uint64(p521Uint1(x653)) + uint64(p521Uint1(x598)))
2574 var x655 uint64
2575 var x656 uint64
2576 x656, x655 = bits.Mul64(x6, arg1[8])
2577 var x657 uint64
2578 var x658 uint64
2579 x658, x657 = bits.Mul64(x6, arg1[7])
2580 var x659 uint64
2581 var x660 uint64
2582 x660, x659 = bits.Mul64(x6, arg1[6])
2583 var x661 uint64
2584 var x662 uint64
2585 x662, x661 = bits.Mul64(x6, arg1[5])
2586 var x663 uint64
2587 var x664 uint64
2588 x664, x663 = bits.Mul64(x6, arg1[4])
2589 var x665 uint64
2590 var x666 uint64
2591 x666, x665 = bits.Mul64(x6, arg1[3])
2592 var x667 uint64
2593 var x668 uint64
2594 x668, x667 = bits.Mul64(x6, arg1[2])
2595 var x669 uint64
2596 var x670 uint64
2597 x670, x669 = bits.Mul64(x6, arg1[1])
2598 var x671 uint64
2599 var x672 uint64
2600 x672, x671 = bits.Mul64(x6, arg1[0])
2601 var x673 uint64
2602 var x674 uint64
2603 x673, x674 = bits.Add64(x672, x669, uint64(0x0))
2604 var x675 uint64
2605 var x676 uint64
2606 x675, x676 = bits.Add64(x670, x667, uint64(p521Uint1(x674)))
2607 var x677 uint64
2608 var x678 uint64
2609 x677, x678 = bits.Add64(x668, x665, uint64(p521Uint1(x676)))
2610 var x679 uint64
2611 var x680 uint64
2612 x679, x680 = bits.Add64(x666, x663, uint64(p521Uint1(x678)))
2613 var x681 uint64
2614 var x682 uint64
2615 x681, x682 = bits.Add64(x664, x661, uint64(p521Uint1(x680)))
2616 var x683 uint64
2617 var x684 uint64
2618 x683, x684 = bits.Add64(x662, x659, uint64(p521Uint1(x682)))
2619 var x685 uint64
2620 var x686 uint64
2621 x685, x686 = bits.Add64(x660, x657, uint64(p521Uint1(x684)))
2622 var x687 uint64
2623 var x688 uint64
2624 x687, x688 = bits.Add64(x658, x655, uint64(p521Uint1(x686)))
2625 x689 := (uint64(p521Uint1(x688)) + x656)
2626 var x690 uint64
2627 var x691 uint64
2628 x690, x691 = bits.Add64(x636, x671, uint64(0x0))
2629 var x692 uint64
2630 var x693 uint64
2631 x692, x693 = bits.Add64(x638, x673, uint64(p521Uint1(x691)))
2632 var x694 uint64
2633 var x695 uint64
2634 x694, x695 = bits.Add64(x640, x675, uint64(p521Uint1(x693)))
2635 var x696 uint64
2636 var x697 uint64
2637 x696, x697 = bits.Add64(x642, x677, uint64(p521Uint1(x695)))
2638 var x698 uint64
2639 var x699 uint64
2640 x698, x699 = bits.Add64(x644, x679, uint64(p521Uint1(x697)))
2641 var x700 uint64
2642 var x701 uint64
2643 x700, x701 = bits.Add64(x646, x681, uint64(p521Uint1(x699)))
2644 var x702 uint64
2645 var x703 uint64
2646 x702, x703 = bits.Add64(x648, x683, uint64(p521Uint1(x701)))
2647 var x704 uint64
2648 var x705 uint64
2649 x704, x705 = bits.Add64(x650, x685, uint64(p521Uint1(x703)))
2650 var x706 uint64
2651 var x707 uint64
2652 x706, x707 = bits.Add64(x652, x687, uint64(p521Uint1(x705)))
2653 var x708 uint64
2654 var x709 uint64
2655 x708, x709 = bits.Add64(x654, x689, uint64(p521Uint1(x707)))
2656 var x710 uint64
2657 var x711 uint64
2658 x711, x710 = bits.Mul64(x690, 0x1ff)
2659 var x712 uint64
2660 var x713 uint64
2661 x713, x712 = bits.Mul64(x690, 0xffffffffffffffff)
2662 var x714 uint64
2663 var x715 uint64
2664 x715, x714 = bits.Mul64(x690, 0xffffffffffffffff)
2665 var x716 uint64
2666 var x717 uint64
2667 x717, x716 = bits.Mul64(x690, 0xffffffffffffffff)
2668 var x718 uint64
2669 var x719 uint64
2670 x719, x718 = bits.Mul64(x690, 0xffffffffffffffff)
2671 var x720 uint64
2672 var x721 uint64
2673 x721, x720 = bits.Mul64(x690, 0xffffffffffffffff)
2674 var x722 uint64
2675 var x723 uint64
2676 x723, x722 = bits.Mul64(x690, 0xffffffffffffffff)
2677 var x724 uint64
2678 var x725 uint64
2679 x725, x724 = bits.Mul64(x690, 0xffffffffffffffff)
2680 var x726 uint64
2681 var x727 uint64
2682 x727, x726 = bits.Mul64(x690, 0xffffffffffffffff)
2683 var x728 uint64
2684 var x729 uint64
2685 x728, x729 = bits.Add64(x727, x724, uint64(0x0))
2686 var x730 uint64
2687 var x731 uint64
2688 x730, x731 = bits.Add64(x725, x722, uint64(p521Uint1(x729)))
2689 var x732 uint64
2690 var x733 uint64
2691 x732, x733 = bits.Add64(x723, x720, uint64(p521Uint1(x731)))
2692 var x734 uint64
2693 var x735 uint64
2694 x734, x735 = bits.Add64(x721, x718, uint64(p521Uint1(x733)))
2695 var x736 uint64
2696 var x737 uint64
2697 x736, x737 = bits.Add64(x719, x716, uint64(p521Uint1(x735)))
2698 var x738 uint64
2699 var x739 uint64
2700 x738, x739 = bits.Add64(x717, x714, uint64(p521Uint1(x737)))
2701 var x740 uint64
2702 var x741 uint64
2703 x740, x741 = bits.Add64(x715, x712, uint64(p521Uint1(x739)))
2704 var x742 uint64
2705 var x743 uint64
2706 x742, x743 = bits.Add64(x713, x710, uint64(p521Uint1(x741)))
2707 x744 := (uint64(p521Uint1(x743)) + x711)
2708 var x746 uint64
2709 _, x746 = bits.Add64(x690, x726, uint64(0x0))
2710 var x747 uint64
2711 var x748 uint64
2712 x747, x748 = bits.Add64(x692, x728, uint64(p521Uint1(x746)))
2713 var x749 uint64
2714 var x750 uint64
2715 x749, x750 = bits.Add64(x694, x730, uint64(p521Uint1(x748)))
2716 var x751 uint64
2717 var x752 uint64
2718 x751, x752 = bits.Add64(x696, x732, uint64(p521Uint1(x750)))
2719 var x753 uint64
2720 var x754 uint64
2721 x753, x754 = bits.Add64(x698, x734, uint64(p521Uint1(x752)))
2722 var x755 uint64
2723 var x756 uint64
2724 x755, x756 = bits.Add64(x700, x736, uint64(p521Uint1(x754)))
2725 var x757 uint64
2726 var x758 uint64
2727 x757, x758 = bits.Add64(x702, x738, uint64(p521Uint1(x756)))
2728 var x759 uint64
2729 var x760 uint64
2730 x759, x760 = bits.Add64(x704, x740, uint64(p521Uint1(x758)))
2731 var x761 uint64
2732 var x762 uint64
2733 x761, x762 = bits.Add64(x706, x742, uint64(p521Uint1(x760)))
2734 var x763 uint64
2735 var x764 uint64
2736 x763, x764 = bits.Add64(x708, x744, uint64(p521Uint1(x762)))
2737 x765 := (uint64(p521Uint1(x764)) + uint64(p521Uint1(x709)))
2738 var x766 uint64
2739 var x767 uint64
2740 x767, x766 = bits.Mul64(x7, arg1[8])
2741 var x768 uint64
2742 var x769 uint64
2743 x769, x768 = bits.Mul64(x7, arg1[7])
2744 var x770 uint64
2745 var x771 uint64
2746 x771, x770 = bits.Mul64(x7, arg1[6])
2747 var x772 uint64
2748 var x773 uint64
2749 x773, x772 = bits.Mul64(x7, arg1[5])
2750 var x774 uint64
2751 var x775 uint64
2752 x775, x774 = bits.Mul64(x7, arg1[4])
2753 var x776 uint64
2754 var x777 uint64
2755 x777, x776 = bits.Mul64(x7, arg1[3])
2756 var x778 uint64
2757 var x779 uint64
2758 x779, x778 = bits.Mul64(x7, arg1[2])
2759 var x780 uint64
2760 var x781 uint64
2761 x781, x780 = bits.Mul64(x7, arg1[1])
2762 var x782 uint64
2763 var x783 uint64
2764 x783, x782 = bits.Mul64(x7, arg1[0])
2765 var x784 uint64
2766 var x785 uint64
2767 x784, x785 = bits.Add64(x783, x780, uint64(0x0))
2768 var x786 uint64
2769 var x787 uint64
2770 x786, x787 = bits.Add64(x781, x778, uint64(p521Uint1(x785)))
2771 var x788 uint64
2772 var x789 uint64
2773 x788, x789 = bits.Add64(x779, x776, uint64(p521Uint1(x787)))
2774 var x790 uint64
2775 var x791 uint64
2776 x790, x791 = bits.Add64(x777, x774, uint64(p521Uint1(x789)))
2777 var x792 uint64
2778 var x793 uint64
2779 x792, x793 = bits.Add64(x775, x772, uint64(p521Uint1(x791)))
2780 var x794 uint64
2781 var x795 uint64
2782 x794, x795 = bits.Add64(x773, x770, uint64(p521Uint1(x793)))
2783 var x796 uint64
2784 var x797 uint64
2785 x796, x797 = bits.Add64(x771, x768, uint64(p521Uint1(x795)))
2786 var x798 uint64
2787 var x799 uint64
2788 x798, x799 = bits.Add64(x769, x766, uint64(p521Uint1(x797)))
2789 x800 := (uint64(p521Uint1(x799)) + x767)
2790 var x801 uint64
2791 var x802 uint64
2792 x801, x802 = bits.Add64(x747, x782, uint64(0x0))
2793 var x803 uint64
2794 var x804 uint64
2795 x803, x804 = bits.Add64(x749, x784, uint64(p521Uint1(x802)))
2796 var x805 uint64
2797 var x806 uint64
2798 x805, x806 = bits.Add64(x751, x786, uint64(p521Uint1(x804)))
2799 var x807 uint64
2800 var x808 uint64
2801 x807, x808 = bits.Add64(x753, x788, uint64(p521Uint1(x806)))
2802 var x809 uint64
2803 var x810 uint64
2804 x809, x810 = bits.Add64(x755, x790, uint64(p521Uint1(x808)))
2805 var x811 uint64
2806 var x812 uint64
2807 x811, x812 = bits.Add64(x757, x792, uint64(p521Uint1(x810)))
2808 var x813 uint64
2809 var x814 uint64
2810 x813, x814 = bits.Add64(x759, x794, uint64(p521Uint1(x812)))
2811 var x815 uint64
2812 var x816 uint64
2813 x815, x816 = bits.Add64(x761, x796, uint64(p521Uint1(x814)))
2814 var x817 uint64
2815 var x818 uint64
2816 x817, x818 = bits.Add64(x763, x798, uint64(p521Uint1(x816)))
2817 var x819 uint64
2818 var x820 uint64
2819 x819, x820 = bits.Add64(x765, x800, uint64(p521Uint1(x818)))
2820 var x821 uint64
2821 var x822 uint64
2822 x822, x821 = bits.Mul64(x801, 0x1ff)
2823 var x823 uint64
2824 var x824 uint64
2825 x824, x823 = bits.Mul64(x801, 0xffffffffffffffff)
2826 var x825 uint64
2827 var x826 uint64
2828 x826, x825 = bits.Mul64(x801, 0xffffffffffffffff)
2829 var x827 uint64
2830 var x828 uint64
2831 x828, x827 = bits.Mul64(x801, 0xffffffffffffffff)
2832 var x829 uint64
2833 var x830 uint64
2834 x830, x829 = bits.Mul64(x801, 0xffffffffffffffff)
2835 var x831 uint64
2836 var x832 uint64
2837 x832, x831 = bits.Mul64(x801, 0xffffffffffffffff)
2838 var x833 uint64
2839 var x834 uint64
2840 x834, x833 = bits.Mul64(x801, 0xffffffffffffffff)
2841 var x835 uint64
2842 var x836 uint64
2843 x836, x835 = bits.Mul64(x801, 0xffffffffffffffff)
2844 var x837 uint64
2845 var x838 uint64
2846 x838, x837 = bits.Mul64(x801, 0xffffffffffffffff)
2847 var x839 uint64
2848 var x840 uint64
2849 x839, x840 = bits.Add64(x838, x835, uint64(0x0))
2850 var x841 uint64
2851 var x842 uint64
2852 x841, x842 = bits.Add64(x836, x833, uint64(p521Uint1(x840)))
2853 var x843 uint64
2854 var x844 uint64
2855 x843, x844 = bits.Add64(x834, x831, uint64(p521Uint1(x842)))
2856 var x845 uint64
2857 var x846 uint64
2858 x845, x846 = bits.Add64(x832, x829, uint64(p521Uint1(x844)))
2859 var x847 uint64
2860 var x848 uint64
2861 x847, x848 = bits.Add64(x830, x827, uint64(p521Uint1(x846)))
2862 var x849 uint64
2863 var x850 uint64
2864 x849, x850 = bits.Add64(x828, x825, uint64(p521Uint1(x848)))
2865 var x851 uint64
2866 var x852 uint64
2867 x851, x852 = bits.Add64(x826, x823, uint64(p521Uint1(x850)))
2868 var x853 uint64
2869 var x854 uint64
2870 x853, x854 = bits.Add64(x824, x821, uint64(p521Uint1(x852)))
2871 x855 := (uint64(p521Uint1(x854)) + x822)
2872 var x857 uint64
2873 _, x857 = bits.Add64(x801, x837, uint64(0x0))
2874 var x858 uint64
2875 var x859 uint64
2876 x858, x859 = bits.Add64(x803, x839, uint64(p521Uint1(x857)))
2877 var x860 uint64
2878 var x861 uint64
2879 x860, x861 = bits.Add64(x805, x841, uint64(p521Uint1(x859)))
2880 var x862 uint64
2881 var x863 uint64
2882 x862, x863 = bits.Add64(x807, x843, uint64(p521Uint1(x861)))
2883 var x864 uint64
2884 var x865 uint64
2885 x864, x865 = bits.Add64(x809, x845, uint64(p521Uint1(x863)))
2886 var x866 uint64
2887 var x867 uint64
2888 x866, x867 = bits.Add64(x811, x847, uint64(p521Uint1(x865)))
2889 var x868 uint64
2890 var x869 uint64
2891 x868, x869 = bits.Add64(x813, x849, uint64(p521Uint1(x867)))
2892 var x870 uint64
2893 var x871 uint64
2894 x870, x871 = bits.Add64(x815, x851, uint64(p521Uint1(x869)))
2895 var x872 uint64
2896 var x873 uint64
2897 x872, x873 = bits.Add64(x817, x853, uint64(p521Uint1(x871)))
2898 var x874 uint64
2899 var x875 uint64
2900 x874, x875 = bits.Add64(x819, x855, uint64(p521Uint1(x873)))
2901 x876 := (uint64(p521Uint1(x875)) + uint64(p521Uint1(x820)))
2902 var x877 uint64
2903 var x878 uint64
2904 x878, x877 = bits.Mul64(x8, arg1[8])
2905 var x879 uint64
2906 var x880 uint64
2907 x880, x879 = bits.Mul64(x8, arg1[7])
2908 var x881 uint64
2909 var x882 uint64
2910 x882, x881 = bits.Mul64(x8, arg1[6])
2911 var x883 uint64
2912 var x884 uint64
2913 x884, x883 = bits.Mul64(x8, arg1[5])
2914 var x885 uint64
2915 var x886 uint64
2916 x886, x885 = bits.Mul64(x8, arg1[4])
2917 var x887 uint64
2918 var x888 uint64
2919 x888, x887 = bits.Mul64(x8, arg1[3])
2920 var x889 uint64
2921 var x890 uint64
2922 x890, x889 = bits.Mul64(x8, arg1[2])
2923 var x891 uint64
2924 var x892 uint64
2925 x892, x891 = bits.Mul64(x8, arg1[1])
2926 var x893 uint64
2927 var x894 uint64
2928 x894, x893 = bits.Mul64(x8, arg1[0])
2929 var x895 uint64
2930 var x896 uint64
2931 x895, x896 = bits.Add64(x894, x891, uint64(0x0))
2932 var x897 uint64
2933 var x898 uint64
2934 x897, x898 = bits.Add64(x892, x889, uint64(p521Uint1(x896)))
2935 var x899 uint64
2936 var x900 uint64
2937 x899, x900 = bits.Add64(x890, x887, uint64(p521Uint1(x898)))
2938 var x901 uint64
2939 var x902 uint64
2940 x901, x902 = bits.Add64(x888, x885, uint64(p521Uint1(x900)))
2941 var x903 uint64
2942 var x904 uint64
2943 x903, x904 = bits.Add64(x886, x883, uint64(p521Uint1(x902)))
2944 var x905 uint64
2945 var x906 uint64
2946 x905, x906 = bits.Add64(x884, x881, uint64(p521Uint1(x904)))
2947 var x907 uint64
2948 var x908 uint64
2949 x907, x908 = bits.Add64(x882, x879, uint64(p521Uint1(x906)))
2950 var x909 uint64
2951 var x910 uint64
2952 x909, x910 = bits.Add64(x880, x877, uint64(p521Uint1(x908)))
2953 x911 := (uint64(p521Uint1(x910)) + x878)
2954 var x912 uint64
2955 var x913 uint64
2956 x912, x913 = bits.Add64(x858, x893, uint64(0x0))
2957 var x914 uint64
2958 var x915 uint64
2959 x914, x915 = bits.Add64(x860, x895, uint64(p521Uint1(x913)))
2960 var x916 uint64
2961 var x917 uint64
2962 x916, x917 = bits.Add64(x862, x897, uint64(p521Uint1(x915)))
2963 var x918 uint64
2964 var x919 uint64
2965 x918, x919 = bits.Add64(x864, x899, uint64(p521Uint1(x917)))
2966 var x920 uint64
2967 var x921 uint64
2968 x920, x921 = bits.Add64(x866, x901, uint64(p521Uint1(x919)))
2969 var x922 uint64
2970 var x923 uint64
2971 x922, x923 = bits.Add64(x868, x903, uint64(p521Uint1(x921)))
2972 var x924 uint64
2973 var x925 uint64
2974 x924, x925 = bits.Add64(x870, x905, uint64(p521Uint1(x923)))
2975 var x926 uint64
2976 var x927 uint64
2977 x926, x927 = bits.Add64(x872, x907, uint64(p521Uint1(x925)))
2978 var x928 uint64
2979 var x929 uint64
2980 x928, x929 = bits.Add64(x874, x909, uint64(p521Uint1(x927)))
2981 var x930 uint64
2982 var x931 uint64
2983 x930, x931 = bits.Add64(x876, x911, uint64(p521Uint1(x929)))
2984 var x932 uint64
2985 var x933 uint64
2986 x933, x932 = bits.Mul64(x912, 0x1ff)
2987 var x934 uint64
2988 var x935 uint64
2989 x935, x934 = bits.Mul64(x912, 0xffffffffffffffff)
2990 var x936 uint64
2991 var x937 uint64
2992 x937, x936 = bits.Mul64(x912, 0xffffffffffffffff)
2993 var x938 uint64
2994 var x939 uint64
2995 x939, x938 = bits.Mul64(x912, 0xffffffffffffffff)
2996 var x940 uint64
2997 var x941 uint64
2998 x941, x940 = bits.Mul64(x912, 0xffffffffffffffff)
2999 var x942 uint64
3000 var x943 uint64
3001 x943, x942 = bits.Mul64(x912, 0xffffffffffffffff)
3002 var x944 uint64
3003 var x945 uint64
3004 x945, x944 = bits.Mul64(x912, 0xffffffffffffffff)
3005 var x946 uint64
3006 var x947 uint64
3007 x947, x946 = bits.Mul64(x912, 0xffffffffffffffff)
3008 var x948 uint64
3009 var x949 uint64
3010 x949, x948 = bits.Mul64(x912, 0xffffffffffffffff)
3011 var x950 uint64
3012 var x951 uint64
3013 x950, x951 = bits.Add64(x949, x946, uint64(0x0))
3014 var x952 uint64
3015 var x953 uint64
3016 x952, x953 = bits.Add64(x947, x944, uint64(p521Uint1(x951)))
3017 var x954 uint64
3018 var x955 uint64
3019 x954, x955 = bits.Add64(x945, x942, uint64(p521Uint1(x953)))
3020 var x956 uint64
3021 var x957 uint64
3022 x956, x957 = bits.Add64(x943, x940, uint64(p521Uint1(x955)))
3023 var x958 uint64
3024 var x959 uint64
3025 x958, x959 = bits.Add64(x941, x938, uint64(p521Uint1(x957)))
3026 var x960 uint64
3027 var x961 uint64
3028 x960, x961 = bits.Add64(x939, x936, uint64(p521Uint1(x959)))
3029 var x962 uint64
3030 var x963 uint64
3031 x962, x963 = bits.Add64(x937, x934, uint64(p521Uint1(x961)))
3032 var x964 uint64
3033 var x965 uint64
3034 x964, x965 = bits.Add64(x935, x932, uint64(p521Uint1(x963)))
3035 x966 := (uint64(p521Uint1(x965)) + x933)
3036 var x968 uint64
3037 _, x968 = bits.Add64(x912, x948, uint64(0x0))
3038 var x969 uint64
3039 var x970 uint64
3040 x969, x970 = bits.Add64(x914, x950, uint64(p521Uint1(x968)))
3041 var x971 uint64
3042 var x972 uint64
3043 x971, x972 = bits.Add64(x916, x952, uint64(p521Uint1(x970)))
3044 var x973 uint64
3045 var x974 uint64
3046 x973, x974 = bits.Add64(x918, x954, uint64(p521Uint1(x972)))
3047 var x975 uint64
3048 var x976 uint64
3049 x975, x976 = bits.Add64(x920, x956, uint64(p521Uint1(x974)))
3050 var x977 uint64
3051 var x978 uint64
3052 x977, x978 = bits.Add64(x922, x958, uint64(p521Uint1(x976)))
3053 var x979 uint64
3054 var x980 uint64
3055 x979, x980 = bits.Add64(x924, x960, uint64(p521Uint1(x978)))
3056 var x981 uint64
3057 var x982 uint64
3058 x981, x982 = bits.Add64(x926, x962, uint64(p521Uint1(x980)))
3059 var x983 uint64
3060 var x984 uint64
3061 x983, x984 = bits.Add64(x928, x964, uint64(p521Uint1(x982)))
3062 var x985 uint64
3063 var x986 uint64
3064 x985, x986 = bits.Add64(x930, x966, uint64(p521Uint1(x984)))
3065 x987 := (uint64(p521Uint1(x986)) + uint64(p521Uint1(x931)))
3066 var x988 uint64
3067 var x989 uint64
3068 x988, x989 = bits.Sub64(x969, 0xffffffffffffffff, uint64(0x0))
3069 var x990 uint64
3070 var x991 uint64
3071 x990, x991 = bits.Sub64(x971, 0xffffffffffffffff, uint64(p521Uint1(x989)))
3072 var x992 uint64
3073 var x993 uint64
3074 x992, x993 = bits.Sub64(x973, 0xffffffffffffffff, uint64(p521Uint1(x991)))
3075 var x994 uint64
3076 var x995 uint64
3077 x994, x995 = bits.Sub64(x975, 0xffffffffffffffff, uint64(p521Uint1(x993)))
3078 var x996 uint64
3079 var x997 uint64
3080 x996, x997 = bits.Sub64(x977, 0xffffffffffffffff, uint64(p521Uint1(x995)))
3081 var x998 uint64
3082 var x999 uint64
3083 x998, x999 = bits.Sub64(x979, 0xffffffffffffffff, uint64(p521Uint1(x997)))
3084 var x1000 uint64
3085 var x1001 uint64
3086 x1000, x1001 = bits.Sub64(x981, 0xffffffffffffffff, uint64(p521Uint1(x999)))
3087 var x1002 uint64
3088 var x1003 uint64
3089 x1002, x1003 = bits.Sub64(x983, 0xffffffffffffffff, uint64(p521Uint1(x1001)))
3090 var x1004 uint64
3091 var x1005 uint64
3092 x1004, x1005 = bits.Sub64(x985, 0x1ff, uint64(p521Uint1(x1003)))
3093 var x1007 uint64
3094 _, x1007 = bits.Sub64(x987, uint64(0x0), uint64(p521Uint1(x1005)))
3095 var x1008 uint64
3096 p521CmovznzU64(&x1008, p521Uint1(x1007), x988, x969)
3097 var x1009 uint64
3098 p521CmovznzU64(&x1009, p521Uint1(x1007), x990, x971)
3099 var x1010 uint64
3100 p521CmovznzU64(&x1010, p521Uint1(x1007), x992, x973)
3101 var x1011 uint64
3102 p521CmovznzU64(&x1011, p521Uint1(x1007), x994, x975)
3103 var x1012 uint64
3104 p521CmovznzU64(&x1012, p521Uint1(x1007), x996, x977)
3105 var x1013 uint64
3106 p521CmovznzU64(&x1013, p521Uint1(x1007), x998, x979)
3107 var x1014 uint64
3108 p521CmovznzU64(&x1014, p521Uint1(x1007), x1000, x981)
3109 var x1015 uint64
3110 p521CmovznzU64(&x1015, p521Uint1(x1007), x1002, x983)
3111 var x1016 uint64
3112 p521CmovznzU64(&x1016, p521Uint1(x1007), x1004, x985)
3113 out1[0] = x1008
3114 out1[1] = x1009
3115 out1[2] = x1010
3116 out1[3] = x1011
3117 out1[4] = x1012
3118 out1[5] = x1013
3119 out1[6] = x1014
3120 out1[7] = x1015
3121 out1[8] = x1016
3122 }
3123
3124 // p521Add adds two field elements in the Montgomery domain.
3125 //
3126 // Preconditions:
3127 //
3128 // 0 ≤ eval arg1 < m
3129 // 0 ≤ eval arg2 < m
3130 //
3131 // Postconditions:
3132 //
3133 // eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m
3134 // 0 ≤ eval out1 < m
3135 func p521Add(out1 *p521MontgomeryDomainFieldElement, arg1 *p521MontgomeryDomainFieldElement, arg2 *p521MontgomeryDomainFieldElement) {
3136 var x1 uint64
3137 var x2 uint64
3138 x1, x2 = bits.Add64(arg1[0], arg2[0], uint64(0x0))
3139 var x3 uint64
3140 var x4 uint64
3141 x3, x4 = bits.Add64(arg1[1], arg2[1], uint64(p521Uint1(x2)))
3142 var x5 uint64
3143 var x6 uint64
3144 x5, x6 = bits.Add64(arg1[2], arg2[2], uint64(p521Uint1(x4)))
3145 var x7 uint64
3146 var x8 uint64
3147 x7, x8 = bits.Add64(arg1[3], arg2[3], uint64(p521Uint1(x6)))
3148 var x9 uint64
3149 var x10 uint64
3150 x9, x10 = bits.Add64(arg1[4], arg2[4], uint64(p521Uint1(x8)))
3151 var x11 uint64
3152 var x12 uint64
3153 x11, x12 = bits.Add64(arg1[5], arg2[5], uint64(p521Uint1(x10)))
3154 var x13 uint64
3155 var x14 uint64
3156 x13, x14 = bits.Add64(arg1[6], arg2[6], uint64(p521Uint1(x12)))
3157 var x15 uint64
3158 var x16 uint64
3159 x15, x16 = bits.Add64(arg1[7], arg2[7], uint64(p521Uint1(x14)))
3160 var x17 uint64
3161 var x18 uint64
3162 x17, x18 = bits.Add64(arg1[8], arg2[8], uint64(p521Uint1(x16)))
3163 var x19 uint64
3164 var x20 uint64
3165 x19, x20 = bits.Sub64(x1, 0xffffffffffffffff, uint64(0x0))
3166 var x21 uint64
3167 var x22 uint64
3168 x21, x22 = bits.Sub64(x3, 0xffffffffffffffff, uint64(p521Uint1(x20)))
3169 var x23 uint64
3170 var x24 uint64
3171 x23, x24 = bits.Sub64(x5, 0xffffffffffffffff, uint64(p521Uint1(x22)))
3172 var x25 uint64
3173 var x26 uint64
3174 x25, x26 = bits.Sub64(x7, 0xffffffffffffffff, uint64(p521Uint1(x24)))
3175 var x27 uint64
3176 var x28 uint64
3177 x27, x28 = bits.Sub64(x9, 0xffffffffffffffff, uint64(p521Uint1(x26)))
3178 var x29 uint64
3179 var x30 uint64
3180 x29, x30 = bits.Sub64(x11, 0xffffffffffffffff, uint64(p521Uint1(x28)))
3181 var x31 uint64
3182 var x32 uint64
3183 x31, x32 = bits.Sub64(x13, 0xffffffffffffffff, uint64(p521Uint1(x30)))
3184 var x33 uint64
3185 var x34 uint64
3186 x33, x34 = bits.Sub64(x15, 0xffffffffffffffff, uint64(p521Uint1(x32)))
3187 var x35 uint64
3188 var x36 uint64
3189 x35, x36 = bits.Sub64(x17, 0x1ff, uint64(p521Uint1(x34)))
3190 var x38 uint64
3191 _, x38 = bits.Sub64(uint64(p521Uint1(x18)), uint64(0x0), uint64(p521Uint1(x36)))
3192 var x39 uint64
3193 p521CmovznzU64(&x39, p521Uint1(x38), x19, x1)
3194 var x40 uint64
3195 p521CmovznzU64(&x40, p521Uint1(x38), x21, x3)
3196 var x41 uint64
3197 p521CmovznzU64(&x41, p521Uint1(x38), x23, x5)
3198 var x42 uint64
3199 p521CmovznzU64(&x42, p521Uint1(x38), x25, x7)
3200 var x43 uint64
3201 p521CmovznzU64(&x43, p521Uint1(x38), x27, x9)
3202 var x44 uint64
3203 p521CmovznzU64(&x44, p521Uint1(x38), x29, x11)
3204 var x45 uint64
3205 p521CmovznzU64(&x45, p521Uint1(x38), x31, x13)
3206 var x46 uint64
3207 p521CmovznzU64(&x46, p521Uint1(x38), x33, x15)
3208 var x47 uint64
3209 p521CmovznzU64(&x47, p521Uint1(x38), x35, x17)
3210 out1[0] = x39
3211 out1[1] = x40
3212 out1[2] = x41
3213 out1[3] = x42
3214 out1[4] = x43
3215 out1[5] = x44
3216 out1[6] = x45
3217 out1[7] = x46
3218 out1[8] = x47
3219 }
3220
3221 // p521Sub subtracts two field elements in the Montgomery domain.
3222 //
3223 // Preconditions:
3224 //
3225 // 0 ≤ eval arg1 < m
3226 // 0 ≤ eval arg2 < m
3227 //
3228 // Postconditions:
3229 //
3230 // eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m
3231 // 0 ≤ eval out1 < m
3232 func p521Sub(out1 *p521MontgomeryDomainFieldElement, arg1 *p521MontgomeryDomainFieldElement, arg2 *p521MontgomeryDomainFieldElement) {
3233 var x1 uint64
3234 var x2 uint64
3235 x1, x2 = bits.Sub64(arg1[0], arg2[0], uint64(0x0))
3236 var x3 uint64
3237 var x4 uint64
3238 x3, x4 = bits.Sub64(arg1[1], arg2[1], uint64(p521Uint1(x2)))
3239 var x5 uint64
3240 var x6 uint64
3241 x5, x6 = bits.Sub64(arg1[2], arg2[2], uint64(p521Uint1(x4)))
3242 var x7 uint64
3243 var x8 uint64
3244 x7, x8 = bits.Sub64(arg1[3], arg2[3], uint64(p521Uint1(x6)))
3245 var x9 uint64
3246 var x10 uint64
3247 x9, x10 = bits.Sub64(arg1[4], arg2[4], uint64(p521Uint1(x8)))
3248 var x11 uint64
3249 var x12 uint64
3250 x11, x12 = bits.Sub64(arg1[5], arg2[5], uint64(p521Uint1(x10)))
3251 var x13 uint64
3252 var x14 uint64
3253 x13, x14 = bits.Sub64(arg1[6], arg2[6], uint64(p521Uint1(x12)))
3254 var x15 uint64
3255 var x16 uint64
3256 x15, x16 = bits.Sub64(arg1[7], arg2[7], uint64(p521Uint1(x14)))
3257 var x17 uint64
3258 var x18 uint64
3259 x17, x18 = bits.Sub64(arg1[8], arg2[8], uint64(p521Uint1(x16)))
3260 var x19 uint64
3261 p521CmovznzU64(&x19, p521Uint1(x18), uint64(0x0), 0xffffffffffffffff)
3262 var x20 uint64
3263 var x21 uint64
3264 x20, x21 = bits.Add64(x1, x19, uint64(0x0))
3265 var x22 uint64
3266 var x23 uint64
3267 x22, x23 = bits.Add64(x3, x19, uint64(p521Uint1(x21)))
3268 var x24 uint64
3269 var x25 uint64
3270 x24, x25 = bits.Add64(x5, x19, uint64(p521Uint1(x23)))
3271 var x26 uint64
3272 var x27 uint64
3273 x26, x27 = bits.Add64(x7, x19, uint64(p521Uint1(x25)))
3274 var x28 uint64
3275 var x29 uint64
3276 x28, x29 = bits.Add64(x9, x19, uint64(p521Uint1(x27)))
3277 var x30 uint64
3278 var x31 uint64
3279 x30, x31 = bits.Add64(x11, x19, uint64(p521Uint1(x29)))
3280 var x32 uint64
3281 var x33 uint64
3282 x32, x33 = bits.Add64(x13, x19, uint64(p521Uint1(x31)))
3283 var x34 uint64
3284 var x35 uint64
3285 x34, x35 = bits.Add64(x15, x19, uint64(p521Uint1(x33)))
3286 var x36 uint64
3287 x36, _ = bits.Add64(x17, (x19 & 0x1ff), uint64(p521Uint1(x35)))
3288 out1[0] = x20
3289 out1[1] = x22
3290 out1[2] = x24
3291 out1[3] = x26
3292 out1[4] = x28
3293 out1[5] = x30
3294 out1[6] = x32
3295 out1[7] = x34
3296 out1[8] = x36
3297 }
3298
3299 // p521SetOne returns the field element one in the Montgomery domain.
3300 //
3301 // Postconditions:
3302 //
3303 // eval (from_montgomery out1) mod m = 1 mod m
3304 // 0 ≤ eval out1 < m
3305 func p521SetOne(out1 *p521MontgomeryDomainFieldElement) {
3306 out1[0] = 0x80000000000000
3307 out1[1] = uint64(0x0)
3308 out1[2] = uint64(0x0)
3309 out1[3] = uint64(0x0)
3310 out1[4] = uint64(0x0)
3311 out1[5] = uint64(0x0)
3312 out1[6] = uint64(0x0)
3313 out1[7] = uint64(0x0)
3314 out1[8] = uint64(0x0)
3315 }
3316
3317 // p521FromMontgomery translates a field element out of the Montgomery domain.
3318 //
3319 // Preconditions:
3320 //
3321 // 0 ≤ eval arg1 < m
3322 //
3323 // Postconditions:
3324 //
3325 // eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^9) mod m
3326 // 0 ≤ eval out1 < m
3327 func p521FromMontgomery(out1 *p521NonMontgomeryDomainFieldElement, arg1 *p521MontgomeryDomainFieldElement) {
3328 x1 := arg1[0]
3329 var x2 uint64
3330 var x3 uint64
3331 x3, x2 = bits.Mul64(x1, 0x1ff)
3332 var x4 uint64
3333 var x5 uint64
3334 x5, x4 = bits.Mul64(x1, 0xffffffffffffffff)
3335 var x6 uint64
3336 var x7 uint64
3337 x7, x6 = bits.Mul64(x1, 0xffffffffffffffff)
3338 var x8 uint64
3339 var x9 uint64
3340 x9, x8 = bits.Mul64(x1, 0xffffffffffffffff)
3341 var x10 uint64
3342 var x11 uint64
3343 x11, x10 = bits.Mul64(x1, 0xffffffffffffffff)
3344 var x12 uint64
3345 var x13 uint64
3346 x13, x12 = bits.Mul64(x1, 0xffffffffffffffff)
3347 var x14 uint64
3348 var x15 uint64
3349 x15, x14 = bits.Mul64(x1, 0xffffffffffffffff)
3350 var x16 uint64
3351 var x17 uint64
3352 x17, x16 = bits.Mul64(x1, 0xffffffffffffffff)
3353 var x18 uint64
3354 var x19 uint64
3355 x19, x18 = bits.Mul64(x1, 0xffffffffffffffff)
3356 var x20 uint64
3357 var x21 uint64
3358 x20, x21 = bits.Add64(x19, x16, uint64(0x0))
3359 var x22 uint64
3360 var x23 uint64
3361 x22, x23 = bits.Add64(x17, x14, uint64(p521Uint1(x21)))
3362 var x24 uint64
3363 var x25 uint64
3364 x24, x25 = bits.Add64(x15, x12, uint64(p521Uint1(x23)))
3365 var x26 uint64
3366 var x27 uint64
3367 x26, x27 = bits.Add64(x13, x10, uint64(p521Uint1(x25)))
3368 var x28 uint64
3369 var x29 uint64
3370 x28, x29 = bits.Add64(x11, x8, uint64(p521Uint1(x27)))
3371 var x30 uint64
3372 var x31 uint64
3373 x30, x31 = bits.Add64(x9, x6, uint64(p521Uint1(x29)))
3374 var x32 uint64
3375 var x33 uint64
3376 x32, x33 = bits.Add64(x7, x4, uint64(p521Uint1(x31)))
3377 var x34 uint64
3378 var x35 uint64
3379 x34, x35 = bits.Add64(x5, x2, uint64(p521Uint1(x33)))
3380 var x37 uint64
3381 _, x37 = bits.Add64(x1, x18, uint64(0x0))
3382 var x38 uint64
3383 var x39 uint64
3384 x38, x39 = bits.Add64(uint64(0x0), x20, uint64(p521Uint1(x37)))
3385 var x40 uint64
3386 var x41 uint64
3387 x40, x41 = bits.Add64(uint64(0x0), x22, uint64(p521Uint1(x39)))
3388 var x42 uint64
3389 var x43 uint64
3390 x42, x43 = bits.Add64(uint64(0x0), x24, uint64(p521Uint1(x41)))
3391 var x44 uint64
3392 var x45 uint64
3393 x44, x45 = bits.Add64(uint64(0x0), x26, uint64(p521Uint1(x43)))
3394 var x46 uint64
3395 var x47 uint64
3396 x46, x47 = bits.Add64(uint64(0x0), x28, uint64(p521Uint1(x45)))
3397 var x48 uint64
3398 var x49 uint64
3399 x48, x49 = bits.Add64(uint64(0x0), x30, uint64(p521Uint1(x47)))
3400 var x50 uint64
3401 var x51 uint64
3402 x50, x51 = bits.Add64(uint64(0x0), x32, uint64(p521Uint1(x49)))
3403 var x52 uint64
3404 var x53 uint64
3405 x52, x53 = bits.Add64(uint64(0x0), x34, uint64(p521Uint1(x51)))
3406 var x54 uint64
3407 var x55 uint64
3408 x54, x55 = bits.Add64(x38, arg1[1], uint64(0x0))
3409 var x56 uint64
3410 var x57 uint64
3411 x56, x57 = bits.Add64(x40, uint64(0x0), uint64(p521Uint1(x55)))
3412 var x58 uint64
3413 var x59 uint64
3414 x58, x59 = bits.Add64(x42, uint64(0x0), uint64(p521Uint1(x57)))
3415 var x60 uint64
3416 var x61 uint64
3417 x60, x61 = bits.Add64(x44, uint64(0x0), uint64(p521Uint1(x59)))
3418 var x62 uint64
3419 var x63 uint64
3420 x62, x63 = bits.Add64(x46, uint64(0x0), uint64(p521Uint1(x61)))
3421 var x64 uint64
3422 var x65 uint64
3423 x64, x65 = bits.Add64(x48, uint64(0x0), uint64(p521Uint1(x63)))
3424 var x66 uint64
3425 var x67 uint64
3426 x66, x67 = bits.Add64(x50, uint64(0x0), uint64(p521Uint1(x65)))
3427 var x68 uint64
3428 var x69 uint64
3429 x68, x69 = bits.Add64(x52, uint64(0x0), uint64(p521Uint1(x67)))
3430 var x70 uint64
3431 var x71 uint64
3432 x71, x70 = bits.Mul64(x54, 0x1ff)
3433 var x72 uint64
3434 var x73 uint64
3435 x73, x72 = bits.Mul64(x54, 0xffffffffffffffff)
3436 var x74 uint64
3437 var x75 uint64
3438 x75, x74 = bits.Mul64(x54, 0xffffffffffffffff)
3439 var x76 uint64
3440 var x77 uint64
3441 x77, x76 = bits.Mul64(x54, 0xffffffffffffffff)
3442 var x78 uint64
3443 var x79 uint64
3444 x79, x78 = bits.Mul64(x54, 0xffffffffffffffff)
3445 var x80 uint64
3446 var x81 uint64
3447 x81, x80 = bits.Mul64(x54, 0xffffffffffffffff)
3448 var x82 uint64
3449 var x83 uint64
3450 x83, x82 = bits.Mul64(x54, 0xffffffffffffffff)
3451 var x84 uint64
3452 var x85 uint64
3453 x85, x84 = bits.Mul64(x54, 0xffffffffffffffff)
3454 var x86 uint64
3455 var x87 uint64
3456 x87, x86 = bits.Mul64(x54, 0xffffffffffffffff)
3457 var x88 uint64
3458 var x89 uint64
3459 x88, x89 = bits.Add64(x87, x84, uint64(0x0))
3460 var x90 uint64
3461 var x91 uint64
3462 x90, x91 = bits.Add64(x85, x82, uint64(p521Uint1(x89)))
3463 var x92 uint64
3464 var x93 uint64
3465 x92, x93 = bits.Add64(x83, x80, uint64(p521Uint1(x91)))
3466 var x94 uint64
3467 var x95 uint64
3468 x94, x95 = bits.Add64(x81, x78, uint64(p521Uint1(x93)))
3469 var x96 uint64
3470 var x97 uint64
3471 x96, x97 = bits.Add64(x79, x76, uint64(p521Uint1(x95)))
3472 var x98 uint64
3473 var x99 uint64
3474 x98, x99 = bits.Add64(x77, x74, uint64(p521Uint1(x97)))
3475 var x100 uint64
3476 var x101 uint64
3477 x100, x101 = bits.Add64(x75, x72, uint64(p521Uint1(x99)))
3478 var x102 uint64
3479 var x103 uint64
3480 x102, x103 = bits.Add64(x73, x70, uint64(p521Uint1(x101)))
3481 var x105 uint64
3482 _, x105 = bits.Add64(x54, x86, uint64(0x0))
3483 var x106 uint64
3484 var x107 uint64
3485 x106, x107 = bits.Add64(x56, x88, uint64(p521Uint1(x105)))
3486 var x108 uint64
3487 var x109 uint64
3488 x108, x109 = bits.Add64(x58, x90, uint64(p521Uint1(x107)))
3489 var x110 uint64
3490 var x111 uint64
3491 x110, x111 = bits.Add64(x60, x92, uint64(p521Uint1(x109)))
3492 var x112 uint64
3493 var x113 uint64
3494 x112, x113 = bits.Add64(x62, x94, uint64(p521Uint1(x111)))
3495 var x114 uint64
3496 var x115 uint64
3497 x114, x115 = bits.Add64(x64, x96, uint64(p521Uint1(x113)))
3498 var x116 uint64
3499 var x117 uint64
3500 x116, x117 = bits.Add64(x66, x98, uint64(p521Uint1(x115)))
3501 var x118 uint64
3502 var x119 uint64
3503 x118, x119 = bits.Add64(x68, x100, uint64(p521Uint1(x117)))
3504 var x120 uint64
3505 var x121 uint64
3506 x120, x121 = bits.Add64((uint64(p521Uint1(x69)) + (uint64(p521Uint1(x53)) + (uint64(p521Uint1(x35)) + x3))), x102, uint64(p521Uint1(x119)))
3507 var x122 uint64
3508 var x123 uint64
3509 x122, x123 = bits.Add64(x106, arg1[2], uint64(0x0))
3510 var x124 uint64
3511 var x125 uint64
3512 x124, x125 = bits.Add64(x108, uint64(0x0), uint64(p521Uint1(x123)))
3513 var x126 uint64
3514 var x127 uint64
3515 x126, x127 = bits.Add64(x110, uint64(0x0), uint64(p521Uint1(x125)))
3516 var x128 uint64
3517 var x129 uint64
3518 x128, x129 = bits.Add64(x112, uint64(0x0), uint64(p521Uint1(x127)))
3519 var x130 uint64
3520 var x131 uint64
3521 x130, x131 = bits.Add64(x114, uint64(0x0), uint64(p521Uint1(x129)))
3522 var x132 uint64
3523 var x133 uint64
3524 x132, x133 = bits.Add64(x116, uint64(0x0), uint64(p521Uint1(x131)))
3525 var x134 uint64
3526 var x135 uint64
3527 x134, x135 = bits.Add64(x118, uint64(0x0), uint64(p521Uint1(x133)))
3528 var x136 uint64
3529 var x137 uint64
3530 x136, x137 = bits.Add64(x120, uint64(0x0), uint64(p521Uint1(x135)))
3531 var x138 uint64
3532 var x139 uint64
3533 x139, x138 = bits.Mul64(x122, 0x1ff)
3534 var x140 uint64
3535 var x141 uint64
3536 x141, x140 = bits.Mul64(x122, 0xffffffffffffffff)
3537 var x142 uint64
3538 var x143 uint64
3539 x143, x142 = bits.Mul64(x122, 0xffffffffffffffff)
3540 var x144 uint64
3541 var x145 uint64
3542 x145, x144 = bits.Mul64(x122, 0xffffffffffffffff)
3543 var x146 uint64
3544 var x147 uint64
3545 x147, x146 = bits.Mul64(x122, 0xffffffffffffffff)
3546 var x148 uint64
3547 var x149 uint64
3548 x149, x148 = bits.Mul64(x122, 0xffffffffffffffff)
3549 var x150 uint64
3550 var x151 uint64
3551 x151, x150 = bits.Mul64(x122, 0xffffffffffffffff)
3552 var x152 uint64
3553 var x153 uint64
3554 x153, x152 = bits.Mul64(x122, 0xffffffffffffffff)
3555 var x154 uint64
3556 var x155 uint64
3557 x155, x154 = bits.Mul64(x122, 0xffffffffffffffff)
3558 var x156 uint64
3559 var x157 uint64
3560 x156, x157 = bits.Add64(x155, x152, uint64(0x0))
3561 var x158 uint64
3562 var x159 uint64
3563 x158, x159 = bits.Add64(x153, x150, uint64(p521Uint1(x157)))
3564 var x160 uint64
3565 var x161 uint64
3566 x160, x161 = bits.Add64(x151, x148, uint64(p521Uint1(x159)))
3567 var x162 uint64
3568 var x163 uint64
3569 x162, x163 = bits.Add64(x149, x146, uint64(p521Uint1(x161)))
3570 var x164 uint64
3571 var x165 uint64
3572 x164, x165 = bits.Add64(x147, x144, uint64(p521Uint1(x163)))
3573 var x166 uint64
3574 var x167 uint64
3575 x166, x167 = bits.Add64(x145, x142, uint64(p521Uint1(x165)))
3576 var x168 uint64
3577 var x169 uint64
3578 x168, x169 = bits.Add64(x143, x140, uint64(p521Uint1(x167)))
3579 var x170 uint64
3580 var x171 uint64
3581 x170, x171 = bits.Add64(x141, x138, uint64(p521Uint1(x169)))
3582 var x173 uint64
3583 _, x173 = bits.Add64(x122, x154, uint64(0x0))
3584 var x174 uint64
3585 var x175 uint64
3586 x174, x175 = bits.Add64(x124, x156, uint64(p521Uint1(x173)))
3587 var x176 uint64
3588 var x177 uint64
3589 x176, x177 = bits.Add64(x126, x158, uint64(p521Uint1(x175)))
3590 var x178 uint64
3591 var x179 uint64
3592 x178, x179 = bits.Add64(x128, x160, uint64(p521Uint1(x177)))
3593 var x180 uint64
3594 var x181 uint64
3595 x180, x181 = bits.Add64(x130, x162, uint64(p521Uint1(x179)))
3596 var x182 uint64
3597 var x183 uint64
3598 x182, x183 = bits.Add64(x132, x164, uint64(p521Uint1(x181)))
3599 var x184 uint64
3600 var x185 uint64
3601 x184, x185 = bits.Add64(x134, x166, uint64(p521Uint1(x183)))
3602 var x186 uint64
3603 var x187 uint64
3604 x186, x187 = bits.Add64(x136, x168, uint64(p521Uint1(x185)))
3605 var x188 uint64
3606 var x189 uint64
3607 x188, x189 = bits.Add64((uint64(p521Uint1(x137)) + (uint64(p521Uint1(x121)) + (uint64(p521Uint1(x103)) + x71))), x170, uint64(p521Uint1(x187)))
3608 var x190 uint64
3609 var x191 uint64
3610 x190, x191 = bits.Add64(x174, arg1[3], uint64(0x0))
3611 var x192 uint64
3612 var x193 uint64
3613 x192, x193 = bits.Add64(x176, uint64(0x0), uint64(p521Uint1(x191)))
3614 var x194 uint64
3615 var x195 uint64
3616 x194, x195 = bits.Add64(x178, uint64(0x0), uint64(p521Uint1(x193)))
3617 var x196 uint64
3618 var x197 uint64
3619 x196, x197 = bits.Add64(x180, uint64(0x0), uint64(p521Uint1(x195)))
3620 var x198 uint64
3621 var x199 uint64
3622 x198, x199 = bits.Add64(x182, uint64(0x0), uint64(p521Uint1(x197)))
3623 var x200 uint64
3624 var x201 uint64
3625 x200, x201 = bits.Add64(x184, uint64(0x0), uint64(p521Uint1(x199)))
3626 var x202 uint64
3627 var x203 uint64
3628 x202, x203 = bits.Add64(x186, uint64(0x0), uint64(p521Uint1(x201)))
3629 var x204 uint64
3630 var x205 uint64
3631 x204, x205 = bits.Add64(x188, uint64(0x0), uint64(p521Uint1(x203)))
3632 var x206 uint64
3633 var x207 uint64
3634 x207, x206 = bits.Mul64(x190, 0x1ff)
3635 var x208 uint64
3636 var x209 uint64
3637 x209, x208 = bits.Mul64(x190, 0xffffffffffffffff)
3638 var x210 uint64
3639 var x211 uint64
3640 x211, x210 = bits.Mul64(x190, 0xffffffffffffffff)
3641 var x212 uint64
3642 var x213 uint64
3643 x213, x212 = bits.Mul64(x190, 0xffffffffffffffff)
3644 var x214 uint64
3645 var x215 uint64
3646 x215, x214 = bits.Mul64(x190, 0xffffffffffffffff)
3647 var x216 uint64
3648 var x217 uint64
3649 x217, x216 = bits.Mul64(x190, 0xffffffffffffffff)
3650 var x218 uint64
3651 var x219 uint64
3652 x219, x218 = bits.Mul64(x190, 0xffffffffffffffff)
3653 var x220 uint64
3654 var x221 uint64
3655 x221, x220 = bits.Mul64(x190, 0xffffffffffffffff)
3656 var x222 uint64
3657 var x223 uint64
3658 x223, x222 = bits.Mul64(x190, 0xffffffffffffffff)
3659 var x224 uint64
3660 var x225 uint64
3661 x224, x225 = bits.Add64(x223, x220, uint64(0x0))
3662 var x226 uint64
3663 var x227 uint64
3664 x226, x227 = bits.Add64(x221, x218, uint64(p521Uint1(x225)))
3665 var x228 uint64
3666 var x229 uint64
3667 x228, x229 = bits.Add64(x219, x216, uint64(p521Uint1(x227)))
3668 var x230 uint64
3669 var x231 uint64
3670 x230, x231 = bits.Add64(x217, x214, uint64(p521Uint1(x229)))
3671 var x232 uint64
3672 var x233 uint64
3673 x232, x233 = bits.Add64(x215, x212, uint64(p521Uint1(x231)))
3674 var x234 uint64
3675 var x235 uint64
3676 x234, x235 = bits.Add64(x213, x210, uint64(p521Uint1(x233)))
3677 var x236 uint64
3678 var x237 uint64
3679 x236, x237 = bits.Add64(x211, x208, uint64(p521Uint1(x235)))
3680 var x238 uint64
3681 var x239 uint64
3682 x238, x239 = bits.Add64(x209, x206, uint64(p521Uint1(x237)))
3683 var x241 uint64
3684 _, x241 = bits.Add64(x190, x222, uint64(0x0))
3685 var x242 uint64
3686 var x243 uint64
3687 x242, x243 = bits.Add64(x192, x224, uint64(p521Uint1(x241)))
3688 var x244 uint64
3689 var x245 uint64
3690 x244, x245 = bits.Add64(x194, x226, uint64(p521Uint1(x243)))
3691 var x246 uint64
3692 var x247 uint64
3693 x246, x247 = bits.Add64(x196, x228, uint64(p521Uint1(x245)))
3694 var x248 uint64
3695 var x249 uint64
3696 x248, x249 = bits.Add64(x198, x230, uint64(p521Uint1(x247)))
3697 var x250 uint64
3698 var x251 uint64
3699 x250, x251 = bits.Add64(x200, x232, uint64(p521Uint1(x249)))
3700 var x252 uint64
3701 var x253 uint64
3702 x252, x253 = bits.Add64(x202, x234, uint64(p521Uint1(x251)))
3703 var x254 uint64
3704 var x255 uint64
3705 x254, x255 = bits.Add64(x204, x236, uint64(p521Uint1(x253)))
3706 var x256 uint64
3707 var x257 uint64
3708 x256, x257 = bits.Add64((uint64(p521Uint1(x205)) + (uint64(p521Uint1(x189)) + (uint64(p521Uint1(x171)) + x139))), x238, uint64(p521Uint1(x255)))
3709 var x258 uint64
3710 var x259 uint64
3711 x258, x259 = bits.Add64(x242, arg1[4], uint64(0x0))
3712 var x260 uint64
3713 var x261 uint64
3714 x260, x261 = bits.Add64(x244, uint64(0x0), uint64(p521Uint1(x259)))
3715 var x262 uint64
3716 var x263 uint64
3717 x262, x263 = bits.Add64(x246, uint64(0x0), uint64(p521Uint1(x261)))
3718 var x264 uint64
3719 var x265 uint64
3720 x264, x265 = bits.Add64(x248, uint64(0x0), uint64(p521Uint1(x263)))
3721 var x266 uint64
3722 var x267 uint64
3723 x266, x267 = bits.Add64(x250, uint64(0x0), uint64(p521Uint1(x265)))
3724 var x268 uint64
3725 var x269 uint64
3726 x268, x269 = bits.Add64(x252, uint64(0x0), uint64(p521Uint1(x267)))
3727 var x270 uint64
3728 var x271 uint64
3729 x270, x271 = bits.Add64(x254, uint64(0x0), uint64(p521Uint1(x269)))
3730 var x272 uint64
3731 var x273 uint64
3732 x272, x273 = bits.Add64(x256, uint64(0x0), uint64(p521Uint1(x271)))
3733 var x274 uint64
3734 var x275 uint64
3735 x275, x274 = bits.Mul64(x258, 0x1ff)
3736 var x276 uint64
3737 var x277 uint64
3738 x277, x276 = bits.Mul64(x258, 0xffffffffffffffff)
3739 var x278 uint64
3740 var x279 uint64
3741 x279, x278 = bits.Mul64(x258, 0xffffffffffffffff)
3742 var x280 uint64
3743 var x281 uint64
3744 x281, x280 = bits.Mul64(x258, 0xffffffffffffffff)
3745 var x282 uint64
3746 var x283 uint64
3747 x283, x282 = bits.Mul64(x258, 0xffffffffffffffff)
3748 var x284 uint64
3749 var x285 uint64
3750 x285, x284 = bits.Mul64(x258, 0xffffffffffffffff)
3751 var x286 uint64
3752 var x287 uint64
3753 x287, x286 = bits.Mul64(x258, 0xffffffffffffffff)
3754 var x288 uint64
3755 var x289 uint64
3756 x289, x288 = bits.Mul64(x258, 0xffffffffffffffff)
3757 var x290 uint64
3758 var x291 uint64
3759 x291, x290 = bits.Mul64(x258, 0xffffffffffffffff)
3760 var x292 uint64
3761 var x293 uint64
3762 x292, x293 = bits.Add64(x291, x288, uint64(0x0))
3763 var x294 uint64
3764 var x295 uint64
3765 x294, x295 = bits.Add64(x289, x286, uint64(p521Uint1(x293)))
3766 var x296 uint64
3767 var x297 uint64
3768 x296, x297 = bits.Add64(x287, x284, uint64(p521Uint1(x295)))
3769 var x298 uint64
3770 var x299 uint64
3771 x298, x299 = bits.Add64(x285, x282, uint64(p521Uint1(x297)))
3772 var x300 uint64
3773 var x301 uint64
3774 x300, x301 = bits.Add64(x283, x280, uint64(p521Uint1(x299)))
3775 var x302 uint64
3776 var x303 uint64
3777 x302, x303 = bits.Add64(x281, x278, uint64(p521Uint1(x301)))
3778 var x304 uint64
3779 var x305 uint64
3780 x304, x305 = bits.Add64(x279, x276, uint64(p521Uint1(x303)))
3781 var x306 uint64
3782 var x307 uint64
3783 x306, x307 = bits.Add64(x277, x274, uint64(p521Uint1(x305)))
3784 var x309 uint64
3785 _, x309 = bits.Add64(x258, x290, uint64(0x0))
3786 var x310 uint64
3787 var x311 uint64
3788 x310, x311 = bits.Add64(x260, x292, uint64(p521Uint1(x309)))
3789 var x312 uint64
3790 var x313 uint64
3791 x312, x313 = bits.Add64(x262, x294, uint64(p521Uint1(x311)))
3792 var x314 uint64
3793 var x315 uint64
3794 x314, x315 = bits.Add64(x264, x296, uint64(p521Uint1(x313)))
3795 var x316 uint64
3796 var x317 uint64
3797 x316, x317 = bits.Add64(x266, x298, uint64(p521Uint1(x315)))
3798 var x318 uint64
3799 var x319 uint64
3800 x318, x319 = bits.Add64(x268, x300, uint64(p521Uint1(x317)))
3801 var x320 uint64
3802 var x321 uint64
3803 x320, x321 = bits.Add64(x270, x302, uint64(p521Uint1(x319)))
3804 var x322 uint64
3805 var x323 uint64
3806 x322, x323 = bits.Add64(x272, x304, uint64(p521Uint1(x321)))
3807 var x324 uint64
3808 var x325 uint64
3809 x324, x325 = bits.Add64((uint64(p521Uint1(x273)) + (uint64(p521Uint1(x257)) + (uint64(p521Uint1(x239)) + x207))), x306, uint64(p521Uint1(x323)))
3810 var x326 uint64
3811 var x327 uint64
3812 x326, x327 = bits.Add64(x310, arg1[5], uint64(0x0))
3813 var x328 uint64
3814 var x329 uint64
3815 x328, x329 = bits.Add64(x312, uint64(0x0), uint64(p521Uint1(x327)))
3816 var x330 uint64
3817 var x331 uint64
3818 x330, x331 = bits.Add64(x314, uint64(0x0), uint64(p521Uint1(x329)))
3819 var x332 uint64
3820 var x333 uint64
3821 x332, x333 = bits.Add64(x316, uint64(0x0), uint64(p521Uint1(x331)))
3822 var x334 uint64
3823 var x335 uint64
3824 x334, x335 = bits.Add64(x318, uint64(0x0), uint64(p521Uint1(x333)))
3825 var x336 uint64
3826 var x337 uint64
3827 x336, x337 = bits.Add64(x320, uint64(0x0), uint64(p521Uint1(x335)))
3828 var x338 uint64
3829 var x339 uint64
3830 x338, x339 = bits.Add64(x322, uint64(0x0), uint64(p521Uint1(x337)))
3831 var x340 uint64
3832 var x341 uint64
3833 x340, x341 = bits.Add64(x324, uint64(0x0), uint64(p521Uint1(x339)))
3834 var x342 uint64
3835 var x343 uint64
3836 x343, x342 = bits.Mul64(x326, 0x1ff)
3837 var x344 uint64
3838 var x345 uint64
3839 x345, x344 = bits.Mul64(x326, 0xffffffffffffffff)
3840 var x346 uint64
3841 var x347 uint64
3842 x347, x346 = bits.Mul64(x326, 0xffffffffffffffff)
3843 var x348 uint64
3844 var x349 uint64
3845 x349, x348 = bits.Mul64(x326, 0xffffffffffffffff)
3846 var x350 uint64
3847 var x351 uint64
3848 x351, x350 = bits.Mul64(x326, 0xffffffffffffffff)
3849 var x352 uint64
3850 var x353 uint64
3851 x353, x352 = bits.Mul64(x326, 0xffffffffffffffff)
3852 var x354 uint64
3853 var x355 uint64
3854 x355, x354 = bits.Mul64(x326, 0xffffffffffffffff)
3855 var x356 uint64
3856 var x357 uint64
3857 x357, x356 = bits.Mul64(x326, 0xffffffffffffffff)
3858 var x358 uint64
3859 var x359 uint64
3860 x359, x358 = bits.Mul64(x326, 0xffffffffffffffff)
3861 var x360 uint64
3862 var x361 uint64
3863 x360, x361 = bits.Add64(x359, x356, uint64(0x0))
3864 var x362 uint64
3865 var x363 uint64
3866 x362, x363 = bits.Add64(x357, x354, uint64(p521Uint1(x361)))
3867 var x364 uint64
3868 var x365 uint64
3869 x364, x365 = bits.Add64(x355, x352, uint64(p521Uint1(x363)))
3870 var x366 uint64
3871 var x367 uint64
3872 x366, x367 = bits.Add64(x353, x350, uint64(p521Uint1(x365)))
3873 var x368 uint64
3874 var x369 uint64
3875 x368, x369 = bits.Add64(x351, x348, uint64(p521Uint1(x367)))
3876 var x370 uint64
3877 var x371 uint64
3878 x370, x371 = bits.Add64(x349, x346, uint64(p521Uint1(x369)))
3879 var x372 uint64
3880 var x373 uint64
3881 x372, x373 = bits.Add64(x347, x344, uint64(p521Uint1(x371)))
3882 var x374 uint64
3883 var x375 uint64
3884 x374, x375 = bits.Add64(x345, x342, uint64(p521Uint1(x373)))
3885 var x377 uint64
3886 _, x377 = bits.Add64(x326, x358, uint64(0x0))
3887 var x378 uint64
3888 var x379 uint64
3889 x378, x379 = bits.Add64(x328, x360, uint64(p521Uint1(x377)))
3890 var x380 uint64
3891 var x381 uint64
3892 x380, x381 = bits.Add64(x330, x362, uint64(p521Uint1(x379)))
3893 var x382 uint64
3894 var x383 uint64
3895 x382, x383 = bits.Add64(x332, x364, uint64(p521Uint1(x381)))
3896 var x384 uint64
3897 var x385 uint64
3898 x384, x385 = bits.Add64(x334, x366, uint64(p521Uint1(x383)))
3899 var x386 uint64
3900 var x387 uint64
3901 x386, x387 = bits.Add64(x336, x368, uint64(p521Uint1(x385)))
3902 var x388 uint64
3903 var x389 uint64
3904 x388, x389 = bits.Add64(x338, x370, uint64(p521Uint1(x387)))
3905 var x390 uint64
3906 var x391 uint64
3907 x390, x391 = bits.Add64(x340, x372, uint64(p521Uint1(x389)))
3908 var x392 uint64
3909 var x393 uint64
3910 x392, x393 = bits.Add64((uint64(p521Uint1(x341)) + (uint64(p521Uint1(x325)) + (uint64(p521Uint1(x307)) + x275))), x374, uint64(p521Uint1(x391)))
3911 var x394 uint64
3912 var x395 uint64
3913 x394, x395 = bits.Add64(x378, arg1[6], uint64(0x0))
3914 var x396 uint64
3915 var x397 uint64
3916 x396, x397 = bits.Add64(x380, uint64(0x0), uint64(p521Uint1(x395)))
3917 var x398 uint64
3918 var x399 uint64
3919 x398, x399 = bits.Add64(x382, uint64(0x0), uint64(p521Uint1(x397)))
3920 var x400 uint64
3921 var x401 uint64
3922 x400, x401 = bits.Add64(x384, uint64(0x0), uint64(p521Uint1(x399)))
3923 var x402 uint64
3924 var x403 uint64
3925 x402, x403 = bits.Add64(x386, uint64(0x0), uint64(p521Uint1(x401)))
3926 var x404 uint64
3927 var x405 uint64
3928 x404, x405 = bits.Add64(x388, uint64(0x0), uint64(p521Uint1(x403)))
3929 var x406 uint64
3930 var x407 uint64
3931 x406, x407 = bits.Add64(x390, uint64(0x0), uint64(p521Uint1(x405)))
3932 var x408 uint64
3933 var x409 uint64
3934 x408, x409 = bits.Add64(x392, uint64(0x0), uint64(p521Uint1(x407)))
3935 var x410 uint64
3936 var x411 uint64
3937 x411, x410 = bits.Mul64(x394, 0x1ff)
3938 var x412 uint64
3939 var x413 uint64
3940 x413, x412 = bits.Mul64(x394, 0xffffffffffffffff)
3941 var x414 uint64
3942 var x415 uint64
3943 x415, x414 = bits.Mul64(x394, 0xffffffffffffffff)
3944 var x416 uint64
3945 var x417 uint64
3946 x417, x416 = bits.Mul64(x394, 0xffffffffffffffff)
3947 var x418 uint64
3948 var x419 uint64
3949 x419, x418 = bits.Mul64(x394, 0xffffffffffffffff)
3950 var x420 uint64
3951 var x421 uint64
3952 x421, x420 = bits.Mul64(x394, 0xffffffffffffffff)
3953 var x422 uint64
3954 var x423 uint64
3955 x423, x422 = bits.Mul64(x394, 0xffffffffffffffff)
3956 var x424 uint64
3957 var x425 uint64
3958 x425, x424 = bits.Mul64(x394, 0xffffffffffffffff)
3959 var x426 uint64
3960 var x427 uint64
3961 x427, x426 = bits.Mul64(x394, 0xffffffffffffffff)
3962 var x428 uint64
3963 var x429 uint64
3964 x428, x429 = bits.Add64(x427, x424, uint64(0x0))
3965 var x430 uint64
3966 var x431 uint64
3967 x430, x431 = bits.Add64(x425, x422, uint64(p521Uint1(x429)))
3968 var x432 uint64
3969 var x433 uint64
3970 x432, x433 = bits.Add64(x423, x420, uint64(p521Uint1(x431)))
3971 var x434 uint64
3972 var x435 uint64
3973 x434, x435 = bits.Add64(x421, x418, uint64(p521Uint1(x433)))
3974 var x436 uint64
3975 var x437 uint64
3976 x436, x437 = bits.Add64(x419, x416, uint64(p521Uint1(x435)))
3977 var x438 uint64
3978 var x439 uint64
3979 x438, x439 = bits.Add64(x417, x414, uint64(p521Uint1(x437)))
3980 var x440 uint64
3981 var x441 uint64
3982 x440, x441 = bits.Add64(x415, x412, uint64(p521Uint1(x439)))
3983 var x442 uint64
3984 var x443 uint64
3985 x442, x443 = bits.Add64(x413, x410, uint64(p521Uint1(x441)))
3986 var x445 uint64
3987 _, x445 = bits.Add64(x394, x426, uint64(0x0))
3988 var x446 uint64
3989 var x447 uint64
3990 x446, x447 = bits.Add64(x396, x428, uint64(p521Uint1(x445)))
3991 var x448 uint64
3992 var x449 uint64
3993 x448, x449 = bits.Add64(x398, x430, uint64(p521Uint1(x447)))
3994 var x450 uint64
3995 var x451 uint64
3996 x450, x451 = bits.Add64(x400, x432, uint64(p521Uint1(x449)))
3997 var x452 uint64
3998 var x453 uint64
3999 x452, x453 = bits.Add64(x402, x434, uint64(p521Uint1(x451)))
4000 var x454 uint64
4001 var x455 uint64
4002 x454, x455 = bits.Add64(x404, x436, uint64(p521Uint1(x453)))
4003 var x456 uint64
4004 var x457 uint64
4005 x456, x457 = bits.Add64(x406, x438, uint64(p521Uint1(x455)))
4006 var x458 uint64
4007 var x459 uint64
4008 x458, x459 = bits.Add64(x408, x440, uint64(p521Uint1(x457)))
4009 var x460 uint64
4010 var x461 uint64
4011 x460, x461 = bits.Add64((uint64(p521Uint1(x409)) + (uint64(p521Uint1(x393)) + (uint64(p521Uint1(x375)) + x343))), x442, uint64(p521Uint1(x459)))
4012 var x462 uint64
4013 var x463 uint64
4014 x462, x463 = bits.Add64(x446, arg1[7], uint64(0x0))
4015 var x464 uint64
4016 var x465 uint64
4017 x464, x465 = bits.Add64(x448, uint64(0x0), uint64(p521Uint1(x463)))
4018 var x466 uint64
4019 var x467 uint64
4020 x466, x467 = bits.Add64(x450, uint64(0x0), uint64(p521Uint1(x465)))
4021 var x468 uint64
4022 var x469 uint64
4023 x468, x469 = bits.Add64(x452, uint64(0x0), uint64(p521Uint1(x467)))
4024 var x470 uint64
4025 var x471 uint64
4026 x470, x471 = bits.Add64(x454, uint64(0x0), uint64(p521Uint1(x469)))
4027 var x472 uint64
4028 var x473 uint64
4029 x472, x473 = bits.Add64(x456, uint64(0x0), uint64(p521Uint1(x471)))
4030 var x474 uint64
4031 var x475 uint64
4032 x474, x475 = bits.Add64(x458, uint64(0x0), uint64(p521Uint1(x473)))
4033 var x476 uint64
4034 var x477 uint64
4035 x476, x477 = bits.Add64(x460, uint64(0x0), uint64(p521Uint1(x475)))
4036 var x478 uint64
4037 var x479 uint64
4038 x479, x478 = bits.Mul64(x462, 0x1ff)
4039 var x480 uint64
4040 var x481 uint64
4041 x481, x480 = bits.Mul64(x462, 0xffffffffffffffff)
4042 var x482 uint64
4043 var x483 uint64
4044 x483, x482 = bits.Mul64(x462, 0xffffffffffffffff)
4045 var x484 uint64
4046 var x485 uint64
4047 x485, x484 = bits.Mul64(x462, 0xffffffffffffffff)
4048 var x486 uint64
4049 var x487 uint64
4050 x487, x486 = bits.Mul64(x462, 0xffffffffffffffff)
4051 var x488 uint64
4052 var x489 uint64
4053 x489, x488 = bits.Mul64(x462, 0xffffffffffffffff)
4054 var x490 uint64
4055 var x491 uint64
4056 x491, x490 = bits.Mul64(x462, 0xffffffffffffffff)
4057 var x492 uint64
4058 var x493 uint64
4059 x493, x492 = bits.Mul64(x462, 0xffffffffffffffff)
4060 var x494 uint64
4061 var x495 uint64
4062 x495, x494 = bits.Mul64(x462, 0xffffffffffffffff)
4063 var x496 uint64
4064 var x497 uint64
4065 x496, x497 = bits.Add64(x495, x492, uint64(0x0))
4066 var x498 uint64
4067 var x499 uint64
4068 x498, x499 = bits.Add64(x493, x490, uint64(p521Uint1(x497)))
4069 var x500 uint64
4070 var x501 uint64
4071 x500, x501 = bits.Add64(x491, x488, uint64(p521Uint1(x499)))
4072 var x502 uint64
4073 var x503 uint64
4074 x502, x503 = bits.Add64(x489, x486, uint64(p521Uint1(x501)))
4075 var x504 uint64
4076 var x505 uint64
4077 x504, x505 = bits.Add64(x487, x484, uint64(p521Uint1(x503)))
4078 var x506 uint64
4079 var x507 uint64
4080 x506, x507 = bits.Add64(x485, x482, uint64(p521Uint1(x505)))
4081 var x508 uint64
4082 var x509 uint64
4083 x508, x509 = bits.Add64(x483, x480, uint64(p521Uint1(x507)))
4084 var x510 uint64
4085 var x511 uint64
4086 x510, x511 = bits.Add64(x481, x478, uint64(p521Uint1(x509)))
4087 var x513 uint64
4088 _, x513 = bits.Add64(x462, x494, uint64(0x0))
4089 var x514 uint64
4090 var x515 uint64
4091 x514, x515 = bits.Add64(x464, x496, uint64(p521Uint1(x513)))
4092 var x516 uint64
4093 var x517 uint64
4094 x516, x517 = bits.Add64(x466, x498, uint64(p521Uint1(x515)))
4095 var x518 uint64
4096 var x519 uint64
4097 x518, x519 = bits.Add64(x468, x500, uint64(p521Uint1(x517)))
4098 var x520 uint64
4099 var x521 uint64
4100 x520, x521 = bits.Add64(x470, x502, uint64(p521Uint1(x519)))
4101 var x522 uint64
4102 var x523 uint64
4103 x522, x523 = bits.Add64(x472, x504, uint64(p521Uint1(x521)))
4104 var x524 uint64
4105 var x525 uint64
4106 x524, x525 = bits.Add64(x474, x506, uint64(p521Uint1(x523)))
4107 var x526 uint64
4108 var x527 uint64
4109 x526, x527 = bits.Add64(x476, x508, uint64(p521Uint1(x525)))
4110 var x528 uint64
4111 var x529 uint64
4112 x528, x529 = bits.Add64((uint64(p521Uint1(x477)) + (uint64(p521Uint1(x461)) + (uint64(p521Uint1(x443)) + x411))), x510, uint64(p521Uint1(x527)))
4113 var x530 uint64
4114 var x531 uint64
4115 x530, x531 = bits.Add64(x514, arg1[8], uint64(0x0))
4116 var x532 uint64
4117 var x533 uint64
4118 x532, x533 = bits.Add64(x516, uint64(0x0), uint64(p521Uint1(x531)))
4119 var x534 uint64
4120 var x535 uint64
4121 x534, x535 = bits.Add64(x518, uint64(0x0), uint64(p521Uint1(x533)))
4122 var x536 uint64
4123 var x537 uint64
4124 x536, x537 = bits.Add64(x520, uint64(0x0), uint64(p521Uint1(x535)))
4125 var x538 uint64
4126 var x539 uint64
4127 x538, x539 = bits.Add64(x522, uint64(0x0), uint64(p521Uint1(x537)))
4128 var x540 uint64
4129 var x541 uint64
4130 x540, x541 = bits.Add64(x524, uint64(0x0), uint64(p521Uint1(x539)))
4131 var x542 uint64
4132 var x543 uint64
4133 x542, x543 = bits.Add64(x526, uint64(0x0), uint64(p521Uint1(x541)))
4134 var x544 uint64
4135 var x545 uint64
4136 x544, x545 = bits.Add64(x528, uint64(0x0), uint64(p521Uint1(x543)))
4137 var x546 uint64
4138 var x547 uint64
4139 x547, x546 = bits.Mul64(x530, 0x1ff)
4140 var x548 uint64
4141 var x549 uint64
4142 x549, x548 = bits.Mul64(x530, 0xffffffffffffffff)
4143 var x550 uint64
4144 var x551 uint64
4145 x551, x550 = bits.Mul64(x530, 0xffffffffffffffff)
4146 var x552 uint64
4147 var x553 uint64
4148 x553, x552 = bits.Mul64(x530, 0xffffffffffffffff)
4149 var x554 uint64
4150 var x555 uint64
4151 x555, x554 = bits.Mul64(x530, 0xffffffffffffffff)
4152 var x556 uint64
4153 var x557 uint64
4154 x557, x556 = bits.Mul64(x530, 0xffffffffffffffff)
4155 var x558 uint64
4156 var x559 uint64
4157 x559, x558 = bits.Mul64(x530, 0xffffffffffffffff)
4158 var x560 uint64
4159 var x561 uint64
4160 x561, x560 = bits.Mul64(x530, 0xffffffffffffffff)
4161 var x562 uint64
4162 var x563 uint64
4163 x563, x562 = bits.Mul64(x530, 0xffffffffffffffff)
4164 var x564 uint64
4165 var x565 uint64
4166 x564, x565 = bits.Add64(x563, x560, uint64(0x0))
4167 var x566 uint64
4168 var x567 uint64
4169 x566, x567 = bits.Add64(x561, x558, uint64(p521Uint1(x565)))
4170 var x568 uint64
4171 var x569 uint64
4172 x568, x569 = bits.Add64(x559, x556, uint64(p521Uint1(x567)))
4173 var x570 uint64
4174 var x571 uint64
4175 x570, x571 = bits.Add64(x557, x554, uint64(p521Uint1(x569)))
4176 var x572 uint64
4177 var x573 uint64
4178 x572, x573 = bits.Add64(x555, x552, uint64(p521Uint1(x571)))
4179 var x574 uint64
4180 var x575 uint64
4181 x574, x575 = bits.Add64(x553, x550, uint64(p521Uint1(x573)))
4182 var x576 uint64
4183 var x577 uint64
4184 x576, x577 = bits.Add64(x551, x548, uint64(p521Uint1(x575)))
4185 var x578 uint64
4186 var x579 uint64
4187 x578, x579 = bits.Add64(x549, x546, uint64(p521Uint1(x577)))
4188 var x581 uint64
4189 _, x581 = bits.Add64(x530, x562, uint64(0x0))
4190 var x582 uint64
4191 var x583 uint64
4192 x582, x583 = bits.Add64(x532, x564, uint64(p521Uint1(x581)))
4193 var x584 uint64
4194 var x585 uint64
4195 x584, x585 = bits.Add64(x534, x566, uint64(p521Uint1(x583)))
4196 var x586 uint64
4197 var x587 uint64
4198 x586, x587 = bits.Add64(x536, x568, uint64(p521Uint1(x585)))
4199 var x588 uint64
4200 var x589 uint64
4201 x588, x589 = bits.Add64(x538, x570, uint64(p521Uint1(x587)))
4202 var x590 uint64
4203 var x591 uint64
4204 x590, x591 = bits.Add64(x540, x572, uint64(p521Uint1(x589)))
4205 var x592 uint64
4206 var x593 uint64
4207 x592, x593 = bits.Add64(x542, x574, uint64(p521Uint1(x591)))
4208 var x594 uint64
4209 var x595 uint64
4210 x594, x595 = bits.Add64(x544, x576, uint64(p521Uint1(x593)))
4211 var x596 uint64
4212 var x597 uint64
4213 x596, x597 = bits.Add64((uint64(p521Uint1(x545)) + (uint64(p521Uint1(x529)) + (uint64(p521Uint1(x511)) + x479))), x578, uint64(p521Uint1(x595)))
4214 x598 := (uint64(p521Uint1(x597)) + (uint64(p521Uint1(x579)) + x547))
4215 var x599 uint64
4216 var x600 uint64
4217 x599, x600 = bits.Sub64(x582, 0xffffffffffffffff, uint64(0x0))
4218 var x601 uint64
4219 var x602 uint64
4220 x601, x602 = bits.Sub64(x584, 0xffffffffffffffff, uint64(p521Uint1(x600)))
4221 var x603 uint64
4222 var x604 uint64
4223 x603, x604 = bits.Sub64(x586, 0xffffffffffffffff, uint64(p521Uint1(x602)))
4224 var x605 uint64
4225 var x606 uint64
4226 x605, x606 = bits.Sub64(x588, 0xffffffffffffffff, uint64(p521Uint1(x604)))
4227 var x607 uint64
4228 var x608 uint64
4229 x607, x608 = bits.Sub64(x590, 0xffffffffffffffff, uint64(p521Uint1(x606)))
4230 var x609 uint64
4231 var x610 uint64
4232 x609, x610 = bits.Sub64(x592, 0xffffffffffffffff, uint64(p521Uint1(x608)))
4233 var x611 uint64
4234 var x612 uint64
4235 x611, x612 = bits.Sub64(x594, 0xffffffffffffffff, uint64(p521Uint1(x610)))
4236 var x613 uint64
4237 var x614 uint64
4238 x613, x614 = bits.Sub64(x596, 0xffffffffffffffff, uint64(p521Uint1(x612)))
4239 var x615 uint64
4240 var x616 uint64
4241 x615, x616 = bits.Sub64(x598, 0x1ff, uint64(p521Uint1(x614)))
4242 var x618 uint64
4243 _, x618 = bits.Sub64(uint64(0x0), uint64(0x0), uint64(p521Uint1(x616)))
4244 var x619 uint64
4245 p521CmovznzU64(&x619, p521Uint1(x618), x599, x582)
4246 var x620 uint64
4247 p521CmovznzU64(&x620, p521Uint1(x618), x601, x584)
4248 var x621 uint64
4249 p521CmovznzU64(&x621, p521Uint1(x618), x603, x586)
4250 var x622 uint64
4251 p521CmovznzU64(&x622, p521Uint1(x618), x605, x588)
4252 var x623 uint64
4253 p521CmovznzU64(&x623, p521Uint1(x618), x607, x590)
4254 var x624 uint64
4255 p521CmovznzU64(&x624, p521Uint1(x618), x609, x592)
4256 var x625 uint64
4257 p521CmovznzU64(&x625, p521Uint1(x618), x611, x594)
4258 var x626 uint64
4259 p521CmovznzU64(&x626, p521Uint1(x618), x613, x596)
4260 var x627 uint64
4261 p521CmovznzU64(&x627, p521Uint1(x618), x615, x598)
4262 out1[0] = x619
4263 out1[1] = x620
4264 out1[2] = x621
4265 out1[3] = x622
4266 out1[4] = x623
4267 out1[5] = x624
4268 out1[6] = x625
4269 out1[7] = x626
4270 out1[8] = x627
4271 }
4272
4273 // p521ToMontgomery translates a field element into the Montgomery domain.
4274 //
4275 // Preconditions:
4276 //
4277 // 0 ≤ eval arg1 < m
4278 //
4279 // Postconditions:
4280 //
4281 // eval (from_montgomery out1) mod m = eval arg1 mod m
4282 // 0 ≤ eval out1 < m
4283 func p521ToMontgomery(out1 *p521MontgomeryDomainFieldElement, arg1 *p521NonMontgomeryDomainFieldElement) {
4284 var x1 uint64
4285 var x2 uint64
4286 x2, x1 = bits.Mul64(arg1[0], 0x400000000000)
4287 var x3 uint64
4288 var x4 uint64
4289 x4, x3 = bits.Mul64(arg1[1], 0x400000000000)
4290 var x5 uint64
4291 var x6 uint64
4292 x5, x6 = bits.Add64(x2, x3, uint64(0x0))
4293 var x7 uint64
4294 var x8 uint64
4295 x8, x7 = bits.Mul64(x1, 0x1ff)
4296 var x9 uint64
4297 var x10 uint64
4298 x10, x9 = bits.Mul64(x1, 0xffffffffffffffff)
4299 var x11 uint64
4300 var x12 uint64
4301 x12, x11 = bits.Mul64(x1, 0xffffffffffffffff)
4302 var x13 uint64
4303 var x14 uint64
4304 x14, x13 = bits.Mul64(x1, 0xffffffffffffffff)
4305 var x15 uint64
4306 var x16 uint64
4307 x16, x15 = bits.Mul64(x1, 0xffffffffffffffff)
4308 var x17 uint64
4309 var x18 uint64
4310 x18, x17 = bits.Mul64(x1, 0xffffffffffffffff)
4311 var x19 uint64
4312 var x20 uint64
4313 x20, x19 = bits.Mul64(x1, 0xffffffffffffffff)
4314 var x21 uint64
4315 var x22 uint64
4316 x22, x21 = bits.Mul64(x1, 0xffffffffffffffff)
4317 var x23 uint64
4318 var x24 uint64
4319 x24, x23 = bits.Mul64(x1, 0xffffffffffffffff)
4320 var x25 uint64
4321 var x26 uint64
4322 x25, x26 = bits.Add64(x24, x21, uint64(0x0))
4323 var x27 uint64
4324 var x28 uint64
4325 x27, x28 = bits.Add64(x22, x19, uint64(p521Uint1(x26)))
4326 var x29 uint64
4327 var x30 uint64
4328 x29, x30 = bits.Add64(x20, x17, uint64(p521Uint1(x28)))
4329 var x31 uint64
4330 var x32 uint64
4331 x31, x32 = bits.Add64(x18, x15, uint64(p521Uint1(x30)))
4332 var x33 uint64
4333 var x34 uint64
4334 x33, x34 = bits.Add64(x16, x13, uint64(p521Uint1(x32)))
4335 var x35 uint64
4336 var x36 uint64
4337 x35, x36 = bits.Add64(x14, x11, uint64(p521Uint1(x34)))
4338 var x37 uint64
4339 var x38 uint64
4340 x37, x38 = bits.Add64(x12, x9, uint64(p521Uint1(x36)))
4341 var x39 uint64
4342 var x40 uint64
4343 x39, x40 = bits.Add64(x10, x7, uint64(p521Uint1(x38)))
4344 var x42 uint64
4345 _, x42 = bits.Add64(x1, x23, uint64(0x0))
4346 var x43 uint64
4347 var x44 uint64
4348 x43, x44 = bits.Add64(x5, x25, uint64(p521Uint1(x42)))
4349 var x45 uint64
4350 var x46 uint64
4351 x45, x46 = bits.Add64((uint64(p521Uint1(x6)) + x4), x27, uint64(p521Uint1(x44)))
4352 var x47 uint64
4353 var x48 uint64
4354 x47, x48 = bits.Add64(uint64(0x0), x29, uint64(p521Uint1(x46)))
4355 var x49 uint64
4356 var x50 uint64
4357 x49, x50 = bits.Add64(uint64(0x0), x31, uint64(p521Uint1(x48)))
4358 var x51 uint64
4359 var x52 uint64
4360 x51, x52 = bits.Add64(uint64(0x0), x33, uint64(p521Uint1(x50)))
4361 var x53 uint64
4362 var x54 uint64
4363 x53, x54 = bits.Add64(uint64(0x0), x35, uint64(p521Uint1(x52)))
4364 var x55 uint64
4365 var x56 uint64
4366 x55, x56 = bits.Add64(uint64(0x0), x37, uint64(p521Uint1(x54)))
4367 var x57 uint64
4368 var x58 uint64
4369 x57, x58 = bits.Add64(uint64(0x0), x39, uint64(p521Uint1(x56)))
4370 var x59 uint64
4371 var x60 uint64
4372 x60, x59 = bits.Mul64(arg1[2], 0x400000000000)
4373 var x61 uint64
4374 var x62 uint64
4375 x61, x62 = bits.Add64(x45, x59, uint64(0x0))
4376 var x63 uint64
4377 var x64 uint64
4378 x63, x64 = bits.Add64(x47, x60, uint64(p521Uint1(x62)))
4379 var x65 uint64
4380 var x66 uint64
4381 x65, x66 = bits.Add64(x49, uint64(0x0), uint64(p521Uint1(x64)))
4382 var x67 uint64
4383 var x68 uint64
4384 x67, x68 = bits.Add64(x51, uint64(0x0), uint64(p521Uint1(x66)))
4385 var x69 uint64
4386 var x70 uint64
4387 x69, x70 = bits.Add64(x53, uint64(0x0), uint64(p521Uint1(x68)))
4388 var x71 uint64
4389 var x72 uint64
4390 x71, x72 = bits.Add64(x55, uint64(0x0), uint64(p521Uint1(x70)))
4391 var x73 uint64
4392 var x74 uint64
4393 x73, x74 = bits.Add64(x57, uint64(0x0), uint64(p521Uint1(x72)))
4394 var x75 uint64
4395 var x76 uint64
4396 x76, x75 = bits.Mul64(x43, 0x1ff)
4397 var x77 uint64
4398 var x78 uint64
4399 x78, x77 = bits.Mul64(x43, 0xffffffffffffffff)
4400 var x79 uint64
4401 var x80 uint64
4402 x80, x79 = bits.Mul64(x43, 0xffffffffffffffff)
4403 var x81 uint64
4404 var x82 uint64
4405 x82, x81 = bits.Mul64(x43, 0xffffffffffffffff)
4406 var x83 uint64
4407 var x84 uint64
4408 x84, x83 = bits.Mul64(x43, 0xffffffffffffffff)
4409 var x85 uint64
4410 var x86 uint64
4411 x86, x85 = bits.Mul64(x43, 0xffffffffffffffff)
4412 var x87 uint64
4413 var x88 uint64
4414 x88, x87 = bits.Mul64(x43, 0xffffffffffffffff)
4415 var x89 uint64
4416 var x90 uint64
4417 x90, x89 = bits.Mul64(x43, 0xffffffffffffffff)
4418 var x91 uint64
4419 var x92 uint64
4420 x92, x91 = bits.Mul64(x43, 0xffffffffffffffff)
4421 var x93 uint64
4422 var x94 uint64
4423 x93, x94 = bits.Add64(x92, x89, uint64(0x0))
4424 var x95 uint64
4425 var x96 uint64
4426 x95, x96 = bits.Add64(x90, x87, uint64(p521Uint1(x94)))
4427 var x97 uint64
4428 var x98 uint64
4429 x97, x98 = bits.Add64(x88, x85, uint64(p521Uint1(x96)))
4430 var x99 uint64
4431 var x100 uint64
4432 x99, x100 = bits.Add64(x86, x83, uint64(p521Uint1(x98)))
4433 var x101 uint64
4434 var x102 uint64
4435 x101, x102 = bits.Add64(x84, x81, uint64(p521Uint1(x100)))
4436 var x103 uint64
4437 var x104 uint64
4438 x103, x104 = bits.Add64(x82, x79, uint64(p521Uint1(x102)))
4439 var x105 uint64
4440 var x106 uint64
4441 x105, x106 = bits.Add64(x80, x77, uint64(p521Uint1(x104)))
4442 var x107 uint64
4443 var x108 uint64
4444 x107, x108 = bits.Add64(x78, x75, uint64(p521Uint1(x106)))
4445 var x110 uint64
4446 _, x110 = bits.Add64(x43, x91, uint64(0x0))
4447 var x111 uint64
4448 var x112 uint64
4449 x111, x112 = bits.Add64(x61, x93, uint64(p521Uint1(x110)))
4450 var x113 uint64
4451 var x114 uint64
4452 x113, x114 = bits.Add64(x63, x95, uint64(p521Uint1(x112)))
4453 var x115 uint64
4454 var x116 uint64
4455 x115, x116 = bits.Add64(x65, x97, uint64(p521Uint1(x114)))
4456 var x117 uint64
4457 var x118 uint64
4458 x117, x118 = bits.Add64(x67, x99, uint64(p521Uint1(x116)))
4459 var x119 uint64
4460 var x120 uint64
4461 x119, x120 = bits.Add64(x69, x101, uint64(p521Uint1(x118)))
4462 var x121 uint64
4463 var x122 uint64
4464 x121, x122 = bits.Add64(x71, x103, uint64(p521Uint1(x120)))
4465 var x123 uint64
4466 var x124 uint64
4467 x123, x124 = bits.Add64(x73, x105, uint64(p521Uint1(x122)))
4468 var x125 uint64
4469 var x126 uint64
4470 x125, x126 = bits.Add64((uint64(p521Uint1(x74)) + (uint64(p521Uint1(x58)) + (uint64(p521Uint1(x40)) + x8))), x107, uint64(p521Uint1(x124)))
4471 var x127 uint64
4472 var x128 uint64
4473 x128, x127 = bits.Mul64(arg1[3], 0x400000000000)
4474 var x129 uint64
4475 var x130 uint64
4476 x129, x130 = bits.Add64(x113, x127, uint64(0x0))
4477 var x131 uint64
4478 var x132 uint64
4479 x131, x132 = bits.Add64(x115, x128, uint64(p521Uint1(x130)))
4480 var x133 uint64
4481 var x134 uint64
4482 x133, x134 = bits.Add64(x117, uint64(0x0), uint64(p521Uint1(x132)))
4483 var x135 uint64
4484 var x136 uint64
4485 x135, x136 = bits.Add64(x119, uint64(0x0), uint64(p521Uint1(x134)))
4486 var x137 uint64
4487 var x138 uint64
4488 x137, x138 = bits.Add64(x121, uint64(0x0), uint64(p521Uint1(x136)))
4489 var x139 uint64
4490 var x140 uint64
4491 x139, x140 = bits.Add64(x123, uint64(0x0), uint64(p521Uint1(x138)))
4492 var x141 uint64
4493 var x142 uint64
4494 x141, x142 = bits.Add64(x125, uint64(0x0), uint64(p521Uint1(x140)))
4495 var x143 uint64
4496 var x144 uint64
4497 x144, x143 = bits.Mul64(x111, 0x1ff)
4498 var x145 uint64
4499 var x146 uint64
4500 x146, x145 = bits.Mul64(x111, 0xffffffffffffffff)
4501 var x147 uint64
4502 var x148 uint64
4503 x148, x147 = bits.Mul64(x111, 0xffffffffffffffff)
4504 var x149 uint64
4505 var x150 uint64
4506 x150, x149 = bits.Mul64(x111, 0xffffffffffffffff)
4507 var x151 uint64
4508 var x152 uint64
4509 x152, x151 = bits.Mul64(x111, 0xffffffffffffffff)
4510 var x153 uint64
4511 var x154 uint64
4512 x154, x153 = bits.Mul64(x111, 0xffffffffffffffff)
4513 var x155 uint64
4514 var x156 uint64
4515 x156, x155 = bits.Mul64(x111, 0xffffffffffffffff)
4516 var x157 uint64
4517 var x158 uint64
4518 x158, x157 = bits.Mul64(x111, 0xffffffffffffffff)
4519 var x159 uint64
4520 var x160 uint64
4521 x160, x159 = bits.Mul64(x111, 0xffffffffffffffff)
4522 var x161 uint64
4523 var x162 uint64
4524 x161, x162 = bits.Add64(x160, x157, uint64(0x0))
4525 var x163 uint64
4526 var x164 uint64
4527 x163, x164 = bits.Add64(x158, x155, uint64(p521Uint1(x162)))
4528 var x165 uint64
4529 var x166 uint64
4530 x165, x166 = bits.Add64(x156, x153, uint64(p521Uint1(x164)))
4531 var x167 uint64
4532 var x168 uint64
4533 x167, x168 = bits.Add64(x154, x151, uint64(p521Uint1(x166)))
4534 var x169 uint64
4535 var x170 uint64
4536 x169, x170 = bits.Add64(x152, x149, uint64(p521Uint1(x168)))
4537 var x171 uint64
4538 var x172 uint64
4539 x171, x172 = bits.Add64(x150, x147, uint64(p521Uint1(x170)))
4540 var x173 uint64
4541 var x174 uint64
4542 x173, x174 = bits.Add64(x148, x145, uint64(p521Uint1(x172)))
4543 var x175 uint64
4544 var x176 uint64
4545 x175, x176 = bits.Add64(x146, x143, uint64(p521Uint1(x174)))
4546 var x178 uint64
4547 _, x178 = bits.Add64(x111, x159, uint64(0x0))
4548 var x179 uint64
4549 var x180 uint64
4550 x179, x180 = bits.Add64(x129, x161, uint64(p521Uint1(x178)))
4551 var x181 uint64
4552 var x182 uint64
4553 x181, x182 = bits.Add64(x131, x163, uint64(p521Uint1(x180)))
4554 var x183 uint64
4555 var x184 uint64
4556 x183, x184 = bits.Add64(x133, x165, uint64(p521Uint1(x182)))
4557 var x185 uint64
4558 var x186 uint64
4559 x185, x186 = bits.Add64(x135, x167, uint64(p521Uint1(x184)))
4560 var x187 uint64
4561 var x188 uint64
4562 x187, x188 = bits.Add64(x137, x169, uint64(p521Uint1(x186)))
4563 var x189 uint64
4564 var x190 uint64
4565 x189, x190 = bits.Add64(x139, x171, uint64(p521Uint1(x188)))
4566 var x191 uint64
4567 var x192 uint64
4568 x191, x192 = bits.Add64(x141, x173, uint64(p521Uint1(x190)))
4569 var x193 uint64
4570 var x194 uint64
4571 x193, x194 = bits.Add64((uint64(p521Uint1(x142)) + (uint64(p521Uint1(x126)) + (uint64(p521Uint1(x108)) + x76))), x175, uint64(p521Uint1(x192)))
4572 var x195 uint64
4573 var x196 uint64
4574 x196, x195 = bits.Mul64(arg1[4], 0x400000000000)
4575 var x197 uint64
4576 var x198 uint64
4577 x197, x198 = bits.Add64(x181, x195, uint64(0x0))
4578 var x199 uint64
4579 var x200 uint64
4580 x199, x200 = bits.Add64(x183, x196, uint64(p521Uint1(x198)))
4581 var x201 uint64
4582 var x202 uint64
4583 x201, x202 = bits.Add64(x185, uint64(0x0), uint64(p521Uint1(x200)))
4584 var x203 uint64
4585 var x204 uint64
4586 x203, x204 = bits.Add64(x187, uint64(0x0), uint64(p521Uint1(x202)))
4587 var x205 uint64
4588 var x206 uint64
4589 x205, x206 = bits.Add64(x189, uint64(0x0), uint64(p521Uint1(x204)))
4590 var x207 uint64
4591 var x208 uint64
4592 x207, x208 = bits.Add64(x191, uint64(0x0), uint64(p521Uint1(x206)))
4593 var x209 uint64
4594 var x210 uint64
4595 x209, x210 = bits.Add64(x193, uint64(0x0), uint64(p521Uint1(x208)))
4596 var x211 uint64
4597 var x212 uint64
4598 x212, x211 = bits.Mul64(x179, 0x1ff)
4599 var x213 uint64
4600 var x214 uint64
4601 x214, x213 = bits.Mul64(x179, 0xffffffffffffffff)
4602 var x215 uint64
4603 var x216 uint64
4604 x216, x215 = bits.Mul64(x179, 0xffffffffffffffff)
4605 var x217 uint64
4606 var x218 uint64
4607 x218, x217 = bits.Mul64(x179, 0xffffffffffffffff)
4608 var x219 uint64
4609 var x220 uint64
4610 x220, x219 = bits.Mul64(x179, 0xffffffffffffffff)
4611 var x221 uint64
4612 var x222 uint64
4613 x222, x221 = bits.Mul64(x179, 0xffffffffffffffff)
4614 var x223 uint64
4615 var x224 uint64
4616 x224, x223 = bits.Mul64(x179, 0xffffffffffffffff)
4617 var x225 uint64
4618 var x226 uint64
4619 x226, x225 = bits.Mul64(x179, 0xffffffffffffffff)
4620 var x227 uint64
4621 var x228 uint64
4622 x228, x227 = bits.Mul64(x179, 0xffffffffffffffff)
4623 var x229 uint64
4624 var x230 uint64
4625 x229, x230 = bits.Add64(x228, x225, uint64(0x0))
4626 var x231 uint64
4627 var x232 uint64
4628 x231, x232 = bits.Add64(x226, x223, uint64(p521Uint1(x230)))
4629 var x233 uint64
4630 var x234 uint64
4631 x233, x234 = bits.Add64(x224, x221, uint64(p521Uint1(x232)))
4632 var x235 uint64
4633 var x236 uint64
4634 x235, x236 = bits.Add64(x222, x219, uint64(p521Uint1(x234)))
4635 var x237 uint64
4636 var x238 uint64
4637 x237, x238 = bits.Add64(x220, x217, uint64(p521Uint1(x236)))
4638 var x239 uint64
4639 var x240 uint64
4640 x239, x240 = bits.Add64(x218, x215, uint64(p521Uint1(x238)))
4641 var x241 uint64
4642 var x242 uint64
4643 x241, x242 = bits.Add64(x216, x213, uint64(p521Uint1(x240)))
4644 var x243 uint64
4645 var x244 uint64
4646 x243, x244 = bits.Add64(x214, x211, uint64(p521Uint1(x242)))
4647 var x246 uint64
4648 _, x246 = bits.Add64(x179, x227, uint64(0x0))
4649 var x247 uint64
4650 var x248 uint64
4651 x247, x248 = bits.Add64(x197, x229, uint64(p521Uint1(x246)))
4652 var x249 uint64
4653 var x250 uint64
4654 x249, x250 = bits.Add64(x199, x231, uint64(p521Uint1(x248)))
4655 var x251 uint64
4656 var x252 uint64
4657 x251, x252 = bits.Add64(x201, x233, uint64(p521Uint1(x250)))
4658 var x253 uint64
4659 var x254 uint64
4660 x253, x254 = bits.Add64(x203, x235, uint64(p521Uint1(x252)))
4661 var x255 uint64
4662 var x256 uint64
4663 x255, x256 = bits.Add64(x205, x237, uint64(p521Uint1(x254)))
4664 var x257 uint64
4665 var x258 uint64
4666 x257, x258 = bits.Add64(x207, x239, uint64(p521Uint1(x256)))
4667 var x259 uint64
4668 var x260 uint64
4669 x259, x260 = bits.Add64(x209, x241, uint64(p521Uint1(x258)))
4670 var x261 uint64
4671 var x262 uint64
4672 x261, x262 = bits.Add64((uint64(p521Uint1(x210)) + (uint64(p521Uint1(x194)) + (uint64(p521Uint1(x176)) + x144))), x243, uint64(p521Uint1(x260)))
4673 var x263 uint64
4674 var x264 uint64
4675 x264, x263 = bits.Mul64(arg1[5], 0x400000000000)
4676 var x265 uint64
4677 var x266 uint64
4678 x265, x266 = bits.Add64(x249, x263, uint64(0x0))
4679 var x267 uint64
4680 var x268 uint64
4681 x267, x268 = bits.Add64(x251, x264, uint64(p521Uint1(x266)))
4682 var x269 uint64
4683 var x270 uint64
4684 x269, x270 = bits.Add64(x253, uint64(0x0), uint64(p521Uint1(x268)))
4685 var x271 uint64
4686 var x272 uint64
4687 x271, x272 = bits.Add64(x255, uint64(0x0), uint64(p521Uint1(x270)))
4688 var x273 uint64
4689 var x274 uint64
4690 x273, x274 = bits.Add64(x257, uint64(0x0), uint64(p521Uint1(x272)))
4691 var x275 uint64
4692 var x276 uint64
4693 x275, x276 = bits.Add64(x259, uint64(0x0), uint64(p521Uint1(x274)))
4694 var x277 uint64
4695 var x278 uint64
4696 x277, x278 = bits.Add64(x261, uint64(0x0), uint64(p521Uint1(x276)))
4697 var x279 uint64
4698 var x280 uint64
4699 x280, x279 = bits.Mul64(x247, 0x1ff)
4700 var x281 uint64
4701 var x282 uint64
4702 x282, x281 = bits.Mul64(x247, 0xffffffffffffffff)
4703 var x283 uint64
4704 var x284 uint64
4705 x284, x283 = bits.Mul64(x247, 0xffffffffffffffff)
4706 var x285 uint64
4707 var x286 uint64
4708 x286, x285 = bits.Mul64(x247, 0xffffffffffffffff)
4709 var x287 uint64
4710 var x288 uint64
4711 x288, x287 = bits.Mul64(x247, 0xffffffffffffffff)
4712 var x289 uint64
4713 var x290 uint64
4714 x290, x289 = bits.Mul64(x247, 0xffffffffffffffff)
4715 var x291 uint64
4716 var x292 uint64
4717 x292, x291 = bits.Mul64(x247, 0xffffffffffffffff)
4718 var x293 uint64
4719 var x294 uint64
4720 x294, x293 = bits.Mul64(x247, 0xffffffffffffffff)
4721 var x295 uint64
4722 var x296 uint64
4723 x296, x295 = bits.Mul64(x247, 0xffffffffffffffff)
4724 var x297 uint64
4725 var x298 uint64
4726 x297, x298 = bits.Add64(x296, x293, uint64(0x0))
4727 var x299 uint64
4728 var x300 uint64
4729 x299, x300 = bits.Add64(x294, x291, uint64(p521Uint1(x298)))
4730 var x301 uint64
4731 var x302 uint64
4732 x301, x302 = bits.Add64(x292, x289, uint64(p521Uint1(x300)))
4733 var x303 uint64
4734 var x304 uint64
4735 x303, x304 = bits.Add64(x290, x287, uint64(p521Uint1(x302)))
4736 var x305 uint64
4737 var x306 uint64
4738 x305, x306 = bits.Add64(x288, x285, uint64(p521Uint1(x304)))
4739 var x307 uint64
4740 var x308 uint64
4741 x307, x308 = bits.Add64(x286, x283, uint64(p521Uint1(x306)))
4742 var x309 uint64
4743 var x310 uint64
4744 x309, x310 = bits.Add64(x284, x281, uint64(p521Uint1(x308)))
4745 var x311 uint64
4746 var x312 uint64
4747 x311, x312 = bits.Add64(x282, x279, uint64(p521Uint1(x310)))
4748 var x314 uint64
4749 _, x314 = bits.Add64(x247, x295, uint64(0x0))
4750 var x315 uint64
4751 var x316 uint64
4752 x315, x316 = bits.Add64(x265, x297, uint64(p521Uint1(x314)))
4753 var x317 uint64
4754 var x318 uint64
4755 x317, x318 = bits.Add64(x267, x299, uint64(p521Uint1(x316)))
4756 var x319 uint64
4757 var x320 uint64
4758 x319, x320 = bits.Add64(x269, x301, uint64(p521Uint1(x318)))
4759 var x321 uint64
4760 var x322 uint64
4761 x321, x322 = bits.Add64(x271, x303, uint64(p521Uint1(x320)))
4762 var x323 uint64
4763 var x324 uint64
4764 x323, x324 = bits.Add64(x273, x305, uint64(p521Uint1(x322)))
4765 var x325 uint64
4766 var x326 uint64
4767 x325, x326 = bits.Add64(x275, x307, uint64(p521Uint1(x324)))
4768 var x327 uint64
4769 var x328 uint64
4770 x327, x328 = bits.Add64(x277, x309, uint64(p521Uint1(x326)))
4771 var x329 uint64
4772 var x330 uint64
4773 x329, x330 = bits.Add64((uint64(p521Uint1(x278)) + (uint64(p521Uint1(x262)) + (uint64(p521Uint1(x244)) + x212))), x311, uint64(p521Uint1(x328)))
4774 var x331 uint64
4775 var x332 uint64
4776 x332, x331 = bits.Mul64(arg1[6], 0x400000000000)
4777 var x333 uint64
4778 var x334 uint64
4779 x333, x334 = bits.Add64(x317, x331, uint64(0x0))
4780 var x335 uint64
4781 var x336 uint64
4782 x335, x336 = bits.Add64(x319, x332, uint64(p521Uint1(x334)))
4783 var x337 uint64
4784 var x338 uint64
4785 x337, x338 = bits.Add64(x321, uint64(0x0), uint64(p521Uint1(x336)))
4786 var x339 uint64
4787 var x340 uint64
4788 x339, x340 = bits.Add64(x323, uint64(0x0), uint64(p521Uint1(x338)))
4789 var x341 uint64
4790 var x342 uint64
4791 x341, x342 = bits.Add64(x325, uint64(0x0), uint64(p521Uint1(x340)))
4792 var x343 uint64
4793 var x344 uint64
4794 x343, x344 = bits.Add64(x327, uint64(0x0), uint64(p521Uint1(x342)))
4795 var x345 uint64
4796 var x346 uint64
4797 x345, x346 = bits.Add64(x329, uint64(0x0), uint64(p521Uint1(x344)))
4798 var x347 uint64
4799 var x348 uint64
4800 x348, x347 = bits.Mul64(x315, 0x1ff)
4801 var x349 uint64
4802 var x350 uint64
4803 x350, x349 = bits.Mul64(x315, 0xffffffffffffffff)
4804 var x351 uint64
4805 var x352 uint64
4806 x352, x351 = bits.Mul64(x315, 0xffffffffffffffff)
4807 var x353 uint64
4808 var x354 uint64
4809 x354, x353 = bits.Mul64(x315, 0xffffffffffffffff)
4810 var x355 uint64
4811 var x356 uint64
4812 x356, x355 = bits.Mul64(x315, 0xffffffffffffffff)
4813 var x357 uint64
4814 var x358 uint64
4815 x358, x357 = bits.Mul64(x315, 0xffffffffffffffff)
4816 var x359 uint64
4817 var x360 uint64
4818 x360, x359 = bits.Mul64(x315, 0xffffffffffffffff)
4819 var x361 uint64
4820 var x362 uint64
4821 x362, x361 = bits.Mul64(x315, 0xffffffffffffffff)
4822 var x363 uint64
4823 var x364 uint64
4824 x364, x363 = bits.Mul64(x315, 0xffffffffffffffff)
4825 var x365 uint64
4826 var x366 uint64
4827 x365, x366 = bits.Add64(x364, x361, uint64(0x0))
4828 var x367 uint64
4829 var x368 uint64
4830 x367, x368 = bits.Add64(x362, x359, uint64(p521Uint1(x366)))
4831 var x369 uint64
4832 var x370 uint64
4833 x369, x370 = bits.Add64(x360, x357, uint64(p521Uint1(x368)))
4834 var x371 uint64
4835 var x372 uint64
4836 x371, x372 = bits.Add64(x358, x355, uint64(p521Uint1(x370)))
4837 var x373 uint64
4838 var x374 uint64
4839 x373, x374 = bits.Add64(x356, x353, uint64(p521Uint1(x372)))
4840 var x375 uint64
4841 var x376 uint64
4842 x375, x376 = bits.Add64(x354, x351, uint64(p521Uint1(x374)))
4843 var x377 uint64
4844 var x378 uint64
4845 x377, x378 = bits.Add64(x352, x349, uint64(p521Uint1(x376)))
4846 var x379 uint64
4847 var x380 uint64
4848 x379, x380 = bits.Add64(x350, x347, uint64(p521Uint1(x378)))
4849 var x382 uint64
4850 _, x382 = bits.Add64(x315, x363, uint64(0x0))
4851 var x383 uint64
4852 var x384 uint64
4853 x383, x384 = bits.Add64(x333, x365, uint64(p521Uint1(x382)))
4854 var x385 uint64
4855 var x386 uint64
4856 x385, x386 = bits.Add64(x335, x367, uint64(p521Uint1(x384)))
4857 var x387 uint64
4858 var x388 uint64
4859 x387, x388 = bits.Add64(x337, x369, uint64(p521Uint1(x386)))
4860 var x389 uint64
4861 var x390 uint64
4862 x389, x390 = bits.Add64(x339, x371, uint64(p521Uint1(x388)))
4863 var x391 uint64
4864 var x392 uint64
4865 x391, x392 = bits.Add64(x341, x373, uint64(p521Uint1(x390)))
4866 var x393 uint64
4867 var x394 uint64
4868 x393, x394 = bits.Add64(x343, x375, uint64(p521Uint1(x392)))
4869 var x395 uint64
4870 var x396 uint64
4871 x395, x396 = bits.Add64(x345, x377, uint64(p521Uint1(x394)))
4872 var x397 uint64
4873 var x398 uint64
4874 x397, x398 = bits.Add64((uint64(p521Uint1(x346)) + (uint64(p521Uint1(x330)) + (uint64(p521Uint1(x312)) + x280))), x379, uint64(p521Uint1(x396)))
4875 var x399 uint64
4876 var x400 uint64
4877 x400, x399 = bits.Mul64(arg1[7], 0x400000000000)
4878 var x401 uint64
4879 var x402 uint64
4880 x401, x402 = bits.Add64(x385, x399, uint64(0x0))
4881 var x403 uint64
4882 var x404 uint64
4883 x403, x404 = bits.Add64(x387, x400, uint64(p521Uint1(x402)))
4884 var x405 uint64
4885 var x406 uint64
4886 x405, x406 = bits.Add64(x389, uint64(0x0), uint64(p521Uint1(x404)))
4887 var x407 uint64
4888 var x408 uint64
4889 x407, x408 = bits.Add64(x391, uint64(0x0), uint64(p521Uint1(x406)))
4890 var x409 uint64
4891 var x410 uint64
4892 x409, x410 = bits.Add64(x393, uint64(0x0), uint64(p521Uint1(x408)))
4893 var x411 uint64
4894 var x412 uint64
4895 x411, x412 = bits.Add64(x395, uint64(0x0), uint64(p521Uint1(x410)))
4896 var x413 uint64
4897 var x414 uint64
4898 x413, x414 = bits.Add64(x397, uint64(0x0), uint64(p521Uint1(x412)))
4899 var x415 uint64
4900 var x416 uint64
4901 x416, x415 = bits.Mul64(x383, 0x1ff)
4902 var x417 uint64
4903 var x418 uint64
4904 x418, x417 = bits.Mul64(x383, 0xffffffffffffffff)
4905 var x419 uint64
4906 var x420 uint64
4907 x420, x419 = bits.Mul64(x383, 0xffffffffffffffff)
4908 var x421 uint64
4909 var x422 uint64
4910 x422, x421 = bits.Mul64(x383, 0xffffffffffffffff)
4911 var x423 uint64
4912 var x424 uint64
4913 x424, x423 = bits.Mul64(x383, 0xffffffffffffffff)
4914 var x425 uint64
4915 var x426 uint64
4916 x426, x425 = bits.Mul64(x383, 0xffffffffffffffff)
4917 var x427 uint64
4918 var x428 uint64
4919 x428, x427 = bits.Mul64(x383, 0xffffffffffffffff)
4920 var x429 uint64
4921 var x430 uint64
4922 x430, x429 = bits.Mul64(x383, 0xffffffffffffffff)
4923 var x431 uint64
4924 var x432 uint64
4925 x432, x431 = bits.Mul64(x383, 0xffffffffffffffff)
4926 var x433 uint64
4927 var x434 uint64
4928 x433, x434 = bits.Add64(x432, x429, uint64(0x0))
4929 var x435 uint64
4930 var x436 uint64
4931 x435, x436 = bits.Add64(x430, x427, uint64(p521Uint1(x434)))
4932 var x437 uint64
4933 var x438 uint64
4934 x437, x438 = bits.Add64(x428, x425, uint64(p521Uint1(x436)))
4935 var x439 uint64
4936 var x440 uint64
4937 x439, x440 = bits.Add64(x426, x423, uint64(p521Uint1(x438)))
4938 var x441 uint64
4939 var x442 uint64
4940 x441, x442 = bits.Add64(x424, x421, uint64(p521Uint1(x440)))
4941 var x443 uint64
4942 var x444 uint64
4943 x443, x444 = bits.Add64(x422, x419, uint64(p521Uint1(x442)))
4944 var x445 uint64
4945 var x446 uint64
4946 x445, x446 = bits.Add64(x420, x417, uint64(p521Uint1(x444)))
4947 var x447 uint64
4948 var x448 uint64
4949 x447, x448 = bits.Add64(x418, x415, uint64(p521Uint1(x446)))
4950 var x450 uint64
4951 _, x450 = bits.Add64(x383, x431, uint64(0x0))
4952 var x451 uint64
4953 var x452 uint64
4954 x451, x452 = bits.Add64(x401, x433, uint64(p521Uint1(x450)))
4955 var x453 uint64
4956 var x454 uint64
4957 x453, x454 = bits.Add64(x403, x435, uint64(p521Uint1(x452)))
4958 var x455 uint64
4959 var x456 uint64
4960 x455, x456 = bits.Add64(x405, x437, uint64(p521Uint1(x454)))
4961 var x457 uint64
4962 var x458 uint64
4963 x457, x458 = bits.Add64(x407, x439, uint64(p521Uint1(x456)))
4964 var x459 uint64
4965 var x460 uint64
4966 x459, x460 = bits.Add64(x409, x441, uint64(p521Uint1(x458)))
4967 var x461 uint64
4968 var x462 uint64
4969 x461, x462 = bits.Add64(x411, x443, uint64(p521Uint1(x460)))
4970 var x463 uint64
4971 var x464 uint64
4972 x463, x464 = bits.Add64(x413, x445, uint64(p521Uint1(x462)))
4973 var x465 uint64
4974 var x466 uint64
4975 x465, x466 = bits.Add64((uint64(p521Uint1(x414)) + (uint64(p521Uint1(x398)) + (uint64(p521Uint1(x380)) + x348))), x447, uint64(p521Uint1(x464)))
4976 var x467 uint64
4977 var x468 uint64
4978 x468, x467 = bits.Mul64(arg1[8], 0x400000000000)
4979 var x469 uint64
4980 var x470 uint64
4981 x469, x470 = bits.Add64(x453, x467, uint64(0x0))
4982 var x471 uint64
4983 var x472 uint64
4984 x471, x472 = bits.Add64(x455, x468, uint64(p521Uint1(x470)))
4985 var x473 uint64
4986 var x474 uint64
4987 x473, x474 = bits.Add64(x457, uint64(0x0), uint64(p521Uint1(x472)))
4988 var x475 uint64
4989 var x476 uint64
4990 x475, x476 = bits.Add64(x459, uint64(0x0), uint64(p521Uint1(x474)))
4991 var x477 uint64
4992 var x478 uint64
4993 x477, x478 = bits.Add64(x461, uint64(0x0), uint64(p521Uint1(x476)))
4994 var x479 uint64
4995 var x480 uint64
4996 x479, x480 = bits.Add64(x463, uint64(0x0), uint64(p521Uint1(x478)))
4997 var x481 uint64
4998 var x482 uint64
4999 x481, x482 = bits.Add64(x465, uint64(0x0), uint64(p521Uint1(x480)))
5000 var x483 uint64
5001 var x484 uint64
5002 x484, x483 = bits.Mul64(x451, 0x1ff)
5003 var x485 uint64
5004 var x486 uint64
5005 x486, x485 = bits.Mul64(x451, 0xffffffffffffffff)
5006 var x487 uint64
5007 var x488 uint64
5008 x488, x487 = bits.Mul64(x451, 0xffffffffffffffff)
5009 var x489 uint64
5010 var x490 uint64
5011 x490, x489 = bits.Mul64(x451, 0xffffffffffffffff)
5012 var x491 uint64
5013 var x492 uint64
5014 x492, x491 = bits.Mul64(x451, 0xffffffffffffffff)
5015 var x493 uint64
5016 var x494 uint64
5017 x494, x493 = bits.Mul64(x451, 0xffffffffffffffff)
5018 var x495 uint64
5019 var x496 uint64
5020 x496, x495 = bits.Mul64(x451, 0xffffffffffffffff)
5021 var x497 uint64
5022 var x498 uint64
5023 x498, x497 = bits.Mul64(x451, 0xffffffffffffffff)
5024 var x499 uint64
5025 var x500 uint64
5026 x500, x499 = bits.Mul64(x451, 0xffffffffffffffff)
5027 var x501 uint64
5028 var x502 uint64
5029 x501, x502 = bits.Add64(x500, x497, uint64(0x0))
5030 var x503 uint64
5031 var x504 uint64
5032 x503, x504 = bits.Add64(x498, x495, uint64(p521Uint1(x502)))
5033 var x505 uint64
5034 var x506 uint64
5035 x505, x506 = bits.Add64(x496, x493, uint64(p521Uint1(x504)))
5036 var x507 uint64
5037 var x508 uint64
5038 x507, x508 = bits.Add64(x494, x491, uint64(p521Uint1(x506)))
5039 var x509 uint64
5040 var x510 uint64
5041 x509, x510 = bits.Add64(x492, x489, uint64(p521Uint1(x508)))
5042 var x511 uint64
5043 var x512 uint64
5044 x511, x512 = bits.Add64(x490, x487, uint64(p521Uint1(x510)))
5045 var x513 uint64
5046 var x514 uint64
5047 x513, x514 = bits.Add64(x488, x485, uint64(p521Uint1(x512)))
5048 var x515 uint64
5049 var x516 uint64
5050 x515, x516 = bits.Add64(x486, x483, uint64(p521Uint1(x514)))
5051 var x518 uint64
5052 _, x518 = bits.Add64(x451, x499, uint64(0x0))
5053 var x519 uint64
5054 var x520 uint64
5055 x519, x520 = bits.Add64(x469, x501, uint64(p521Uint1(x518)))
5056 var x521 uint64
5057 var x522 uint64
5058 x521, x522 = bits.Add64(x471, x503, uint64(p521Uint1(x520)))
5059 var x523 uint64
5060 var x524 uint64
5061 x523, x524 = bits.Add64(x473, x505, uint64(p521Uint1(x522)))
5062 var x525 uint64
5063 var x526 uint64
5064 x525, x526 = bits.Add64(x475, x507, uint64(p521Uint1(x524)))
5065 var x527 uint64
5066 var x528 uint64
5067 x527, x528 = bits.Add64(x477, x509, uint64(p521Uint1(x526)))
5068 var x529 uint64
5069 var x530 uint64
5070 x529, x530 = bits.Add64(x479, x511, uint64(p521Uint1(x528)))
5071 var x531 uint64
5072 var x532 uint64
5073 x531, x532 = bits.Add64(x481, x513, uint64(p521Uint1(x530)))
5074 var x533 uint64
5075 var x534 uint64
5076 x533, x534 = bits.Add64((uint64(p521Uint1(x482)) + (uint64(p521Uint1(x466)) + (uint64(p521Uint1(x448)) + x416))), x515, uint64(p521Uint1(x532)))
5077 x535 := (uint64(p521Uint1(x534)) + (uint64(p521Uint1(x516)) + x484))
5078 var x536 uint64
5079 var x537 uint64
5080 x536, x537 = bits.Sub64(x519, 0xffffffffffffffff, uint64(0x0))
5081 var x538 uint64
5082 var x539 uint64
5083 x538, x539 = bits.Sub64(x521, 0xffffffffffffffff, uint64(p521Uint1(x537)))
5084 var x540 uint64
5085 var x541 uint64
5086 x540, x541 = bits.Sub64(x523, 0xffffffffffffffff, uint64(p521Uint1(x539)))
5087 var x542 uint64
5088 var x543 uint64
5089 x542, x543 = bits.Sub64(x525, 0xffffffffffffffff, uint64(p521Uint1(x541)))
5090 var x544 uint64
5091 var x545 uint64
5092 x544, x545 = bits.Sub64(x527, 0xffffffffffffffff, uint64(p521Uint1(x543)))
5093 var x546 uint64
5094 var x547 uint64
5095 x546, x547 = bits.Sub64(x529, 0xffffffffffffffff, uint64(p521Uint1(x545)))
5096 var x548 uint64
5097 var x549 uint64
5098 x548, x549 = bits.Sub64(x531, 0xffffffffffffffff, uint64(p521Uint1(x547)))
5099 var x550 uint64
5100 var x551 uint64
5101 x550, x551 = bits.Sub64(x533, 0xffffffffffffffff, uint64(p521Uint1(x549)))
5102 var x552 uint64
5103 var x553 uint64
5104 x552, x553 = bits.Sub64(x535, 0x1ff, uint64(p521Uint1(x551)))
5105 var x555 uint64
5106 _, x555 = bits.Sub64(uint64(0x0), uint64(0x0), uint64(p521Uint1(x553)))
5107 var x556 uint64
5108 p521CmovznzU64(&x556, p521Uint1(x555), x536, x519)
5109 var x557 uint64
5110 p521CmovznzU64(&x557, p521Uint1(x555), x538, x521)
5111 var x558 uint64
5112 p521CmovznzU64(&x558, p521Uint1(x555), x540, x523)
5113 var x559 uint64
5114 p521CmovznzU64(&x559, p521Uint1(x555), x542, x525)
5115 var x560 uint64
5116 p521CmovznzU64(&x560, p521Uint1(x555), x544, x527)
5117 var x561 uint64
5118 p521CmovznzU64(&x561, p521Uint1(x555), x546, x529)
5119 var x562 uint64
5120 p521CmovznzU64(&x562, p521Uint1(x555), x548, x531)
5121 var x563 uint64
5122 p521CmovznzU64(&x563, p521Uint1(x555), x550, x533)
5123 var x564 uint64
5124 p521CmovznzU64(&x564, p521Uint1(x555), x552, x535)
5125 out1[0] = x556
5126 out1[1] = x557
5127 out1[2] = x558
5128 out1[3] = x559
5129 out1[4] = x560
5130 out1[5] = x561
5131 out1[6] = x562
5132 out1[7] = x563
5133 out1[8] = x564
5134 }
5135
5136 // p521Selectznz is a multi-limb conditional select.
5137 //
5138 // Postconditions:
5139 //
5140 // eval out1 = (if arg1 = 0 then eval arg2 else eval arg3)
5141 //
5142 // Input Bounds:
5143 //
5144 // arg1: [0x0 ~> 0x1]
5145 // arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
5146 // arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
5147 //
5148 // Output Bounds:
5149 //
5150 // out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
5151 func p521Selectznz(out1 *[9]uint64, arg1 p521Uint1, arg2 *[9]uint64, arg3 *[9]uint64) {
5152 var x1 uint64
5153 p521CmovznzU64(&x1, arg1, arg2[0], arg3[0])
5154 var x2 uint64
5155 p521CmovznzU64(&x2, arg1, arg2[1], arg3[1])
5156 var x3 uint64
5157 p521CmovznzU64(&x3, arg1, arg2[2], arg3[2])
5158 var x4 uint64
5159 p521CmovznzU64(&x4, arg1, arg2[3], arg3[3])
5160 var x5 uint64
5161 p521CmovznzU64(&x5, arg1, arg2[4], arg3[4])
5162 var x6 uint64
5163 p521CmovznzU64(&x6, arg1, arg2[5], arg3[5])
5164 var x7 uint64
5165 p521CmovznzU64(&x7, arg1, arg2[6], arg3[6])
5166 var x8 uint64
5167 p521CmovznzU64(&x8, arg1, arg2[7], arg3[7])
5168 var x9 uint64
5169 p521CmovznzU64(&x9, arg1, arg2[8], arg3[8])
5170 out1[0] = x1
5171 out1[1] = x2
5172 out1[2] = x3
5173 out1[3] = x4
5174 out1[4] = x5
5175 out1[5] = x6
5176 out1[6] = x7
5177 out1[7] = x8
5178 out1[8] = x9
5179 }
5180
5181 // p521ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.
5182 //
5183 // Preconditions:
5184 //
5185 // 0 ≤ eval arg1 < m
5186 //
5187 // Postconditions:
5188 //
5189 // out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..65]
5190 //
5191 // Input Bounds:
5192 //
5193 // arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1ff]]
5194 //
5195 // Output Bounds:
5196 //
5197 // out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1]]
5198 func p521ToBytes(out1 *[66]uint8, arg1 *[9]uint64) {
5199 x1 := arg1[8]
5200 x2 := arg1[7]
5201 x3 := arg1[6]
5202 x4 := arg1[5]
5203 x5 := arg1[4]
5204 x6 := arg1[3]
5205 x7 := arg1[2]
5206 x8 := arg1[1]
5207 x9 := arg1[0]
5208 x10 := (uint8(x9) & 0xff)
5209 x11 := (x9 >> 8)
5210 x12 := (uint8(x11) & 0xff)
5211 x13 := (x11 >> 8)
5212 x14 := (uint8(x13) & 0xff)
5213 x15 := (x13 >> 8)
5214 x16 := (uint8(x15) & 0xff)
5215 x17 := (x15 >> 8)
5216 x18 := (uint8(x17) & 0xff)
5217 x19 := (x17 >> 8)
5218 x20 := (uint8(x19) & 0xff)
5219 x21 := (x19 >> 8)
5220 x22 := (uint8(x21) & 0xff)
5221 x23 := uint8((x21 >> 8))
5222 x24 := (uint8(x8) & 0xff)
5223 x25 := (x8 >> 8)
5224 x26 := (uint8(x25) & 0xff)
5225 x27 := (x25 >> 8)
5226 x28 := (uint8(x27) & 0xff)
5227 x29 := (x27 >> 8)
5228 x30 := (uint8(x29) & 0xff)
5229 x31 := (x29 >> 8)
5230 x32 := (uint8(x31) & 0xff)
5231 x33 := (x31 >> 8)
5232 x34 := (uint8(x33) & 0xff)
5233 x35 := (x33 >> 8)
5234 x36 := (uint8(x35) & 0xff)
5235 x37 := uint8((x35 >> 8))
5236 x38 := (uint8(x7) & 0xff)
5237 x39 := (x7 >> 8)
5238 x40 := (uint8(x39) & 0xff)
5239 x41 := (x39 >> 8)
5240 x42 := (uint8(x41) & 0xff)
5241 x43 := (x41 >> 8)
5242 x44 := (uint8(x43) & 0xff)
5243 x45 := (x43 >> 8)
5244 x46 := (uint8(x45) & 0xff)
5245 x47 := (x45 >> 8)
5246 x48 := (uint8(x47) & 0xff)
5247 x49 := (x47 >> 8)
5248 x50 := (uint8(x49) & 0xff)
5249 x51 := uint8((x49 >> 8))
5250 x52 := (uint8(x6) & 0xff)
5251 x53 := (x6 >> 8)
5252 x54 := (uint8(x53) & 0xff)
5253 x55 := (x53 >> 8)
5254 x56 := (uint8(x55) & 0xff)
5255 x57 := (x55 >> 8)
5256 x58 := (uint8(x57) & 0xff)
5257 x59 := (x57 >> 8)
5258 x60 := (uint8(x59) & 0xff)
5259 x61 := (x59 >> 8)
5260 x62 := (uint8(x61) & 0xff)
5261 x63 := (x61 >> 8)
5262 x64 := (uint8(x63) & 0xff)
5263 x65 := uint8((x63 >> 8))
5264 x66 := (uint8(x5) & 0xff)
5265 x67 := (x5 >> 8)
5266 x68 := (uint8(x67) & 0xff)
5267 x69 := (x67 >> 8)
5268 x70 := (uint8(x69) & 0xff)
5269 x71 := (x69 >> 8)
5270 x72 := (uint8(x71) & 0xff)
5271 x73 := (x71 >> 8)
5272 x74 := (uint8(x73) & 0xff)
5273 x75 := (x73 >> 8)
5274 x76 := (uint8(x75) & 0xff)
5275 x77 := (x75 >> 8)
5276 x78 := (uint8(x77) & 0xff)
5277 x79 := uint8((x77 >> 8))
5278 x80 := (uint8(x4) & 0xff)
5279 x81 := (x4 >> 8)
5280 x82 := (uint8(x81) & 0xff)
5281 x83 := (x81 >> 8)
5282 x84 := (uint8(x83) & 0xff)
5283 x85 := (x83 >> 8)
5284 x86 := (uint8(x85) & 0xff)
5285 x87 := (x85 >> 8)
5286 x88 := (uint8(x87) & 0xff)
5287 x89 := (x87 >> 8)
5288 x90 := (uint8(x89) & 0xff)
5289 x91 := (x89 >> 8)
5290 x92 := (uint8(x91) & 0xff)
5291 x93 := uint8((x91 >> 8))
5292 x94 := (uint8(x3) & 0xff)
5293 x95 := (x3 >> 8)
5294 x96 := (uint8(x95) & 0xff)
5295 x97 := (x95 >> 8)
5296 x98 := (uint8(x97) & 0xff)
5297 x99 := (x97 >> 8)
5298 x100 := (uint8(x99) & 0xff)
5299 x101 := (x99 >> 8)
5300 x102 := (uint8(x101) & 0xff)
5301 x103 := (x101 >> 8)
5302 x104 := (uint8(x103) & 0xff)
5303 x105 := (x103 >> 8)
5304 x106 := (uint8(x105) & 0xff)
5305 x107 := uint8((x105 >> 8))
5306 x108 := (uint8(x2) & 0xff)
5307 x109 := (x2 >> 8)
5308 x110 := (uint8(x109) & 0xff)
5309 x111 := (x109 >> 8)
5310 x112 := (uint8(x111) & 0xff)
5311 x113 := (x111 >> 8)
5312 x114 := (uint8(x113) & 0xff)
5313 x115 := (x113 >> 8)
5314 x116 := (uint8(x115) & 0xff)
5315 x117 := (x115 >> 8)
5316 x118 := (uint8(x117) & 0xff)
5317 x119 := (x117 >> 8)
5318 x120 := (uint8(x119) & 0xff)
5319 x121 := uint8((x119 >> 8))
5320 x122 := (uint8(x1) & 0xff)
5321 x123 := p521Uint1((x1 >> 8))
5322 out1[0] = x10
5323 out1[1] = x12
5324 out1[2] = x14
5325 out1[3] = x16
5326 out1[4] = x18
5327 out1[5] = x20
5328 out1[6] = x22
5329 out1[7] = x23
5330 out1[8] = x24
5331 out1[9] = x26
5332 out1[10] = x28
5333 out1[11] = x30
5334 out1[12] = x32
5335 out1[13] = x34
5336 out1[14] = x36
5337 out1[15] = x37
5338 out1[16] = x38
5339 out1[17] = x40
5340 out1[18] = x42
5341 out1[19] = x44
5342 out1[20] = x46
5343 out1[21] = x48
5344 out1[22] = x50
5345 out1[23] = x51
5346 out1[24] = x52
5347 out1[25] = x54
5348 out1[26] = x56
5349 out1[27] = x58
5350 out1[28] = x60
5351 out1[29] = x62
5352 out1[30] = x64
5353 out1[31] = x65
5354 out1[32] = x66
5355 out1[33] = x68
5356 out1[34] = x70
5357 out1[35] = x72
5358 out1[36] = x74
5359 out1[37] = x76
5360 out1[38] = x78
5361 out1[39] = x79
5362 out1[40] = x80
5363 out1[41] = x82
5364 out1[42] = x84
5365 out1[43] = x86
5366 out1[44] = x88
5367 out1[45] = x90
5368 out1[46] = x92
5369 out1[47] = x93
5370 out1[48] = x94
5371 out1[49] = x96
5372 out1[50] = x98
5373 out1[51] = x100
5374 out1[52] = x102
5375 out1[53] = x104
5376 out1[54] = x106
5377 out1[55] = x107
5378 out1[56] = x108
5379 out1[57] = x110
5380 out1[58] = x112
5381 out1[59] = x114
5382 out1[60] = x116
5383 out1[61] = x118
5384 out1[62] = x120
5385 out1[63] = x121
5386 out1[64] = x122
5387 out1[65] = uint8(x123)
5388 }
5389
5390 // p521FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.
5391 //
5392 // Preconditions:
5393 //
5394 // 0 ≤ bytes_eval arg1 < m
5395 //
5396 // Postconditions:
5397 //
5398 // eval out1 mod m = bytes_eval arg1 mod m
5399 // 0 ≤ eval out1 < m
5400 //
5401 // Input Bounds:
5402 //
5403 // arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1]]
5404 //
5405 // Output Bounds:
5406 //
5407 // out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1ff]]
5408 func p521FromBytes(out1 *[9]uint64, arg1 *[66]uint8) {
5409 x1 := (uint64(p521Uint1(arg1[65])) << 8)
5410 x2 := arg1[64]
5411 x3 := (uint64(arg1[63]) << 56)
5412 x4 := (uint64(arg1[62]) << 48)
5413 x5 := (uint64(arg1[61]) << 40)
5414 x6 := (uint64(arg1[60]) << 32)
5415 x7 := (uint64(arg1[59]) << 24)
5416 x8 := (uint64(arg1[58]) << 16)
5417 x9 := (uint64(arg1[57]) << 8)
5418 x10 := arg1[56]
5419 x11 := (uint64(arg1[55]) << 56)
5420 x12 := (uint64(arg1[54]) << 48)
5421 x13 := (uint64(arg1[53]) << 40)
5422 x14 := (uint64(arg1[52]) << 32)
5423 x15 := (uint64(arg1[51]) << 24)
5424 x16 := (uint64(arg1[50]) << 16)
5425 x17 := (uint64(arg1[49]) << 8)
5426 x18 := arg1[48]
5427 x19 := (uint64(arg1[47]) << 56)
5428 x20 := (uint64(arg1[46]) << 48)
5429 x21 := (uint64(arg1[45]) << 40)
5430 x22 := (uint64(arg1[44]) << 32)
5431 x23 := (uint64(arg1[43]) << 24)
5432 x24 := (uint64(arg1[42]) << 16)
5433 x25 := (uint64(arg1[41]) << 8)
5434 x26 := arg1[40]
5435 x27 := (uint64(arg1[39]) << 56)
5436 x28 := (uint64(arg1[38]) << 48)
5437 x29 := (uint64(arg1[37]) << 40)
5438 x30 := (uint64(arg1[36]) << 32)
5439 x31 := (uint64(arg1[35]) << 24)
5440 x32 := (uint64(arg1[34]) << 16)
5441 x33 := (uint64(arg1[33]) << 8)
5442 x34 := arg1[32]
5443 x35 := (uint64(arg1[31]) << 56)
5444 x36 := (uint64(arg1[30]) << 48)
5445 x37 := (uint64(arg1[29]) << 40)
5446 x38 := (uint64(arg1[28]) << 32)
5447 x39 := (uint64(arg1[27]) << 24)
5448 x40 := (uint64(arg1[26]) << 16)
5449 x41 := (uint64(arg1[25]) << 8)
5450 x42 := arg1[24]
5451 x43 := (uint64(arg1[23]) << 56)
5452 x44 := (uint64(arg1[22]) << 48)
5453 x45 := (uint64(arg1[21]) << 40)
5454 x46 := (uint64(arg1[20]) << 32)
5455 x47 := (uint64(arg1[19]) << 24)
5456 x48 := (uint64(arg1[18]) << 16)
5457 x49 := (uint64(arg1[17]) << 8)
5458 x50 := arg1[16]
5459 x51 := (uint64(arg1[15]) << 56)
5460 x52 := (uint64(arg1[14]) << 48)
5461 x53 := (uint64(arg1[13]) << 40)
5462 x54 := (uint64(arg1[12]) << 32)
5463 x55 := (uint64(arg1[11]) << 24)
5464 x56 := (uint64(arg1[10]) << 16)
5465 x57 := (uint64(arg1[9]) << 8)
5466 x58 := arg1[8]
5467 x59 := (uint64(arg1[7]) << 56)
5468 x60 := (uint64(arg1[6]) << 48)
5469 x61 := (uint64(arg1[5]) << 40)
5470 x62 := (uint64(arg1[4]) << 32)
5471 x63 := (uint64(arg1[3]) << 24)
5472 x64 := (uint64(arg1[2]) << 16)
5473 x65 := (uint64(arg1[1]) << 8)
5474 x66 := arg1[0]
5475 x67 := (x65 + uint64(x66))
5476 x68 := (x64 + x67)
5477 x69 := (x63 + x68)
5478 x70 := (x62 + x69)
5479 x71 := (x61 + x70)
5480 x72 := (x60 + x71)
5481 x73 := (x59 + x72)
5482 x74 := (x57 + uint64(x58))
5483 x75 := (x56 + x74)
5484 x76 := (x55 + x75)
5485 x77 := (x54 + x76)
5486 x78 := (x53 + x77)
5487 x79 := (x52 + x78)
5488 x80 := (x51 + x79)
5489 x81 := (x49 + uint64(x50))
5490 x82 := (x48 + x81)
5491 x83 := (x47 + x82)
5492 x84 := (x46 + x83)
5493 x85 := (x45 + x84)
5494 x86 := (x44 + x85)
5495 x87 := (x43 + x86)
5496 x88 := (x41 + uint64(x42))
5497 x89 := (x40 + x88)
5498 x90 := (x39 + x89)
5499 x91 := (x38 + x90)
5500 x92 := (x37 + x91)
5501 x93 := (x36 + x92)
5502 x94 := (x35 + x93)
5503 x95 := (x33 + uint64(x34))
5504 x96 := (x32 + x95)
5505 x97 := (x31 + x96)
5506 x98 := (x30 + x97)
5507 x99 := (x29 + x98)
5508 x100 := (x28 + x99)
5509 x101 := (x27 + x100)
5510 x102 := (x25 + uint64(x26))
5511 x103 := (x24 + x102)
5512 x104 := (x23 + x103)
5513 x105 := (x22 + x104)
5514 x106 := (x21 + x105)
5515 x107 := (x20 + x106)
5516 x108 := (x19 + x107)
5517 x109 := (x17 + uint64(x18))
5518 x110 := (x16 + x109)
5519 x111 := (x15 + x110)
5520 x112 := (x14 + x111)
5521 x113 := (x13 + x112)
5522 x114 := (x12 + x113)
5523 x115 := (x11 + x114)
5524 x116 := (x9 + uint64(x10))
5525 x117 := (x8 + x116)
5526 x118 := (x7 + x117)
5527 x119 := (x6 + x118)
5528 x120 := (x5 + x119)
5529 x121 := (x4 + x120)
5530 x122 := (x3 + x121)
5531 x123 := (x1 + uint64(x2))
5532 out1[0] = x73
5533 out1[1] = x80
5534 out1[2] = x87
5535 out1[3] = x94
5536 out1[4] = x101
5537 out1[5] = x108
5538 out1[6] = x115
5539 out1[7] = x122
5540 out1[8] = x123
5541 }
5542