github.com/consensys/gnark-crypto@v0.14.0/ecc/bls24-315/internal/fptower/e2_amd64.s (about)

     1  // Copyright 2020 ConsenSys Software Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  #include "textflag.h"
    16  #include "funcdata.h"
    17  
    18  // modulus q
    19  DATA q<>+0(SB)/8, $0x6fe802ff40300001
    20  DATA q<>+8(SB)/8, $0x421ee5da52bde502
    21  DATA q<>+16(SB)/8, $0xdec1d01aa27a1ae0
    22  DATA q<>+24(SB)/8, $0xd3f7498be97c5eaf
    23  DATA q<>+32(SB)/8, $0x04c23a02b586d650
    24  GLOBL q<>(SB), (RODATA+NOPTR), $40
    25  
    26  // qInv0 q'[0]
    27  DATA qInv0<>(SB)/8, $0x702ff9ff402fffff
    28  GLOBL qInv0<>(SB), (RODATA+NOPTR), $8
    29  
    30  #define REDUCE(ra0, ra1, ra2, ra3, ra4, rb0, rb1, rb2, rb3, rb4) \
    31  	MOVQ    ra0, rb0;        \
    32  	SUBQ    q<>(SB), ra0;    \
    33  	MOVQ    ra1, rb1;        \
    34  	SBBQ    q<>+8(SB), ra1;  \
    35  	MOVQ    ra2, rb2;        \
    36  	SBBQ    q<>+16(SB), ra2; \
    37  	MOVQ    ra3, rb3;        \
    38  	SBBQ    q<>+24(SB), ra3; \
    39  	MOVQ    ra4, rb4;        \
    40  	SBBQ    q<>+32(SB), ra4; \
    41  	CMOVQCS rb0, ra0;        \
    42  	CMOVQCS rb1, ra1;        \
    43  	CMOVQCS rb2, ra2;        \
    44  	CMOVQCS rb3, ra3;        \
    45  	CMOVQCS rb4, ra4;        \
    46  
    47  TEXT ·addE2(SB), NOSPLIT, $0-24
    48  	MOVQ x+8(FP), AX
    49  	MOVQ 0(AX), BX
    50  	MOVQ 8(AX), SI
    51  	MOVQ 16(AX), DI
    52  	MOVQ 24(AX), R8
    53  	MOVQ 32(AX), R9
    54  	MOVQ y+16(FP), DX
    55  	ADDQ 0(DX), BX
    56  	ADCQ 8(DX), SI
    57  	ADCQ 16(DX), DI
    58  	ADCQ 24(DX), R8
    59  	ADCQ 32(DX), R9
    60  
    61  	// reduce element(BX,SI,DI,R8,R9) using temp registers (R10,R11,R12,R13,R14)
    62  	REDUCE(BX,SI,DI,R8,R9,R10,R11,R12,R13,R14)
    63  
    64  	MOVQ res+0(FP), CX
    65  	MOVQ BX, 0(CX)
    66  	MOVQ SI, 8(CX)
    67  	MOVQ DI, 16(CX)
    68  	MOVQ R8, 24(CX)
    69  	MOVQ R9, 32(CX)
    70  	MOVQ 40(AX), BX
    71  	MOVQ 48(AX), SI
    72  	MOVQ 56(AX), DI
    73  	MOVQ 64(AX), R8
    74  	MOVQ 72(AX), R9
    75  	ADDQ 40(DX), BX
    76  	ADCQ 48(DX), SI
    77  	ADCQ 56(DX), DI
    78  	ADCQ 64(DX), R8
    79  	ADCQ 72(DX), R9
    80  
    81  	// reduce element(BX,SI,DI,R8,R9) using temp registers (R15,R10,R11,R12,R13)
    82  	REDUCE(BX,SI,DI,R8,R9,R15,R10,R11,R12,R13)
    83  
    84  	MOVQ BX, 40(CX)
    85  	MOVQ SI, 48(CX)
    86  	MOVQ DI, 56(CX)
    87  	MOVQ R8, 64(CX)
    88  	MOVQ R9, 72(CX)
    89  	RET
    90  
    91  TEXT ·doubleE2(SB), NOSPLIT, $0-16
    92  	MOVQ res+0(FP), DX
    93  	MOVQ x+8(FP), AX
    94  	MOVQ 0(AX), CX
    95  	MOVQ 8(AX), BX
    96  	MOVQ 16(AX), SI
    97  	MOVQ 24(AX), DI
    98  	MOVQ 32(AX), R8
    99  	ADDQ CX, CX
   100  	ADCQ BX, BX
   101  	ADCQ SI, SI
   102  	ADCQ DI, DI
   103  	ADCQ R8, R8
   104  
   105  	// reduce element(CX,BX,SI,DI,R8) using temp registers (R9,R10,R11,R12,R13)
   106  	REDUCE(CX,BX,SI,DI,R8,R9,R10,R11,R12,R13)
   107  
   108  	MOVQ CX, 0(DX)
   109  	MOVQ BX, 8(DX)
   110  	MOVQ SI, 16(DX)
   111  	MOVQ DI, 24(DX)
   112  	MOVQ R8, 32(DX)
   113  	MOVQ 40(AX), CX
   114  	MOVQ 48(AX), BX
   115  	MOVQ 56(AX), SI
   116  	MOVQ 64(AX), DI
   117  	MOVQ 72(AX), R8
   118  	ADDQ CX, CX
   119  	ADCQ BX, BX
   120  	ADCQ SI, SI
   121  	ADCQ DI, DI
   122  	ADCQ R8, R8
   123  
   124  	// reduce element(CX,BX,SI,DI,R8) using temp registers (R14,R15,R9,R10,R11)
   125  	REDUCE(CX,BX,SI,DI,R8,R14,R15,R9,R10,R11)
   126  
   127  	MOVQ CX, 40(DX)
   128  	MOVQ BX, 48(DX)
   129  	MOVQ SI, 56(DX)
   130  	MOVQ DI, 64(DX)
   131  	MOVQ R8, 72(DX)
   132  	RET
   133  
   134  TEXT ·subE2(SB), NOSPLIT, $0-24
   135  	XORQ    R8, R8
   136  	MOVQ    x+8(FP), DI
   137  	MOVQ    0(DI), AX
   138  	MOVQ    8(DI), DX
   139  	MOVQ    16(DI), CX
   140  	MOVQ    24(DI), BX
   141  	MOVQ    32(DI), SI
   142  	MOVQ    y+16(FP), DI
   143  	SUBQ    0(DI), AX
   144  	SBBQ    8(DI), DX
   145  	SBBQ    16(DI), CX
   146  	SBBQ    24(DI), BX
   147  	SBBQ    32(DI), SI
   148  	MOVQ    x+8(FP), DI
   149  	MOVQ    $0x6fe802ff40300001, R9
   150  	MOVQ    $0x421ee5da52bde502, R10
   151  	MOVQ    $0xdec1d01aa27a1ae0, R11
   152  	MOVQ    $0xd3f7498be97c5eaf, R12
   153  	MOVQ    $0x04c23a02b586d650, R13
   154  	CMOVQCC R8, R9
   155  	CMOVQCC R8, R10
   156  	CMOVQCC R8, R11
   157  	CMOVQCC R8, R12
   158  	CMOVQCC R8, R13
   159  	ADDQ    R9, AX
   160  	ADCQ    R10, DX
   161  	ADCQ    R11, CX
   162  	ADCQ    R12, BX
   163  	ADCQ    R13, SI
   164  	MOVQ    res+0(FP), R14
   165  	MOVQ    AX, 0(R14)
   166  	MOVQ    DX, 8(R14)
   167  	MOVQ    CX, 16(R14)
   168  	MOVQ    BX, 24(R14)
   169  	MOVQ    SI, 32(R14)
   170  	MOVQ    40(DI), AX
   171  	MOVQ    48(DI), DX
   172  	MOVQ    56(DI), CX
   173  	MOVQ    64(DI), BX
   174  	MOVQ    72(DI), SI
   175  	MOVQ    y+16(FP), DI
   176  	SUBQ    40(DI), AX
   177  	SBBQ    48(DI), DX
   178  	SBBQ    56(DI), CX
   179  	SBBQ    64(DI), BX
   180  	SBBQ    72(DI), SI
   181  	MOVQ    $0x6fe802ff40300001, R15
   182  	MOVQ    $0x421ee5da52bde502, R9
   183  	MOVQ    $0xdec1d01aa27a1ae0, R10
   184  	MOVQ    $0xd3f7498be97c5eaf, R11
   185  	MOVQ    $0x04c23a02b586d650, R12
   186  	CMOVQCC R8, R15
   187  	CMOVQCC R8, R9
   188  	CMOVQCC R8, R10
   189  	CMOVQCC R8, R11
   190  	CMOVQCC R8, R12
   191  	ADDQ    R15, AX
   192  	ADCQ    R9, DX
   193  	ADCQ    R10, CX
   194  	ADCQ    R11, BX
   195  	ADCQ    R12, SI
   196  	MOVQ    res+0(FP), DI
   197  	MOVQ    AX, 40(DI)
   198  	MOVQ    DX, 48(DI)
   199  	MOVQ    CX, 56(DI)
   200  	MOVQ    BX, 64(DI)
   201  	MOVQ    SI, 72(DI)
   202  	RET
   203  
   204  TEXT ·negE2(SB), NOSPLIT, $0-16
   205  	MOVQ  res+0(FP), DX
   206  	MOVQ  x+8(FP), AX
   207  	MOVQ  0(AX), BX
   208  	MOVQ  8(AX), SI
   209  	MOVQ  16(AX), DI
   210  	MOVQ  24(AX), R8
   211  	MOVQ  32(AX), R9
   212  	MOVQ  BX, AX
   213  	ORQ   SI, AX
   214  	ORQ   DI, AX
   215  	ORQ   R8, AX
   216  	ORQ   R9, AX
   217  	TESTQ AX, AX
   218  	JNE   l1
   219  	MOVQ  AX, 0(DX)
   220  	MOVQ  AX, 8(DX)
   221  	MOVQ  AX, 16(DX)
   222  	MOVQ  AX, 24(DX)
   223  	MOVQ  AX, 32(DX)
   224  	JMP   l3
   225  
   226  l1:
   227  	MOVQ $0x6fe802ff40300001, CX
   228  	SUBQ BX, CX
   229  	MOVQ CX, 0(DX)
   230  	MOVQ $0x421ee5da52bde502, CX
   231  	SBBQ SI, CX
   232  	MOVQ CX, 8(DX)
   233  	MOVQ $0xdec1d01aa27a1ae0, CX
   234  	SBBQ DI, CX
   235  	MOVQ CX, 16(DX)
   236  	MOVQ $0xd3f7498be97c5eaf, CX
   237  	SBBQ R8, CX
   238  	MOVQ CX, 24(DX)
   239  	MOVQ $0x04c23a02b586d650, CX
   240  	SBBQ R9, CX
   241  	MOVQ CX, 32(DX)
   242  
   243  l3:
   244  	MOVQ  x+8(FP), AX
   245  	MOVQ  40(AX), BX
   246  	MOVQ  48(AX), SI
   247  	MOVQ  56(AX), DI
   248  	MOVQ  64(AX), R8
   249  	MOVQ  72(AX), R9
   250  	MOVQ  BX, AX
   251  	ORQ   SI, AX
   252  	ORQ   DI, AX
   253  	ORQ   R8, AX
   254  	ORQ   R9, AX
   255  	TESTQ AX, AX
   256  	JNE   l2
   257  	MOVQ  AX, 40(DX)
   258  	MOVQ  AX, 48(DX)
   259  	MOVQ  AX, 56(DX)
   260  	MOVQ  AX, 64(DX)
   261  	MOVQ  AX, 72(DX)
   262  	RET
   263  
   264  l2:
   265  	MOVQ $0x6fe802ff40300001, CX
   266  	SUBQ BX, CX
   267  	MOVQ CX, 40(DX)
   268  	MOVQ $0x421ee5da52bde502, CX
   269  	SBBQ SI, CX
   270  	MOVQ CX, 48(DX)
   271  	MOVQ $0xdec1d01aa27a1ae0, CX
   272  	SBBQ DI, CX
   273  	MOVQ CX, 56(DX)
   274  	MOVQ $0xd3f7498be97c5eaf, CX
   275  	SBBQ R8, CX
   276  	MOVQ CX, 64(DX)
   277  	MOVQ $0x04c23a02b586d650, CX
   278  	SBBQ R9, CX
   279  	MOVQ CX, 72(DX)
   280  	RET
   281  
   282  TEXT ·mulNonResE2(SB), NOSPLIT, $0-16
   283  	MOVQ x+8(FP), AX
   284  	MOVQ 40(AX), DX
   285  	MOVQ 48(AX), CX
   286  	MOVQ 56(AX), BX
   287  	MOVQ 64(AX), SI
   288  	MOVQ 72(AX), DI
   289  	ADDQ DX, DX
   290  	ADCQ CX, CX
   291  	ADCQ BX, BX
   292  	ADCQ SI, SI
   293  	ADCQ DI, DI
   294  
   295  	// reduce element(DX,CX,BX,SI,DI) using temp registers (R8,R9,R10,R11,R12)
   296  	REDUCE(DX,CX,BX,SI,DI,R8,R9,R10,R11,R12)
   297  
   298  	ADDQ DX, DX
   299  	ADCQ CX, CX
   300  	ADCQ BX, BX
   301  	ADCQ SI, SI
   302  	ADCQ DI, DI
   303  
   304  	// reduce element(DX,CX,BX,SI,DI) using temp registers (R13,R14,R15,s0-8(SP),s1-16(SP))
   305  	REDUCE(DX,CX,BX,SI,DI,R13,R14,R15,s0-8(SP),s1-16(SP))
   306  
   307  	MOVQ DX, R13
   308  	MOVQ CX, R14
   309  	MOVQ BX, R15
   310  	MOVQ SI, s0-8(SP)
   311  	MOVQ DI, s1-16(SP)
   312  	ADDQ DX, DX
   313  	ADCQ CX, CX
   314  	ADCQ BX, BX
   315  	ADCQ SI, SI
   316  	ADCQ DI, DI
   317  
   318  	// reduce element(DX,CX,BX,SI,DI) using temp registers (R8,R9,R10,R11,R12)
   319  	REDUCE(DX,CX,BX,SI,DI,R8,R9,R10,R11,R12)
   320  
   321  	ADDQ R13, DX
   322  	ADCQ R14, CX
   323  	ADCQ R15, BX
   324  	ADCQ s0-8(SP), SI
   325  	ADCQ s1-16(SP), DI
   326  
   327  	// reduce element(DX,CX,BX,SI,DI) using temp registers (R8,R9,R10,R11,R12)
   328  	REDUCE(DX,CX,BX,SI,DI,R8,R9,R10,R11,R12)
   329  
   330  	ADDQ 40(AX), DX
   331  	ADCQ 48(AX), CX
   332  	ADCQ 56(AX), BX
   333  	ADCQ 64(AX), SI
   334  	ADCQ 72(AX), DI
   335  
   336  	// reduce element(DX,CX,BX,SI,DI) using temp registers (R8,R9,R10,R11,R12)
   337  	REDUCE(DX,CX,BX,SI,DI,R8,R9,R10,R11,R12)
   338  
   339  	MOVQ res+0(FP), R13
   340  	MOVQ 0(AX), R8
   341  	MOVQ 8(AX), R9
   342  	MOVQ 16(AX), R10
   343  	MOVQ 24(AX), R11
   344  	MOVQ 32(AX), R12
   345  	MOVQ R8, 40(R13)
   346  	MOVQ R9, 48(R13)
   347  	MOVQ R10, 56(R13)
   348  	MOVQ R11, 64(R13)
   349  	MOVQ R12, 72(R13)
   350  	MOVQ DX, 0(R13)
   351  	MOVQ CX, 8(R13)
   352  	MOVQ BX, 16(R13)
   353  	MOVQ SI, 24(R13)
   354  	MOVQ DI, 32(R13)
   355  	RET
   356  
   357  TEXT ·mulAdxE2(SB), $80-24
   358  	NO_LOCAL_POINTERS
   359  
   360  	// 	var a, b, c fp.Element
   361  	// 	a.Add(&x.A0, &x.A1)
   362  	// 	b.Add(&y.A0, &y.A1)
   363  	// 	a.Mul(&a, &b)
   364  	// 	b.Mul(&x.A0, &y.A0)
   365  	// 	c.Mul(&x.A1, &y.A1)
   366  	// 	z.A1.Sub(&a, &b).Sub(&z.A1, &c)
   367  	// 	fp.MulBy13(&c)
   368  	// 	z.A0.Add(&c, &b)
   369  
   370  	CMPB ·supportAdx(SB), $1
   371  	JNE  l4
   372  	MOVQ x+8(FP), AX
   373  	MOVQ 40(AX), R14
   374  	MOVQ 48(AX), R15
   375  	MOVQ 56(AX), CX
   376  	MOVQ 64(AX), BX
   377  	MOVQ 72(AX), SI
   378  
   379  	// A -> BP
   380  	// t[0] -> DI
   381  	// t[1] -> R8
   382  	// t[2] -> R9
   383  	// t[3] -> R10
   384  	// t[4] -> R11
   385  	// clear the flags
   386  	XORQ AX, AX
   387  	MOVQ y+16(FP), DX
   388  	MOVQ 40(DX), DX
   389  
   390  	// (A,t[0])  := x[0]*y[0] + A
   391  	MULXQ R14, DI, R8
   392  
   393  	// (A,t[1])  := x[1]*y[0] + A
   394  	MULXQ R15, AX, R9
   395  	ADOXQ AX, R8
   396  
   397  	// (A,t[2])  := x[2]*y[0] + A
   398  	MULXQ CX, AX, R10
   399  	ADOXQ AX, R9
   400  
   401  	// (A,t[3])  := x[3]*y[0] + A
   402  	MULXQ BX, AX, R11
   403  	ADOXQ AX, R10
   404  
   405  	// (A,t[4])  := x[4]*y[0] + A
   406  	MULXQ SI, AX, BP
   407  	ADOXQ AX, R11
   408  
   409  	// A += carries from ADCXQ and ADOXQ
   410  	MOVQ  $0, AX
   411  	ADOXQ AX, BP
   412  
   413  	// m := t[0]*q'[0] mod W
   414  	MOVQ  qInv0<>(SB), DX
   415  	IMULQ DI, DX
   416  
   417  	// clear the flags
   418  	XORQ AX, AX
   419  
   420  	// C,_ := t[0] + m*q[0]
   421  	MULXQ q<>+0(SB), AX, R12
   422  	ADCXQ DI, AX
   423  	MOVQ  R12, DI
   424  
   425  	// (C,t[0]) := t[1] + m*q[1] + C
   426  	ADCXQ R8, DI
   427  	MULXQ q<>+8(SB), AX, R8
   428  	ADOXQ AX, DI
   429  
   430  	// (C,t[1]) := t[2] + m*q[2] + C
   431  	ADCXQ R9, R8
   432  	MULXQ q<>+16(SB), AX, R9
   433  	ADOXQ AX, R8
   434  
   435  	// (C,t[2]) := t[3] + m*q[3] + C
   436  	ADCXQ R10, R9
   437  	MULXQ q<>+24(SB), AX, R10
   438  	ADOXQ AX, R9
   439  
   440  	// (C,t[3]) := t[4] + m*q[4] + C
   441  	ADCXQ R11, R10
   442  	MULXQ q<>+32(SB), AX, R11
   443  	ADOXQ AX, R10
   444  
   445  	// t[4] = C + A
   446  	MOVQ  $0, AX
   447  	ADCXQ AX, R11
   448  	ADOXQ BP, R11
   449  
   450  	// clear the flags
   451  	XORQ AX, AX
   452  	MOVQ y+16(FP), DX
   453  	MOVQ 48(DX), DX
   454  
   455  	// (A,t[0])  := t[0] + x[0]*y[1] + A
   456  	MULXQ R14, AX, BP
   457  	ADOXQ AX, DI
   458  
   459  	// (A,t[1])  := t[1] + x[1]*y[1] + A
   460  	ADCXQ BP, R8
   461  	MULXQ R15, AX, BP
   462  	ADOXQ AX, R8
   463  
   464  	// (A,t[2])  := t[2] + x[2]*y[1] + A
   465  	ADCXQ BP, R9
   466  	MULXQ CX, AX, BP
   467  	ADOXQ AX, R9
   468  
   469  	// (A,t[3])  := t[3] + x[3]*y[1] + A
   470  	ADCXQ BP, R10
   471  	MULXQ BX, AX, BP
   472  	ADOXQ AX, R10
   473  
   474  	// (A,t[4])  := t[4] + x[4]*y[1] + A
   475  	ADCXQ BP, R11
   476  	MULXQ SI, AX, BP
   477  	ADOXQ AX, R11
   478  
   479  	// A += carries from ADCXQ and ADOXQ
   480  	MOVQ  $0, AX
   481  	ADCXQ AX, BP
   482  	ADOXQ AX, BP
   483  
   484  	// m := t[0]*q'[0] mod W
   485  	MOVQ  qInv0<>(SB), DX
   486  	IMULQ DI, DX
   487  
   488  	// clear the flags
   489  	XORQ AX, AX
   490  
   491  	// C,_ := t[0] + m*q[0]
   492  	MULXQ q<>+0(SB), AX, R12
   493  	ADCXQ DI, AX
   494  	MOVQ  R12, DI
   495  
   496  	// (C,t[0]) := t[1] + m*q[1] + C
   497  	ADCXQ R8, DI
   498  	MULXQ q<>+8(SB), AX, R8
   499  	ADOXQ AX, DI
   500  
   501  	// (C,t[1]) := t[2] + m*q[2] + C
   502  	ADCXQ R9, R8
   503  	MULXQ q<>+16(SB), AX, R9
   504  	ADOXQ AX, R8
   505  
   506  	// (C,t[2]) := t[3] + m*q[3] + C
   507  	ADCXQ R10, R9
   508  	MULXQ q<>+24(SB), AX, R10
   509  	ADOXQ AX, R9
   510  
   511  	// (C,t[3]) := t[4] + m*q[4] + C
   512  	ADCXQ R11, R10
   513  	MULXQ q<>+32(SB), AX, R11
   514  	ADOXQ AX, R10
   515  
   516  	// t[4] = C + A
   517  	MOVQ  $0, AX
   518  	ADCXQ AX, R11
   519  	ADOXQ BP, R11
   520  
   521  	// clear the flags
   522  	XORQ AX, AX
   523  	MOVQ y+16(FP), DX
   524  	MOVQ 56(DX), DX
   525  
   526  	// (A,t[0])  := t[0] + x[0]*y[2] + A
   527  	MULXQ R14, AX, BP
   528  	ADOXQ AX, DI
   529  
   530  	// (A,t[1])  := t[1] + x[1]*y[2] + A
   531  	ADCXQ BP, R8
   532  	MULXQ R15, AX, BP
   533  	ADOXQ AX, R8
   534  
   535  	// (A,t[2])  := t[2] + x[2]*y[2] + A
   536  	ADCXQ BP, R9
   537  	MULXQ CX, AX, BP
   538  	ADOXQ AX, R9
   539  
   540  	// (A,t[3])  := t[3] + x[3]*y[2] + A
   541  	ADCXQ BP, R10
   542  	MULXQ BX, AX, BP
   543  	ADOXQ AX, R10
   544  
   545  	// (A,t[4])  := t[4] + x[4]*y[2] + A
   546  	ADCXQ BP, R11
   547  	MULXQ SI, AX, BP
   548  	ADOXQ AX, R11
   549  
   550  	// A += carries from ADCXQ and ADOXQ
   551  	MOVQ  $0, AX
   552  	ADCXQ AX, BP
   553  	ADOXQ AX, BP
   554  
   555  	// m := t[0]*q'[0] mod W
   556  	MOVQ  qInv0<>(SB), DX
   557  	IMULQ DI, DX
   558  
   559  	// clear the flags
   560  	XORQ AX, AX
   561  
   562  	// C,_ := t[0] + m*q[0]
   563  	MULXQ q<>+0(SB), AX, R12
   564  	ADCXQ DI, AX
   565  	MOVQ  R12, DI
   566  
   567  	// (C,t[0]) := t[1] + m*q[1] + C
   568  	ADCXQ R8, DI
   569  	MULXQ q<>+8(SB), AX, R8
   570  	ADOXQ AX, DI
   571  
   572  	// (C,t[1]) := t[2] + m*q[2] + C
   573  	ADCXQ R9, R8
   574  	MULXQ q<>+16(SB), AX, R9
   575  	ADOXQ AX, R8
   576  
   577  	// (C,t[2]) := t[3] + m*q[3] + C
   578  	ADCXQ R10, R9
   579  	MULXQ q<>+24(SB), AX, R10
   580  	ADOXQ AX, R9
   581  
   582  	// (C,t[3]) := t[4] + m*q[4] + C
   583  	ADCXQ R11, R10
   584  	MULXQ q<>+32(SB), AX, R11
   585  	ADOXQ AX, R10
   586  
   587  	// t[4] = C + A
   588  	MOVQ  $0, AX
   589  	ADCXQ AX, R11
   590  	ADOXQ BP, R11
   591  
   592  	// clear the flags
   593  	XORQ AX, AX
   594  	MOVQ y+16(FP), DX
   595  	MOVQ 64(DX), DX
   596  
   597  	// (A,t[0])  := t[0] + x[0]*y[3] + A
   598  	MULXQ R14, AX, BP
   599  	ADOXQ AX, DI
   600  
   601  	// (A,t[1])  := t[1] + x[1]*y[3] + A
   602  	ADCXQ BP, R8
   603  	MULXQ R15, AX, BP
   604  	ADOXQ AX, R8
   605  
   606  	// (A,t[2])  := t[2] + x[2]*y[3] + A
   607  	ADCXQ BP, R9
   608  	MULXQ CX, AX, BP
   609  	ADOXQ AX, R9
   610  
   611  	// (A,t[3])  := t[3] + x[3]*y[3] + A
   612  	ADCXQ BP, R10
   613  	MULXQ BX, AX, BP
   614  	ADOXQ AX, R10
   615  
   616  	// (A,t[4])  := t[4] + x[4]*y[3] + A
   617  	ADCXQ BP, R11
   618  	MULXQ SI, AX, BP
   619  	ADOXQ AX, R11
   620  
   621  	// A += carries from ADCXQ and ADOXQ
   622  	MOVQ  $0, AX
   623  	ADCXQ AX, BP
   624  	ADOXQ AX, BP
   625  
   626  	// m := t[0]*q'[0] mod W
   627  	MOVQ  qInv0<>(SB), DX
   628  	IMULQ DI, DX
   629  
   630  	// clear the flags
   631  	XORQ AX, AX
   632  
   633  	// C,_ := t[0] + m*q[0]
   634  	MULXQ q<>+0(SB), AX, R12
   635  	ADCXQ DI, AX
   636  	MOVQ  R12, DI
   637  
   638  	// (C,t[0]) := t[1] + m*q[1] + C
   639  	ADCXQ R8, DI
   640  	MULXQ q<>+8(SB), AX, R8
   641  	ADOXQ AX, DI
   642  
   643  	// (C,t[1]) := t[2] + m*q[2] + C
   644  	ADCXQ R9, R8
   645  	MULXQ q<>+16(SB), AX, R9
   646  	ADOXQ AX, R8
   647  
   648  	// (C,t[2]) := t[3] + m*q[3] + C
   649  	ADCXQ R10, R9
   650  	MULXQ q<>+24(SB), AX, R10
   651  	ADOXQ AX, R9
   652  
   653  	// (C,t[3]) := t[4] + m*q[4] + C
   654  	ADCXQ R11, R10
   655  	MULXQ q<>+32(SB), AX, R11
   656  	ADOXQ AX, R10
   657  
   658  	// t[4] = C + A
   659  	MOVQ  $0, AX
   660  	ADCXQ AX, R11
   661  	ADOXQ BP, R11
   662  
   663  	// clear the flags
   664  	XORQ AX, AX
   665  	MOVQ y+16(FP), DX
   666  	MOVQ 72(DX), DX
   667  
   668  	// (A,t[0])  := t[0] + x[0]*y[4] + A
   669  	MULXQ R14, AX, BP
   670  	ADOXQ AX, DI
   671  
   672  	// (A,t[1])  := t[1] + x[1]*y[4] + A
   673  	ADCXQ BP, R8
   674  	MULXQ R15, AX, BP
   675  	ADOXQ AX, R8
   676  
   677  	// (A,t[2])  := t[2] + x[2]*y[4] + A
   678  	ADCXQ BP, R9
   679  	MULXQ CX, AX, BP
   680  	ADOXQ AX, R9
   681  
   682  	// (A,t[3])  := t[3] + x[3]*y[4] + A
   683  	ADCXQ BP, R10
   684  	MULXQ BX, AX, BP
   685  	ADOXQ AX, R10
   686  
   687  	// (A,t[4])  := t[4] + x[4]*y[4] + A
   688  	ADCXQ BP, R11
   689  	MULXQ SI, AX, BP
   690  	ADOXQ AX, R11
   691  
   692  	// A += carries from ADCXQ and ADOXQ
   693  	MOVQ  $0, AX
   694  	ADCXQ AX, BP
   695  	ADOXQ AX, BP
   696  
   697  	// m := t[0]*q'[0] mod W
   698  	MOVQ  qInv0<>(SB), DX
   699  	IMULQ DI, DX
   700  
   701  	// clear the flags
   702  	XORQ AX, AX
   703  
   704  	// C,_ := t[0] + m*q[0]
   705  	MULXQ q<>+0(SB), AX, R12
   706  	ADCXQ DI, AX
   707  	MOVQ  R12, DI
   708  
   709  	// (C,t[0]) := t[1] + m*q[1] + C
   710  	ADCXQ R8, DI
   711  	MULXQ q<>+8(SB), AX, R8
   712  	ADOXQ AX, DI
   713  
   714  	// (C,t[1]) := t[2] + m*q[2] + C
   715  	ADCXQ R9, R8
   716  	MULXQ q<>+16(SB), AX, R9
   717  	ADOXQ AX, R8
   718  
   719  	// (C,t[2]) := t[3] + m*q[3] + C
   720  	ADCXQ R10, R9
   721  	MULXQ q<>+24(SB), AX, R10
   722  	ADOXQ AX, R9
   723  
   724  	// (C,t[3]) := t[4] + m*q[4] + C
   725  	ADCXQ R11, R10
   726  	MULXQ q<>+32(SB), AX, R11
   727  	ADOXQ AX, R10
   728  
   729  	// t[4] = C + A
   730  	MOVQ  $0, AX
   731  	ADCXQ AX, R11
   732  	ADOXQ BP, R11
   733  
   734  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
   735  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
   736  
   737  	MOVQ DI, s5-48(SP)
   738  	MOVQ R8, s6-56(SP)
   739  	MOVQ R9, s7-64(SP)
   740  	MOVQ R10, s8-72(SP)
   741  	MOVQ R11, s9-80(SP)
   742  	MOVQ x+8(FP), AX
   743  	MOVQ y+16(FP), DX
   744  	MOVQ 40(AX), R14
   745  	MOVQ 48(AX), R15
   746  	MOVQ 56(AX), CX
   747  	MOVQ 64(AX), BX
   748  	MOVQ 72(AX), SI
   749  	ADDQ 0(AX), R14
   750  	ADCQ 8(AX), R15
   751  	ADCQ 16(AX), CX
   752  	ADCQ 24(AX), BX
   753  	ADCQ 32(AX), SI
   754  	MOVQ R14, s0-8(SP)
   755  	MOVQ R15, s1-16(SP)
   756  	MOVQ CX, s2-24(SP)
   757  	MOVQ BX, s3-32(SP)
   758  	MOVQ SI, s4-40(SP)
   759  	MOVQ 0(DX), R14
   760  	MOVQ 8(DX), R15
   761  	MOVQ 16(DX), CX
   762  	MOVQ 24(DX), BX
   763  	MOVQ 32(DX), SI
   764  	ADDQ 40(DX), R14
   765  	ADCQ 48(DX), R15
   766  	ADCQ 56(DX), CX
   767  	ADCQ 64(DX), BX
   768  	ADCQ 72(DX), SI
   769  
   770  	// A -> BP
   771  	// t[0] -> DI
   772  	// t[1] -> R8
   773  	// t[2] -> R9
   774  	// t[3] -> R10
   775  	// t[4] -> R11
   776  	// clear the flags
   777  	XORQ AX, AX
   778  	MOVQ s0-8(SP), DX
   779  
   780  	// (A,t[0])  := x[0]*y[0] + A
   781  	MULXQ R14, DI, R8
   782  
   783  	// (A,t[1])  := x[1]*y[0] + A
   784  	MULXQ R15, AX, R9
   785  	ADOXQ AX, R8
   786  
   787  	// (A,t[2])  := x[2]*y[0] + A
   788  	MULXQ CX, AX, R10
   789  	ADOXQ AX, R9
   790  
   791  	// (A,t[3])  := x[3]*y[0] + A
   792  	MULXQ BX, AX, R11
   793  	ADOXQ AX, R10
   794  
   795  	// (A,t[4])  := x[4]*y[0] + A
   796  	MULXQ SI, AX, BP
   797  	ADOXQ AX, R11
   798  
   799  	// A += carries from ADCXQ and ADOXQ
   800  	MOVQ  $0, AX
   801  	ADOXQ AX, BP
   802  
   803  	// m := t[0]*q'[0] mod W
   804  	MOVQ  qInv0<>(SB), DX
   805  	IMULQ DI, DX
   806  
   807  	// clear the flags
   808  	XORQ AX, AX
   809  
   810  	// C,_ := t[0] + m*q[0]
   811  	MULXQ q<>+0(SB), AX, R13
   812  	ADCXQ DI, AX
   813  	MOVQ  R13, DI
   814  
   815  	// (C,t[0]) := t[1] + m*q[1] + C
   816  	ADCXQ R8, DI
   817  	MULXQ q<>+8(SB), AX, R8
   818  	ADOXQ AX, DI
   819  
   820  	// (C,t[1]) := t[2] + m*q[2] + C
   821  	ADCXQ R9, R8
   822  	MULXQ q<>+16(SB), AX, R9
   823  	ADOXQ AX, R8
   824  
   825  	// (C,t[2]) := t[3] + m*q[3] + C
   826  	ADCXQ R10, R9
   827  	MULXQ q<>+24(SB), AX, R10
   828  	ADOXQ AX, R9
   829  
   830  	// (C,t[3]) := t[4] + m*q[4] + C
   831  	ADCXQ R11, R10
   832  	MULXQ q<>+32(SB), AX, R11
   833  	ADOXQ AX, R10
   834  
   835  	// t[4] = C + A
   836  	MOVQ  $0, AX
   837  	ADCXQ AX, R11
   838  	ADOXQ BP, R11
   839  
   840  	// clear the flags
   841  	XORQ AX, AX
   842  	MOVQ s1-16(SP), DX
   843  
   844  	// (A,t[0])  := t[0] + x[0]*y[1] + A
   845  	MULXQ R14, AX, BP
   846  	ADOXQ AX, DI
   847  
   848  	// (A,t[1])  := t[1] + x[1]*y[1] + A
   849  	ADCXQ BP, R8
   850  	MULXQ R15, AX, BP
   851  	ADOXQ AX, R8
   852  
   853  	// (A,t[2])  := t[2] + x[2]*y[1] + A
   854  	ADCXQ BP, R9
   855  	MULXQ CX, AX, BP
   856  	ADOXQ AX, R9
   857  
   858  	// (A,t[3])  := t[3] + x[3]*y[1] + A
   859  	ADCXQ BP, R10
   860  	MULXQ BX, AX, BP
   861  	ADOXQ AX, R10
   862  
   863  	// (A,t[4])  := t[4] + x[4]*y[1] + A
   864  	ADCXQ BP, R11
   865  	MULXQ SI, AX, BP
   866  	ADOXQ AX, R11
   867  
   868  	// A += carries from ADCXQ and ADOXQ
   869  	MOVQ  $0, AX
   870  	ADCXQ AX, BP
   871  	ADOXQ AX, BP
   872  
   873  	// m := t[0]*q'[0] mod W
   874  	MOVQ  qInv0<>(SB), DX
   875  	IMULQ DI, DX
   876  
   877  	// clear the flags
   878  	XORQ AX, AX
   879  
   880  	// C,_ := t[0] + m*q[0]
   881  	MULXQ q<>+0(SB), AX, R13
   882  	ADCXQ DI, AX
   883  	MOVQ  R13, DI
   884  
   885  	// (C,t[0]) := t[1] + m*q[1] + C
   886  	ADCXQ R8, DI
   887  	MULXQ q<>+8(SB), AX, R8
   888  	ADOXQ AX, DI
   889  
   890  	// (C,t[1]) := t[2] + m*q[2] + C
   891  	ADCXQ R9, R8
   892  	MULXQ q<>+16(SB), AX, R9
   893  	ADOXQ AX, R8
   894  
   895  	// (C,t[2]) := t[3] + m*q[3] + C
   896  	ADCXQ R10, R9
   897  	MULXQ q<>+24(SB), AX, R10
   898  	ADOXQ AX, R9
   899  
   900  	// (C,t[3]) := t[4] + m*q[4] + C
   901  	ADCXQ R11, R10
   902  	MULXQ q<>+32(SB), AX, R11
   903  	ADOXQ AX, R10
   904  
   905  	// t[4] = C + A
   906  	MOVQ  $0, AX
   907  	ADCXQ AX, R11
   908  	ADOXQ BP, R11
   909  
   910  	// clear the flags
   911  	XORQ AX, AX
   912  	MOVQ s2-24(SP), DX
   913  
   914  	// (A,t[0])  := t[0] + x[0]*y[2] + A
   915  	MULXQ R14, AX, BP
   916  	ADOXQ AX, DI
   917  
   918  	// (A,t[1])  := t[1] + x[1]*y[2] + A
   919  	ADCXQ BP, R8
   920  	MULXQ R15, AX, BP
   921  	ADOXQ AX, R8
   922  
   923  	// (A,t[2])  := t[2] + x[2]*y[2] + A
   924  	ADCXQ BP, R9
   925  	MULXQ CX, AX, BP
   926  	ADOXQ AX, R9
   927  
   928  	// (A,t[3])  := t[3] + x[3]*y[2] + A
   929  	ADCXQ BP, R10
   930  	MULXQ BX, AX, BP
   931  	ADOXQ AX, R10
   932  
   933  	// (A,t[4])  := t[4] + x[4]*y[2] + A
   934  	ADCXQ BP, R11
   935  	MULXQ SI, AX, BP
   936  	ADOXQ AX, R11
   937  
   938  	// A += carries from ADCXQ and ADOXQ
   939  	MOVQ  $0, AX
   940  	ADCXQ AX, BP
   941  	ADOXQ AX, BP
   942  
   943  	// m := t[0]*q'[0] mod W
   944  	MOVQ  qInv0<>(SB), DX
   945  	IMULQ DI, DX
   946  
   947  	// clear the flags
   948  	XORQ AX, AX
   949  
   950  	// C,_ := t[0] + m*q[0]
   951  	MULXQ q<>+0(SB), AX, R13
   952  	ADCXQ DI, AX
   953  	MOVQ  R13, DI
   954  
   955  	// (C,t[0]) := t[1] + m*q[1] + C
   956  	ADCXQ R8, DI
   957  	MULXQ q<>+8(SB), AX, R8
   958  	ADOXQ AX, DI
   959  
   960  	// (C,t[1]) := t[2] + m*q[2] + C
   961  	ADCXQ R9, R8
   962  	MULXQ q<>+16(SB), AX, R9
   963  	ADOXQ AX, R8
   964  
   965  	// (C,t[2]) := t[3] + m*q[3] + C
   966  	ADCXQ R10, R9
   967  	MULXQ q<>+24(SB), AX, R10
   968  	ADOXQ AX, R9
   969  
   970  	// (C,t[3]) := t[4] + m*q[4] + C
   971  	ADCXQ R11, R10
   972  	MULXQ q<>+32(SB), AX, R11
   973  	ADOXQ AX, R10
   974  
   975  	// t[4] = C + A
   976  	MOVQ  $0, AX
   977  	ADCXQ AX, R11
   978  	ADOXQ BP, R11
   979  
   980  	// clear the flags
   981  	XORQ AX, AX
   982  	MOVQ s3-32(SP), DX
   983  
   984  	// (A,t[0])  := t[0] + x[0]*y[3] + A
   985  	MULXQ R14, AX, BP
   986  	ADOXQ AX, DI
   987  
   988  	// (A,t[1])  := t[1] + x[1]*y[3] + A
   989  	ADCXQ BP, R8
   990  	MULXQ R15, AX, BP
   991  	ADOXQ AX, R8
   992  
   993  	// (A,t[2])  := t[2] + x[2]*y[3] + A
   994  	ADCXQ BP, R9
   995  	MULXQ CX, AX, BP
   996  	ADOXQ AX, R9
   997  
   998  	// (A,t[3])  := t[3] + x[3]*y[3] + A
   999  	ADCXQ BP, R10
  1000  	MULXQ BX, AX, BP
  1001  	ADOXQ AX, R10
  1002  
  1003  	// (A,t[4])  := t[4] + x[4]*y[3] + A
  1004  	ADCXQ BP, R11
  1005  	MULXQ SI, AX, BP
  1006  	ADOXQ AX, R11
  1007  
  1008  	// A += carries from ADCXQ and ADOXQ
  1009  	MOVQ  $0, AX
  1010  	ADCXQ AX, BP
  1011  	ADOXQ AX, BP
  1012  
  1013  	// m := t[0]*q'[0] mod W
  1014  	MOVQ  qInv0<>(SB), DX
  1015  	IMULQ DI, DX
  1016  
  1017  	// clear the flags
  1018  	XORQ AX, AX
  1019  
  1020  	// C,_ := t[0] + m*q[0]
  1021  	MULXQ q<>+0(SB), AX, R13
  1022  	ADCXQ DI, AX
  1023  	MOVQ  R13, DI
  1024  
  1025  	// (C,t[0]) := t[1] + m*q[1] + C
  1026  	ADCXQ R8, DI
  1027  	MULXQ q<>+8(SB), AX, R8
  1028  	ADOXQ AX, DI
  1029  
  1030  	// (C,t[1]) := t[2] + m*q[2] + C
  1031  	ADCXQ R9, R8
  1032  	MULXQ q<>+16(SB), AX, R9
  1033  	ADOXQ AX, R8
  1034  
  1035  	// (C,t[2]) := t[3] + m*q[3] + C
  1036  	ADCXQ R10, R9
  1037  	MULXQ q<>+24(SB), AX, R10
  1038  	ADOXQ AX, R9
  1039  
  1040  	// (C,t[3]) := t[4] + m*q[4] + C
  1041  	ADCXQ R11, R10
  1042  	MULXQ q<>+32(SB), AX, R11
  1043  	ADOXQ AX, R10
  1044  
  1045  	// t[4] = C + A
  1046  	MOVQ  $0, AX
  1047  	ADCXQ AX, R11
  1048  	ADOXQ BP, R11
  1049  
  1050  	// clear the flags
  1051  	XORQ AX, AX
  1052  	MOVQ s4-40(SP), DX
  1053  
  1054  	// (A,t[0])  := t[0] + x[0]*y[4] + A
  1055  	MULXQ R14, AX, BP
  1056  	ADOXQ AX, DI
  1057  
  1058  	// (A,t[1])  := t[1] + x[1]*y[4] + A
  1059  	ADCXQ BP, R8
  1060  	MULXQ R15, AX, BP
  1061  	ADOXQ AX, R8
  1062  
  1063  	// (A,t[2])  := t[2] + x[2]*y[4] + A
  1064  	ADCXQ BP, R9
  1065  	MULXQ CX, AX, BP
  1066  	ADOXQ AX, R9
  1067  
  1068  	// (A,t[3])  := t[3] + x[3]*y[4] + A
  1069  	ADCXQ BP, R10
  1070  	MULXQ BX, AX, BP
  1071  	ADOXQ AX, R10
  1072  
  1073  	// (A,t[4])  := t[4] + x[4]*y[4] + A
  1074  	ADCXQ BP, R11
  1075  	MULXQ SI, AX, BP
  1076  	ADOXQ AX, R11
  1077  
  1078  	// A += carries from ADCXQ and ADOXQ
  1079  	MOVQ  $0, AX
  1080  	ADCXQ AX, BP
  1081  	ADOXQ AX, BP
  1082  
  1083  	// m := t[0]*q'[0] mod W
  1084  	MOVQ  qInv0<>(SB), DX
  1085  	IMULQ DI, DX
  1086  
  1087  	// clear the flags
  1088  	XORQ AX, AX
  1089  
  1090  	// C,_ := t[0] + m*q[0]
  1091  	MULXQ q<>+0(SB), AX, R13
  1092  	ADCXQ DI, AX
  1093  	MOVQ  R13, DI
  1094  
  1095  	// (C,t[0]) := t[1] + m*q[1] + C
  1096  	ADCXQ R8, DI
  1097  	MULXQ q<>+8(SB), AX, R8
  1098  	ADOXQ AX, DI
  1099  
  1100  	// (C,t[1]) := t[2] + m*q[2] + C
  1101  	ADCXQ R9, R8
  1102  	MULXQ q<>+16(SB), AX, R9
  1103  	ADOXQ AX, R8
  1104  
  1105  	// (C,t[2]) := t[3] + m*q[3] + C
  1106  	ADCXQ R10, R9
  1107  	MULXQ q<>+24(SB), AX, R10
  1108  	ADOXQ AX, R9
  1109  
  1110  	// (C,t[3]) := t[4] + m*q[4] + C
  1111  	ADCXQ R11, R10
  1112  	MULXQ q<>+32(SB), AX, R11
  1113  	ADOXQ AX, R10
  1114  
  1115  	// t[4] = C + A
  1116  	MOVQ  $0, AX
  1117  	ADCXQ AX, R11
  1118  	ADOXQ BP, R11
  1119  
  1120  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
  1121  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
  1122  
  1123  	MOVQ DI, s0-8(SP)
  1124  	MOVQ R8, s1-16(SP)
  1125  	MOVQ R9, s2-24(SP)
  1126  	MOVQ R10, s3-32(SP)
  1127  	MOVQ R11, s4-40(SP)
  1128  	MOVQ x+8(FP), AX
  1129  	MOVQ 0(AX), R14
  1130  	MOVQ 8(AX), R15
  1131  	MOVQ 16(AX), CX
  1132  	MOVQ 24(AX), BX
  1133  	MOVQ 32(AX), SI
  1134  
  1135  	// A -> BP
  1136  	// t[0] -> DI
  1137  	// t[1] -> R8
  1138  	// t[2] -> R9
  1139  	// t[3] -> R10
  1140  	// t[4] -> R11
  1141  	// clear the flags
  1142  	XORQ AX, AX
  1143  	MOVQ y+16(FP), DX
  1144  	MOVQ 0(DX), DX
  1145  
  1146  	// (A,t[0])  := x[0]*y[0] + A
  1147  	MULXQ R14, DI, R8
  1148  
  1149  	// (A,t[1])  := x[1]*y[0] + A
  1150  	MULXQ R15, AX, R9
  1151  	ADOXQ AX, R8
  1152  
  1153  	// (A,t[2])  := x[2]*y[0] + A
  1154  	MULXQ CX, AX, R10
  1155  	ADOXQ AX, R9
  1156  
  1157  	// (A,t[3])  := x[3]*y[0] + A
  1158  	MULXQ BX, AX, R11
  1159  	ADOXQ AX, R10
  1160  
  1161  	// (A,t[4])  := x[4]*y[0] + A
  1162  	MULXQ SI, AX, BP
  1163  	ADOXQ AX, R11
  1164  
  1165  	// A += carries from ADCXQ and ADOXQ
  1166  	MOVQ  $0, AX
  1167  	ADOXQ AX, BP
  1168  
  1169  	// m := t[0]*q'[0] mod W
  1170  	MOVQ  qInv0<>(SB), DX
  1171  	IMULQ DI, DX
  1172  
  1173  	// clear the flags
  1174  	XORQ AX, AX
  1175  
  1176  	// C,_ := t[0] + m*q[0]
  1177  	MULXQ q<>+0(SB), AX, R12
  1178  	ADCXQ DI, AX
  1179  	MOVQ  R12, DI
  1180  
  1181  	// (C,t[0]) := t[1] + m*q[1] + C
  1182  	ADCXQ R8, DI
  1183  	MULXQ q<>+8(SB), AX, R8
  1184  	ADOXQ AX, DI
  1185  
  1186  	// (C,t[1]) := t[2] + m*q[2] + C
  1187  	ADCXQ R9, R8
  1188  	MULXQ q<>+16(SB), AX, R9
  1189  	ADOXQ AX, R8
  1190  
  1191  	// (C,t[2]) := t[3] + m*q[3] + C
  1192  	ADCXQ R10, R9
  1193  	MULXQ q<>+24(SB), AX, R10
  1194  	ADOXQ AX, R9
  1195  
  1196  	// (C,t[3]) := t[4] + m*q[4] + C
  1197  	ADCXQ R11, R10
  1198  	MULXQ q<>+32(SB), AX, R11
  1199  	ADOXQ AX, R10
  1200  
  1201  	// t[4] = C + A
  1202  	MOVQ  $0, AX
  1203  	ADCXQ AX, R11
  1204  	ADOXQ BP, R11
  1205  
  1206  	// clear the flags
  1207  	XORQ AX, AX
  1208  	MOVQ y+16(FP), DX
  1209  	MOVQ 8(DX), DX
  1210  
  1211  	// (A,t[0])  := t[0] + x[0]*y[1] + A
  1212  	MULXQ R14, AX, BP
  1213  	ADOXQ AX, DI
  1214  
  1215  	// (A,t[1])  := t[1] + x[1]*y[1] + A
  1216  	ADCXQ BP, R8
  1217  	MULXQ R15, AX, BP
  1218  	ADOXQ AX, R8
  1219  
  1220  	// (A,t[2])  := t[2] + x[2]*y[1] + A
  1221  	ADCXQ BP, R9
  1222  	MULXQ CX, AX, BP
  1223  	ADOXQ AX, R9
  1224  
  1225  	// (A,t[3])  := t[3] + x[3]*y[1] + A
  1226  	ADCXQ BP, R10
  1227  	MULXQ BX, AX, BP
  1228  	ADOXQ AX, R10
  1229  
  1230  	// (A,t[4])  := t[4] + x[4]*y[1] + A
  1231  	ADCXQ BP, R11
  1232  	MULXQ SI, AX, BP
  1233  	ADOXQ AX, R11
  1234  
  1235  	// A += carries from ADCXQ and ADOXQ
  1236  	MOVQ  $0, AX
  1237  	ADCXQ AX, BP
  1238  	ADOXQ AX, BP
  1239  
  1240  	// m := t[0]*q'[0] mod W
  1241  	MOVQ  qInv0<>(SB), DX
  1242  	IMULQ DI, DX
  1243  
  1244  	// clear the flags
  1245  	XORQ AX, AX
  1246  
  1247  	// C,_ := t[0] + m*q[0]
  1248  	MULXQ q<>+0(SB), AX, R12
  1249  	ADCXQ DI, AX
  1250  	MOVQ  R12, DI
  1251  
  1252  	// (C,t[0]) := t[1] + m*q[1] + C
  1253  	ADCXQ R8, DI
  1254  	MULXQ q<>+8(SB), AX, R8
  1255  	ADOXQ AX, DI
  1256  
  1257  	// (C,t[1]) := t[2] + m*q[2] + C
  1258  	ADCXQ R9, R8
  1259  	MULXQ q<>+16(SB), AX, R9
  1260  	ADOXQ AX, R8
  1261  
  1262  	// (C,t[2]) := t[3] + m*q[3] + C
  1263  	ADCXQ R10, R9
  1264  	MULXQ q<>+24(SB), AX, R10
  1265  	ADOXQ AX, R9
  1266  
  1267  	// (C,t[3]) := t[4] + m*q[4] + C
  1268  	ADCXQ R11, R10
  1269  	MULXQ q<>+32(SB), AX, R11
  1270  	ADOXQ AX, R10
  1271  
  1272  	// t[4] = C + A
  1273  	MOVQ  $0, AX
  1274  	ADCXQ AX, R11
  1275  	ADOXQ BP, R11
  1276  
  1277  	// clear the flags
  1278  	XORQ AX, AX
  1279  	MOVQ y+16(FP), DX
  1280  	MOVQ 16(DX), DX
  1281  
  1282  	// (A,t[0])  := t[0] + x[0]*y[2] + A
  1283  	MULXQ R14, AX, BP
  1284  	ADOXQ AX, DI
  1285  
  1286  	// (A,t[1])  := t[1] + x[1]*y[2] + A
  1287  	ADCXQ BP, R8
  1288  	MULXQ R15, AX, BP
  1289  	ADOXQ AX, R8
  1290  
  1291  	// (A,t[2])  := t[2] + x[2]*y[2] + A
  1292  	ADCXQ BP, R9
  1293  	MULXQ CX, AX, BP
  1294  	ADOXQ AX, R9
  1295  
  1296  	// (A,t[3])  := t[3] + x[3]*y[2] + A
  1297  	ADCXQ BP, R10
  1298  	MULXQ BX, AX, BP
  1299  	ADOXQ AX, R10
  1300  
  1301  	// (A,t[4])  := t[4] + x[4]*y[2] + A
  1302  	ADCXQ BP, R11
  1303  	MULXQ SI, AX, BP
  1304  	ADOXQ AX, R11
  1305  
  1306  	// A += carries from ADCXQ and ADOXQ
  1307  	MOVQ  $0, AX
  1308  	ADCXQ AX, BP
  1309  	ADOXQ AX, BP
  1310  
  1311  	// m := t[0]*q'[0] mod W
  1312  	MOVQ  qInv0<>(SB), DX
  1313  	IMULQ DI, DX
  1314  
  1315  	// clear the flags
  1316  	XORQ AX, AX
  1317  
  1318  	// C,_ := t[0] + m*q[0]
  1319  	MULXQ q<>+0(SB), AX, R12
  1320  	ADCXQ DI, AX
  1321  	MOVQ  R12, DI
  1322  
  1323  	// (C,t[0]) := t[1] + m*q[1] + C
  1324  	ADCXQ R8, DI
  1325  	MULXQ q<>+8(SB), AX, R8
  1326  	ADOXQ AX, DI
  1327  
  1328  	// (C,t[1]) := t[2] + m*q[2] + C
  1329  	ADCXQ R9, R8
  1330  	MULXQ q<>+16(SB), AX, R9
  1331  	ADOXQ AX, R8
  1332  
  1333  	// (C,t[2]) := t[3] + m*q[3] + C
  1334  	ADCXQ R10, R9
  1335  	MULXQ q<>+24(SB), AX, R10
  1336  	ADOXQ AX, R9
  1337  
  1338  	// (C,t[3]) := t[4] + m*q[4] + C
  1339  	ADCXQ R11, R10
  1340  	MULXQ q<>+32(SB), AX, R11
  1341  	ADOXQ AX, R10
  1342  
  1343  	// t[4] = C + A
  1344  	MOVQ  $0, AX
  1345  	ADCXQ AX, R11
  1346  	ADOXQ BP, R11
  1347  
  1348  	// clear the flags
  1349  	XORQ AX, AX
  1350  	MOVQ y+16(FP), DX
  1351  	MOVQ 24(DX), DX
  1352  
  1353  	// (A,t[0])  := t[0] + x[0]*y[3] + A
  1354  	MULXQ R14, AX, BP
  1355  	ADOXQ AX, DI
  1356  
  1357  	// (A,t[1])  := t[1] + x[1]*y[3] + A
  1358  	ADCXQ BP, R8
  1359  	MULXQ R15, AX, BP
  1360  	ADOXQ AX, R8
  1361  
  1362  	// (A,t[2])  := t[2] + x[2]*y[3] + A
  1363  	ADCXQ BP, R9
  1364  	MULXQ CX, AX, BP
  1365  	ADOXQ AX, R9
  1366  
  1367  	// (A,t[3])  := t[3] + x[3]*y[3] + A
  1368  	ADCXQ BP, R10
  1369  	MULXQ BX, AX, BP
  1370  	ADOXQ AX, R10
  1371  
  1372  	// (A,t[4])  := t[4] + x[4]*y[3] + A
  1373  	ADCXQ BP, R11
  1374  	MULXQ SI, AX, BP
  1375  	ADOXQ AX, R11
  1376  
  1377  	// A += carries from ADCXQ and ADOXQ
  1378  	MOVQ  $0, AX
  1379  	ADCXQ AX, BP
  1380  	ADOXQ AX, BP
  1381  
  1382  	// m := t[0]*q'[0] mod W
  1383  	MOVQ  qInv0<>(SB), DX
  1384  	IMULQ DI, DX
  1385  
  1386  	// clear the flags
  1387  	XORQ AX, AX
  1388  
  1389  	// C,_ := t[0] + m*q[0]
  1390  	MULXQ q<>+0(SB), AX, R12
  1391  	ADCXQ DI, AX
  1392  	MOVQ  R12, DI
  1393  
  1394  	// (C,t[0]) := t[1] + m*q[1] + C
  1395  	ADCXQ R8, DI
  1396  	MULXQ q<>+8(SB), AX, R8
  1397  	ADOXQ AX, DI
  1398  
  1399  	// (C,t[1]) := t[2] + m*q[2] + C
  1400  	ADCXQ R9, R8
  1401  	MULXQ q<>+16(SB), AX, R9
  1402  	ADOXQ AX, R8
  1403  
  1404  	// (C,t[2]) := t[3] + m*q[3] + C
  1405  	ADCXQ R10, R9
  1406  	MULXQ q<>+24(SB), AX, R10
  1407  	ADOXQ AX, R9
  1408  
  1409  	// (C,t[3]) := t[4] + m*q[4] + C
  1410  	ADCXQ R11, R10
  1411  	MULXQ q<>+32(SB), AX, R11
  1412  	ADOXQ AX, R10
  1413  
  1414  	// t[4] = C + A
  1415  	MOVQ  $0, AX
  1416  	ADCXQ AX, R11
  1417  	ADOXQ BP, R11
  1418  
  1419  	// clear the flags
  1420  	XORQ AX, AX
  1421  	MOVQ y+16(FP), DX
  1422  	MOVQ 32(DX), DX
  1423  
  1424  	// (A,t[0])  := t[0] + x[0]*y[4] + A
  1425  	MULXQ R14, AX, BP
  1426  	ADOXQ AX, DI
  1427  
  1428  	// (A,t[1])  := t[1] + x[1]*y[4] + A
  1429  	ADCXQ BP, R8
  1430  	MULXQ R15, AX, BP
  1431  	ADOXQ AX, R8
  1432  
  1433  	// (A,t[2])  := t[2] + x[2]*y[4] + A
  1434  	ADCXQ BP, R9
  1435  	MULXQ CX, AX, BP
  1436  	ADOXQ AX, R9
  1437  
  1438  	// (A,t[3])  := t[3] + x[3]*y[4] + A
  1439  	ADCXQ BP, R10
  1440  	MULXQ BX, AX, BP
  1441  	ADOXQ AX, R10
  1442  
  1443  	// (A,t[4])  := t[4] + x[4]*y[4] + A
  1444  	ADCXQ BP, R11
  1445  	MULXQ SI, AX, BP
  1446  	ADOXQ AX, R11
  1447  
  1448  	// A += carries from ADCXQ and ADOXQ
  1449  	MOVQ  $0, AX
  1450  	ADCXQ AX, BP
  1451  	ADOXQ AX, BP
  1452  
  1453  	// m := t[0]*q'[0] mod W
  1454  	MOVQ  qInv0<>(SB), DX
  1455  	IMULQ DI, DX
  1456  
  1457  	// clear the flags
  1458  	XORQ AX, AX
  1459  
  1460  	// C,_ := t[0] + m*q[0]
  1461  	MULXQ q<>+0(SB), AX, R12
  1462  	ADCXQ DI, AX
  1463  	MOVQ  R12, DI
  1464  
  1465  	// (C,t[0]) := t[1] + m*q[1] + C
  1466  	ADCXQ R8, DI
  1467  	MULXQ q<>+8(SB), AX, R8
  1468  	ADOXQ AX, DI
  1469  
  1470  	// (C,t[1]) := t[2] + m*q[2] + C
  1471  	ADCXQ R9, R8
  1472  	MULXQ q<>+16(SB), AX, R9
  1473  	ADOXQ AX, R8
  1474  
  1475  	// (C,t[2]) := t[3] + m*q[3] + C
  1476  	ADCXQ R10, R9
  1477  	MULXQ q<>+24(SB), AX, R10
  1478  	ADOXQ AX, R9
  1479  
  1480  	// (C,t[3]) := t[4] + m*q[4] + C
  1481  	ADCXQ R11, R10
  1482  	MULXQ q<>+32(SB), AX, R11
  1483  	ADOXQ AX, R10
  1484  
  1485  	// t[4] = C + A
  1486  	MOVQ  $0, AX
  1487  	ADCXQ AX, R11
  1488  	ADOXQ BP, R11
  1489  
  1490  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
  1491  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
  1492  
  1493  	XORQ    DX, DX
  1494  	MOVQ    s0-8(SP), R14
  1495  	MOVQ    s1-16(SP), R15
  1496  	MOVQ    s2-24(SP), CX
  1497  	MOVQ    s3-32(SP), BX
  1498  	MOVQ    s4-40(SP), SI
  1499  	SUBQ    DI, R14
  1500  	SBBQ    R8, R15
  1501  	SBBQ    R9, CX
  1502  	SBBQ    R10, BX
  1503  	SBBQ    R11, SI
  1504  	MOVQ    DI, s0-8(SP)
  1505  	MOVQ    R8, s1-16(SP)
  1506  	MOVQ    R9, s2-24(SP)
  1507  	MOVQ    R10, s3-32(SP)
  1508  	MOVQ    R11, s4-40(SP)
  1509  	MOVQ    $0x6fe802ff40300001, DI
  1510  	MOVQ    $0x421ee5da52bde502, R8
  1511  	MOVQ    $0xdec1d01aa27a1ae0, R9
  1512  	MOVQ    $0xd3f7498be97c5eaf, R10
  1513  	MOVQ    $0x04c23a02b586d650, R11
  1514  	CMOVQCC DX, DI
  1515  	CMOVQCC DX, R8
  1516  	CMOVQCC DX, R9
  1517  	CMOVQCC DX, R10
  1518  	CMOVQCC DX, R11
  1519  	ADDQ    DI, R14
  1520  	ADCQ    R8, R15
  1521  	ADCQ    R9, CX
  1522  	ADCQ    R10, BX
  1523  	ADCQ    R11, SI
  1524  	SUBQ    s5-48(SP), R14
  1525  	SBBQ    s6-56(SP), R15
  1526  	SBBQ    s7-64(SP), CX
  1527  	SBBQ    s8-72(SP), BX
  1528  	SBBQ    s9-80(SP), SI
  1529  	MOVQ    $0x6fe802ff40300001, DI
  1530  	MOVQ    $0x421ee5da52bde502, R8
  1531  	MOVQ    $0xdec1d01aa27a1ae0, R9
  1532  	MOVQ    $0xd3f7498be97c5eaf, R10
  1533  	MOVQ    $0x04c23a02b586d650, R11
  1534  	CMOVQCC DX, DI
  1535  	CMOVQCC DX, R8
  1536  	CMOVQCC DX, R9
  1537  	CMOVQCC DX, R10
  1538  	CMOVQCC DX, R11
  1539  	ADDQ    DI, R14
  1540  	ADCQ    R8, R15
  1541  	ADCQ    R9, CX
  1542  	ADCQ    R10, BX
  1543  	ADCQ    R11, SI
  1544  	MOVQ    res+0(FP), AX
  1545  	MOVQ    R14, 40(AX)
  1546  	MOVQ    R15, 48(AX)
  1547  	MOVQ    CX, 56(AX)
  1548  	MOVQ    BX, 64(AX)
  1549  	MOVQ    SI, 72(AX)
  1550  	MOVQ    s5-48(SP), DI
  1551  	MOVQ    s6-56(SP), R8
  1552  	MOVQ    s7-64(SP), R9
  1553  	MOVQ    s8-72(SP), R10
  1554  	MOVQ    s9-80(SP), R11
  1555  	MOVQ    s0-8(SP), R14
  1556  	MOVQ    s1-16(SP), R15
  1557  	MOVQ    s2-24(SP), CX
  1558  	MOVQ    s3-32(SP), BX
  1559  	MOVQ    s4-40(SP), SI
  1560  	ADDQ    DI, R14
  1561  	ADCQ    R8, R15
  1562  	ADCQ    R9, CX
  1563  	ADCQ    R10, BX
  1564  	ADCQ    R11, SI
  1565  
  1566  	// reduce element(R14,R15,CX,BX,SI) using temp registers (DI,R8,R9,R10,R11)
  1567  	REDUCE(R14,R15,CX,BX,SI,DI,R8,R9,R10,R11)
  1568  
  1569  	MOVQ s5-48(SP), DI
  1570  	MOVQ s6-56(SP), R8
  1571  	MOVQ s7-64(SP), R9
  1572  	MOVQ s8-72(SP), R10
  1573  	MOVQ s9-80(SP), R11
  1574  	MOVQ R14, s5-48(SP)
  1575  	MOVQ R15, s6-56(SP)
  1576  	MOVQ CX, s7-64(SP)
  1577  	MOVQ BX, s8-72(SP)
  1578  	MOVQ SI, s9-80(SP)
  1579  	ADDQ DI, DI
  1580  	ADCQ R8, R8
  1581  	ADCQ R9, R9
  1582  	ADCQ R10, R10
  1583  	ADCQ R11, R11
  1584  
  1585  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
  1586  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
  1587  
  1588  	ADDQ DI, DI
  1589  	ADCQ R8, R8
  1590  	ADCQ R9, R9
  1591  	ADCQ R10, R10
  1592  	ADCQ R11, R11
  1593  
  1594  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
  1595  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
  1596  
  1597  	MOVQ DI, s0-8(SP)
  1598  	MOVQ R8, s1-16(SP)
  1599  	MOVQ R9, s2-24(SP)
  1600  	MOVQ R10, s3-32(SP)
  1601  	MOVQ R11, s4-40(SP)
  1602  	ADDQ DI, DI
  1603  	ADCQ R8, R8
  1604  	ADCQ R9, R9
  1605  	ADCQ R10, R10
  1606  	ADCQ R11, R11
  1607  
  1608  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
  1609  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
  1610  
  1611  	ADDQ s0-8(SP), DI
  1612  	ADCQ s1-16(SP), R8
  1613  	ADCQ s2-24(SP), R9
  1614  	ADCQ s3-32(SP), R10
  1615  	ADCQ s4-40(SP), R11
  1616  
  1617  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
  1618  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
  1619  
  1620  	ADDQ s5-48(SP), DI
  1621  	ADCQ s6-56(SP), R8
  1622  	ADCQ s7-64(SP), R9
  1623  	ADCQ s8-72(SP), R10
  1624  	ADCQ s9-80(SP), R11
  1625  
  1626  	// reduce element(DI,R8,R9,R10,R11) using temp registers (R14,R15,CX,BX,SI)
  1627  	REDUCE(DI,R8,R9,R10,R11,R14,R15,CX,BX,SI)
  1628  
  1629  	MOVQ DI, 0(AX)
  1630  	MOVQ R8, 8(AX)
  1631  	MOVQ R9, 16(AX)
  1632  	MOVQ R10, 24(AX)
  1633  	MOVQ R11, 32(AX)
  1634  	RET
  1635  
  1636  l4:
  1637  	MOVQ res+0(FP), AX
  1638  	MOVQ AX, (SP)
  1639  	MOVQ x+8(FP), AX
  1640  	MOVQ AX, 8(SP)
  1641  	MOVQ y+16(FP), AX
  1642  	MOVQ AX, 16(SP)
  1643  	CALL ·mulGenericE2(SB)
  1644  	RET