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