Source file src/crypto/elliptic/internal/fiat/p384_fiat64.go

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

View as plain text