Source file src/crypto/internal/nistec/fiat/p521_fiat64.go

Documentation: crypto/internal/nistec/fiat

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

View as plain text