Source file src/crypto/internal/nistec/fiat/p384_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 p384 64 '2^384 - 2^128 - 2^96 + 2^32 - 1' mul square add sub one from_montgomery to_montgomery selectznz to_bytes from_bytes
     4  //
     5  // curve description: p384
     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 = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff (from "2^384 - 2^128 - 2^96 + 2^32 - 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)
    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)
    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) in
    36  //
    37  //                            if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384
    38  
    39  package fiat
    40  
    41  import "math/bits"
    42  
    43  type p384Uint1 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 p384Int1 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 p384MontgomeryDomainFieldElement is a field element in the Montgomery domain.
    47  //
    48  // Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
    49  type p384MontgomeryDomainFieldElement [6]uint64
    50  
    51  // The type p384NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain.
    52  //
    53  // Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
    54  type p384NonMontgomeryDomainFieldElement [6]uint64
    55  
    56  // p384CmovznzU64 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 p384CmovznzU64(out1 *uint64, arg1 p384Uint1, arg2 uint64, arg3 uint64) {
    72  	x1 := (uint64(arg1) * 0xffffffffffffffff)
    73  	x2 := ((x1 & arg3) | ((^x1) & arg2))
    74  	*out1 = x2
    75  }
    76  
    77  // p384Mul 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 p384Mul(out1 *p384MontgomeryDomainFieldElement, arg1 *p384MontgomeryDomainFieldElement, arg2 *p384MontgomeryDomainFieldElement) {
    89  	x1 := arg1[1]
    90  	x2 := arg1[2]
    91  	x3 := arg1[3]
    92  	x4 := arg1[4]
    93  	x5 := arg1[5]
    94  	x6 := arg1[0]
    95  	var x7 uint64
    96  	var x8 uint64
    97  	x8, x7 = bits.Mul64(x6, arg2[5])
    98  	var x9 uint64
    99  	var x10 uint64
   100  	x10, x9 = bits.Mul64(x6, arg2[4])
   101  	var x11 uint64
   102  	var x12 uint64
   103  	x12, x11 = bits.Mul64(x6, arg2[3])
   104  	var x13 uint64
   105  	var x14 uint64
   106  	x14, x13 = bits.Mul64(x6, arg2[2])
   107  	var x15 uint64
   108  	var x16 uint64
   109  	x16, x15 = bits.Mul64(x6, arg2[1])
   110  	var x17 uint64
   111  	var x18 uint64
   112  	x18, x17 = bits.Mul64(x6, arg2[0])
   113  	var x19 uint64
   114  	var x20 uint64
   115  	x19, x20 = bits.Add64(x18, x15, uint64(0x0))
   116  	var x21 uint64
   117  	var x22 uint64
   118  	x21, x22 = bits.Add64(x16, x13, uint64(p384Uint1(x20)))
   119  	var x23 uint64
   120  	var x24 uint64
   121  	x23, x24 = bits.Add64(x14, x11, uint64(p384Uint1(x22)))
   122  	var x25 uint64
   123  	var x26 uint64
   124  	x25, x26 = bits.Add64(x12, x9, uint64(p384Uint1(x24)))
   125  	var x27 uint64
   126  	var x28 uint64
   127  	x27, x28 = bits.Add64(x10, x7, uint64(p384Uint1(x26)))
   128  	x29 := (uint64(p384Uint1(x28)) + x8)
   129  	var x30 uint64
   130  	_, x30 = bits.Mul64(x17, 0x100000001)
   131  	var x32 uint64
   132  	var x33 uint64
   133  	x33, x32 = bits.Mul64(x30, 0xffffffffffffffff)
   134  	var x34 uint64
   135  	var x35 uint64
   136  	x35, x34 = bits.Mul64(x30, 0xffffffffffffffff)
   137  	var x36 uint64
   138  	var x37 uint64
   139  	x37, x36 = bits.Mul64(x30, 0xffffffffffffffff)
   140  	var x38 uint64
   141  	var x39 uint64
   142  	x39, x38 = bits.Mul64(x30, 0xfffffffffffffffe)
   143  	var x40 uint64
   144  	var x41 uint64
   145  	x41, x40 = bits.Mul64(x30, 0xffffffff00000000)
   146  	var x42 uint64
   147  	var x43 uint64
   148  	x43, x42 = bits.Mul64(x30, 0xffffffff)
   149  	var x44 uint64
   150  	var x45 uint64
   151  	x44, x45 = bits.Add64(x43, x40, uint64(0x0))
   152  	var x46 uint64
   153  	var x47 uint64
   154  	x46, x47 = bits.Add64(x41, x38, uint64(p384Uint1(x45)))
   155  	var x48 uint64
   156  	var x49 uint64
   157  	x48, x49 = bits.Add64(x39, x36, uint64(p384Uint1(x47)))
   158  	var x50 uint64
   159  	var x51 uint64
   160  	x50, x51 = bits.Add64(x37, x34, uint64(p384Uint1(x49)))
   161  	var x52 uint64
   162  	var x53 uint64
   163  	x52, x53 = bits.Add64(x35, x32, uint64(p384Uint1(x51)))
   164  	x54 := (uint64(p384Uint1(x53)) + x33)
   165  	var x56 uint64
   166  	_, x56 = bits.Add64(x17, x42, uint64(0x0))
   167  	var x57 uint64
   168  	var x58 uint64
   169  	x57, x58 = bits.Add64(x19, x44, uint64(p384Uint1(x56)))
   170  	var x59 uint64
   171  	var x60 uint64
   172  	x59, x60 = bits.Add64(x21, x46, uint64(p384Uint1(x58)))
   173  	var x61 uint64
   174  	var x62 uint64
   175  	x61, x62 = bits.Add64(x23, x48, uint64(p384Uint1(x60)))
   176  	var x63 uint64
   177  	var x64 uint64
   178  	x63, x64 = bits.Add64(x25, x50, uint64(p384Uint1(x62)))
   179  	var x65 uint64
   180  	var x66 uint64
   181  	x65, x66 = bits.Add64(x27, x52, uint64(p384Uint1(x64)))
   182  	var x67 uint64
   183  	var x68 uint64
   184  	x67, x68 = bits.Add64(x29, x54, uint64(p384Uint1(x66)))
   185  	var x69 uint64
   186  	var x70 uint64
   187  	x70, x69 = bits.Mul64(x1, arg2[5])
   188  	var x71 uint64
   189  	var x72 uint64
   190  	x72, x71 = bits.Mul64(x1, arg2[4])
   191  	var x73 uint64
   192  	var x74 uint64
   193  	x74, x73 = bits.Mul64(x1, arg2[3])
   194  	var x75 uint64
   195  	var x76 uint64
   196  	x76, x75 = bits.Mul64(x1, arg2[2])
   197  	var x77 uint64
   198  	var x78 uint64
   199  	x78, x77 = bits.Mul64(x1, arg2[1])
   200  	var x79 uint64
   201  	var x80 uint64
   202  	x80, x79 = bits.Mul64(x1, arg2[0])
   203  	var x81 uint64
   204  	var x82 uint64
   205  	x81, x82 = bits.Add64(x80, x77, uint64(0x0))
   206  	var x83 uint64
   207  	var x84 uint64
   208  	x83, x84 = bits.Add64(x78, x75, uint64(p384Uint1(x82)))
   209  	var x85 uint64
   210  	var x86 uint64
   211  	x85, x86 = bits.Add64(x76, x73, uint64(p384Uint1(x84)))
   212  	var x87 uint64
   213  	var x88 uint64
   214  	x87, x88 = bits.Add64(x74, x71, uint64(p384Uint1(x86)))
   215  	var x89 uint64
   216  	var x90 uint64
   217  	x89, x90 = bits.Add64(x72, x69, uint64(p384Uint1(x88)))
   218  	x91 := (uint64(p384Uint1(x90)) + x70)
   219  	var x92 uint64
   220  	var x93 uint64
   221  	x92, x93 = bits.Add64(x57, x79, uint64(0x0))
   222  	var x94 uint64
   223  	var x95 uint64
   224  	x94, x95 = bits.Add64(x59, x81, uint64(p384Uint1(x93)))
   225  	var x96 uint64
   226  	var x97 uint64
   227  	x96, x97 = bits.Add64(x61, x83, uint64(p384Uint1(x95)))
   228  	var x98 uint64
   229  	var x99 uint64
   230  	x98, x99 = bits.Add64(x63, x85, uint64(p384Uint1(x97)))
   231  	var x100 uint64
   232  	var x101 uint64
   233  	x100, x101 = bits.Add64(x65, x87, uint64(p384Uint1(x99)))
   234  	var x102 uint64
   235  	var x103 uint64
   236  	x102, x103 = bits.Add64(x67, x89, uint64(p384Uint1(x101)))
   237  	var x104 uint64
   238  	var x105 uint64
   239  	x104, x105 = bits.Add64(uint64(p384Uint1(x68)), x91, uint64(p384Uint1(x103)))
   240  	var x106 uint64
   241  	_, x106 = bits.Mul64(x92, 0x100000001)
   242  	var x108 uint64
   243  	var x109 uint64
   244  	x109, x108 = bits.Mul64(x106, 0xffffffffffffffff)
   245  	var x110 uint64
   246  	var x111 uint64
   247  	x111, x110 = bits.Mul64(x106, 0xffffffffffffffff)
   248  	var x112 uint64
   249  	var x113 uint64
   250  	x113, x112 = bits.Mul64(x106, 0xffffffffffffffff)
   251  	var x114 uint64
   252  	var x115 uint64
   253  	x115, x114 = bits.Mul64(x106, 0xfffffffffffffffe)
   254  	var x116 uint64
   255  	var x117 uint64
   256  	x117, x116 = bits.Mul64(x106, 0xffffffff00000000)
   257  	var x118 uint64
   258  	var x119 uint64
   259  	x119, x118 = bits.Mul64(x106, 0xffffffff)
   260  	var x120 uint64
   261  	var x121 uint64
   262  	x120, x121 = bits.Add64(x119, x116, uint64(0x0))
   263  	var x122 uint64
   264  	var x123 uint64
   265  	x122, x123 = bits.Add64(x117, x114, uint64(p384Uint1(x121)))
   266  	var x124 uint64
   267  	var x125 uint64
   268  	x124, x125 = bits.Add64(x115, x112, uint64(p384Uint1(x123)))
   269  	var x126 uint64
   270  	var x127 uint64
   271  	x126, x127 = bits.Add64(x113, x110, uint64(p384Uint1(x125)))
   272  	var x128 uint64
   273  	var x129 uint64
   274  	x128, x129 = bits.Add64(x111, x108, uint64(p384Uint1(x127)))
   275  	x130 := (uint64(p384Uint1(x129)) + x109)
   276  	var x132 uint64
   277  	_, x132 = bits.Add64(x92, x118, uint64(0x0))
   278  	var x133 uint64
   279  	var x134 uint64
   280  	x133, x134 = bits.Add64(x94, x120, uint64(p384Uint1(x132)))
   281  	var x135 uint64
   282  	var x136 uint64
   283  	x135, x136 = bits.Add64(x96, x122, uint64(p384Uint1(x134)))
   284  	var x137 uint64
   285  	var x138 uint64
   286  	x137, x138 = bits.Add64(x98, x124, uint64(p384Uint1(x136)))
   287  	var x139 uint64
   288  	var x140 uint64
   289  	x139, x140 = bits.Add64(x100, x126, uint64(p384Uint1(x138)))
   290  	var x141 uint64
   291  	var x142 uint64
   292  	x141, x142 = bits.Add64(x102, x128, uint64(p384Uint1(x140)))
   293  	var x143 uint64
   294  	var x144 uint64
   295  	x143, x144 = bits.Add64(x104, x130, uint64(p384Uint1(x142)))
   296  	x145 := (uint64(p384Uint1(x144)) + uint64(p384Uint1(x105)))
   297  	var x146 uint64
   298  	var x147 uint64
   299  	x147, x146 = bits.Mul64(x2, arg2[5])
   300  	var x148 uint64
   301  	var x149 uint64
   302  	x149, x148 = bits.Mul64(x2, arg2[4])
   303  	var x150 uint64
   304  	var x151 uint64
   305  	x151, x150 = bits.Mul64(x2, arg2[3])
   306  	var x152 uint64
   307  	var x153 uint64
   308  	x153, x152 = bits.Mul64(x2, arg2[2])
   309  	var x154 uint64
   310  	var x155 uint64
   311  	x155, x154 = bits.Mul64(x2, arg2[1])
   312  	var x156 uint64
   313  	var x157 uint64
   314  	x157, x156 = bits.Mul64(x2, arg2[0])
   315  	var x158 uint64
   316  	var x159 uint64
   317  	x158, x159 = bits.Add64(x157, x154, uint64(0x0))
   318  	var x160 uint64
   319  	var x161 uint64
   320  	x160, x161 = bits.Add64(x155, x152, uint64(p384Uint1(x159)))
   321  	var x162 uint64
   322  	var x163 uint64
   323  	x162, x163 = bits.Add64(x153, x150, uint64(p384Uint1(x161)))
   324  	var x164 uint64
   325  	var x165 uint64
   326  	x164, x165 = bits.Add64(x151, x148, uint64(p384Uint1(x163)))
   327  	var x166 uint64
   328  	var x167 uint64
   329  	x166, x167 = bits.Add64(x149, x146, uint64(p384Uint1(x165)))
   330  	x168 := (uint64(p384Uint1(x167)) + x147)
   331  	var x169 uint64
   332  	var x170 uint64
   333  	x169, x170 = bits.Add64(x133, x156, uint64(0x0))
   334  	var x171 uint64
   335  	var x172 uint64
   336  	x171, x172 = bits.Add64(x135, x158, uint64(p384Uint1(x170)))
   337  	var x173 uint64
   338  	var x174 uint64
   339  	x173, x174 = bits.Add64(x137, x160, uint64(p384Uint1(x172)))
   340  	var x175 uint64
   341  	var x176 uint64
   342  	x175, x176 = bits.Add64(x139, x162, uint64(p384Uint1(x174)))
   343  	var x177 uint64
   344  	var x178 uint64
   345  	x177, x178 = bits.Add64(x141, x164, uint64(p384Uint1(x176)))
   346  	var x179 uint64
   347  	var x180 uint64
   348  	x179, x180 = bits.Add64(x143, x166, uint64(p384Uint1(x178)))
   349  	var x181 uint64
   350  	var x182 uint64
   351  	x181, x182 = bits.Add64(x145, x168, uint64(p384Uint1(x180)))
   352  	var x183 uint64
   353  	_, x183 = bits.Mul64(x169, 0x100000001)
   354  	var x185 uint64
   355  	var x186 uint64
   356  	x186, x185 = bits.Mul64(x183, 0xffffffffffffffff)
   357  	var x187 uint64
   358  	var x188 uint64
   359  	x188, x187 = bits.Mul64(x183, 0xffffffffffffffff)
   360  	var x189 uint64
   361  	var x190 uint64
   362  	x190, x189 = bits.Mul64(x183, 0xffffffffffffffff)
   363  	var x191 uint64
   364  	var x192 uint64
   365  	x192, x191 = bits.Mul64(x183, 0xfffffffffffffffe)
   366  	var x193 uint64
   367  	var x194 uint64
   368  	x194, x193 = bits.Mul64(x183, 0xffffffff00000000)
   369  	var x195 uint64
   370  	var x196 uint64
   371  	x196, x195 = bits.Mul64(x183, 0xffffffff)
   372  	var x197 uint64
   373  	var x198 uint64
   374  	x197, x198 = bits.Add64(x196, x193, uint64(0x0))
   375  	var x199 uint64
   376  	var x200 uint64
   377  	x199, x200 = bits.Add64(x194, x191, uint64(p384Uint1(x198)))
   378  	var x201 uint64
   379  	var x202 uint64
   380  	x201, x202 = bits.Add64(x192, x189, uint64(p384Uint1(x200)))
   381  	var x203 uint64
   382  	var x204 uint64
   383  	x203, x204 = bits.Add64(x190, x187, uint64(p384Uint1(x202)))
   384  	var x205 uint64
   385  	var x206 uint64
   386  	x205, x206 = bits.Add64(x188, x185, uint64(p384Uint1(x204)))
   387  	x207 := (uint64(p384Uint1(x206)) + x186)
   388  	var x209 uint64
   389  	_, x209 = bits.Add64(x169, x195, uint64(0x0))
   390  	var x210 uint64
   391  	var x211 uint64
   392  	x210, x211 = bits.Add64(x171, x197, uint64(p384Uint1(x209)))
   393  	var x212 uint64
   394  	var x213 uint64
   395  	x212, x213 = bits.Add64(x173, x199, uint64(p384Uint1(x211)))
   396  	var x214 uint64
   397  	var x215 uint64
   398  	x214, x215 = bits.Add64(x175, x201, uint64(p384Uint1(x213)))
   399  	var x216 uint64
   400  	var x217 uint64
   401  	x216, x217 = bits.Add64(x177, x203, uint64(p384Uint1(x215)))
   402  	var x218 uint64
   403  	var x219 uint64
   404  	x218, x219 = bits.Add64(x179, x205, uint64(p384Uint1(x217)))
   405  	var x220 uint64
   406  	var x221 uint64
   407  	x220, x221 = bits.Add64(x181, x207, uint64(p384Uint1(x219)))
   408  	x222 := (uint64(p384Uint1(x221)) + uint64(p384Uint1(x182)))
   409  	var x223 uint64
   410  	var x224 uint64
   411  	x224, x223 = bits.Mul64(x3, arg2[5])
   412  	var x225 uint64
   413  	var x226 uint64
   414  	x226, x225 = bits.Mul64(x3, arg2[4])
   415  	var x227 uint64
   416  	var x228 uint64
   417  	x228, x227 = bits.Mul64(x3, arg2[3])
   418  	var x229 uint64
   419  	var x230 uint64
   420  	x230, x229 = bits.Mul64(x3, arg2[2])
   421  	var x231 uint64
   422  	var x232 uint64
   423  	x232, x231 = bits.Mul64(x3, arg2[1])
   424  	var x233 uint64
   425  	var x234 uint64
   426  	x234, x233 = bits.Mul64(x3, arg2[0])
   427  	var x235 uint64
   428  	var x236 uint64
   429  	x235, x236 = bits.Add64(x234, x231, uint64(0x0))
   430  	var x237 uint64
   431  	var x238 uint64
   432  	x237, x238 = bits.Add64(x232, x229, uint64(p384Uint1(x236)))
   433  	var x239 uint64
   434  	var x240 uint64
   435  	x239, x240 = bits.Add64(x230, x227, uint64(p384Uint1(x238)))
   436  	var x241 uint64
   437  	var x242 uint64
   438  	x241, x242 = bits.Add64(x228, x225, uint64(p384Uint1(x240)))
   439  	var x243 uint64
   440  	var x244 uint64
   441  	x243, x244 = bits.Add64(x226, x223, uint64(p384Uint1(x242)))
   442  	x245 := (uint64(p384Uint1(x244)) + x224)
   443  	var x246 uint64
   444  	var x247 uint64
   445  	x246, x247 = bits.Add64(x210, x233, uint64(0x0))
   446  	var x248 uint64
   447  	var x249 uint64
   448  	x248, x249 = bits.Add64(x212, x235, uint64(p384Uint1(x247)))
   449  	var x250 uint64
   450  	var x251 uint64
   451  	x250, x251 = bits.Add64(x214, x237, uint64(p384Uint1(x249)))
   452  	var x252 uint64
   453  	var x253 uint64
   454  	x252, x253 = bits.Add64(x216, x239, uint64(p384Uint1(x251)))
   455  	var x254 uint64
   456  	var x255 uint64
   457  	x254, x255 = bits.Add64(x218, x241, uint64(p384Uint1(x253)))
   458  	var x256 uint64
   459  	var x257 uint64
   460  	x256, x257 = bits.Add64(x220, x243, uint64(p384Uint1(x255)))
   461  	var x258 uint64
   462  	var x259 uint64
   463  	x258, x259 = bits.Add64(x222, x245, uint64(p384Uint1(x257)))
   464  	var x260 uint64
   465  	_, x260 = bits.Mul64(x246, 0x100000001)
   466  	var x262 uint64
   467  	var x263 uint64
   468  	x263, x262 = bits.Mul64(x260, 0xffffffffffffffff)
   469  	var x264 uint64
   470  	var x265 uint64
   471  	x265, x264 = bits.Mul64(x260, 0xffffffffffffffff)
   472  	var x266 uint64
   473  	var x267 uint64
   474  	x267, x266 = bits.Mul64(x260, 0xffffffffffffffff)
   475  	var x268 uint64
   476  	var x269 uint64
   477  	x269, x268 = bits.Mul64(x260, 0xfffffffffffffffe)
   478  	var x270 uint64
   479  	var x271 uint64
   480  	x271, x270 = bits.Mul64(x260, 0xffffffff00000000)
   481  	var x272 uint64
   482  	var x273 uint64
   483  	x273, x272 = bits.Mul64(x260, 0xffffffff)
   484  	var x274 uint64
   485  	var x275 uint64
   486  	x274, x275 = bits.Add64(x273, x270, uint64(0x0))
   487  	var x276 uint64
   488  	var x277 uint64
   489  	x276, x277 = bits.Add64(x271, x268, uint64(p384Uint1(x275)))
   490  	var x278 uint64
   491  	var x279 uint64
   492  	x278, x279 = bits.Add64(x269, x266, uint64(p384Uint1(x277)))
   493  	var x280 uint64
   494  	var x281 uint64
   495  	x280, x281 = bits.Add64(x267, x264, uint64(p384Uint1(x279)))
   496  	var x282 uint64
   497  	var x283 uint64
   498  	x282, x283 = bits.Add64(x265, x262, uint64(p384Uint1(x281)))
   499  	x284 := (uint64(p384Uint1(x283)) + x263)
   500  	var x286 uint64
   501  	_, x286 = bits.Add64(x246, x272, uint64(0x0))
   502  	var x287 uint64
   503  	var x288 uint64
   504  	x287, x288 = bits.Add64(x248, x274, uint64(p384Uint1(x286)))
   505  	var x289 uint64
   506  	var x290 uint64
   507  	x289, x290 = bits.Add64(x250, x276, uint64(p384Uint1(x288)))
   508  	var x291 uint64
   509  	var x292 uint64
   510  	x291, x292 = bits.Add64(x252, x278, uint64(p384Uint1(x290)))
   511  	var x293 uint64
   512  	var x294 uint64
   513  	x293, x294 = bits.Add64(x254, x280, uint64(p384Uint1(x292)))
   514  	var x295 uint64
   515  	var x296 uint64
   516  	x295, x296 = bits.Add64(x256, x282, uint64(p384Uint1(x294)))
   517  	var x297 uint64
   518  	var x298 uint64
   519  	x297, x298 = bits.Add64(x258, x284, uint64(p384Uint1(x296)))
   520  	x299 := (uint64(p384Uint1(x298)) + uint64(p384Uint1(x259)))
   521  	var x300 uint64
   522  	var x301 uint64
   523  	x301, x300 = bits.Mul64(x4, arg2[5])
   524  	var x302 uint64
   525  	var x303 uint64
   526  	x303, x302 = bits.Mul64(x4, arg2[4])
   527  	var x304 uint64
   528  	var x305 uint64
   529  	x305, x304 = bits.Mul64(x4, arg2[3])
   530  	var x306 uint64
   531  	var x307 uint64
   532  	x307, x306 = bits.Mul64(x4, arg2[2])
   533  	var x308 uint64
   534  	var x309 uint64
   535  	x309, x308 = bits.Mul64(x4, arg2[1])
   536  	var x310 uint64
   537  	var x311 uint64
   538  	x311, x310 = bits.Mul64(x4, arg2[0])
   539  	var x312 uint64
   540  	var x313 uint64
   541  	x312, x313 = bits.Add64(x311, x308, uint64(0x0))
   542  	var x314 uint64
   543  	var x315 uint64
   544  	x314, x315 = bits.Add64(x309, x306, uint64(p384Uint1(x313)))
   545  	var x316 uint64
   546  	var x317 uint64
   547  	x316, x317 = bits.Add64(x307, x304, uint64(p384Uint1(x315)))
   548  	var x318 uint64
   549  	var x319 uint64
   550  	x318, x319 = bits.Add64(x305, x302, uint64(p384Uint1(x317)))
   551  	var x320 uint64
   552  	var x321 uint64
   553  	x320, x321 = bits.Add64(x303, x300, uint64(p384Uint1(x319)))
   554  	x322 := (uint64(p384Uint1(x321)) + x301)
   555  	var x323 uint64
   556  	var x324 uint64
   557  	x323, x324 = bits.Add64(x287, x310, uint64(0x0))
   558  	var x325 uint64
   559  	var x326 uint64
   560  	x325, x326 = bits.Add64(x289, x312, uint64(p384Uint1(x324)))
   561  	var x327 uint64
   562  	var x328 uint64
   563  	x327, x328 = bits.Add64(x291, x314, uint64(p384Uint1(x326)))
   564  	var x329 uint64
   565  	var x330 uint64
   566  	x329, x330 = bits.Add64(x293, x316, uint64(p384Uint1(x328)))
   567  	var x331 uint64
   568  	var x332 uint64
   569  	x331, x332 = bits.Add64(x295, x318, uint64(p384Uint1(x330)))
   570  	var x333 uint64
   571  	var x334 uint64
   572  	x333, x334 = bits.Add64(x297, x320, uint64(p384Uint1(x332)))
   573  	var x335 uint64
   574  	var x336 uint64
   575  	x335, x336 = bits.Add64(x299, x322, uint64(p384Uint1(x334)))
   576  	var x337 uint64
   577  	_, x337 = bits.Mul64(x323, 0x100000001)
   578  	var x339 uint64
   579  	var x340 uint64
   580  	x340, x339 = bits.Mul64(x337, 0xffffffffffffffff)
   581  	var x341 uint64
   582  	var x342 uint64
   583  	x342, x341 = bits.Mul64(x337, 0xffffffffffffffff)
   584  	var x343 uint64
   585  	var x344 uint64
   586  	x344, x343 = bits.Mul64(x337, 0xffffffffffffffff)
   587  	var x345 uint64
   588  	var x346 uint64
   589  	x346, x345 = bits.Mul64(x337, 0xfffffffffffffffe)
   590  	var x347 uint64
   591  	var x348 uint64
   592  	x348, x347 = bits.Mul64(x337, 0xffffffff00000000)
   593  	var x349 uint64
   594  	var x350 uint64
   595  	x350, x349 = bits.Mul64(x337, 0xffffffff)
   596  	var x351 uint64
   597  	var x352 uint64
   598  	x351, x352 = bits.Add64(x350, x347, uint64(0x0))
   599  	var x353 uint64
   600  	var x354 uint64
   601  	x353, x354 = bits.Add64(x348, x345, uint64(p384Uint1(x352)))
   602  	var x355 uint64
   603  	var x356 uint64
   604  	x355, x356 = bits.Add64(x346, x343, uint64(p384Uint1(x354)))
   605  	var x357 uint64
   606  	var x358 uint64
   607  	x357, x358 = bits.Add64(x344, x341, uint64(p384Uint1(x356)))
   608  	var x359 uint64
   609  	var x360 uint64
   610  	x359, x360 = bits.Add64(x342, x339, uint64(p384Uint1(x358)))
   611  	x361 := (uint64(p384Uint1(x360)) + x340)
   612  	var x363 uint64
   613  	_, x363 = bits.Add64(x323, x349, uint64(0x0))
   614  	var x364 uint64
   615  	var x365 uint64
   616  	x364, x365 = bits.Add64(x325, x351, uint64(p384Uint1(x363)))
   617  	var x366 uint64
   618  	var x367 uint64
   619  	x366, x367 = bits.Add64(x327, x353, uint64(p384Uint1(x365)))
   620  	var x368 uint64
   621  	var x369 uint64
   622  	x368, x369 = bits.Add64(x329, x355, uint64(p384Uint1(x367)))
   623  	var x370 uint64
   624  	var x371 uint64
   625  	x370, x371 = bits.Add64(x331, x357, uint64(p384Uint1(x369)))
   626  	var x372 uint64
   627  	var x373 uint64
   628  	x372, x373 = bits.Add64(x333, x359, uint64(p384Uint1(x371)))
   629  	var x374 uint64
   630  	var x375 uint64
   631  	x374, x375 = bits.Add64(x335, x361, uint64(p384Uint1(x373)))
   632  	x376 := (uint64(p384Uint1(x375)) + uint64(p384Uint1(x336)))
   633  	var x377 uint64
   634  	var x378 uint64
   635  	x378, x377 = bits.Mul64(x5, arg2[5])
   636  	var x379 uint64
   637  	var x380 uint64
   638  	x380, x379 = bits.Mul64(x5, arg2[4])
   639  	var x381 uint64
   640  	var x382 uint64
   641  	x382, x381 = bits.Mul64(x5, arg2[3])
   642  	var x383 uint64
   643  	var x384 uint64
   644  	x384, x383 = bits.Mul64(x5, arg2[2])
   645  	var x385 uint64
   646  	var x386 uint64
   647  	x386, x385 = bits.Mul64(x5, arg2[1])
   648  	var x387 uint64
   649  	var x388 uint64
   650  	x388, x387 = bits.Mul64(x5, arg2[0])
   651  	var x389 uint64
   652  	var x390 uint64
   653  	x389, x390 = bits.Add64(x388, x385, uint64(0x0))
   654  	var x391 uint64
   655  	var x392 uint64
   656  	x391, x392 = bits.Add64(x386, x383, uint64(p384Uint1(x390)))
   657  	var x393 uint64
   658  	var x394 uint64
   659  	x393, x394 = bits.Add64(x384, x381, uint64(p384Uint1(x392)))
   660  	var x395 uint64
   661  	var x396 uint64
   662  	x395, x396 = bits.Add64(x382, x379, uint64(p384Uint1(x394)))
   663  	var x397 uint64
   664  	var x398 uint64
   665  	x397, x398 = bits.Add64(x380, x377, uint64(p384Uint1(x396)))
   666  	x399 := (uint64(p384Uint1(x398)) + x378)
   667  	var x400 uint64
   668  	var x401 uint64
   669  	x400, x401 = bits.Add64(x364, x387, uint64(0x0))
   670  	var x402 uint64
   671  	var x403 uint64
   672  	x402, x403 = bits.Add64(x366, x389, uint64(p384Uint1(x401)))
   673  	var x404 uint64
   674  	var x405 uint64
   675  	x404, x405 = bits.Add64(x368, x391, uint64(p384Uint1(x403)))
   676  	var x406 uint64
   677  	var x407 uint64
   678  	x406, x407 = bits.Add64(x370, x393, uint64(p384Uint1(x405)))
   679  	var x408 uint64
   680  	var x409 uint64
   681  	x408, x409 = bits.Add64(x372, x395, uint64(p384Uint1(x407)))
   682  	var x410 uint64
   683  	var x411 uint64
   684  	x410, x411 = bits.Add64(x374, x397, uint64(p384Uint1(x409)))
   685  	var x412 uint64
   686  	var x413 uint64
   687  	x412, x413 = bits.Add64(x376, x399, uint64(p384Uint1(x411)))
   688  	var x414 uint64
   689  	_, x414 = bits.Mul64(x400, 0x100000001)
   690  	var x416 uint64
   691  	var x417 uint64
   692  	x417, x416 = bits.Mul64(x414, 0xffffffffffffffff)
   693  	var x418 uint64
   694  	var x419 uint64
   695  	x419, x418 = bits.Mul64(x414, 0xffffffffffffffff)
   696  	var x420 uint64
   697  	var x421 uint64
   698  	x421, x420 = bits.Mul64(x414, 0xffffffffffffffff)
   699  	var x422 uint64
   700  	var x423 uint64
   701  	x423, x422 = bits.Mul64(x414, 0xfffffffffffffffe)
   702  	var x424 uint64
   703  	var x425 uint64
   704  	x425, x424 = bits.Mul64(x414, 0xffffffff00000000)
   705  	var x426 uint64
   706  	var x427 uint64
   707  	x427, x426 = bits.Mul64(x414, 0xffffffff)
   708  	var x428 uint64
   709  	var x429 uint64
   710  	x428, x429 = bits.Add64(x427, x424, uint64(0x0))
   711  	var x430 uint64
   712  	var x431 uint64
   713  	x430, x431 = bits.Add64(x425, x422, uint64(p384Uint1(x429)))
   714  	var x432 uint64
   715  	var x433 uint64
   716  	x432, x433 = bits.Add64(x423, x420, uint64(p384Uint1(x431)))
   717  	var x434 uint64
   718  	var x435 uint64
   719  	x434, x435 = bits.Add64(x421, x418, uint64(p384Uint1(x433)))
   720  	var x436 uint64
   721  	var x437 uint64
   722  	x436, x437 = bits.Add64(x419, x416, uint64(p384Uint1(x435)))
   723  	x438 := (uint64(p384Uint1(x437)) + x417)
   724  	var x440 uint64
   725  	_, x440 = bits.Add64(x400, x426, uint64(0x0))
   726  	var x441 uint64
   727  	var x442 uint64
   728  	x441, x442 = bits.Add64(x402, x428, uint64(p384Uint1(x440)))
   729  	var x443 uint64
   730  	var x444 uint64
   731  	x443, x444 = bits.Add64(x404, x430, uint64(p384Uint1(x442)))
   732  	var x445 uint64
   733  	var x446 uint64
   734  	x445, x446 = bits.Add64(x406, x432, uint64(p384Uint1(x444)))
   735  	var x447 uint64
   736  	var x448 uint64
   737  	x447, x448 = bits.Add64(x408, x434, uint64(p384Uint1(x446)))
   738  	var x449 uint64
   739  	var x450 uint64
   740  	x449, x450 = bits.Add64(x410, x436, uint64(p384Uint1(x448)))
   741  	var x451 uint64
   742  	var x452 uint64
   743  	x451, x452 = bits.Add64(x412, x438, uint64(p384Uint1(x450)))
   744  	x453 := (uint64(p384Uint1(x452)) + uint64(p384Uint1(x413)))
   745  	var x454 uint64
   746  	var x455 uint64
   747  	x454, x455 = bits.Sub64(x441, 0xffffffff, uint64(0x0))
   748  	var x456 uint64
   749  	var x457 uint64
   750  	x456, x457 = bits.Sub64(x443, 0xffffffff00000000, uint64(p384Uint1(x455)))
   751  	var x458 uint64
   752  	var x459 uint64
   753  	x458, x459 = bits.Sub64(x445, 0xfffffffffffffffe, uint64(p384Uint1(x457)))
   754  	var x460 uint64
   755  	var x461 uint64
   756  	x460, x461 = bits.Sub64(x447, 0xffffffffffffffff, uint64(p384Uint1(x459)))
   757  	var x462 uint64
   758  	var x463 uint64
   759  	x462, x463 = bits.Sub64(x449, 0xffffffffffffffff, uint64(p384Uint1(x461)))
   760  	var x464 uint64
   761  	var x465 uint64
   762  	x464, x465 = bits.Sub64(x451, 0xffffffffffffffff, uint64(p384Uint1(x463)))
   763  	var x467 uint64
   764  	_, x467 = bits.Sub64(x453, uint64(0x0), uint64(p384Uint1(x465)))
   765  	var x468 uint64
   766  	p384CmovznzU64(&x468, p384Uint1(x467), x454, x441)
   767  	var x469 uint64
   768  	p384CmovznzU64(&x469, p384Uint1(x467), x456, x443)
   769  	var x470 uint64
   770  	p384CmovznzU64(&x470, p384Uint1(x467), x458, x445)
   771  	var x471 uint64
   772  	p384CmovznzU64(&x471, p384Uint1(x467), x460, x447)
   773  	var x472 uint64
   774  	p384CmovznzU64(&x472, p384Uint1(x467), x462, x449)
   775  	var x473 uint64
   776  	p384CmovznzU64(&x473, p384Uint1(x467), x464, x451)
   777  	out1[0] = x468
   778  	out1[1] = x469
   779  	out1[2] = x470
   780  	out1[3] = x471
   781  	out1[4] = x472
   782  	out1[5] = x473
   783  }
   784  
   785  // p384Square squares a field element in the Montgomery domain.
   786  //
   787  // Preconditions:
   788  //
   789  //	0 ≤ eval arg1 < m
   790  //
   791  // Postconditions:
   792  //
   793  //	eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m
   794  //	0 ≤ eval out1 < m
   795  func p384Square(out1 *p384MontgomeryDomainFieldElement, arg1 *p384MontgomeryDomainFieldElement) {
   796  	x1 := arg1[1]
   797  	x2 := arg1[2]
   798  	x3 := arg1[3]
   799  	x4 := arg1[4]
   800  	x5 := arg1[5]
   801  	x6 := arg1[0]
   802  	var x7 uint64
   803  	var x8 uint64
   804  	x8, x7 = bits.Mul64(x6, arg1[5])
   805  	var x9 uint64
   806  	var x10 uint64
   807  	x10, x9 = bits.Mul64(x6, arg1[4])
   808  	var x11 uint64
   809  	var x12 uint64
   810  	x12, x11 = bits.Mul64(x6, arg1[3])
   811  	var x13 uint64
   812  	var x14 uint64
   813  	x14, x13 = bits.Mul64(x6, arg1[2])
   814  	var x15 uint64
   815  	var x16 uint64
   816  	x16, x15 = bits.Mul64(x6, arg1[1])
   817  	var x17 uint64
   818  	var x18 uint64
   819  	x18, x17 = bits.Mul64(x6, arg1[0])
   820  	var x19 uint64
   821  	var x20 uint64
   822  	x19, x20 = bits.Add64(x18, x15, uint64(0x0))
   823  	var x21 uint64
   824  	var x22 uint64
   825  	x21, x22 = bits.Add64(x16, x13, uint64(p384Uint1(x20)))
   826  	var x23 uint64
   827  	var x24 uint64
   828  	x23, x24 = bits.Add64(x14, x11, uint64(p384Uint1(x22)))
   829  	var x25 uint64
   830  	var x26 uint64
   831  	x25, x26 = bits.Add64(x12, x9, uint64(p384Uint1(x24)))
   832  	var x27 uint64
   833  	var x28 uint64
   834  	x27, x28 = bits.Add64(x10, x7, uint64(p384Uint1(x26)))
   835  	x29 := (uint64(p384Uint1(x28)) + x8)
   836  	var x30 uint64
   837  	_, x30 = bits.Mul64(x17, 0x100000001)
   838  	var x32 uint64
   839  	var x33 uint64
   840  	x33, x32 = bits.Mul64(x30, 0xffffffffffffffff)
   841  	var x34 uint64
   842  	var x35 uint64
   843  	x35, x34 = bits.Mul64(x30, 0xffffffffffffffff)
   844  	var x36 uint64
   845  	var x37 uint64
   846  	x37, x36 = bits.Mul64(x30, 0xffffffffffffffff)
   847  	var x38 uint64
   848  	var x39 uint64
   849  	x39, x38 = bits.Mul64(x30, 0xfffffffffffffffe)
   850  	var x40 uint64
   851  	var x41 uint64
   852  	x41, x40 = bits.Mul64(x30, 0xffffffff00000000)
   853  	var x42 uint64
   854  	var x43 uint64
   855  	x43, x42 = bits.Mul64(x30, 0xffffffff)
   856  	var x44 uint64
   857  	var x45 uint64
   858  	x44, x45 = bits.Add64(x43, x40, uint64(0x0))
   859  	var x46 uint64
   860  	var x47 uint64
   861  	x46, x47 = bits.Add64(x41, x38, uint64(p384Uint1(x45)))
   862  	var x48 uint64
   863  	var x49 uint64
   864  	x48, x49 = bits.Add64(x39, x36, uint64(p384Uint1(x47)))
   865  	var x50 uint64
   866  	var x51 uint64
   867  	x50, x51 = bits.Add64(x37, x34, uint64(p384Uint1(x49)))
   868  	var x52 uint64
   869  	var x53 uint64
   870  	x52, x53 = bits.Add64(x35, x32, uint64(p384Uint1(x51)))
   871  	x54 := (uint64(p384Uint1(x53)) + x33)
   872  	var x56 uint64
   873  	_, x56 = bits.Add64(x17, x42, uint64(0x0))
   874  	var x57 uint64
   875  	var x58 uint64
   876  	x57, x58 = bits.Add64(x19, x44, uint64(p384Uint1(x56)))
   877  	var x59 uint64
   878  	var x60 uint64
   879  	x59, x60 = bits.Add64(x21, x46, uint64(p384Uint1(x58)))
   880  	var x61 uint64
   881  	var x62 uint64
   882  	x61, x62 = bits.Add64(x23, x48, uint64(p384Uint1(x60)))
   883  	var x63 uint64
   884  	var x64 uint64
   885  	x63, x64 = bits.Add64(x25, x50, uint64(p384Uint1(x62)))
   886  	var x65 uint64
   887  	var x66 uint64
   888  	x65, x66 = bits.Add64(x27, x52, uint64(p384Uint1(x64)))
   889  	var x67 uint64
   890  	var x68 uint64
   891  	x67, x68 = bits.Add64(x29, x54, uint64(p384Uint1(x66)))
   892  	var x69 uint64
   893  	var x70 uint64
   894  	x70, x69 = bits.Mul64(x1, arg1[5])
   895  	var x71 uint64
   896  	var x72 uint64
   897  	x72, x71 = bits.Mul64(x1, arg1[4])
   898  	var x73 uint64
   899  	var x74 uint64
   900  	x74, x73 = bits.Mul64(x1, arg1[3])
   901  	var x75 uint64
   902  	var x76 uint64
   903  	x76, x75 = bits.Mul64(x1, arg1[2])
   904  	var x77 uint64
   905  	var x78 uint64
   906  	x78, x77 = bits.Mul64(x1, arg1[1])
   907  	var x79 uint64
   908  	var x80 uint64
   909  	x80, x79 = bits.Mul64(x1, arg1[0])
   910  	var x81 uint64
   911  	var x82 uint64
   912  	x81, x82 = bits.Add64(x80, x77, uint64(0x0))
   913  	var x83 uint64
   914  	var x84 uint64
   915  	x83, x84 = bits.Add64(x78, x75, uint64(p384Uint1(x82)))
   916  	var x85 uint64
   917  	var x86 uint64
   918  	x85, x86 = bits.Add64(x76, x73, uint64(p384Uint1(x84)))
   919  	var x87 uint64
   920  	var x88 uint64
   921  	x87, x88 = bits.Add64(x74, x71, uint64(p384Uint1(x86)))
   922  	var x89 uint64
   923  	var x90 uint64
   924  	x89, x90 = bits.Add64(x72, x69, uint64(p384Uint1(x88)))
   925  	x91 := (uint64(p384Uint1(x90)) + x70)
   926  	var x92 uint64
   927  	var x93 uint64
   928  	x92, x93 = bits.Add64(x57, x79, uint64(0x0))
   929  	var x94 uint64
   930  	var x95 uint64
   931  	x94, x95 = bits.Add64(x59, x81, uint64(p384Uint1(x93)))
   932  	var x96 uint64
   933  	var x97 uint64
   934  	x96, x97 = bits.Add64(x61, x83, uint64(p384Uint1(x95)))
   935  	var x98 uint64
   936  	var x99 uint64
   937  	x98, x99 = bits.Add64(x63, x85, uint64(p384Uint1(x97)))
   938  	var x100 uint64
   939  	var x101 uint64
   940  	x100, x101 = bits.Add64(x65, x87, uint64(p384Uint1(x99)))
   941  	var x102 uint64
   942  	var x103 uint64
   943  	x102, x103 = bits.Add64(x67, x89, uint64(p384Uint1(x101)))
   944  	var x104 uint64
   945  	var x105 uint64
   946  	x104, x105 = bits.Add64(uint64(p384Uint1(x68)), x91, uint64(p384Uint1(x103)))
   947  	var x106 uint64
   948  	_, x106 = bits.Mul64(x92, 0x100000001)
   949  	var x108 uint64
   950  	var x109 uint64
   951  	x109, x108 = bits.Mul64(x106, 0xffffffffffffffff)
   952  	var x110 uint64
   953  	var x111 uint64
   954  	x111, x110 = bits.Mul64(x106, 0xffffffffffffffff)
   955  	var x112 uint64
   956  	var x113 uint64
   957  	x113, x112 = bits.Mul64(x106, 0xffffffffffffffff)
   958  	var x114 uint64
   959  	var x115 uint64
   960  	x115, x114 = bits.Mul64(x106, 0xfffffffffffffffe)
   961  	var x116 uint64
   962  	var x117 uint64
   963  	x117, x116 = bits.Mul64(x106, 0xffffffff00000000)
   964  	var x118 uint64
   965  	var x119 uint64
   966  	x119, x118 = bits.Mul64(x106, 0xffffffff)
   967  	var x120 uint64
   968  	var x121 uint64
   969  	x120, x121 = bits.Add64(x119, x116, uint64(0x0))
   970  	var x122 uint64
   971  	var x123 uint64
   972  	x122, x123 = bits.Add64(x117, x114, uint64(p384Uint1(x121)))
   973  	var x124 uint64
   974  	var x125 uint64
   975  	x124, x125 = bits.Add64(x115, x112, uint64(p384Uint1(x123)))
   976  	var x126 uint64
   977  	var x127 uint64
   978  	x126, x127 = bits.Add64(x113, x110, uint64(p384Uint1(x125)))
   979  	var x128 uint64
   980  	var x129 uint64
   981  	x128, x129 = bits.Add64(x111, x108, uint64(p384Uint1(x127)))
   982  	x130 := (uint64(p384Uint1(x129)) + x109)
   983  	var x132 uint64
   984  	_, x132 = bits.Add64(x92, x118, uint64(0x0))
   985  	var x133 uint64
   986  	var x134 uint64
   987  	x133, x134 = bits.Add64(x94, x120, uint64(p384Uint1(x132)))
   988  	var x135 uint64
   989  	var x136 uint64
   990  	x135, x136 = bits.Add64(x96, x122, uint64(p384Uint1(x134)))
   991  	var x137 uint64
   992  	var x138 uint64
   993  	x137, x138 = bits.Add64(x98, x124, uint64(p384Uint1(x136)))
   994  	var x139 uint64
   995  	var x140 uint64
   996  	x139, x140 = bits.Add64(x100, x126, uint64(p384Uint1(x138)))
   997  	var x141 uint64
   998  	var x142 uint64
   999  	x141, x142 = bits.Add64(x102, x128, uint64(p384Uint1(x140)))
  1000  	var x143 uint64
  1001  	var x144 uint64
  1002  	x143, x144 = bits.Add64(x104, x130, uint64(p384Uint1(x142)))
  1003  	x145 := (uint64(p384Uint1(x144)) + uint64(p384Uint1(x105)))
  1004  	var x146 uint64
  1005  	var x147 uint64
  1006  	x147, x146 = bits.Mul64(x2, arg1[5])
  1007  	var x148 uint64
  1008  	var x149 uint64
  1009  	x149, x148 = bits.Mul64(x2, arg1[4])
  1010  	var x150 uint64
  1011  	var x151 uint64
  1012  	x151, x150 = bits.Mul64(x2, arg1[3])
  1013  	var x152 uint64
  1014  	var x153 uint64
  1015  	x153, x152 = bits.Mul64(x2, arg1[2])
  1016  	var x154 uint64
  1017  	var x155 uint64
  1018  	x155, x154 = bits.Mul64(x2, arg1[1])
  1019  	var x156 uint64
  1020  	var x157 uint64
  1021  	x157, x156 = bits.Mul64(x2, arg1[0])
  1022  	var x158 uint64
  1023  	var x159 uint64
  1024  	x158, x159 = bits.Add64(x157, x154, uint64(0x0))
  1025  	var x160 uint64
  1026  	var x161 uint64
  1027  	x160, x161 = bits.Add64(x155, x152, uint64(p384Uint1(x159)))
  1028  	var x162 uint64
  1029  	var x163 uint64
  1030  	x162, x163 = bits.Add64(x153, x150, uint64(p384Uint1(x161)))
  1031  	var x164 uint64
  1032  	var x165 uint64
  1033  	x164, x165 = bits.Add64(x151, x148, uint64(p384Uint1(x163)))
  1034  	var x166 uint64
  1035  	var x167 uint64
  1036  	x166, x167 = bits.Add64(x149, x146, uint64(p384Uint1(x165)))
  1037  	x168 := (uint64(p384Uint1(x167)) + x147)
  1038  	var x169 uint64
  1039  	var x170 uint64
  1040  	x169, x170 = bits.Add64(x133, x156, uint64(0x0))
  1041  	var x171 uint64
  1042  	var x172 uint64
  1043  	x171, x172 = bits.Add64(x135, x158, uint64(p384Uint1(x170)))
  1044  	var x173 uint64
  1045  	var x174 uint64
  1046  	x173, x174 = bits.Add64(x137, x160, uint64(p384Uint1(x172)))
  1047  	var x175 uint64
  1048  	var x176 uint64
  1049  	x175, x176 = bits.Add64(x139, x162, uint64(p384Uint1(x174)))
  1050  	var x177 uint64
  1051  	var x178 uint64
  1052  	x177, x178 = bits.Add64(x141, x164, uint64(p384Uint1(x176)))
  1053  	var x179 uint64
  1054  	var x180 uint64
  1055  	x179, x180 = bits.Add64(x143, x166, uint64(p384Uint1(x178)))
  1056  	var x181 uint64
  1057  	var x182 uint64
  1058  	x181, x182 = bits.Add64(x145, x168, uint64(p384Uint1(x180)))
  1059  	var x183 uint64
  1060  	_, x183 = bits.Mul64(x169, 0x100000001)
  1061  	var x185 uint64
  1062  	var x186 uint64
  1063  	x186, x185 = bits.Mul64(x183, 0xffffffffffffffff)
  1064  	var x187 uint64
  1065  	var x188 uint64
  1066  	x188, x187 = bits.Mul64(x183, 0xffffffffffffffff)
  1067  	var x189 uint64
  1068  	var x190 uint64
  1069  	x190, x189 = bits.Mul64(x183, 0xffffffffffffffff)
  1070  	var x191 uint64
  1071  	var x192 uint64
  1072  	x192, x191 = bits.Mul64(x183, 0xfffffffffffffffe)
  1073  	var x193 uint64
  1074  	var x194 uint64
  1075  	x194, x193 = bits.Mul64(x183, 0xffffffff00000000)
  1076  	var x195 uint64
  1077  	var x196 uint64
  1078  	x196, x195 = bits.Mul64(x183, 0xffffffff)
  1079  	var x197 uint64
  1080  	var x198 uint64
  1081  	x197, x198 = bits.Add64(x196, x193, uint64(0x0))
  1082  	var x199 uint64
  1083  	var x200 uint64
  1084  	x199, x200 = bits.Add64(x194, x191, uint64(p384Uint1(x198)))
  1085  	var x201 uint64
  1086  	var x202 uint64
  1087  	x201, x202 = bits.Add64(x192, x189, uint64(p384Uint1(x200)))
  1088  	var x203 uint64
  1089  	var x204 uint64
  1090  	x203, x204 = bits.Add64(x190, x187, uint64(p384Uint1(x202)))
  1091  	var x205 uint64
  1092  	var x206 uint64
  1093  	x205, x206 = bits.Add64(x188, x185, uint64(p384Uint1(x204)))
  1094  	x207 := (uint64(p384Uint1(x206)) + x186)
  1095  	var x209 uint64
  1096  	_, x209 = bits.Add64(x169, x195, uint64(0x0))
  1097  	var x210 uint64
  1098  	var x211 uint64
  1099  	x210, x211 = bits.Add64(x171, x197, uint64(p384Uint1(x209)))
  1100  	var x212 uint64
  1101  	var x213 uint64
  1102  	x212, x213 = bits.Add64(x173, x199, uint64(p384Uint1(x211)))
  1103  	var x214 uint64
  1104  	var x215 uint64
  1105  	x214, x215 = bits.Add64(x175, x201, uint64(p384Uint1(x213)))
  1106  	var x216 uint64
  1107  	var x217 uint64
  1108  	x216, x217 = bits.Add64(x177, x203, uint64(p384Uint1(x215)))
  1109  	var x218 uint64
  1110  	var x219 uint64
  1111  	x218, x219 = bits.Add64(x179, x205, uint64(p384Uint1(x217)))
  1112  	var x220 uint64
  1113  	var x221 uint64
  1114  	x220, x221 = bits.Add64(x181, x207, uint64(p384Uint1(x219)))
  1115  	x222 := (uint64(p384Uint1(x221)) + uint64(p384Uint1(x182)))
  1116  	var x223 uint64
  1117  	var x224 uint64
  1118  	x224, x223 = bits.Mul64(x3, arg1[5])
  1119  	var x225 uint64
  1120  	var x226 uint64
  1121  	x226, x225 = bits.Mul64(x3, arg1[4])
  1122  	var x227 uint64
  1123  	var x228 uint64
  1124  	x228, x227 = bits.Mul64(x3, arg1[3])
  1125  	var x229 uint64
  1126  	var x230 uint64
  1127  	x230, x229 = bits.Mul64(x3, arg1[2])
  1128  	var x231 uint64
  1129  	var x232 uint64
  1130  	x232, x231 = bits.Mul64(x3, arg1[1])
  1131  	var x233 uint64
  1132  	var x234 uint64
  1133  	x234, x233 = bits.Mul64(x3, arg1[0])
  1134  	var x235 uint64
  1135  	var x236 uint64
  1136  	x235, x236 = bits.Add64(x234, x231, uint64(0x0))
  1137  	var x237 uint64
  1138  	var x238 uint64
  1139  	x237, x238 = bits.Add64(x232, x229, uint64(p384Uint1(x236)))
  1140  	var x239 uint64
  1141  	var x240 uint64
  1142  	x239, x240 = bits.Add64(x230, x227, uint64(p384Uint1(x238)))
  1143  	var x241 uint64
  1144  	var x242 uint64
  1145  	x241, x242 = bits.Add64(x228, x225, uint64(p384Uint1(x240)))
  1146  	var x243 uint64
  1147  	var x244 uint64
  1148  	x243, x244 = bits.Add64(x226, x223, uint64(p384Uint1(x242)))
  1149  	x245 := (uint64(p384Uint1(x244)) + x224)
  1150  	var x246 uint64
  1151  	var x247 uint64
  1152  	x246, x247 = bits.Add64(x210, x233, uint64(0x0))
  1153  	var x248 uint64
  1154  	var x249 uint64
  1155  	x248, x249 = bits.Add64(x212, x235, uint64(p384Uint1(x247)))
  1156  	var x250 uint64
  1157  	var x251 uint64
  1158  	x250, x251 = bits.Add64(x214, x237, uint64(p384Uint1(x249)))
  1159  	var x252 uint64
  1160  	var x253 uint64
  1161  	x252, x253 = bits.Add64(x216, x239, uint64(p384Uint1(x251)))
  1162  	var x254 uint64
  1163  	var x255 uint64
  1164  	x254, x255 = bits.Add64(x218, x241, uint64(p384Uint1(x253)))
  1165  	var x256 uint64
  1166  	var x257 uint64
  1167  	x256, x257 = bits.Add64(x220, x243, uint64(p384Uint1(x255)))
  1168  	var x258 uint64
  1169  	var x259 uint64
  1170  	x258, x259 = bits.Add64(x222, x245, uint64(p384Uint1(x257)))
  1171  	var x260 uint64
  1172  	_, x260 = bits.Mul64(x246, 0x100000001)
  1173  	var x262 uint64
  1174  	var x263 uint64
  1175  	x263, x262 = bits.Mul64(x260, 0xffffffffffffffff)
  1176  	var x264 uint64
  1177  	var x265 uint64
  1178  	x265, x264 = bits.Mul64(x260, 0xffffffffffffffff)
  1179  	var x266 uint64
  1180  	var x267 uint64
  1181  	x267, x266 = bits.Mul64(x260, 0xffffffffffffffff)
  1182  	var x268 uint64
  1183  	var x269 uint64
  1184  	x269, x268 = bits.Mul64(x260, 0xfffffffffffffffe)
  1185  	var x270 uint64
  1186  	var x271 uint64
  1187  	x271, x270 = bits.Mul64(x260, 0xffffffff00000000)
  1188  	var x272 uint64
  1189  	var x273 uint64
  1190  	x273, x272 = bits.Mul64(x260, 0xffffffff)
  1191  	var x274 uint64
  1192  	var x275 uint64
  1193  	x274, x275 = bits.Add64(x273, x270, uint64(0x0))
  1194  	var x276 uint64
  1195  	var x277 uint64
  1196  	x276, x277 = bits.Add64(x271, x268, uint64(p384Uint1(x275)))
  1197  	var x278 uint64
  1198  	var x279 uint64
  1199  	x278, x279 = bits.Add64(x269, x266, uint64(p384Uint1(x277)))
  1200  	var x280 uint64
  1201  	var x281 uint64
  1202  	x280, x281 = bits.Add64(x267, x264, uint64(p384Uint1(x279)))
  1203  	var x282 uint64
  1204  	var x283 uint64
  1205  	x282, x283 = bits.Add64(x265, x262, uint64(p384Uint1(x281)))
  1206  	x284 := (uint64(p384Uint1(x283)) + x263)
  1207  	var x286 uint64
  1208  	_, x286 = bits.Add64(x246, x272, uint64(0x0))
  1209  	var x287 uint64
  1210  	var x288 uint64
  1211  	x287, x288 = bits.Add64(x248, x274, uint64(p384Uint1(x286)))
  1212  	var x289 uint64
  1213  	var x290 uint64
  1214  	x289, x290 = bits.Add64(x250, x276, uint64(p384Uint1(x288)))
  1215  	var x291 uint64
  1216  	var x292 uint64
  1217  	x291, x292 = bits.Add64(x252, x278, uint64(p384Uint1(x290)))
  1218  	var x293 uint64
  1219  	var x294 uint64
  1220  	x293, x294 = bits.Add64(x254, x280, uint64(p384Uint1(x292)))
  1221  	var x295 uint64
  1222  	var x296 uint64
  1223  	x295, x296 = bits.Add64(x256, x282, uint64(p384Uint1(x294)))
  1224  	var x297 uint64
  1225  	var x298 uint64
  1226  	x297, x298 = bits.Add64(x258, x284, uint64(p384Uint1(x296)))
  1227  	x299 := (uint64(p384Uint1(x298)) + uint64(p384Uint1(x259)))
  1228  	var x300 uint64
  1229  	var x301 uint64
  1230  	x301, x300 = bits.Mul64(x4, arg1[5])
  1231  	var x302 uint64
  1232  	var x303 uint64
  1233  	x303, x302 = bits.Mul64(x4, arg1[4])
  1234  	var x304 uint64
  1235  	var x305 uint64
  1236  	x305, x304 = bits.Mul64(x4, arg1[3])
  1237  	var x306 uint64
  1238  	var x307 uint64
  1239  	x307, x306 = bits.Mul64(x4, arg1[2])
  1240  	var x308 uint64
  1241  	var x309 uint64
  1242  	x309, x308 = bits.Mul64(x4, arg1[1])
  1243  	var x310 uint64
  1244  	var x311 uint64
  1245  	x311, x310 = bits.Mul64(x4, arg1[0])
  1246  	var x312 uint64
  1247  	var x313 uint64
  1248  	x312, x313 = bits.Add64(x311, x308, uint64(0x0))
  1249  	var x314 uint64
  1250  	var x315 uint64
  1251  	x314, x315 = bits.Add64(x309, x306, uint64(p384Uint1(x313)))
  1252  	var x316 uint64
  1253  	var x317 uint64
  1254  	x316, x317 = bits.Add64(x307, x304, uint64(p384Uint1(x315)))
  1255  	var x318 uint64
  1256  	var x319 uint64
  1257  	x318, x319 = bits.Add64(x305, x302, uint64(p384Uint1(x317)))
  1258  	var x320 uint64
  1259  	var x321 uint64
  1260  	x320, x321 = bits.Add64(x303, x300, uint64(p384Uint1(x319)))
  1261  	x322 := (uint64(p384Uint1(x321)) + x301)
  1262  	var x323 uint64
  1263  	var x324 uint64
  1264  	x323, x324 = bits.Add64(x287, x310, uint64(0x0))
  1265  	var x325 uint64
  1266  	var x326 uint64
  1267  	x325, x326 = bits.Add64(x289, x312, uint64(p384Uint1(x324)))
  1268  	var x327 uint64
  1269  	var x328 uint64
  1270  	x327, x328 = bits.Add64(x291, x314, uint64(p384Uint1(x326)))
  1271  	var x329 uint64
  1272  	var x330 uint64
  1273  	x329, x330 = bits.Add64(x293, x316, uint64(p384Uint1(x328)))
  1274  	var x331 uint64
  1275  	var x332 uint64
  1276  	x331, x332 = bits.Add64(x295, x318, uint64(p384Uint1(x330)))
  1277  	var x333 uint64
  1278  	var x334 uint64
  1279  	x333, x334 = bits.Add64(x297, x320, uint64(p384Uint1(x332)))
  1280  	var x335 uint64
  1281  	var x336 uint64
  1282  	x335, x336 = bits.Add64(x299, x322, uint64(p384Uint1(x334)))
  1283  	var x337 uint64
  1284  	_, x337 = bits.Mul64(x323, 0x100000001)
  1285  	var x339 uint64
  1286  	var x340 uint64
  1287  	x340, x339 = bits.Mul64(x337, 0xffffffffffffffff)
  1288  	var x341 uint64
  1289  	var x342 uint64
  1290  	x342, x341 = bits.Mul64(x337, 0xffffffffffffffff)
  1291  	var x343 uint64
  1292  	var x344 uint64
  1293  	x344, x343 = bits.Mul64(x337, 0xffffffffffffffff)
  1294  	var x345 uint64
  1295  	var x346 uint64
  1296  	x346, x345 = bits.Mul64(x337, 0xfffffffffffffffe)
  1297  	var x347 uint64
  1298  	var x348 uint64
  1299  	x348, x347 = bits.Mul64(x337, 0xffffffff00000000)
  1300  	var x349 uint64
  1301  	var x350 uint64
  1302  	x350, x349 = bits.Mul64(x337, 0xffffffff)
  1303  	var x351 uint64
  1304  	var x352 uint64
  1305  	x351, x352 = bits.Add64(x350, x347, uint64(0x0))
  1306  	var x353 uint64
  1307  	var x354 uint64
  1308  	x353, x354 = bits.Add64(x348, x345, uint64(p384Uint1(x352)))
  1309  	var x355 uint64
  1310  	var x356 uint64
  1311  	x355, x356 = bits.Add64(x346, x343, uint64(p384Uint1(x354)))
  1312  	var x357 uint64
  1313  	var x358 uint64
  1314  	x357, x358 = bits.Add64(x344, x341, uint64(p384Uint1(x356)))
  1315  	var x359 uint64
  1316  	var x360 uint64
  1317  	x359, x360 = bits.Add64(x342, x339, uint64(p384Uint1(x358)))
  1318  	x361 := (uint64(p384Uint1(x360)) + x340)
  1319  	var x363 uint64
  1320  	_, x363 = bits.Add64(x323, x349, uint64(0x0))
  1321  	var x364 uint64
  1322  	var x365 uint64
  1323  	x364, x365 = bits.Add64(x325, x351, uint64(p384Uint1(x363)))
  1324  	var x366 uint64
  1325  	var x367 uint64
  1326  	x366, x367 = bits.Add64(x327, x353, uint64(p384Uint1(x365)))
  1327  	var x368 uint64
  1328  	var x369 uint64
  1329  	x368, x369 = bits.Add64(x329, x355, uint64(p384Uint1(x367)))
  1330  	var x370 uint64
  1331  	var x371 uint64
  1332  	x370, x371 = bits.Add64(x331, x357, uint64(p384Uint1(x369)))
  1333  	var x372 uint64
  1334  	var x373 uint64
  1335  	x372, x373 = bits.Add64(x333, x359, uint64(p384Uint1(x371)))
  1336  	var x374 uint64
  1337  	var x375 uint64
  1338  	x374, x375 = bits.Add64(x335, x361, uint64(p384Uint1(x373)))
  1339  	x376 := (uint64(p384Uint1(x375)) + uint64(p384Uint1(x336)))
  1340  	var x377 uint64
  1341  	var x378 uint64
  1342  	x378, x377 = bits.Mul64(x5, arg1[5])
  1343  	var x379 uint64
  1344  	var x380 uint64
  1345  	x380, x379 = bits.Mul64(x5, arg1[4])
  1346  	var x381 uint64
  1347  	var x382 uint64
  1348  	x382, x381 = bits.Mul64(x5, arg1[3])
  1349  	var x383 uint64
  1350  	var x384 uint64
  1351  	x384, x383 = bits.Mul64(x5, arg1[2])
  1352  	var x385 uint64
  1353  	var x386 uint64
  1354  	x386, x385 = bits.Mul64(x5, arg1[1])
  1355  	var x387 uint64
  1356  	var x388 uint64
  1357  	x388, x387 = bits.Mul64(x5, arg1[0])
  1358  	var x389 uint64
  1359  	var x390 uint64
  1360  	x389, x390 = bits.Add64(x388, x385, uint64(0x0))
  1361  	var x391 uint64
  1362  	var x392 uint64
  1363  	x391, x392 = bits.Add64(x386, x383, uint64(p384Uint1(x390)))
  1364  	var x393 uint64
  1365  	var x394 uint64
  1366  	x393, x394 = bits.Add64(x384, x381, uint64(p384Uint1(x392)))
  1367  	var x395 uint64
  1368  	var x396 uint64
  1369  	x395, x396 = bits.Add64(x382, x379, uint64(p384Uint1(x394)))
  1370  	var x397 uint64
  1371  	var x398 uint64
  1372  	x397, x398 = bits.Add64(x380, x377, uint64(p384Uint1(x396)))
  1373  	x399 := (uint64(p384Uint1(x398)) + x378)
  1374  	var x400 uint64
  1375  	var x401 uint64
  1376  	x400, x401 = bits.Add64(x364, x387, uint64(0x0))
  1377  	var x402 uint64
  1378  	var x403 uint64
  1379  	x402, x403 = bits.Add64(x366, x389, uint64(p384Uint1(x401)))
  1380  	var x404 uint64
  1381  	var x405 uint64
  1382  	x404, x405 = bits.Add64(x368, x391, uint64(p384Uint1(x403)))
  1383  	var x406 uint64
  1384  	var x407 uint64
  1385  	x406, x407 = bits.Add64(x370, x393, uint64(p384Uint1(x405)))
  1386  	var x408 uint64
  1387  	var x409 uint64
  1388  	x408, x409 = bits.Add64(x372, x395, uint64(p384Uint1(x407)))
  1389  	var x410 uint64
  1390  	var x411 uint64
  1391  	x410, x411 = bits.Add64(x374, x397, uint64(p384Uint1(x409)))
  1392  	var x412 uint64
  1393  	var x413 uint64
  1394  	x412, x413 = bits.Add64(x376, x399, uint64(p384Uint1(x411)))
  1395  	var x414 uint64
  1396  	_, x414 = bits.Mul64(x400, 0x100000001)
  1397  	var x416 uint64
  1398  	var x417 uint64
  1399  	x417, x416 = bits.Mul64(x414, 0xffffffffffffffff)
  1400  	var x418 uint64
  1401  	var x419 uint64
  1402  	x419, x418 = bits.Mul64(x414, 0xffffffffffffffff)
  1403  	var x420 uint64
  1404  	var x421 uint64
  1405  	x421, x420 = bits.Mul64(x414, 0xffffffffffffffff)
  1406  	var x422 uint64
  1407  	var x423 uint64
  1408  	x423, x422 = bits.Mul64(x414, 0xfffffffffffffffe)
  1409  	var x424 uint64
  1410  	var x425 uint64
  1411  	x425, x424 = bits.Mul64(x414, 0xffffffff00000000)
  1412  	var x426 uint64
  1413  	var x427 uint64
  1414  	x427, x426 = bits.Mul64(x414, 0xffffffff)
  1415  	var x428 uint64
  1416  	var x429 uint64
  1417  	x428, x429 = bits.Add64(x427, x424, uint64(0x0))
  1418  	var x430 uint64
  1419  	var x431 uint64
  1420  	x430, x431 = bits.Add64(x425, x422, uint64(p384Uint1(x429)))
  1421  	var x432 uint64
  1422  	var x433 uint64
  1423  	x432, x433 = bits.Add64(x423, x420, uint64(p384Uint1(x431)))
  1424  	var x434 uint64
  1425  	var x435 uint64
  1426  	x434, x435 = bits.Add64(x421, x418, uint64(p384Uint1(x433)))
  1427  	var x436 uint64
  1428  	var x437 uint64
  1429  	x436, x437 = bits.Add64(x419, x416, uint64(p384Uint1(x435)))
  1430  	x438 := (uint64(p384Uint1(x437)) + x417)
  1431  	var x440 uint64
  1432  	_, x440 = bits.Add64(x400, x426, uint64(0x0))
  1433  	var x441 uint64
  1434  	var x442 uint64
  1435  	x441, x442 = bits.Add64(x402, x428, uint64(p384Uint1(x440)))
  1436  	var x443 uint64
  1437  	var x444 uint64
  1438  	x443, x444 = bits.Add64(x404, x430, uint64(p384Uint1(x442)))
  1439  	var x445 uint64
  1440  	var x446 uint64
  1441  	x445, x446 = bits.Add64(x406, x432, uint64(p384Uint1(x444)))
  1442  	var x447 uint64
  1443  	var x448 uint64
  1444  	x447, x448 = bits.Add64(x408, x434, uint64(p384Uint1(x446)))
  1445  	var x449 uint64
  1446  	var x450 uint64
  1447  	x449, x450 = bits.Add64(x410, x436, uint64(p384Uint1(x448)))
  1448  	var x451 uint64
  1449  	var x452 uint64
  1450  	x451, x452 = bits.Add64(x412, x438, uint64(p384Uint1(x450)))
  1451  	x453 := (uint64(p384Uint1(x452)) + uint64(p384Uint1(x413)))
  1452  	var x454 uint64
  1453  	var x455 uint64
  1454  	x454, x455 = bits.Sub64(x441, 0xffffffff, uint64(0x0))
  1455  	var x456 uint64
  1456  	var x457 uint64
  1457  	x456, x457 = bits.Sub64(x443, 0xffffffff00000000, uint64(p384Uint1(x455)))
  1458  	var x458 uint64
  1459  	var x459 uint64
  1460  	x458, x459 = bits.Sub64(x445, 0xfffffffffffffffe, uint64(p384Uint1(x457)))
  1461  	var x460 uint64
  1462  	var x461 uint64
  1463  	x460, x461 = bits.Sub64(x447, 0xffffffffffffffff, uint64(p384Uint1(x459)))
  1464  	var x462 uint64
  1465  	var x463 uint64
  1466  	x462, x463 = bits.Sub64(x449, 0xffffffffffffffff, uint64(p384Uint1(x461)))
  1467  	var x464 uint64
  1468  	var x465 uint64
  1469  	x464, x465 = bits.Sub64(x451, 0xffffffffffffffff, uint64(p384Uint1(x463)))
  1470  	var x467 uint64
  1471  	_, x467 = bits.Sub64(x453, uint64(0x0), uint64(p384Uint1(x465)))
  1472  	var x468 uint64
  1473  	p384CmovznzU64(&x468, p384Uint1(x467), x454, x441)
  1474  	var x469 uint64
  1475  	p384CmovznzU64(&x469, p384Uint1(x467), x456, x443)
  1476  	var x470 uint64
  1477  	p384CmovznzU64(&x470, p384Uint1(x467), x458, x445)
  1478  	var x471 uint64
  1479  	p384CmovznzU64(&x471, p384Uint1(x467), x460, x447)
  1480  	var x472 uint64
  1481  	p384CmovznzU64(&x472, p384Uint1(x467), x462, x449)
  1482  	var x473 uint64
  1483  	p384CmovznzU64(&x473, p384Uint1(x467), x464, x451)
  1484  	out1[0] = x468
  1485  	out1[1] = x469
  1486  	out1[2] = x470
  1487  	out1[3] = x471
  1488  	out1[4] = x472
  1489  	out1[5] = x473
  1490  }
  1491  
  1492  // p384Add adds two field elements in the Montgomery domain.
  1493  //
  1494  // Preconditions:
  1495  //
  1496  //	0 ≤ eval arg1 < m
  1497  //	0 ≤ eval arg2 < m
  1498  //
  1499  // Postconditions:
  1500  //
  1501  //	eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m
  1502  //	0 ≤ eval out1 < m
  1503  func p384Add(out1 *p384MontgomeryDomainFieldElement, arg1 *p384MontgomeryDomainFieldElement, arg2 *p384MontgomeryDomainFieldElement) {
  1504  	var x1 uint64
  1505  	var x2 uint64
  1506  	x1, x2 = bits.Add64(arg1[0], arg2[0], uint64(0x0))
  1507  	var x3 uint64
  1508  	var x4 uint64
  1509  	x3, x4 = bits.Add64(arg1[1], arg2[1], uint64(p384Uint1(x2)))
  1510  	var x5 uint64
  1511  	var x6 uint64
  1512  	x5, x6 = bits.Add64(arg1[2], arg2[2], uint64(p384Uint1(x4)))
  1513  	var x7 uint64
  1514  	var x8 uint64
  1515  	x7, x8 = bits.Add64(arg1[3], arg2[3], uint64(p384Uint1(x6)))
  1516  	var x9 uint64
  1517  	var x10 uint64
  1518  	x9, x10 = bits.Add64(arg1[4], arg2[4], uint64(p384Uint1(x8)))
  1519  	var x11 uint64
  1520  	var x12 uint64
  1521  	x11, x12 = bits.Add64(arg1[5], arg2[5], uint64(p384Uint1(x10)))
  1522  	var x13 uint64
  1523  	var x14 uint64
  1524  	x13, x14 = bits.Sub64(x1, 0xffffffff, uint64(0x0))
  1525  	var x15 uint64
  1526  	var x16 uint64
  1527  	x15, x16 = bits.Sub64(x3, 0xffffffff00000000, uint64(p384Uint1(x14)))
  1528  	var x17 uint64
  1529  	var x18 uint64
  1530  	x17, x18 = bits.Sub64(x5, 0xfffffffffffffffe, uint64(p384Uint1(x16)))
  1531  	var x19 uint64
  1532  	var x20 uint64
  1533  	x19, x20 = bits.Sub64(x7, 0xffffffffffffffff, uint64(p384Uint1(x18)))
  1534  	var x21 uint64
  1535  	var x22 uint64
  1536  	x21, x22 = bits.Sub64(x9, 0xffffffffffffffff, uint64(p384Uint1(x20)))
  1537  	var x23 uint64
  1538  	var x24 uint64
  1539  	x23, x24 = bits.Sub64(x11, 0xffffffffffffffff, uint64(p384Uint1(x22)))
  1540  	var x26 uint64
  1541  	_, x26 = bits.Sub64(uint64(p384Uint1(x12)), uint64(0x0), uint64(p384Uint1(x24)))
  1542  	var x27 uint64
  1543  	p384CmovznzU64(&x27, p384Uint1(x26), x13, x1)
  1544  	var x28 uint64
  1545  	p384CmovznzU64(&x28, p384Uint1(x26), x15, x3)
  1546  	var x29 uint64
  1547  	p384CmovznzU64(&x29, p384Uint1(x26), x17, x5)
  1548  	var x30 uint64
  1549  	p384CmovznzU64(&x30, p384Uint1(x26), x19, x7)
  1550  	var x31 uint64
  1551  	p384CmovznzU64(&x31, p384Uint1(x26), x21, x9)
  1552  	var x32 uint64
  1553  	p384CmovznzU64(&x32, p384Uint1(x26), x23, x11)
  1554  	out1[0] = x27
  1555  	out1[1] = x28
  1556  	out1[2] = x29
  1557  	out1[3] = x30
  1558  	out1[4] = x31
  1559  	out1[5] = x32
  1560  }
  1561  
  1562  // p384Sub subtracts two field elements in the Montgomery domain.
  1563  //
  1564  // Preconditions:
  1565  //
  1566  //	0 ≤ eval arg1 < m
  1567  //	0 ≤ eval arg2 < m
  1568  //
  1569  // Postconditions:
  1570  //
  1571  //	eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m
  1572  //	0 ≤ eval out1 < m
  1573  func p384Sub(out1 *p384MontgomeryDomainFieldElement, arg1 *p384MontgomeryDomainFieldElement, arg2 *p384MontgomeryDomainFieldElement) {
  1574  	var x1 uint64
  1575  	var x2 uint64
  1576  	x1, x2 = bits.Sub64(arg1[0], arg2[0], uint64(0x0))
  1577  	var x3 uint64
  1578  	var x4 uint64
  1579  	x3, x4 = bits.Sub64(arg1[1], arg2[1], uint64(p384Uint1(x2)))
  1580  	var x5 uint64
  1581  	var x6 uint64
  1582  	x5, x6 = bits.Sub64(arg1[2], arg2[2], uint64(p384Uint1(x4)))
  1583  	var x7 uint64
  1584  	var x8 uint64
  1585  	x7, x8 = bits.Sub64(arg1[3], arg2[3], uint64(p384Uint1(x6)))
  1586  	var x9 uint64
  1587  	var x10 uint64
  1588  	x9, x10 = bits.Sub64(arg1[4], arg2[4], uint64(p384Uint1(x8)))
  1589  	var x11 uint64
  1590  	var x12 uint64
  1591  	x11, x12 = bits.Sub64(arg1[5], arg2[5], uint64(p384Uint1(x10)))
  1592  	var x13 uint64
  1593  	p384CmovznzU64(&x13, p384Uint1(x12), uint64(0x0), 0xffffffffffffffff)
  1594  	var x14 uint64
  1595  	var x15 uint64
  1596  	x14, x15 = bits.Add64(x1, (x13 & 0xffffffff), uint64(0x0))
  1597  	var x16 uint64
  1598  	var x17 uint64
  1599  	x16, x17 = bits.Add64(x3, (x13 & 0xffffffff00000000), uint64(p384Uint1(x15)))
  1600  	var x18 uint64
  1601  	var x19 uint64
  1602  	x18, x19 = bits.Add64(x5, (x13 & 0xfffffffffffffffe), uint64(p384Uint1(x17)))
  1603  	var x20 uint64
  1604  	var x21 uint64
  1605  	x20, x21 = bits.Add64(x7, x13, uint64(p384Uint1(x19)))
  1606  	var x22 uint64
  1607  	var x23 uint64
  1608  	x22, x23 = bits.Add64(x9, x13, uint64(p384Uint1(x21)))
  1609  	var x24 uint64
  1610  	x24, _ = bits.Add64(x11, x13, uint64(p384Uint1(x23)))
  1611  	out1[0] = x14
  1612  	out1[1] = x16
  1613  	out1[2] = x18
  1614  	out1[3] = x20
  1615  	out1[4] = x22
  1616  	out1[5] = x24
  1617  }
  1618  
  1619  // p384SetOne returns the field element one in the Montgomery domain.
  1620  //
  1621  // Postconditions:
  1622  //
  1623  //	eval (from_montgomery out1) mod m = 1 mod m
  1624  //	0 ≤ eval out1 < m
  1625  func p384SetOne(out1 *p384MontgomeryDomainFieldElement) {
  1626  	out1[0] = 0xffffffff00000001
  1627  	out1[1] = 0xffffffff
  1628  	out1[2] = uint64(0x1)
  1629  	out1[3] = uint64(0x0)
  1630  	out1[4] = uint64(0x0)
  1631  	out1[5] = uint64(0x0)
  1632  }
  1633  
  1634  // p384FromMontgomery translates a field element out of the Montgomery domain.
  1635  //
  1636  // Preconditions:
  1637  //
  1638  //	0 ≤ eval arg1 < m
  1639  //
  1640  // Postconditions:
  1641  //
  1642  //	eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^6) mod m
  1643  //	0 ≤ eval out1 < m
  1644  func p384FromMontgomery(out1 *p384NonMontgomeryDomainFieldElement, arg1 *p384MontgomeryDomainFieldElement) {
  1645  	x1 := arg1[0]
  1646  	var x2 uint64
  1647  	_, x2 = bits.Mul64(x1, 0x100000001)
  1648  	var x4 uint64
  1649  	var x5 uint64
  1650  	x5, x4 = bits.Mul64(x2, 0xffffffffffffffff)
  1651  	var x6 uint64
  1652  	var x7 uint64
  1653  	x7, x6 = bits.Mul64(x2, 0xffffffffffffffff)
  1654  	var x8 uint64
  1655  	var x9 uint64
  1656  	x9, x8 = bits.Mul64(x2, 0xffffffffffffffff)
  1657  	var x10 uint64
  1658  	var x11 uint64
  1659  	x11, x10 = bits.Mul64(x2, 0xfffffffffffffffe)
  1660  	var x12 uint64
  1661  	var x13 uint64
  1662  	x13, x12 = bits.Mul64(x2, 0xffffffff00000000)
  1663  	var x14 uint64
  1664  	var x15 uint64
  1665  	x15, x14 = bits.Mul64(x2, 0xffffffff)
  1666  	var x16 uint64
  1667  	var x17 uint64
  1668  	x16, x17 = bits.Add64(x15, x12, uint64(0x0))
  1669  	var x18 uint64
  1670  	var x19 uint64
  1671  	x18, x19 = bits.Add64(x13, x10, uint64(p384Uint1(x17)))
  1672  	var x20 uint64
  1673  	var x21 uint64
  1674  	x20, x21 = bits.Add64(x11, x8, uint64(p384Uint1(x19)))
  1675  	var x22 uint64
  1676  	var x23 uint64
  1677  	x22, x23 = bits.Add64(x9, x6, uint64(p384Uint1(x21)))
  1678  	var x24 uint64
  1679  	var x25 uint64
  1680  	x24, x25 = bits.Add64(x7, x4, uint64(p384Uint1(x23)))
  1681  	var x27 uint64
  1682  	_, x27 = bits.Add64(x1, x14, uint64(0x0))
  1683  	var x28 uint64
  1684  	var x29 uint64
  1685  	x28, x29 = bits.Add64(uint64(0x0), x16, uint64(p384Uint1(x27)))
  1686  	var x30 uint64
  1687  	var x31 uint64
  1688  	x30, x31 = bits.Add64(uint64(0x0), x18, uint64(p384Uint1(x29)))
  1689  	var x32 uint64
  1690  	var x33 uint64
  1691  	x32, x33 = bits.Add64(uint64(0x0), x20, uint64(p384Uint1(x31)))
  1692  	var x34 uint64
  1693  	var x35 uint64
  1694  	x34, x35 = bits.Add64(uint64(0x0), x22, uint64(p384Uint1(x33)))
  1695  	var x36 uint64
  1696  	var x37 uint64
  1697  	x36, x37 = bits.Add64(uint64(0x0), x24, uint64(p384Uint1(x35)))
  1698  	var x38 uint64
  1699  	var x39 uint64
  1700  	x38, x39 = bits.Add64(uint64(0x0), (uint64(p384Uint1(x25)) + x5), uint64(p384Uint1(x37)))
  1701  	var x40 uint64
  1702  	var x41 uint64
  1703  	x40, x41 = bits.Add64(x28, arg1[1], uint64(0x0))
  1704  	var x42 uint64
  1705  	var x43 uint64
  1706  	x42, x43 = bits.Add64(x30, uint64(0x0), uint64(p384Uint1(x41)))
  1707  	var x44 uint64
  1708  	var x45 uint64
  1709  	x44, x45 = bits.Add64(x32, uint64(0x0), uint64(p384Uint1(x43)))
  1710  	var x46 uint64
  1711  	var x47 uint64
  1712  	x46, x47 = bits.Add64(x34, uint64(0x0), uint64(p384Uint1(x45)))
  1713  	var x48 uint64
  1714  	var x49 uint64
  1715  	x48, x49 = bits.Add64(x36, uint64(0x0), uint64(p384Uint1(x47)))
  1716  	var x50 uint64
  1717  	var x51 uint64
  1718  	x50, x51 = bits.Add64(x38, uint64(0x0), uint64(p384Uint1(x49)))
  1719  	var x52 uint64
  1720  	_, x52 = bits.Mul64(x40, 0x100000001)
  1721  	var x54 uint64
  1722  	var x55 uint64
  1723  	x55, x54 = bits.Mul64(x52, 0xffffffffffffffff)
  1724  	var x56 uint64
  1725  	var x57 uint64
  1726  	x57, x56 = bits.Mul64(x52, 0xffffffffffffffff)
  1727  	var x58 uint64
  1728  	var x59 uint64
  1729  	x59, x58 = bits.Mul64(x52, 0xffffffffffffffff)
  1730  	var x60 uint64
  1731  	var x61 uint64
  1732  	x61, x60 = bits.Mul64(x52, 0xfffffffffffffffe)
  1733  	var x62 uint64
  1734  	var x63 uint64
  1735  	x63, x62 = bits.Mul64(x52, 0xffffffff00000000)
  1736  	var x64 uint64
  1737  	var x65 uint64
  1738  	x65, x64 = bits.Mul64(x52, 0xffffffff)
  1739  	var x66 uint64
  1740  	var x67 uint64
  1741  	x66, x67 = bits.Add64(x65, x62, uint64(0x0))
  1742  	var x68 uint64
  1743  	var x69 uint64
  1744  	x68, x69 = bits.Add64(x63, x60, uint64(p384Uint1(x67)))
  1745  	var x70 uint64
  1746  	var x71 uint64
  1747  	x70, x71 = bits.Add64(x61, x58, uint64(p384Uint1(x69)))
  1748  	var x72 uint64
  1749  	var x73 uint64
  1750  	x72, x73 = bits.Add64(x59, x56, uint64(p384Uint1(x71)))
  1751  	var x74 uint64
  1752  	var x75 uint64
  1753  	x74, x75 = bits.Add64(x57, x54, uint64(p384Uint1(x73)))
  1754  	var x77 uint64
  1755  	_, x77 = bits.Add64(x40, x64, uint64(0x0))
  1756  	var x78 uint64
  1757  	var x79 uint64
  1758  	x78, x79 = bits.Add64(x42, x66, uint64(p384Uint1(x77)))
  1759  	var x80 uint64
  1760  	var x81 uint64
  1761  	x80, x81 = bits.Add64(x44, x68, uint64(p384Uint1(x79)))
  1762  	var x82 uint64
  1763  	var x83 uint64
  1764  	x82, x83 = bits.Add64(x46, x70, uint64(p384Uint1(x81)))
  1765  	var x84 uint64
  1766  	var x85 uint64
  1767  	x84, x85 = bits.Add64(x48, x72, uint64(p384Uint1(x83)))
  1768  	var x86 uint64
  1769  	var x87 uint64
  1770  	x86, x87 = bits.Add64(x50, x74, uint64(p384Uint1(x85)))
  1771  	var x88 uint64
  1772  	var x89 uint64
  1773  	x88, x89 = bits.Add64((uint64(p384Uint1(x51)) + uint64(p384Uint1(x39))), (uint64(p384Uint1(x75)) + x55), uint64(p384Uint1(x87)))
  1774  	var x90 uint64
  1775  	var x91 uint64
  1776  	x90, x91 = bits.Add64(x78, arg1[2], uint64(0x0))
  1777  	var x92 uint64
  1778  	var x93 uint64
  1779  	x92, x93 = bits.Add64(x80, uint64(0x0), uint64(p384Uint1(x91)))
  1780  	var x94 uint64
  1781  	var x95 uint64
  1782  	x94, x95 = bits.Add64(x82, uint64(0x0), uint64(p384Uint1(x93)))
  1783  	var x96 uint64
  1784  	var x97 uint64
  1785  	x96, x97 = bits.Add64(x84, uint64(0x0), uint64(p384Uint1(x95)))
  1786  	var x98 uint64
  1787  	var x99 uint64
  1788  	x98, x99 = bits.Add64(x86, uint64(0x0), uint64(p384Uint1(x97)))
  1789  	var x100 uint64
  1790  	var x101 uint64
  1791  	x100, x101 = bits.Add64(x88, uint64(0x0), uint64(p384Uint1(x99)))
  1792  	var x102 uint64
  1793  	_, x102 = bits.Mul64(x90, 0x100000001)
  1794  	var x104 uint64
  1795  	var x105 uint64
  1796  	x105, x104 = bits.Mul64(x102, 0xffffffffffffffff)
  1797  	var x106 uint64
  1798  	var x107 uint64
  1799  	x107, x106 = bits.Mul64(x102, 0xffffffffffffffff)
  1800  	var x108 uint64
  1801  	var x109 uint64
  1802  	x109, x108 = bits.Mul64(x102, 0xffffffffffffffff)
  1803  	var x110 uint64
  1804  	var x111 uint64
  1805  	x111, x110 = bits.Mul64(x102, 0xfffffffffffffffe)
  1806  	var x112 uint64
  1807  	var x113 uint64
  1808  	x113, x112 = bits.Mul64(x102, 0xffffffff00000000)
  1809  	var x114 uint64
  1810  	var x115 uint64
  1811  	x115, x114 = bits.Mul64(x102, 0xffffffff)
  1812  	var x116 uint64
  1813  	var x117 uint64
  1814  	x116, x117 = bits.Add64(x115, x112, uint64(0x0))
  1815  	var x118 uint64
  1816  	var x119 uint64
  1817  	x118, x119 = bits.Add64(x113, x110, uint64(p384Uint1(x117)))
  1818  	var x120 uint64
  1819  	var x121 uint64
  1820  	x120, x121 = bits.Add64(x111, x108, uint64(p384Uint1(x119)))
  1821  	var x122 uint64
  1822  	var x123 uint64
  1823  	x122, x123 = bits.Add64(x109, x106, uint64(p384Uint1(x121)))
  1824  	var x124 uint64
  1825  	var x125 uint64
  1826  	x124, x125 = bits.Add64(x107, x104, uint64(p384Uint1(x123)))
  1827  	var x127 uint64
  1828  	_, x127 = bits.Add64(x90, x114, uint64(0x0))
  1829  	var x128 uint64
  1830  	var x129 uint64
  1831  	x128, x129 = bits.Add64(x92, x116, uint64(p384Uint1(x127)))
  1832  	var x130 uint64
  1833  	var x131 uint64
  1834  	x130, x131 = bits.Add64(x94, x118, uint64(p384Uint1(x129)))
  1835  	var x132 uint64
  1836  	var x133 uint64
  1837  	x132, x133 = bits.Add64(x96, x120, uint64(p384Uint1(x131)))
  1838  	var x134 uint64
  1839  	var x135 uint64
  1840  	x134, x135 = bits.Add64(x98, x122, uint64(p384Uint1(x133)))
  1841  	var x136 uint64
  1842  	var x137 uint64
  1843  	x136, x137 = bits.Add64(x100, x124, uint64(p384Uint1(x135)))
  1844  	var x138 uint64
  1845  	var x139 uint64
  1846  	x138, x139 = bits.Add64((uint64(p384Uint1(x101)) + uint64(p384Uint1(x89))), (uint64(p384Uint1(x125)) + x105), uint64(p384Uint1(x137)))
  1847  	var x140 uint64
  1848  	var x141 uint64
  1849  	x140, x141 = bits.Add64(x128, arg1[3], uint64(0x0))
  1850  	var x142 uint64
  1851  	var x143 uint64
  1852  	x142, x143 = bits.Add64(x130, uint64(0x0), uint64(p384Uint1(x141)))
  1853  	var x144 uint64
  1854  	var x145 uint64
  1855  	x144, x145 = bits.Add64(x132, uint64(0x0), uint64(p384Uint1(x143)))
  1856  	var x146 uint64
  1857  	var x147 uint64
  1858  	x146, x147 = bits.Add64(x134, uint64(0x0), uint64(p384Uint1(x145)))
  1859  	var x148 uint64
  1860  	var x149 uint64
  1861  	x148, x149 = bits.Add64(x136, uint64(0x0), uint64(p384Uint1(x147)))
  1862  	var x150 uint64
  1863  	var x151 uint64
  1864  	x150, x151 = bits.Add64(x138, uint64(0x0), uint64(p384Uint1(x149)))
  1865  	var x152 uint64
  1866  	_, x152 = bits.Mul64(x140, 0x100000001)
  1867  	var x154 uint64
  1868  	var x155 uint64
  1869  	x155, x154 = bits.Mul64(x152, 0xffffffffffffffff)
  1870  	var x156 uint64
  1871  	var x157 uint64
  1872  	x157, x156 = bits.Mul64(x152, 0xffffffffffffffff)
  1873  	var x158 uint64
  1874  	var x159 uint64
  1875  	x159, x158 = bits.Mul64(x152, 0xffffffffffffffff)
  1876  	var x160 uint64
  1877  	var x161 uint64
  1878  	x161, x160 = bits.Mul64(x152, 0xfffffffffffffffe)
  1879  	var x162 uint64
  1880  	var x163 uint64
  1881  	x163, x162 = bits.Mul64(x152, 0xffffffff00000000)
  1882  	var x164 uint64
  1883  	var x165 uint64
  1884  	x165, x164 = bits.Mul64(x152, 0xffffffff)
  1885  	var x166 uint64
  1886  	var x167 uint64
  1887  	x166, x167 = bits.Add64(x165, x162, uint64(0x0))
  1888  	var x168 uint64
  1889  	var x169 uint64
  1890  	x168, x169 = bits.Add64(x163, x160, uint64(p384Uint1(x167)))
  1891  	var x170 uint64
  1892  	var x171 uint64
  1893  	x170, x171 = bits.Add64(x161, x158, uint64(p384Uint1(x169)))
  1894  	var x172 uint64
  1895  	var x173 uint64
  1896  	x172, x173 = bits.Add64(x159, x156, uint64(p384Uint1(x171)))
  1897  	var x174 uint64
  1898  	var x175 uint64
  1899  	x174, x175 = bits.Add64(x157, x154, uint64(p384Uint1(x173)))
  1900  	var x177 uint64
  1901  	_, x177 = bits.Add64(x140, x164, uint64(0x0))
  1902  	var x178 uint64
  1903  	var x179 uint64
  1904  	x178, x179 = bits.Add64(x142, x166, uint64(p384Uint1(x177)))
  1905  	var x180 uint64
  1906  	var x181 uint64
  1907  	x180, x181 = bits.Add64(x144, x168, uint64(p384Uint1(x179)))
  1908  	var x182 uint64
  1909  	var x183 uint64
  1910  	x182, x183 = bits.Add64(x146, x170, uint64(p384Uint1(x181)))
  1911  	var x184 uint64
  1912  	var x185 uint64
  1913  	x184, x185 = bits.Add64(x148, x172, uint64(p384Uint1(x183)))
  1914  	var x186 uint64
  1915  	var x187 uint64
  1916  	x186, x187 = bits.Add64(x150, x174, uint64(p384Uint1(x185)))
  1917  	var x188 uint64
  1918  	var x189 uint64
  1919  	x188, x189 = bits.Add64((uint64(p384Uint1(x151)) + uint64(p384Uint1(x139))), (uint64(p384Uint1(x175)) + x155), uint64(p384Uint1(x187)))
  1920  	var x190 uint64
  1921  	var x191 uint64
  1922  	x190, x191 = bits.Add64(x178, arg1[4], uint64(0x0))
  1923  	var x192 uint64
  1924  	var x193 uint64
  1925  	x192, x193 = bits.Add64(x180, uint64(0x0), uint64(p384Uint1(x191)))
  1926  	var x194 uint64
  1927  	var x195 uint64
  1928  	x194, x195 = bits.Add64(x182, uint64(0x0), uint64(p384Uint1(x193)))
  1929  	var x196 uint64
  1930  	var x197 uint64
  1931  	x196, x197 = bits.Add64(x184, uint64(0x0), uint64(p384Uint1(x195)))
  1932  	var x198 uint64
  1933  	var x199 uint64
  1934  	x198, x199 = bits.Add64(x186, uint64(0x0), uint64(p384Uint1(x197)))
  1935  	var x200 uint64
  1936  	var x201 uint64
  1937  	x200, x201 = bits.Add64(x188, uint64(0x0), uint64(p384Uint1(x199)))
  1938  	var x202 uint64
  1939  	_, x202 = bits.Mul64(x190, 0x100000001)
  1940  	var x204 uint64
  1941  	var x205 uint64
  1942  	x205, x204 = bits.Mul64(x202, 0xffffffffffffffff)
  1943  	var x206 uint64
  1944  	var x207 uint64
  1945  	x207, x206 = bits.Mul64(x202, 0xffffffffffffffff)
  1946  	var x208 uint64
  1947  	var x209 uint64
  1948  	x209, x208 = bits.Mul64(x202, 0xffffffffffffffff)
  1949  	var x210 uint64
  1950  	var x211 uint64
  1951  	x211, x210 = bits.Mul64(x202, 0xfffffffffffffffe)
  1952  	var x212 uint64
  1953  	var x213 uint64
  1954  	x213, x212 = bits.Mul64(x202, 0xffffffff00000000)
  1955  	var x214 uint64
  1956  	var x215 uint64
  1957  	x215, x214 = bits.Mul64(x202, 0xffffffff)
  1958  	var x216 uint64
  1959  	var x217 uint64
  1960  	x216, x217 = bits.Add64(x215, x212, uint64(0x0))
  1961  	var x218 uint64
  1962  	var x219 uint64
  1963  	x218, x219 = bits.Add64(x213, x210, uint64(p384Uint1(x217)))
  1964  	var x220 uint64
  1965  	var x221 uint64
  1966  	x220, x221 = bits.Add64(x211, x208, uint64(p384Uint1(x219)))
  1967  	var x222 uint64
  1968  	var x223 uint64
  1969  	x222, x223 = bits.Add64(x209, x206, uint64(p384Uint1(x221)))
  1970  	var x224 uint64
  1971  	var x225 uint64
  1972  	x224, x225 = bits.Add64(x207, x204, uint64(p384Uint1(x223)))
  1973  	var x227 uint64
  1974  	_, x227 = bits.Add64(x190, x214, uint64(0x0))
  1975  	var x228 uint64
  1976  	var x229 uint64
  1977  	x228, x229 = bits.Add64(x192, x216, uint64(p384Uint1(x227)))
  1978  	var x230 uint64
  1979  	var x231 uint64
  1980  	x230, x231 = bits.Add64(x194, x218, uint64(p384Uint1(x229)))
  1981  	var x232 uint64
  1982  	var x233 uint64
  1983  	x232, x233 = bits.Add64(x196, x220, uint64(p384Uint1(x231)))
  1984  	var x234 uint64
  1985  	var x235 uint64
  1986  	x234, x235 = bits.Add64(x198, x222, uint64(p384Uint1(x233)))
  1987  	var x236 uint64
  1988  	var x237 uint64
  1989  	x236, x237 = bits.Add64(x200, x224, uint64(p384Uint1(x235)))
  1990  	var x238 uint64
  1991  	var x239 uint64
  1992  	x238, x239 = bits.Add64((uint64(p384Uint1(x201)) + uint64(p384Uint1(x189))), (uint64(p384Uint1(x225)) + x205), uint64(p384Uint1(x237)))
  1993  	var x240 uint64
  1994  	var x241 uint64
  1995  	x240, x241 = bits.Add64(x228, arg1[5], uint64(0x0))
  1996  	var x242 uint64
  1997  	var x243 uint64
  1998  	x242, x243 = bits.Add64(x230, uint64(0x0), uint64(p384Uint1(x241)))
  1999  	var x244 uint64
  2000  	var x245 uint64
  2001  	x244, x245 = bits.Add64(x232, uint64(0x0), uint64(p384Uint1(x243)))
  2002  	var x246 uint64
  2003  	var x247 uint64
  2004  	x246, x247 = bits.Add64(x234, uint64(0x0), uint64(p384Uint1(x245)))
  2005  	var x248 uint64
  2006  	var x249 uint64
  2007  	x248, x249 = bits.Add64(x236, uint64(0x0), uint64(p384Uint1(x247)))
  2008  	var x250 uint64
  2009  	var x251 uint64
  2010  	x250, x251 = bits.Add64(x238, uint64(0x0), uint64(p384Uint1(x249)))
  2011  	var x252 uint64
  2012  	_, x252 = bits.Mul64(x240, 0x100000001)
  2013  	var x254 uint64
  2014  	var x255 uint64
  2015  	x255, x254 = bits.Mul64(x252, 0xffffffffffffffff)
  2016  	var x256 uint64
  2017  	var x257 uint64
  2018  	x257, x256 = bits.Mul64(x252, 0xffffffffffffffff)
  2019  	var x258 uint64
  2020  	var x259 uint64
  2021  	x259, x258 = bits.Mul64(x252, 0xffffffffffffffff)
  2022  	var x260 uint64
  2023  	var x261 uint64
  2024  	x261, x260 = bits.Mul64(x252, 0xfffffffffffffffe)
  2025  	var x262 uint64
  2026  	var x263 uint64
  2027  	x263, x262 = bits.Mul64(x252, 0xffffffff00000000)
  2028  	var x264 uint64
  2029  	var x265 uint64
  2030  	x265, x264 = bits.Mul64(x252, 0xffffffff)
  2031  	var x266 uint64
  2032  	var x267 uint64
  2033  	x266, x267 = bits.Add64(x265, x262, uint64(0x0))
  2034  	var x268 uint64
  2035  	var x269 uint64
  2036  	x268, x269 = bits.Add64(x263, x260, uint64(p384Uint1(x267)))
  2037  	var x270 uint64
  2038  	var x271 uint64
  2039  	x270, x271 = bits.Add64(x261, x258, uint64(p384Uint1(x269)))
  2040  	var x272 uint64
  2041  	var x273 uint64
  2042  	x272, x273 = bits.Add64(x259, x256, uint64(p384Uint1(x271)))
  2043  	var x274 uint64
  2044  	var x275 uint64
  2045  	x274, x275 = bits.Add64(x257, x254, uint64(p384Uint1(x273)))
  2046  	var x277 uint64
  2047  	_, x277 = bits.Add64(x240, x264, uint64(0x0))
  2048  	var x278 uint64
  2049  	var x279 uint64
  2050  	x278, x279 = bits.Add64(x242, x266, uint64(p384Uint1(x277)))
  2051  	var x280 uint64
  2052  	var x281 uint64
  2053  	x280, x281 = bits.Add64(x244, x268, uint64(p384Uint1(x279)))
  2054  	var x282 uint64
  2055  	var x283 uint64
  2056  	x282, x283 = bits.Add64(x246, x270, uint64(p384Uint1(x281)))
  2057  	var x284 uint64
  2058  	var x285 uint64
  2059  	x284, x285 = bits.Add64(x248, x272, uint64(p384Uint1(x283)))
  2060  	var x286 uint64
  2061  	var x287 uint64
  2062  	x286, x287 = bits.Add64(x250, x274, uint64(p384Uint1(x285)))
  2063  	var x288 uint64
  2064  	var x289 uint64
  2065  	x288, x289 = bits.Add64((uint64(p384Uint1(x251)) + uint64(p384Uint1(x239))), (uint64(p384Uint1(x275)) + x255), uint64(p384Uint1(x287)))
  2066  	var x290 uint64
  2067  	var x291 uint64
  2068  	x290, x291 = bits.Sub64(x278, 0xffffffff, uint64(0x0))
  2069  	var x292 uint64
  2070  	var x293 uint64
  2071  	x292, x293 = bits.Sub64(x280, 0xffffffff00000000, uint64(p384Uint1(x291)))
  2072  	var x294 uint64
  2073  	var x295 uint64
  2074  	x294, x295 = bits.Sub64(x282, 0xfffffffffffffffe, uint64(p384Uint1(x293)))
  2075  	var x296 uint64
  2076  	var x297 uint64
  2077  	x296, x297 = bits.Sub64(x284, 0xffffffffffffffff, uint64(p384Uint1(x295)))
  2078  	var x298 uint64
  2079  	var x299 uint64
  2080  	x298, x299 = bits.Sub64(x286, 0xffffffffffffffff, uint64(p384Uint1(x297)))
  2081  	var x300 uint64
  2082  	var x301 uint64
  2083  	x300, x301 = bits.Sub64(x288, 0xffffffffffffffff, uint64(p384Uint1(x299)))
  2084  	var x303 uint64
  2085  	_, x303 = bits.Sub64(uint64(p384Uint1(x289)), uint64(0x0), uint64(p384Uint1(x301)))
  2086  	var x304 uint64
  2087  	p384CmovznzU64(&x304, p384Uint1(x303), x290, x278)
  2088  	var x305 uint64
  2089  	p384CmovznzU64(&x305, p384Uint1(x303), x292, x280)
  2090  	var x306 uint64
  2091  	p384CmovznzU64(&x306, p384Uint1(x303), x294, x282)
  2092  	var x307 uint64
  2093  	p384CmovznzU64(&x307, p384Uint1(x303), x296, x284)
  2094  	var x308 uint64
  2095  	p384CmovznzU64(&x308, p384Uint1(x303), x298, x286)
  2096  	var x309 uint64
  2097  	p384CmovznzU64(&x309, p384Uint1(x303), x300, x288)
  2098  	out1[0] = x304
  2099  	out1[1] = x305
  2100  	out1[2] = x306
  2101  	out1[3] = x307
  2102  	out1[4] = x308
  2103  	out1[5] = x309
  2104  }
  2105  
  2106  // p384ToMontgomery translates a field element into the Montgomery domain.
  2107  //
  2108  // Preconditions:
  2109  //
  2110  //	0 ≤ eval arg1 < m
  2111  //
  2112  // Postconditions:
  2113  //
  2114  //	eval (from_montgomery out1) mod m = eval arg1 mod m
  2115  //	0 ≤ eval out1 < m
  2116  func p384ToMontgomery(out1 *p384MontgomeryDomainFieldElement, arg1 *p384NonMontgomeryDomainFieldElement) {
  2117  	x1 := arg1[1]
  2118  	x2 := arg1[2]
  2119  	x3 := arg1[3]
  2120  	x4 := arg1[4]
  2121  	x5 := arg1[5]
  2122  	x6 := arg1[0]
  2123  	var x7 uint64
  2124  	var x8 uint64
  2125  	x8, x7 = bits.Mul64(x6, 0x200000000)
  2126  	var x9 uint64
  2127  	var x10 uint64
  2128  	x10, x9 = bits.Mul64(x6, 0xfffffffe00000000)
  2129  	var x11 uint64
  2130  	var x12 uint64
  2131  	x12, x11 = bits.Mul64(x6, 0x200000000)
  2132  	var x13 uint64
  2133  	var x14 uint64
  2134  	x14, x13 = bits.Mul64(x6, 0xfffffffe00000001)
  2135  	var x15 uint64
  2136  	var x16 uint64
  2137  	x15, x16 = bits.Add64(x14, x11, uint64(0x0))
  2138  	var x17 uint64
  2139  	var x18 uint64
  2140  	x17, x18 = bits.Add64(x12, x9, uint64(p384Uint1(x16)))
  2141  	var x19 uint64
  2142  	var x20 uint64
  2143  	x19, x20 = bits.Add64(x10, x7, uint64(p384Uint1(x18)))
  2144  	var x21 uint64
  2145  	var x22 uint64
  2146  	x21, x22 = bits.Add64(x8, x6, uint64(p384Uint1(x20)))
  2147  	var x23 uint64
  2148  	_, x23 = bits.Mul64(x13, 0x100000001)
  2149  	var x25 uint64
  2150  	var x26 uint64
  2151  	x26, x25 = bits.Mul64(x23, 0xffffffffffffffff)
  2152  	var x27 uint64
  2153  	var x28 uint64
  2154  	x28, x27 = bits.Mul64(x23, 0xffffffffffffffff)
  2155  	var x29 uint64
  2156  	var x30 uint64
  2157  	x30, x29 = bits.Mul64(x23, 0xffffffffffffffff)
  2158  	var x31 uint64
  2159  	var x32 uint64
  2160  	x32, x31 = bits.Mul64(x23, 0xfffffffffffffffe)
  2161  	var x33 uint64
  2162  	var x34 uint64
  2163  	x34, x33 = bits.Mul64(x23, 0xffffffff00000000)
  2164  	var x35 uint64
  2165  	var x36 uint64
  2166  	x36, x35 = bits.Mul64(x23, 0xffffffff)
  2167  	var x37 uint64
  2168  	var x38 uint64
  2169  	x37, x38 = bits.Add64(x36, x33, uint64(0x0))
  2170  	var x39 uint64
  2171  	var x40 uint64
  2172  	x39, x40 = bits.Add64(x34, x31, uint64(p384Uint1(x38)))
  2173  	var x41 uint64
  2174  	var x42 uint64
  2175  	x41, x42 = bits.Add64(x32, x29, uint64(p384Uint1(x40)))
  2176  	var x43 uint64
  2177  	var x44 uint64
  2178  	x43, x44 = bits.Add64(x30, x27, uint64(p384Uint1(x42)))
  2179  	var x45 uint64
  2180  	var x46 uint64
  2181  	x45, x46 = bits.Add64(x28, x25, uint64(p384Uint1(x44)))
  2182  	var x48 uint64
  2183  	_, x48 = bits.Add64(x13, x35, uint64(0x0))
  2184  	var x49 uint64
  2185  	var x50 uint64
  2186  	x49, x50 = bits.Add64(x15, x37, uint64(p384Uint1(x48)))
  2187  	var x51 uint64
  2188  	var x52 uint64
  2189  	x51, x52 = bits.Add64(x17, x39, uint64(p384Uint1(x50)))
  2190  	var x53 uint64
  2191  	var x54 uint64
  2192  	x53, x54 = bits.Add64(x19, x41, uint64(p384Uint1(x52)))
  2193  	var x55 uint64
  2194  	var x56 uint64
  2195  	x55, x56 = bits.Add64(x21, x43, uint64(p384Uint1(x54)))
  2196  	var x57 uint64
  2197  	var x58 uint64
  2198  	x57, x58 = bits.Add64(uint64(p384Uint1(x22)), x45, uint64(p384Uint1(x56)))
  2199  	var x59 uint64
  2200  	var x60 uint64
  2201  	x59, x60 = bits.Add64(uint64(0x0), (uint64(p384Uint1(x46)) + x26), uint64(p384Uint1(x58)))
  2202  	var x61 uint64
  2203  	var x62 uint64
  2204  	x62, x61 = bits.Mul64(x1, 0x200000000)
  2205  	var x63 uint64
  2206  	var x64 uint64
  2207  	x64, x63 = bits.Mul64(x1, 0xfffffffe00000000)
  2208  	var x65 uint64
  2209  	var x66 uint64
  2210  	x66, x65 = bits.Mul64(x1, 0x200000000)
  2211  	var x67 uint64
  2212  	var x68 uint64
  2213  	x68, x67 = bits.Mul64(x1, 0xfffffffe00000001)
  2214  	var x69 uint64
  2215  	var x70 uint64
  2216  	x69, x70 = bits.Add64(x68, x65, uint64(0x0))
  2217  	var x71 uint64
  2218  	var x72 uint64
  2219  	x71, x72 = bits.Add64(x66, x63, uint64(p384Uint1(x70)))
  2220  	var x73 uint64
  2221  	var x74 uint64
  2222  	x73, x74 = bits.Add64(x64, x61, uint64(p384Uint1(x72)))
  2223  	var x75 uint64
  2224  	var x76 uint64
  2225  	x75, x76 = bits.Add64(x62, x1, uint64(p384Uint1(x74)))
  2226  	var x77 uint64
  2227  	var x78 uint64
  2228  	x77, x78 = bits.Add64(x49, x67, uint64(0x0))
  2229  	var x79 uint64
  2230  	var x80 uint64
  2231  	x79, x80 = bits.Add64(x51, x69, uint64(p384Uint1(x78)))
  2232  	var x81 uint64
  2233  	var x82 uint64
  2234  	x81, x82 = bits.Add64(x53, x71, uint64(p384Uint1(x80)))
  2235  	var x83 uint64
  2236  	var x84 uint64
  2237  	x83, x84 = bits.Add64(x55, x73, uint64(p384Uint1(x82)))
  2238  	var x85 uint64
  2239  	var x86 uint64
  2240  	x85, x86 = bits.Add64(x57, x75, uint64(p384Uint1(x84)))
  2241  	var x87 uint64
  2242  	var x88 uint64
  2243  	x87, x88 = bits.Add64(x59, uint64(p384Uint1(x76)), uint64(p384Uint1(x86)))
  2244  	var x89 uint64
  2245  	_, x89 = bits.Mul64(x77, 0x100000001)
  2246  	var x91 uint64
  2247  	var x92 uint64
  2248  	x92, x91 = bits.Mul64(x89, 0xffffffffffffffff)
  2249  	var x93 uint64
  2250  	var x94 uint64
  2251  	x94, x93 = bits.Mul64(x89, 0xffffffffffffffff)
  2252  	var x95 uint64
  2253  	var x96 uint64
  2254  	x96, x95 = bits.Mul64(x89, 0xffffffffffffffff)
  2255  	var x97 uint64
  2256  	var x98 uint64
  2257  	x98, x97 = bits.Mul64(x89, 0xfffffffffffffffe)
  2258  	var x99 uint64
  2259  	var x100 uint64
  2260  	x100, x99 = bits.Mul64(x89, 0xffffffff00000000)
  2261  	var x101 uint64
  2262  	var x102 uint64
  2263  	x102, x101 = bits.Mul64(x89, 0xffffffff)
  2264  	var x103 uint64
  2265  	var x104 uint64
  2266  	x103, x104 = bits.Add64(x102, x99, uint64(0x0))
  2267  	var x105 uint64
  2268  	var x106 uint64
  2269  	x105, x106 = bits.Add64(x100, x97, uint64(p384Uint1(x104)))
  2270  	var x107 uint64
  2271  	var x108 uint64
  2272  	x107, x108 = bits.Add64(x98, x95, uint64(p384Uint1(x106)))
  2273  	var x109 uint64
  2274  	var x110 uint64
  2275  	x109, x110 = bits.Add64(x96, x93, uint64(p384Uint1(x108)))
  2276  	var x111 uint64
  2277  	var x112 uint64
  2278  	x111, x112 = bits.Add64(x94, x91, uint64(p384Uint1(x110)))
  2279  	var x114 uint64
  2280  	_, x114 = bits.Add64(x77, x101, uint64(0x0))
  2281  	var x115 uint64
  2282  	var x116 uint64
  2283  	x115, x116 = bits.Add64(x79, x103, uint64(p384Uint1(x114)))
  2284  	var x117 uint64
  2285  	var x118 uint64
  2286  	x117, x118 = bits.Add64(x81, x105, uint64(p384Uint1(x116)))
  2287  	var x119 uint64
  2288  	var x120 uint64
  2289  	x119, x120 = bits.Add64(x83, x107, uint64(p384Uint1(x118)))
  2290  	var x121 uint64
  2291  	var x122 uint64
  2292  	x121, x122 = bits.Add64(x85, x109, uint64(p384Uint1(x120)))
  2293  	var x123 uint64
  2294  	var x124 uint64
  2295  	x123, x124 = bits.Add64(x87, x111, uint64(p384Uint1(x122)))
  2296  	var x125 uint64
  2297  	var x126 uint64
  2298  	x125, x126 = bits.Add64((uint64(p384Uint1(x88)) + uint64(p384Uint1(x60))), (uint64(p384Uint1(x112)) + x92), uint64(p384Uint1(x124)))
  2299  	var x127 uint64
  2300  	var x128 uint64
  2301  	x128, x127 = bits.Mul64(x2, 0x200000000)
  2302  	var x129 uint64
  2303  	var x130 uint64
  2304  	x130, x129 = bits.Mul64(x2, 0xfffffffe00000000)
  2305  	var x131 uint64
  2306  	var x132 uint64
  2307  	x132, x131 = bits.Mul64(x2, 0x200000000)
  2308  	var x133 uint64
  2309  	var x134 uint64
  2310  	x134, x133 = bits.Mul64(x2, 0xfffffffe00000001)
  2311  	var x135 uint64
  2312  	var x136 uint64
  2313  	x135, x136 = bits.Add64(x134, x131, uint64(0x0))
  2314  	var x137 uint64
  2315  	var x138 uint64
  2316  	x137, x138 = bits.Add64(x132, x129, uint64(p384Uint1(x136)))
  2317  	var x139 uint64
  2318  	var x140 uint64
  2319  	x139, x140 = bits.Add64(x130, x127, uint64(p384Uint1(x138)))
  2320  	var x141 uint64
  2321  	var x142 uint64
  2322  	x141, x142 = bits.Add64(x128, x2, uint64(p384Uint1(x140)))
  2323  	var x143 uint64
  2324  	var x144 uint64
  2325  	x143, x144 = bits.Add64(x115, x133, uint64(0x0))
  2326  	var x145 uint64
  2327  	var x146 uint64
  2328  	x145, x146 = bits.Add64(x117, x135, uint64(p384Uint1(x144)))
  2329  	var x147 uint64
  2330  	var x148 uint64
  2331  	x147, x148 = bits.Add64(x119, x137, uint64(p384Uint1(x146)))
  2332  	var x149 uint64
  2333  	var x150 uint64
  2334  	x149, x150 = bits.Add64(x121, x139, uint64(p384Uint1(x148)))
  2335  	var x151 uint64
  2336  	var x152 uint64
  2337  	x151, x152 = bits.Add64(x123, x141, uint64(p384Uint1(x150)))
  2338  	var x153 uint64
  2339  	var x154 uint64
  2340  	x153, x154 = bits.Add64(x125, uint64(p384Uint1(x142)), uint64(p384Uint1(x152)))
  2341  	var x155 uint64
  2342  	_, x155 = bits.Mul64(x143, 0x100000001)
  2343  	var x157 uint64
  2344  	var x158 uint64
  2345  	x158, x157 = bits.Mul64(x155, 0xffffffffffffffff)
  2346  	var x159 uint64
  2347  	var x160 uint64
  2348  	x160, x159 = bits.Mul64(x155, 0xffffffffffffffff)
  2349  	var x161 uint64
  2350  	var x162 uint64
  2351  	x162, x161 = bits.Mul64(x155, 0xffffffffffffffff)
  2352  	var x163 uint64
  2353  	var x164 uint64
  2354  	x164, x163 = bits.Mul64(x155, 0xfffffffffffffffe)
  2355  	var x165 uint64
  2356  	var x166 uint64
  2357  	x166, x165 = bits.Mul64(x155, 0xffffffff00000000)
  2358  	var x167 uint64
  2359  	var x168 uint64
  2360  	x168, x167 = bits.Mul64(x155, 0xffffffff)
  2361  	var x169 uint64
  2362  	var x170 uint64
  2363  	x169, x170 = bits.Add64(x168, x165, uint64(0x0))
  2364  	var x171 uint64
  2365  	var x172 uint64
  2366  	x171, x172 = bits.Add64(x166, x163, uint64(p384Uint1(x170)))
  2367  	var x173 uint64
  2368  	var x174 uint64
  2369  	x173, x174 = bits.Add64(x164, x161, uint64(p384Uint1(x172)))
  2370  	var x175 uint64
  2371  	var x176 uint64
  2372  	x175, x176 = bits.Add64(x162, x159, uint64(p384Uint1(x174)))
  2373  	var x177 uint64
  2374  	var x178 uint64
  2375  	x177, x178 = bits.Add64(x160, x157, uint64(p384Uint1(x176)))
  2376  	var x180 uint64
  2377  	_, x180 = bits.Add64(x143, x167, uint64(0x0))
  2378  	var x181 uint64
  2379  	var x182 uint64
  2380  	x181, x182 = bits.Add64(x145, x169, uint64(p384Uint1(x180)))
  2381  	var x183 uint64
  2382  	var x184 uint64
  2383  	x183, x184 = bits.Add64(x147, x171, uint64(p384Uint1(x182)))
  2384  	var x185 uint64
  2385  	var x186 uint64
  2386  	x185, x186 = bits.Add64(x149, x173, uint64(p384Uint1(x184)))
  2387  	var x187 uint64
  2388  	var x188 uint64
  2389  	x187, x188 = bits.Add64(x151, x175, uint64(p384Uint1(x186)))
  2390  	var x189 uint64
  2391  	var x190 uint64
  2392  	x189, x190 = bits.Add64(x153, x177, uint64(p384Uint1(x188)))
  2393  	var x191 uint64
  2394  	var x192 uint64
  2395  	x191, x192 = bits.Add64((uint64(p384Uint1(x154)) + uint64(p384Uint1(x126))), (uint64(p384Uint1(x178)) + x158), uint64(p384Uint1(x190)))
  2396  	var x193 uint64
  2397  	var x194 uint64
  2398  	x194, x193 = bits.Mul64(x3, 0x200000000)
  2399  	var x195 uint64
  2400  	var x196 uint64
  2401  	x196, x195 = bits.Mul64(x3, 0xfffffffe00000000)
  2402  	var x197 uint64
  2403  	var x198 uint64
  2404  	x198, x197 = bits.Mul64(x3, 0x200000000)
  2405  	var x199 uint64
  2406  	var x200 uint64
  2407  	x200, x199 = bits.Mul64(x3, 0xfffffffe00000001)
  2408  	var x201 uint64
  2409  	var x202 uint64
  2410  	x201, x202 = bits.Add64(x200, x197, uint64(0x0))
  2411  	var x203 uint64
  2412  	var x204 uint64
  2413  	x203, x204 = bits.Add64(x198, x195, uint64(p384Uint1(x202)))
  2414  	var x205 uint64
  2415  	var x206 uint64
  2416  	x205, x206 = bits.Add64(x196, x193, uint64(p384Uint1(x204)))
  2417  	var x207 uint64
  2418  	var x208 uint64
  2419  	x207, x208 = bits.Add64(x194, x3, uint64(p384Uint1(x206)))
  2420  	var x209 uint64
  2421  	var x210 uint64
  2422  	x209, x210 = bits.Add64(x181, x199, uint64(0x0))
  2423  	var x211 uint64
  2424  	var x212 uint64
  2425  	x211, x212 = bits.Add64(x183, x201, uint64(p384Uint1(x210)))
  2426  	var x213 uint64
  2427  	var x214 uint64
  2428  	x213, x214 = bits.Add64(x185, x203, uint64(p384Uint1(x212)))
  2429  	var x215 uint64
  2430  	var x216 uint64
  2431  	x215, x216 = bits.Add64(x187, x205, uint64(p384Uint1(x214)))
  2432  	var x217 uint64
  2433  	var x218 uint64
  2434  	x217, x218 = bits.Add64(x189, x207, uint64(p384Uint1(x216)))
  2435  	var x219 uint64
  2436  	var x220 uint64
  2437  	x219, x220 = bits.Add64(x191, uint64(p384Uint1(x208)), uint64(p384Uint1(x218)))
  2438  	var x221 uint64
  2439  	_, x221 = bits.Mul64(x209, 0x100000001)
  2440  	var x223 uint64
  2441  	var x224 uint64
  2442  	x224, x223 = bits.Mul64(x221, 0xffffffffffffffff)
  2443  	var x225 uint64
  2444  	var x226 uint64
  2445  	x226, x225 = bits.Mul64(x221, 0xffffffffffffffff)
  2446  	var x227 uint64
  2447  	var x228 uint64
  2448  	x228, x227 = bits.Mul64(x221, 0xffffffffffffffff)
  2449  	var x229 uint64
  2450  	var x230 uint64
  2451  	x230, x229 = bits.Mul64(x221, 0xfffffffffffffffe)
  2452  	var x231 uint64
  2453  	var x232 uint64
  2454  	x232, x231 = bits.Mul64(x221, 0xffffffff00000000)
  2455  	var x233 uint64
  2456  	var x234 uint64
  2457  	x234, x233 = bits.Mul64(x221, 0xffffffff)
  2458  	var x235 uint64
  2459  	var x236 uint64
  2460  	x235, x236 = bits.Add64(x234, x231, uint64(0x0))
  2461  	var x237 uint64
  2462  	var x238 uint64
  2463  	x237, x238 = bits.Add64(x232, x229, uint64(p384Uint1(x236)))
  2464  	var x239 uint64
  2465  	var x240 uint64
  2466  	x239, x240 = bits.Add64(x230, x227, uint64(p384Uint1(x238)))
  2467  	var x241 uint64
  2468  	var x242 uint64
  2469  	x241, x242 = bits.Add64(x228, x225, uint64(p384Uint1(x240)))
  2470  	var x243 uint64
  2471  	var x244 uint64
  2472  	x243, x244 = bits.Add64(x226, x223, uint64(p384Uint1(x242)))
  2473  	var x246 uint64
  2474  	_, x246 = bits.Add64(x209, x233, uint64(0x0))
  2475  	var x247 uint64
  2476  	var x248 uint64
  2477  	x247, x248 = bits.Add64(x211, x235, uint64(p384Uint1(x246)))
  2478  	var x249 uint64
  2479  	var x250 uint64
  2480  	x249, x250 = bits.Add64(x213, x237, uint64(p384Uint1(x248)))
  2481  	var x251 uint64
  2482  	var x252 uint64
  2483  	x251, x252 = bits.Add64(x215, x239, uint64(p384Uint1(x250)))
  2484  	var x253 uint64
  2485  	var x254 uint64
  2486  	x253, x254 = bits.Add64(x217, x241, uint64(p384Uint1(x252)))
  2487  	var x255 uint64
  2488  	var x256 uint64
  2489  	x255, x256 = bits.Add64(x219, x243, uint64(p384Uint1(x254)))
  2490  	var x257 uint64
  2491  	var x258 uint64
  2492  	x257, x258 = bits.Add64((uint64(p384Uint1(x220)) + uint64(p384Uint1(x192))), (uint64(p384Uint1(x244)) + x224), uint64(p384Uint1(x256)))
  2493  	var x259 uint64
  2494  	var x260 uint64
  2495  	x260, x259 = bits.Mul64(x4, 0x200000000)
  2496  	var x261 uint64
  2497  	var x262 uint64
  2498  	x262, x261 = bits.Mul64(x4, 0xfffffffe00000000)
  2499  	var x263 uint64
  2500  	var x264 uint64
  2501  	x264, x263 = bits.Mul64(x4, 0x200000000)
  2502  	var x265 uint64
  2503  	var x266 uint64
  2504  	x266, x265 = bits.Mul64(x4, 0xfffffffe00000001)
  2505  	var x267 uint64
  2506  	var x268 uint64
  2507  	x267, x268 = bits.Add64(x266, x263, uint64(0x0))
  2508  	var x269 uint64
  2509  	var x270 uint64
  2510  	x269, x270 = bits.Add64(x264, x261, uint64(p384Uint1(x268)))
  2511  	var x271 uint64
  2512  	var x272 uint64
  2513  	x271, x272 = bits.Add64(x262, x259, uint64(p384Uint1(x270)))
  2514  	var x273 uint64
  2515  	var x274 uint64
  2516  	x273, x274 = bits.Add64(x260, x4, uint64(p384Uint1(x272)))
  2517  	var x275 uint64
  2518  	var x276 uint64
  2519  	x275, x276 = bits.Add64(x247, x265, uint64(0x0))
  2520  	var x277 uint64
  2521  	var x278 uint64
  2522  	x277, x278 = bits.Add64(x249, x267, uint64(p384Uint1(x276)))
  2523  	var x279 uint64
  2524  	var x280 uint64
  2525  	x279, x280 = bits.Add64(x251, x269, uint64(p384Uint1(x278)))
  2526  	var x281 uint64
  2527  	var x282 uint64
  2528  	x281, x282 = bits.Add64(x253, x271, uint64(p384Uint1(x280)))
  2529  	var x283 uint64
  2530  	var x284 uint64
  2531  	x283, x284 = bits.Add64(x255, x273, uint64(p384Uint1(x282)))
  2532  	var x285 uint64
  2533  	var x286 uint64
  2534  	x285, x286 = bits.Add64(x257, uint64(p384Uint1(x274)), uint64(p384Uint1(x284)))
  2535  	var x287 uint64
  2536  	_, x287 = bits.Mul64(x275, 0x100000001)
  2537  	var x289 uint64
  2538  	var x290 uint64
  2539  	x290, x289 = bits.Mul64(x287, 0xffffffffffffffff)
  2540  	var x291 uint64
  2541  	var x292 uint64
  2542  	x292, x291 = bits.Mul64(x287, 0xffffffffffffffff)
  2543  	var x293 uint64
  2544  	var x294 uint64
  2545  	x294, x293 = bits.Mul64(x287, 0xffffffffffffffff)
  2546  	var x295 uint64
  2547  	var x296 uint64
  2548  	x296, x295 = bits.Mul64(x287, 0xfffffffffffffffe)
  2549  	var x297 uint64
  2550  	var x298 uint64
  2551  	x298, x297 = bits.Mul64(x287, 0xffffffff00000000)
  2552  	var x299 uint64
  2553  	var x300 uint64
  2554  	x300, x299 = bits.Mul64(x287, 0xffffffff)
  2555  	var x301 uint64
  2556  	var x302 uint64
  2557  	x301, x302 = bits.Add64(x300, x297, uint64(0x0))
  2558  	var x303 uint64
  2559  	var x304 uint64
  2560  	x303, x304 = bits.Add64(x298, x295, uint64(p384Uint1(x302)))
  2561  	var x305 uint64
  2562  	var x306 uint64
  2563  	x305, x306 = bits.Add64(x296, x293, uint64(p384Uint1(x304)))
  2564  	var x307 uint64
  2565  	var x308 uint64
  2566  	x307, x308 = bits.Add64(x294, x291, uint64(p384Uint1(x306)))
  2567  	var x309 uint64
  2568  	var x310 uint64
  2569  	x309, x310 = bits.Add64(x292, x289, uint64(p384Uint1(x308)))
  2570  	var x312 uint64
  2571  	_, x312 = bits.Add64(x275, x299, uint64(0x0))
  2572  	var x313 uint64
  2573  	var x314 uint64
  2574  	x313, x314 = bits.Add64(x277, x301, uint64(p384Uint1(x312)))
  2575  	var x315 uint64
  2576  	var x316 uint64
  2577  	x315, x316 = bits.Add64(x279, x303, uint64(p384Uint1(x314)))
  2578  	var x317 uint64
  2579  	var x318 uint64
  2580  	x317, x318 = bits.Add64(x281, x305, uint64(p384Uint1(x316)))
  2581  	var x319 uint64
  2582  	var x320 uint64
  2583  	x319, x320 = bits.Add64(x283, x307, uint64(p384Uint1(x318)))
  2584  	var x321 uint64
  2585  	var x322 uint64
  2586  	x321, x322 = bits.Add64(x285, x309, uint64(p384Uint1(x320)))
  2587  	var x323 uint64
  2588  	var x324 uint64
  2589  	x323, x324 = bits.Add64((uint64(p384Uint1(x286)) + uint64(p384Uint1(x258))), (uint64(p384Uint1(x310)) + x290), uint64(p384Uint1(x322)))
  2590  	var x325 uint64
  2591  	var x326 uint64
  2592  	x326, x325 = bits.Mul64(x5, 0x200000000)
  2593  	var x327 uint64
  2594  	var x328 uint64
  2595  	x328, x327 = bits.Mul64(x5, 0xfffffffe00000000)
  2596  	var x329 uint64
  2597  	var x330 uint64
  2598  	x330, x329 = bits.Mul64(x5, 0x200000000)
  2599  	var x331 uint64
  2600  	var x332 uint64
  2601  	x332, x331 = bits.Mul64(x5, 0xfffffffe00000001)
  2602  	var x333 uint64
  2603  	var x334 uint64
  2604  	x333, x334 = bits.Add64(x332, x329, uint64(0x0))
  2605  	var x335 uint64
  2606  	var x336 uint64
  2607  	x335, x336 = bits.Add64(x330, x327, uint64(p384Uint1(x334)))
  2608  	var x337 uint64
  2609  	var x338 uint64
  2610  	x337, x338 = bits.Add64(x328, x325, uint64(p384Uint1(x336)))
  2611  	var x339 uint64
  2612  	var x340 uint64
  2613  	x339, x340 = bits.Add64(x326, x5, uint64(p384Uint1(x338)))
  2614  	var x341 uint64
  2615  	var x342 uint64
  2616  	x341, x342 = bits.Add64(x313, x331, uint64(0x0))
  2617  	var x343 uint64
  2618  	var x344 uint64
  2619  	x343, x344 = bits.Add64(x315, x333, uint64(p384Uint1(x342)))
  2620  	var x345 uint64
  2621  	var x346 uint64
  2622  	x345, x346 = bits.Add64(x317, x335, uint64(p384Uint1(x344)))
  2623  	var x347 uint64
  2624  	var x348 uint64
  2625  	x347, x348 = bits.Add64(x319, x337, uint64(p384Uint1(x346)))
  2626  	var x349 uint64
  2627  	var x350 uint64
  2628  	x349, x350 = bits.Add64(x321, x339, uint64(p384Uint1(x348)))
  2629  	var x351 uint64
  2630  	var x352 uint64
  2631  	x351, x352 = bits.Add64(x323, uint64(p384Uint1(x340)), uint64(p384Uint1(x350)))
  2632  	var x353 uint64
  2633  	_, x353 = bits.Mul64(x341, 0x100000001)
  2634  	var x355 uint64
  2635  	var x356 uint64
  2636  	x356, x355 = bits.Mul64(x353, 0xffffffffffffffff)
  2637  	var x357 uint64
  2638  	var x358 uint64
  2639  	x358, x357 = bits.Mul64(x353, 0xffffffffffffffff)
  2640  	var x359 uint64
  2641  	var x360 uint64
  2642  	x360, x359 = bits.Mul64(x353, 0xffffffffffffffff)
  2643  	var x361 uint64
  2644  	var x362 uint64
  2645  	x362, x361 = bits.Mul64(x353, 0xfffffffffffffffe)
  2646  	var x363 uint64
  2647  	var x364 uint64
  2648  	x364, x363 = bits.Mul64(x353, 0xffffffff00000000)
  2649  	var x365 uint64
  2650  	var x366 uint64
  2651  	x366, x365 = bits.Mul64(x353, 0xffffffff)
  2652  	var x367 uint64
  2653  	var x368 uint64
  2654  	x367, x368 = bits.Add64(x366, x363, uint64(0x0))
  2655  	var x369 uint64
  2656  	var x370 uint64
  2657  	x369, x370 = bits.Add64(x364, x361, uint64(p384Uint1(x368)))
  2658  	var x371 uint64
  2659  	var x372 uint64
  2660  	x371, x372 = bits.Add64(x362, x359, uint64(p384Uint1(x370)))
  2661  	var x373 uint64
  2662  	var x374 uint64
  2663  	x373, x374 = bits.Add64(x360, x357, uint64(p384Uint1(x372)))
  2664  	var x375 uint64
  2665  	var x376 uint64
  2666  	x375, x376 = bits.Add64(x358, x355, uint64(p384Uint1(x374)))
  2667  	var x378 uint64
  2668  	_, x378 = bits.Add64(x341, x365, uint64(0x0))
  2669  	var x379 uint64
  2670  	var x380 uint64
  2671  	x379, x380 = bits.Add64(x343, x367, uint64(p384Uint1(x378)))
  2672  	var x381 uint64
  2673  	var x382 uint64
  2674  	x381, x382 = bits.Add64(x345, x369, uint64(p384Uint1(x380)))
  2675  	var x383 uint64
  2676  	var x384 uint64
  2677  	x383, x384 = bits.Add64(x347, x371, uint64(p384Uint1(x382)))
  2678  	var x385 uint64
  2679  	var x386 uint64
  2680  	x385, x386 = bits.Add64(x349, x373, uint64(p384Uint1(x384)))
  2681  	var x387 uint64
  2682  	var x388 uint64
  2683  	x387, x388 = bits.Add64(x351, x375, uint64(p384Uint1(x386)))
  2684  	var x389 uint64
  2685  	var x390 uint64
  2686  	x389, x390 = bits.Add64((uint64(p384Uint1(x352)) + uint64(p384Uint1(x324))), (uint64(p384Uint1(x376)) + x356), uint64(p384Uint1(x388)))
  2687  	var x391 uint64
  2688  	var x392 uint64
  2689  	x391, x392 = bits.Sub64(x379, 0xffffffff, uint64(0x0))
  2690  	var x393 uint64
  2691  	var x394 uint64
  2692  	x393, x394 = bits.Sub64(x381, 0xffffffff00000000, uint64(p384Uint1(x392)))
  2693  	var x395 uint64
  2694  	var x396 uint64
  2695  	x395, x396 = bits.Sub64(x383, 0xfffffffffffffffe, uint64(p384Uint1(x394)))
  2696  	var x397 uint64
  2697  	var x398 uint64
  2698  	x397, x398 = bits.Sub64(x385, 0xffffffffffffffff, uint64(p384Uint1(x396)))
  2699  	var x399 uint64
  2700  	var x400 uint64
  2701  	x399, x400 = bits.Sub64(x387, 0xffffffffffffffff, uint64(p384Uint1(x398)))
  2702  	var x401 uint64
  2703  	var x402 uint64
  2704  	x401, x402 = bits.Sub64(x389, 0xffffffffffffffff, uint64(p384Uint1(x400)))
  2705  	var x404 uint64
  2706  	_, x404 = bits.Sub64(uint64(p384Uint1(x390)), uint64(0x0), uint64(p384Uint1(x402)))
  2707  	var x405 uint64
  2708  	p384CmovznzU64(&x405, p384Uint1(x404), x391, x379)
  2709  	var x406 uint64
  2710  	p384CmovznzU64(&x406, p384Uint1(x404), x393, x381)
  2711  	var x407 uint64
  2712  	p384CmovznzU64(&x407, p384Uint1(x404), x395, x383)
  2713  	var x408 uint64
  2714  	p384CmovznzU64(&x408, p384Uint1(x404), x397, x385)
  2715  	var x409 uint64
  2716  	p384CmovznzU64(&x409, p384Uint1(x404), x399, x387)
  2717  	var x410 uint64
  2718  	p384CmovznzU64(&x410, p384Uint1(x404), x401, x389)
  2719  	out1[0] = x405
  2720  	out1[1] = x406
  2721  	out1[2] = x407
  2722  	out1[3] = x408
  2723  	out1[4] = x409
  2724  	out1[5] = x410
  2725  }
  2726  
  2727  // p384Selectznz is a multi-limb conditional select.
  2728  //
  2729  // Postconditions:
  2730  //
  2731  //	eval out1 = (if arg1 = 0 then eval arg2 else eval arg3)
  2732  //
  2733  // Input Bounds:
  2734  //
  2735  //	arg1: [0x0 ~> 0x1]
  2736  //	arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
  2737  //	arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
  2738  //
  2739  // Output Bounds:
  2740  //
  2741  //	out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
  2742  func p384Selectznz(out1 *[6]uint64, arg1 p384Uint1, arg2 *[6]uint64, arg3 *[6]uint64) {
  2743  	var x1 uint64
  2744  	p384CmovznzU64(&x1, arg1, arg2[0], arg3[0])
  2745  	var x2 uint64
  2746  	p384CmovznzU64(&x2, arg1, arg2[1], arg3[1])
  2747  	var x3 uint64
  2748  	p384CmovznzU64(&x3, arg1, arg2[2], arg3[2])
  2749  	var x4 uint64
  2750  	p384CmovznzU64(&x4, arg1, arg2[3], arg3[3])
  2751  	var x5 uint64
  2752  	p384CmovznzU64(&x5, arg1, arg2[4], arg3[4])
  2753  	var x6 uint64
  2754  	p384CmovznzU64(&x6, arg1, arg2[5], arg3[5])
  2755  	out1[0] = x1
  2756  	out1[1] = x2
  2757  	out1[2] = x3
  2758  	out1[3] = x4
  2759  	out1[4] = x5
  2760  	out1[5] = x6
  2761  }
  2762  
  2763  // p384ToBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.
  2764  //
  2765  // Preconditions:
  2766  //
  2767  //	0 ≤ eval arg1 < m
  2768  //
  2769  // Postconditions:
  2770  //
  2771  //	out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47]
  2772  //
  2773  // Input Bounds:
  2774  //
  2775  //	arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
  2776  //
  2777  // Output Bounds:
  2778  //
  2779  //	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]]
  2780  func p384ToBytes(out1 *[48]uint8, arg1 *[6]uint64) {
  2781  	x1 := arg1[5]
  2782  	x2 := arg1[4]
  2783  	x3 := arg1[3]
  2784  	x4 := arg1[2]
  2785  	x5 := arg1[1]
  2786  	x6 := arg1[0]
  2787  	x7 := (uint8(x6) & 0xff)
  2788  	x8 := (x6 >> 8)
  2789  	x9 := (uint8(x8) & 0xff)
  2790  	x10 := (x8 >> 8)
  2791  	x11 := (uint8(x10) & 0xff)
  2792  	x12 := (x10 >> 8)
  2793  	x13 := (uint8(x12) & 0xff)
  2794  	x14 := (x12 >> 8)
  2795  	x15 := (uint8(x14) & 0xff)
  2796  	x16 := (x14 >> 8)
  2797  	x17 := (uint8(x16) & 0xff)
  2798  	x18 := (x16 >> 8)
  2799  	x19 := (uint8(x18) & 0xff)
  2800  	x20 := uint8((x18 >> 8))
  2801  	x21 := (uint8(x5) & 0xff)
  2802  	x22 := (x5 >> 8)
  2803  	x23 := (uint8(x22) & 0xff)
  2804  	x24 := (x22 >> 8)
  2805  	x25 := (uint8(x24) & 0xff)
  2806  	x26 := (x24 >> 8)
  2807  	x27 := (uint8(x26) & 0xff)
  2808  	x28 := (x26 >> 8)
  2809  	x29 := (uint8(x28) & 0xff)
  2810  	x30 := (x28 >> 8)
  2811  	x31 := (uint8(x30) & 0xff)
  2812  	x32 := (x30 >> 8)
  2813  	x33 := (uint8(x32) & 0xff)
  2814  	x34 := uint8((x32 >> 8))
  2815  	x35 := (uint8(x4) & 0xff)
  2816  	x36 := (x4 >> 8)
  2817  	x37 := (uint8(x36) & 0xff)
  2818  	x38 := (x36 >> 8)
  2819  	x39 := (uint8(x38) & 0xff)
  2820  	x40 := (x38 >> 8)
  2821  	x41 := (uint8(x40) & 0xff)
  2822  	x42 := (x40 >> 8)
  2823  	x43 := (uint8(x42) & 0xff)
  2824  	x44 := (x42 >> 8)
  2825  	x45 := (uint8(x44) & 0xff)
  2826  	x46 := (x44 >> 8)
  2827  	x47 := (uint8(x46) & 0xff)
  2828  	x48 := uint8((x46 >> 8))
  2829  	x49 := (uint8(x3) & 0xff)
  2830  	x50 := (x3 >> 8)
  2831  	x51 := (uint8(x50) & 0xff)
  2832  	x52 := (x50 >> 8)
  2833  	x53 := (uint8(x52) & 0xff)
  2834  	x54 := (x52 >> 8)
  2835  	x55 := (uint8(x54) & 0xff)
  2836  	x56 := (x54 >> 8)
  2837  	x57 := (uint8(x56) & 0xff)
  2838  	x58 := (x56 >> 8)
  2839  	x59 := (uint8(x58) & 0xff)
  2840  	x60 := (x58 >> 8)
  2841  	x61 := (uint8(x60) & 0xff)
  2842  	x62 := uint8((x60 >> 8))
  2843  	x63 := (uint8(x2) & 0xff)
  2844  	x64 := (x2 >> 8)
  2845  	x65 := (uint8(x64) & 0xff)
  2846  	x66 := (x64 >> 8)
  2847  	x67 := (uint8(x66) & 0xff)
  2848  	x68 := (x66 >> 8)
  2849  	x69 := (uint8(x68) & 0xff)
  2850  	x70 := (x68 >> 8)
  2851  	x71 := (uint8(x70) & 0xff)
  2852  	x72 := (x70 >> 8)
  2853  	x73 := (uint8(x72) & 0xff)
  2854  	x74 := (x72 >> 8)
  2855  	x75 := (uint8(x74) & 0xff)
  2856  	x76 := uint8((x74 >> 8))
  2857  	x77 := (uint8(x1) & 0xff)
  2858  	x78 := (x1 >> 8)
  2859  	x79 := (uint8(x78) & 0xff)
  2860  	x80 := (x78 >> 8)
  2861  	x81 := (uint8(x80) & 0xff)
  2862  	x82 := (x80 >> 8)
  2863  	x83 := (uint8(x82) & 0xff)
  2864  	x84 := (x82 >> 8)
  2865  	x85 := (uint8(x84) & 0xff)
  2866  	x86 := (x84 >> 8)
  2867  	x87 := (uint8(x86) & 0xff)
  2868  	x88 := (x86 >> 8)
  2869  	x89 := (uint8(x88) & 0xff)
  2870  	x90 := uint8((x88 >> 8))
  2871  	out1[0] = x7
  2872  	out1[1] = x9
  2873  	out1[2] = x11
  2874  	out1[3] = x13
  2875  	out1[4] = x15
  2876  	out1[5] = x17
  2877  	out1[6] = x19
  2878  	out1[7] = x20
  2879  	out1[8] = x21
  2880  	out1[9] = x23
  2881  	out1[10] = x25
  2882  	out1[11] = x27
  2883  	out1[12] = x29
  2884  	out1[13] = x31
  2885  	out1[14] = x33
  2886  	out1[15] = x34
  2887  	out1[16] = x35
  2888  	out1[17] = x37
  2889  	out1[18] = x39
  2890  	out1[19] = x41
  2891  	out1[20] = x43
  2892  	out1[21] = x45
  2893  	out1[22] = x47
  2894  	out1[23] = x48
  2895  	out1[24] = x49
  2896  	out1[25] = x51
  2897  	out1[26] = x53
  2898  	out1[27] = x55
  2899  	out1[28] = x57
  2900  	out1[29] = x59
  2901  	out1[30] = x61
  2902  	out1[31] = x62
  2903  	out1[32] = x63
  2904  	out1[33] = x65
  2905  	out1[34] = x67
  2906  	out1[35] = x69
  2907  	out1[36] = x71
  2908  	out1[37] = x73
  2909  	out1[38] = x75
  2910  	out1[39] = x76
  2911  	out1[40] = x77
  2912  	out1[41] = x79
  2913  	out1[42] = x81
  2914  	out1[43] = x83
  2915  	out1[44] = x85
  2916  	out1[45] = x87
  2917  	out1[46] = x89
  2918  	out1[47] = x90
  2919  }
  2920  
  2921  // p384FromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.
  2922  //
  2923  // Preconditions:
  2924  //
  2925  //	0 ≤ bytes_eval arg1 < m
  2926  //
  2927  // Postconditions:
  2928  //
  2929  //	eval out1 mod m = bytes_eval arg1 mod m
  2930  //	0 ≤ eval out1 < m
  2931  //
  2932  // Input Bounds:
  2933  //
  2934  //	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]]
  2935  //
  2936  // Output Bounds:
  2937  //
  2938  //	out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
  2939  func p384FromBytes(out1 *[6]uint64, arg1 *[48]uint8) {
  2940  	x1 := (uint64(arg1[47]) << 56)
  2941  	x2 := (uint64(arg1[46]) << 48)
  2942  	x3 := (uint64(arg1[45]) << 40)
  2943  	x4 := (uint64(arg1[44]) << 32)
  2944  	x5 := (uint64(arg1[43]) << 24)
  2945  	x6 := (uint64(arg1[42]) << 16)
  2946  	x7 := (uint64(arg1[41]) << 8)
  2947  	x8 := arg1[40]
  2948  	x9 := (uint64(arg1[39]) << 56)
  2949  	x10 := (uint64(arg1[38]) << 48)
  2950  	x11 := (uint64(arg1[37]) << 40)
  2951  	x12 := (uint64(arg1[36]) << 32)
  2952  	x13 := (uint64(arg1[35]) << 24)
  2953  	x14 := (uint64(arg1[34]) << 16)
  2954  	x15 := (uint64(arg1[33]) << 8)
  2955  	x16 := arg1[32]
  2956  	x17 := (uint64(arg1[31]) << 56)
  2957  	x18 := (uint64(arg1[30]) << 48)
  2958  	x19 := (uint64(arg1[29]) << 40)
  2959  	x20 := (uint64(arg1[28]) << 32)
  2960  	x21 := (uint64(arg1[27]) << 24)
  2961  	x22 := (uint64(arg1[26]) << 16)
  2962  	x23 := (uint64(arg1[25]) << 8)
  2963  	x24 := arg1[24]
  2964  	x25 := (uint64(arg1[23]) << 56)
  2965  	x26 := (uint64(arg1[22]) << 48)
  2966  	x27 := (uint64(arg1[21]) << 40)
  2967  	x28 := (uint64(arg1[20]) << 32)
  2968  	x29 := (uint64(arg1[19]) << 24)
  2969  	x30 := (uint64(arg1[18]) << 16)
  2970  	x31 := (uint64(arg1[17]) << 8)
  2971  	x32 := arg1[16]
  2972  	x33 := (uint64(arg1[15]) << 56)
  2973  	x34 := (uint64(arg1[14]) << 48)
  2974  	x35 := (uint64(arg1[13]) << 40)
  2975  	x36 := (uint64(arg1[12]) << 32)
  2976  	x37 := (uint64(arg1[11]) << 24)
  2977  	x38 := (uint64(arg1[10]) << 16)
  2978  	x39 := (uint64(arg1[9]) << 8)
  2979  	x40 := arg1[8]
  2980  	x41 := (uint64(arg1[7]) << 56)
  2981  	x42 := (uint64(arg1[6]) << 48)
  2982  	x43 := (uint64(arg1[5]) << 40)
  2983  	x44 := (uint64(arg1[4]) << 32)
  2984  	x45 := (uint64(arg1[3]) << 24)
  2985  	x46 := (uint64(arg1[2]) << 16)
  2986  	x47 := (uint64(arg1[1]) << 8)
  2987  	x48 := arg1[0]
  2988  	x49 := (x47 + uint64(x48))
  2989  	x50 := (x46 + x49)
  2990  	x51 := (x45 + x50)
  2991  	x52 := (x44 + x51)
  2992  	x53 := (x43 + x52)
  2993  	x54 := (x42 + x53)
  2994  	x55 := (x41 + x54)
  2995  	x56 := (x39 + uint64(x40))
  2996  	x57 := (x38 + x56)
  2997  	x58 := (x37 + x57)
  2998  	x59 := (x36 + x58)
  2999  	x60 := (x35 + x59)
  3000  	x61 := (x34 + x60)
  3001  	x62 := (x33 + x61)
  3002  	x63 := (x31 + uint64(x32))
  3003  	x64 := (x30 + x63)
  3004  	x65 := (x29 + x64)
  3005  	x66 := (x28 + x65)
  3006  	x67 := (x27 + x66)
  3007  	x68 := (x26 + x67)
  3008  	x69 := (x25 + x68)
  3009  	x70 := (x23 + uint64(x24))
  3010  	x71 := (x22 + x70)
  3011  	x72 := (x21 + x71)
  3012  	x73 := (x20 + x72)
  3013  	x74 := (x19 + x73)
  3014  	x75 := (x18 + x74)
  3015  	x76 := (x17 + x75)
  3016  	x77 := (x15 + uint64(x16))
  3017  	x78 := (x14 + x77)
  3018  	x79 := (x13 + x78)
  3019  	x80 := (x12 + x79)
  3020  	x81 := (x11 + x80)
  3021  	x82 := (x10 + x81)
  3022  	x83 := (x9 + x82)
  3023  	x84 := (x7 + uint64(x8))
  3024  	x85 := (x6 + x84)
  3025  	x86 := (x5 + x85)
  3026  	x87 := (x4 + x86)
  3027  	x88 := (x3 + x87)
  3028  	x89 := (x2 + x88)
  3029  	x90 := (x1 + x89)
  3030  	out1[0] = x55
  3031  	out1[1] = x62
  3032  	out1[2] = x69
  3033  	out1[3] = x76
  3034  	out1[4] = x83
  3035  	out1[5] = x90
  3036  }
  3037  

View as plain text