github.com/consensys/gnark-crypto@v0.14.0/ecc/bw6-756/fp/element_mul_amd64.s (about)

     1  // +build !purego
     2  
     3  // Copyright 2020 ConsenSys Software Inc.
     4  //
     5  // Licensed under the Apache License, Version 2.0 (the "License");
     6  // you may not use this file except in compliance with the License.
     7  // You may obtain a copy of the License at
     8  //
     9  //     http://www.apache.org/licenses/LICENSE-2.0
    10  //
    11  // Unless required by applicable law or agreed to in writing, software
    12  // distributed under the License is distributed on an "AS IS" BASIS,
    13  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  // See the License for the specific language governing permissions and
    15  // limitations under the License.
    16  
    17  #include "textflag.h"
    18  #include "funcdata.h"
    19  
    20  // modulus q
    21  DATA q<>+0(SB)/8, $1
    22  DATA q<>+8(SB)/8, $0x33c7e63f86840000
    23  DATA q<>+16(SB)/8, $0xd0b685e868524ec0
    24  DATA q<>+24(SB)/8, $0x4302aa3c258de7de
    25  DATA q<>+32(SB)/8, $0xe292cd15edb646a5
    26  DATA q<>+40(SB)/8, $0x0a7eb1cb3d06e646
    27  DATA q<>+48(SB)/8, $0xeb02c812ea04faaa
    28  DATA q<>+56(SB)/8, $0xccc6ae73c42a46d9
    29  DATA q<>+64(SB)/8, $0xfbf23221455163a6
    30  DATA q<>+72(SB)/8, $0x5c978cd2fac2ce89
    31  DATA q<>+80(SB)/8, $0xe2ac127e1e3568cf
    32  DATA q<>+88(SB)/8, $0x000f76adbb5bb98a
    33  GLOBL q<>(SB), (RODATA+NOPTR), $96
    34  
    35  // qInv0 q'[0]
    36  DATA qInv0<>(SB)/8, $0xffffffffffffffff
    37  GLOBL qInv0<>(SB), (RODATA+NOPTR), $8
    38  
    39  #define REDUCE(ra0, ra1, ra2, ra3, ra4, ra5, ra6, ra7, ra8, ra9, ra10, ra11, rb0, rb1, rb2, rb3, rb4, rb5, rb6, rb7, rb8, rb9, rb10, rb11) \
    40  	MOVQ    ra0, rb0;         \
    41  	SUBQ    q<>(SB), ra0;     \
    42  	MOVQ    ra1, rb1;         \
    43  	SBBQ    q<>+8(SB), ra1;   \
    44  	MOVQ    ra2, rb2;         \
    45  	SBBQ    q<>+16(SB), ra2;  \
    46  	MOVQ    ra3, rb3;         \
    47  	SBBQ    q<>+24(SB), ra3;  \
    48  	MOVQ    ra4, rb4;         \
    49  	SBBQ    q<>+32(SB), ra4;  \
    50  	MOVQ    ra5, rb5;         \
    51  	SBBQ    q<>+40(SB), ra5;  \
    52  	MOVQ    ra6, rb6;         \
    53  	SBBQ    q<>+48(SB), ra6;  \
    54  	MOVQ    ra7, rb7;         \
    55  	SBBQ    q<>+56(SB), ra7;  \
    56  	MOVQ    ra8, rb8;         \
    57  	SBBQ    q<>+64(SB), ra8;  \
    58  	MOVQ    ra9, rb9;         \
    59  	SBBQ    q<>+72(SB), ra9;  \
    60  	MOVQ    ra10, rb10;       \
    61  	SBBQ    q<>+80(SB), ra10; \
    62  	MOVQ    ra11, rb11;       \
    63  	SBBQ    q<>+88(SB), ra11; \
    64  	CMOVQCS rb0, ra0;         \
    65  	CMOVQCS rb1, ra1;         \
    66  	CMOVQCS rb2, ra2;         \
    67  	CMOVQCS rb3, ra3;         \
    68  	CMOVQCS rb4, ra4;         \
    69  	CMOVQCS rb5, ra5;         \
    70  	CMOVQCS rb6, ra6;         \
    71  	CMOVQCS rb7, ra7;         \
    72  	CMOVQCS rb8, ra8;         \
    73  	CMOVQCS rb9, ra9;         \
    74  	CMOVQCS rb10, ra10;       \
    75  	CMOVQCS rb11, ra11;       \
    76  
    77  // mul(res, x, y *Element)
    78  TEXT ·mul(SB), $96-24
    79  
    80  	// the algorithm is described in the Element.Mul declaration (.go)
    81  	// however, to benefit from the ADCX and ADOX carry chains
    82  	// we split the inner loops in 2:
    83  	// for i=0 to N-1
    84  	// 		for j=0 to N-1
    85  	// 		    (A,t[j])  := t[j] + x[j]*y[i] + A
    86  	// 		m := t[0]*q'[0] mod W
    87  	// 		C,_ := t[0] + m*q[0]
    88  	// 		for j=1 to N-1
    89  	// 		    (C,t[j-1]) := t[j] + m*q[j] + C
    90  	// 		t[N-1] = C + A
    91  
    92  	NO_LOCAL_POINTERS
    93  	CMPB ·supportAdx(SB), $1
    94  	JNE  l1
    95  	MOVQ x+8(FP), AX
    96  
    97  	// x[0] -> s0-8(SP)
    98  	// x[1] -> s1-16(SP)
    99  	// x[2] -> s2-24(SP)
   100  	// x[3] -> s3-32(SP)
   101  	// x[4] -> s4-40(SP)
   102  	// x[5] -> s5-48(SP)
   103  	// x[6] -> s6-56(SP)
   104  	// x[7] -> s7-64(SP)
   105  	// x[8] -> s8-72(SP)
   106  	// x[9] -> s9-80(SP)
   107  	// x[10] -> s10-88(SP)
   108  	// x[11] -> s11-96(SP)
   109  	MOVQ 0(AX), R14
   110  	MOVQ 8(AX), R15
   111  	MOVQ 16(AX), CX
   112  	MOVQ 24(AX), BX
   113  	MOVQ 32(AX), SI
   114  	MOVQ 40(AX), DI
   115  	MOVQ 48(AX), R8
   116  	MOVQ 56(AX), R9
   117  	MOVQ 64(AX), R10
   118  	MOVQ 72(AX), R11
   119  	MOVQ 80(AX), R12
   120  	MOVQ 88(AX), R13
   121  	MOVQ R14, s0-8(SP)
   122  	MOVQ R15, s1-16(SP)
   123  	MOVQ CX, s2-24(SP)
   124  	MOVQ BX, s3-32(SP)
   125  	MOVQ SI, s4-40(SP)
   126  	MOVQ DI, s5-48(SP)
   127  	MOVQ R8, s6-56(SP)
   128  	MOVQ R9, s7-64(SP)
   129  	MOVQ R10, s8-72(SP)
   130  	MOVQ R11, s9-80(SP)
   131  	MOVQ R12, s10-88(SP)
   132  	MOVQ R13, s11-96(SP)
   133  
   134  	// A -> BP
   135  	// t[0] -> R14
   136  	// t[1] -> R15
   137  	// t[2] -> CX
   138  	// t[3] -> BX
   139  	// t[4] -> SI
   140  	// t[5] -> DI
   141  	// t[6] -> R8
   142  	// t[7] -> R9
   143  	// t[8] -> R10
   144  	// t[9] -> R11
   145  	// t[10] -> R12
   146  	// t[11] -> R13
   147  	// clear the flags
   148  	XORQ AX, AX
   149  	MOVQ y+16(FP), AX
   150  	MOVQ 0(AX), DX
   151  
   152  	// (A,t[0])  := x[0]*y[0] + A
   153  	MULXQ s0-8(SP), R14, R15
   154  
   155  	// (A,t[1])  := x[1]*y[0] + A
   156  	MULXQ s1-16(SP), AX, CX
   157  	ADOXQ AX, R15
   158  
   159  	// (A,t[2])  := x[2]*y[0] + A
   160  	MULXQ s2-24(SP), AX, BX
   161  	ADOXQ AX, CX
   162  
   163  	// (A,t[3])  := x[3]*y[0] + A
   164  	MULXQ s3-32(SP), AX, SI
   165  	ADOXQ AX, BX
   166  
   167  	// (A,t[4])  := x[4]*y[0] + A
   168  	MULXQ s4-40(SP), AX, DI
   169  	ADOXQ AX, SI
   170  
   171  	// (A,t[5])  := x[5]*y[0] + A
   172  	MULXQ s5-48(SP), AX, R8
   173  	ADOXQ AX, DI
   174  
   175  	// (A,t[6])  := x[6]*y[0] + A
   176  	MULXQ s6-56(SP), AX, R9
   177  	ADOXQ AX, R8
   178  
   179  	// (A,t[7])  := x[7]*y[0] + A
   180  	MULXQ s7-64(SP), AX, R10
   181  	ADOXQ AX, R9
   182  
   183  	// (A,t[8])  := x[8]*y[0] + A
   184  	MULXQ s8-72(SP), AX, R11
   185  	ADOXQ AX, R10
   186  
   187  	// (A,t[9])  := x[9]*y[0] + A
   188  	MULXQ s9-80(SP), AX, R12
   189  	ADOXQ AX, R11
   190  
   191  	// (A,t[10])  := x[10]*y[0] + A
   192  	MULXQ s10-88(SP), AX, R13
   193  	ADOXQ AX, R12
   194  
   195  	// (A,t[11])  := x[11]*y[0] + A
   196  	MULXQ s11-96(SP), AX, BP
   197  	ADOXQ AX, R13
   198  
   199  	// A += carries from ADCXQ and ADOXQ
   200  	MOVQ  $0, AX
   201  	ADOXQ AX, BP
   202  	PUSHQ BP
   203  
   204  	// m := t[0]*q'[0] mod W
   205  	MOVQ  qInv0<>(SB), DX
   206  	IMULQ R14, DX
   207  
   208  	// clear the flags
   209  	XORQ AX, AX
   210  
   211  	// C,_ := t[0] + m*q[0]
   212  	MULXQ q<>+0(SB), AX, BP
   213  	ADCXQ R14, AX
   214  	MOVQ  BP, R14
   215  	POPQ  BP
   216  
   217  	// (C,t[0]) := t[1] + m*q[1] + C
   218  	ADCXQ R15, R14
   219  	MULXQ q<>+8(SB), AX, R15
   220  	ADOXQ AX, R14
   221  
   222  	// (C,t[1]) := t[2] + m*q[2] + C
   223  	ADCXQ CX, R15
   224  	MULXQ q<>+16(SB), AX, CX
   225  	ADOXQ AX, R15
   226  
   227  	// (C,t[2]) := t[3] + m*q[3] + C
   228  	ADCXQ BX, CX
   229  	MULXQ q<>+24(SB), AX, BX
   230  	ADOXQ AX, CX
   231  
   232  	// (C,t[3]) := t[4] + m*q[4] + C
   233  	ADCXQ SI, BX
   234  	MULXQ q<>+32(SB), AX, SI
   235  	ADOXQ AX, BX
   236  
   237  	// (C,t[4]) := t[5] + m*q[5] + C
   238  	ADCXQ DI, SI
   239  	MULXQ q<>+40(SB), AX, DI
   240  	ADOXQ AX, SI
   241  
   242  	// (C,t[5]) := t[6] + m*q[6] + C
   243  	ADCXQ R8, DI
   244  	MULXQ q<>+48(SB), AX, R8
   245  	ADOXQ AX, DI
   246  
   247  	// (C,t[6]) := t[7] + m*q[7] + C
   248  	ADCXQ R9, R8
   249  	MULXQ q<>+56(SB), AX, R9
   250  	ADOXQ AX, R8
   251  
   252  	// (C,t[7]) := t[8] + m*q[8] + C
   253  	ADCXQ R10, R9
   254  	MULXQ q<>+64(SB), AX, R10
   255  	ADOXQ AX, R9
   256  
   257  	// (C,t[8]) := t[9] + m*q[9] + C
   258  	ADCXQ R11, R10
   259  	MULXQ q<>+72(SB), AX, R11
   260  	ADOXQ AX, R10
   261  
   262  	// (C,t[9]) := t[10] + m*q[10] + C
   263  	ADCXQ R12, R11
   264  	MULXQ q<>+80(SB), AX, R12
   265  	ADOXQ AX, R11
   266  
   267  	// (C,t[10]) := t[11] + m*q[11] + C
   268  	ADCXQ R13, R12
   269  	MULXQ q<>+88(SB), AX, R13
   270  	ADOXQ AX, R12
   271  
   272  	// t[11] = C + A
   273  	MOVQ  $0, AX
   274  	ADCXQ AX, R13
   275  	ADOXQ BP, R13
   276  
   277  	// clear the flags
   278  	XORQ AX, AX
   279  	MOVQ y+16(FP), AX
   280  	MOVQ 8(AX), DX
   281  
   282  	// (A,t[0])  := t[0] + x[0]*y[1] + A
   283  	MULXQ s0-8(SP), AX, BP
   284  	ADOXQ AX, R14
   285  
   286  	// (A,t[1])  := t[1] + x[1]*y[1] + A
   287  	ADCXQ BP, R15
   288  	MULXQ s1-16(SP), AX, BP
   289  	ADOXQ AX, R15
   290  
   291  	// (A,t[2])  := t[2] + x[2]*y[1] + A
   292  	ADCXQ BP, CX
   293  	MULXQ s2-24(SP), AX, BP
   294  	ADOXQ AX, CX
   295  
   296  	// (A,t[3])  := t[3] + x[3]*y[1] + A
   297  	ADCXQ BP, BX
   298  	MULXQ s3-32(SP), AX, BP
   299  	ADOXQ AX, BX
   300  
   301  	// (A,t[4])  := t[4] + x[4]*y[1] + A
   302  	ADCXQ BP, SI
   303  	MULXQ s4-40(SP), AX, BP
   304  	ADOXQ AX, SI
   305  
   306  	// (A,t[5])  := t[5] + x[5]*y[1] + A
   307  	ADCXQ BP, DI
   308  	MULXQ s5-48(SP), AX, BP
   309  	ADOXQ AX, DI
   310  
   311  	// (A,t[6])  := t[6] + x[6]*y[1] + A
   312  	ADCXQ BP, R8
   313  	MULXQ s6-56(SP), AX, BP
   314  	ADOXQ AX, R8
   315  
   316  	// (A,t[7])  := t[7] + x[7]*y[1] + A
   317  	ADCXQ BP, R9
   318  	MULXQ s7-64(SP), AX, BP
   319  	ADOXQ AX, R9
   320  
   321  	// (A,t[8])  := t[8] + x[8]*y[1] + A
   322  	ADCXQ BP, R10
   323  	MULXQ s8-72(SP), AX, BP
   324  	ADOXQ AX, R10
   325  
   326  	// (A,t[9])  := t[9] + x[9]*y[1] + A
   327  	ADCXQ BP, R11
   328  	MULXQ s9-80(SP), AX, BP
   329  	ADOXQ AX, R11
   330  
   331  	// (A,t[10])  := t[10] + x[10]*y[1] + A
   332  	ADCXQ BP, R12
   333  	MULXQ s10-88(SP), AX, BP
   334  	ADOXQ AX, R12
   335  
   336  	// (A,t[11])  := t[11] + x[11]*y[1] + A
   337  	ADCXQ BP, R13
   338  	MULXQ s11-96(SP), AX, BP
   339  	ADOXQ AX, R13
   340  
   341  	// A += carries from ADCXQ and ADOXQ
   342  	MOVQ  $0, AX
   343  	ADCXQ AX, BP
   344  	ADOXQ AX, BP
   345  	PUSHQ BP
   346  
   347  	// m := t[0]*q'[0] mod W
   348  	MOVQ  qInv0<>(SB), DX
   349  	IMULQ R14, DX
   350  
   351  	// clear the flags
   352  	XORQ AX, AX
   353  
   354  	// C,_ := t[0] + m*q[0]
   355  	MULXQ q<>+0(SB), AX, BP
   356  	ADCXQ R14, AX
   357  	MOVQ  BP, R14
   358  	POPQ  BP
   359  
   360  	// (C,t[0]) := t[1] + m*q[1] + C
   361  	ADCXQ R15, R14
   362  	MULXQ q<>+8(SB), AX, R15
   363  	ADOXQ AX, R14
   364  
   365  	// (C,t[1]) := t[2] + m*q[2] + C
   366  	ADCXQ CX, R15
   367  	MULXQ q<>+16(SB), AX, CX
   368  	ADOXQ AX, R15
   369  
   370  	// (C,t[2]) := t[3] + m*q[3] + C
   371  	ADCXQ BX, CX
   372  	MULXQ q<>+24(SB), AX, BX
   373  	ADOXQ AX, CX
   374  
   375  	// (C,t[3]) := t[4] + m*q[4] + C
   376  	ADCXQ SI, BX
   377  	MULXQ q<>+32(SB), AX, SI
   378  	ADOXQ AX, BX
   379  
   380  	// (C,t[4]) := t[5] + m*q[5] + C
   381  	ADCXQ DI, SI
   382  	MULXQ q<>+40(SB), AX, DI
   383  	ADOXQ AX, SI
   384  
   385  	// (C,t[5]) := t[6] + m*q[6] + C
   386  	ADCXQ R8, DI
   387  	MULXQ q<>+48(SB), AX, R8
   388  	ADOXQ AX, DI
   389  
   390  	// (C,t[6]) := t[7] + m*q[7] + C
   391  	ADCXQ R9, R8
   392  	MULXQ q<>+56(SB), AX, R9
   393  	ADOXQ AX, R8
   394  
   395  	// (C,t[7]) := t[8] + m*q[8] + C
   396  	ADCXQ R10, R9
   397  	MULXQ q<>+64(SB), AX, R10
   398  	ADOXQ AX, R9
   399  
   400  	// (C,t[8]) := t[9] + m*q[9] + C
   401  	ADCXQ R11, R10
   402  	MULXQ q<>+72(SB), AX, R11
   403  	ADOXQ AX, R10
   404  
   405  	// (C,t[9]) := t[10] + m*q[10] + C
   406  	ADCXQ R12, R11
   407  	MULXQ q<>+80(SB), AX, R12
   408  	ADOXQ AX, R11
   409  
   410  	// (C,t[10]) := t[11] + m*q[11] + C
   411  	ADCXQ R13, R12
   412  	MULXQ q<>+88(SB), AX, R13
   413  	ADOXQ AX, R12
   414  
   415  	// t[11] = C + A
   416  	MOVQ  $0, AX
   417  	ADCXQ AX, R13
   418  	ADOXQ BP, R13
   419  
   420  	// clear the flags
   421  	XORQ AX, AX
   422  	MOVQ y+16(FP), AX
   423  	MOVQ 16(AX), DX
   424  
   425  	// (A,t[0])  := t[0] + x[0]*y[2] + A
   426  	MULXQ s0-8(SP), AX, BP
   427  	ADOXQ AX, R14
   428  
   429  	// (A,t[1])  := t[1] + x[1]*y[2] + A
   430  	ADCXQ BP, R15
   431  	MULXQ s1-16(SP), AX, BP
   432  	ADOXQ AX, R15
   433  
   434  	// (A,t[2])  := t[2] + x[2]*y[2] + A
   435  	ADCXQ BP, CX
   436  	MULXQ s2-24(SP), AX, BP
   437  	ADOXQ AX, CX
   438  
   439  	// (A,t[3])  := t[3] + x[3]*y[2] + A
   440  	ADCXQ BP, BX
   441  	MULXQ s3-32(SP), AX, BP
   442  	ADOXQ AX, BX
   443  
   444  	// (A,t[4])  := t[4] + x[4]*y[2] + A
   445  	ADCXQ BP, SI
   446  	MULXQ s4-40(SP), AX, BP
   447  	ADOXQ AX, SI
   448  
   449  	// (A,t[5])  := t[5] + x[5]*y[2] + A
   450  	ADCXQ BP, DI
   451  	MULXQ s5-48(SP), AX, BP
   452  	ADOXQ AX, DI
   453  
   454  	// (A,t[6])  := t[6] + x[6]*y[2] + A
   455  	ADCXQ BP, R8
   456  	MULXQ s6-56(SP), AX, BP
   457  	ADOXQ AX, R8
   458  
   459  	// (A,t[7])  := t[7] + x[7]*y[2] + A
   460  	ADCXQ BP, R9
   461  	MULXQ s7-64(SP), AX, BP
   462  	ADOXQ AX, R9
   463  
   464  	// (A,t[8])  := t[8] + x[8]*y[2] + A
   465  	ADCXQ BP, R10
   466  	MULXQ s8-72(SP), AX, BP
   467  	ADOXQ AX, R10
   468  
   469  	// (A,t[9])  := t[9] + x[9]*y[2] + A
   470  	ADCXQ BP, R11
   471  	MULXQ s9-80(SP), AX, BP
   472  	ADOXQ AX, R11
   473  
   474  	// (A,t[10])  := t[10] + x[10]*y[2] + A
   475  	ADCXQ BP, R12
   476  	MULXQ s10-88(SP), AX, BP
   477  	ADOXQ AX, R12
   478  
   479  	// (A,t[11])  := t[11] + x[11]*y[2] + A
   480  	ADCXQ BP, R13
   481  	MULXQ s11-96(SP), AX, BP
   482  	ADOXQ AX, R13
   483  
   484  	// A += carries from ADCXQ and ADOXQ
   485  	MOVQ  $0, AX
   486  	ADCXQ AX, BP
   487  	ADOXQ AX, BP
   488  	PUSHQ BP
   489  
   490  	// m := t[0]*q'[0] mod W
   491  	MOVQ  qInv0<>(SB), DX
   492  	IMULQ R14, DX
   493  
   494  	// clear the flags
   495  	XORQ AX, AX
   496  
   497  	// C,_ := t[0] + m*q[0]
   498  	MULXQ q<>+0(SB), AX, BP
   499  	ADCXQ R14, AX
   500  	MOVQ  BP, R14
   501  	POPQ  BP
   502  
   503  	// (C,t[0]) := t[1] + m*q[1] + C
   504  	ADCXQ R15, R14
   505  	MULXQ q<>+8(SB), AX, R15
   506  	ADOXQ AX, R14
   507  
   508  	// (C,t[1]) := t[2] + m*q[2] + C
   509  	ADCXQ CX, R15
   510  	MULXQ q<>+16(SB), AX, CX
   511  	ADOXQ AX, R15
   512  
   513  	// (C,t[2]) := t[3] + m*q[3] + C
   514  	ADCXQ BX, CX
   515  	MULXQ q<>+24(SB), AX, BX
   516  	ADOXQ AX, CX
   517  
   518  	// (C,t[3]) := t[4] + m*q[4] + C
   519  	ADCXQ SI, BX
   520  	MULXQ q<>+32(SB), AX, SI
   521  	ADOXQ AX, BX
   522  
   523  	// (C,t[4]) := t[5] + m*q[5] + C
   524  	ADCXQ DI, SI
   525  	MULXQ q<>+40(SB), AX, DI
   526  	ADOXQ AX, SI
   527  
   528  	// (C,t[5]) := t[6] + m*q[6] + C
   529  	ADCXQ R8, DI
   530  	MULXQ q<>+48(SB), AX, R8
   531  	ADOXQ AX, DI
   532  
   533  	// (C,t[6]) := t[7] + m*q[7] + C
   534  	ADCXQ R9, R8
   535  	MULXQ q<>+56(SB), AX, R9
   536  	ADOXQ AX, R8
   537  
   538  	// (C,t[7]) := t[8] + m*q[8] + C
   539  	ADCXQ R10, R9
   540  	MULXQ q<>+64(SB), AX, R10
   541  	ADOXQ AX, R9
   542  
   543  	// (C,t[8]) := t[9] + m*q[9] + C
   544  	ADCXQ R11, R10
   545  	MULXQ q<>+72(SB), AX, R11
   546  	ADOXQ AX, R10
   547  
   548  	// (C,t[9]) := t[10] + m*q[10] + C
   549  	ADCXQ R12, R11
   550  	MULXQ q<>+80(SB), AX, R12
   551  	ADOXQ AX, R11
   552  
   553  	// (C,t[10]) := t[11] + m*q[11] + C
   554  	ADCXQ R13, R12
   555  	MULXQ q<>+88(SB), AX, R13
   556  	ADOXQ AX, R12
   557  
   558  	// t[11] = C + A
   559  	MOVQ  $0, AX
   560  	ADCXQ AX, R13
   561  	ADOXQ BP, R13
   562  
   563  	// clear the flags
   564  	XORQ AX, AX
   565  	MOVQ y+16(FP), AX
   566  	MOVQ 24(AX), DX
   567  
   568  	// (A,t[0])  := t[0] + x[0]*y[3] + A
   569  	MULXQ s0-8(SP), AX, BP
   570  	ADOXQ AX, R14
   571  
   572  	// (A,t[1])  := t[1] + x[1]*y[3] + A
   573  	ADCXQ BP, R15
   574  	MULXQ s1-16(SP), AX, BP
   575  	ADOXQ AX, R15
   576  
   577  	// (A,t[2])  := t[2] + x[2]*y[3] + A
   578  	ADCXQ BP, CX
   579  	MULXQ s2-24(SP), AX, BP
   580  	ADOXQ AX, CX
   581  
   582  	// (A,t[3])  := t[3] + x[3]*y[3] + A
   583  	ADCXQ BP, BX
   584  	MULXQ s3-32(SP), AX, BP
   585  	ADOXQ AX, BX
   586  
   587  	// (A,t[4])  := t[4] + x[4]*y[3] + A
   588  	ADCXQ BP, SI
   589  	MULXQ s4-40(SP), AX, BP
   590  	ADOXQ AX, SI
   591  
   592  	// (A,t[5])  := t[5] + x[5]*y[3] + A
   593  	ADCXQ BP, DI
   594  	MULXQ s5-48(SP), AX, BP
   595  	ADOXQ AX, DI
   596  
   597  	// (A,t[6])  := t[6] + x[6]*y[3] + A
   598  	ADCXQ BP, R8
   599  	MULXQ s6-56(SP), AX, BP
   600  	ADOXQ AX, R8
   601  
   602  	// (A,t[7])  := t[7] + x[7]*y[3] + A
   603  	ADCXQ BP, R9
   604  	MULXQ s7-64(SP), AX, BP
   605  	ADOXQ AX, R9
   606  
   607  	// (A,t[8])  := t[8] + x[8]*y[3] + A
   608  	ADCXQ BP, R10
   609  	MULXQ s8-72(SP), AX, BP
   610  	ADOXQ AX, R10
   611  
   612  	// (A,t[9])  := t[9] + x[9]*y[3] + A
   613  	ADCXQ BP, R11
   614  	MULXQ s9-80(SP), AX, BP
   615  	ADOXQ AX, R11
   616  
   617  	// (A,t[10])  := t[10] + x[10]*y[3] + A
   618  	ADCXQ BP, R12
   619  	MULXQ s10-88(SP), AX, BP
   620  	ADOXQ AX, R12
   621  
   622  	// (A,t[11])  := t[11] + x[11]*y[3] + A
   623  	ADCXQ BP, R13
   624  	MULXQ s11-96(SP), AX, BP
   625  	ADOXQ AX, R13
   626  
   627  	// A += carries from ADCXQ and ADOXQ
   628  	MOVQ  $0, AX
   629  	ADCXQ AX, BP
   630  	ADOXQ AX, BP
   631  	PUSHQ BP
   632  
   633  	// m := t[0]*q'[0] mod W
   634  	MOVQ  qInv0<>(SB), DX
   635  	IMULQ R14, DX
   636  
   637  	// clear the flags
   638  	XORQ AX, AX
   639  
   640  	// C,_ := t[0] + m*q[0]
   641  	MULXQ q<>+0(SB), AX, BP
   642  	ADCXQ R14, AX
   643  	MOVQ  BP, R14
   644  	POPQ  BP
   645  
   646  	// (C,t[0]) := t[1] + m*q[1] + C
   647  	ADCXQ R15, R14
   648  	MULXQ q<>+8(SB), AX, R15
   649  	ADOXQ AX, R14
   650  
   651  	// (C,t[1]) := t[2] + m*q[2] + C
   652  	ADCXQ CX, R15
   653  	MULXQ q<>+16(SB), AX, CX
   654  	ADOXQ AX, R15
   655  
   656  	// (C,t[2]) := t[3] + m*q[3] + C
   657  	ADCXQ BX, CX
   658  	MULXQ q<>+24(SB), AX, BX
   659  	ADOXQ AX, CX
   660  
   661  	// (C,t[3]) := t[4] + m*q[4] + C
   662  	ADCXQ SI, BX
   663  	MULXQ q<>+32(SB), AX, SI
   664  	ADOXQ AX, BX
   665  
   666  	// (C,t[4]) := t[5] + m*q[5] + C
   667  	ADCXQ DI, SI
   668  	MULXQ q<>+40(SB), AX, DI
   669  	ADOXQ AX, SI
   670  
   671  	// (C,t[5]) := t[6] + m*q[6] + C
   672  	ADCXQ R8, DI
   673  	MULXQ q<>+48(SB), AX, R8
   674  	ADOXQ AX, DI
   675  
   676  	// (C,t[6]) := t[7] + m*q[7] + C
   677  	ADCXQ R9, R8
   678  	MULXQ q<>+56(SB), AX, R9
   679  	ADOXQ AX, R8
   680  
   681  	// (C,t[7]) := t[8] + m*q[8] + C
   682  	ADCXQ R10, R9
   683  	MULXQ q<>+64(SB), AX, R10
   684  	ADOXQ AX, R9
   685  
   686  	// (C,t[8]) := t[9] + m*q[9] + C
   687  	ADCXQ R11, R10
   688  	MULXQ q<>+72(SB), AX, R11
   689  	ADOXQ AX, R10
   690  
   691  	// (C,t[9]) := t[10] + m*q[10] + C
   692  	ADCXQ R12, R11
   693  	MULXQ q<>+80(SB), AX, R12
   694  	ADOXQ AX, R11
   695  
   696  	// (C,t[10]) := t[11] + m*q[11] + C
   697  	ADCXQ R13, R12
   698  	MULXQ q<>+88(SB), AX, R13
   699  	ADOXQ AX, R12
   700  
   701  	// t[11] = C + A
   702  	MOVQ  $0, AX
   703  	ADCXQ AX, R13
   704  	ADOXQ BP, R13
   705  
   706  	// clear the flags
   707  	XORQ AX, AX
   708  	MOVQ y+16(FP), AX
   709  	MOVQ 32(AX), DX
   710  
   711  	// (A,t[0])  := t[0] + x[0]*y[4] + A
   712  	MULXQ s0-8(SP), AX, BP
   713  	ADOXQ AX, R14
   714  
   715  	// (A,t[1])  := t[1] + x[1]*y[4] + A
   716  	ADCXQ BP, R15
   717  	MULXQ s1-16(SP), AX, BP
   718  	ADOXQ AX, R15
   719  
   720  	// (A,t[2])  := t[2] + x[2]*y[4] + A
   721  	ADCXQ BP, CX
   722  	MULXQ s2-24(SP), AX, BP
   723  	ADOXQ AX, CX
   724  
   725  	// (A,t[3])  := t[3] + x[3]*y[4] + A
   726  	ADCXQ BP, BX
   727  	MULXQ s3-32(SP), AX, BP
   728  	ADOXQ AX, BX
   729  
   730  	// (A,t[4])  := t[4] + x[4]*y[4] + A
   731  	ADCXQ BP, SI
   732  	MULXQ s4-40(SP), AX, BP
   733  	ADOXQ AX, SI
   734  
   735  	// (A,t[5])  := t[5] + x[5]*y[4] + A
   736  	ADCXQ BP, DI
   737  	MULXQ s5-48(SP), AX, BP
   738  	ADOXQ AX, DI
   739  
   740  	// (A,t[6])  := t[6] + x[6]*y[4] + A
   741  	ADCXQ BP, R8
   742  	MULXQ s6-56(SP), AX, BP
   743  	ADOXQ AX, R8
   744  
   745  	// (A,t[7])  := t[7] + x[7]*y[4] + A
   746  	ADCXQ BP, R9
   747  	MULXQ s7-64(SP), AX, BP
   748  	ADOXQ AX, R9
   749  
   750  	// (A,t[8])  := t[8] + x[8]*y[4] + A
   751  	ADCXQ BP, R10
   752  	MULXQ s8-72(SP), AX, BP
   753  	ADOXQ AX, R10
   754  
   755  	// (A,t[9])  := t[9] + x[9]*y[4] + A
   756  	ADCXQ BP, R11
   757  	MULXQ s9-80(SP), AX, BP
   758  	ADOXQ AX, R11
   759  
   760  	// (A,t[10])  := t[10] + x[10]*y[4] + A
   761  	ADCXQ BP, R12
   762  	MULXQ s10-88(SP), AX, BP
   763  	ADOXQ AX, R12
   764  
   765  	// (A,t[11])  := t[11] + x[11]*y[4] + A
   766  	ADCXQ BP, R13
   767  	MULXQ s11-96(SP), AX, BP
   768  	ADOXQ AX, R13
   769  
   770  	// A += carries from ADCXQ and ADOXQ
   771  	MOVQ  $0, AX
   772  	ADCXQ AX, BP
   773  	ADOXQ AX, BP
   774  	PUSHQ BP
   775  
   776  	// m := t[0]*q'[0] mod W
   777  	MOVQ  qInv0<>(SB), DX
   778  	IMULQ R14, DX
   779  
   780  	// clear the flags
   781  	XORQ AX, AX
   782  
   783  	// C,_ := t[0] + m*q[0]
   784  	MULXQ q<>+0(SB), AX, BP
   785  	ADCXQ R14, AX
   786  	MOVQ  BP, R14
   787  	POPQ  BP
   788  
   789  	// (C,t[0]) := t[1] + m*q[1] + C
   790  	ADCXQ R15, R14
   791  	MULXQ q<>+8(SB), AX, R15
   792  	ADOXQ AX, R14
   793  
   794  	// (C,t[1]) := t[2] + m*q[2] + C
   795  	ADCXQ CX, R15
   796  	MULXQ q<>+16(SB), AX, CX
   797  	ADOXQ AX, R15
   798  
   799  	// (C,t[2]) := t[3] + m*q[3] + C
   800  	ADCXQ BX, CX
   801  	MULXQ q<>+24(SB), AX, BX
   802  	ADOXQ AX, CX
   803  
   804  	// (C,t[3]) := t[4] + m*q[4] + C
   805  	ADCXQ SI, BX
   806  	MULXQ q<>+32(SB), AX, SI
   807  	ADOXQ AX, BX
   808  
   809  	// (C,t[4]) := t[5] + m*q[5] + C
   810  	ADCXQ DI, SI
   811  	MULXQ q<>+40(SB), AX, DI
   812  	ADOXQ AX, SI
   813  
   814  	// (C,t[5]) := t[6] + m*q[6] + C
   815  	ADCXQ R8, DI
   816  	MULXQ q<>+48(SB), AX, R8
   817  	ADOXQ AX, DI
   818  
   819  	// (C,t[6]) := t[7] + m*q[7] + C
   820  	ADCXQ R9, R8
   821  	MULXQ q<>+56(SB), AX, R9
   822  	ADOXQ AX, R8
   823  
   824  	// (C,t[7]) := t[8] + m*q[8] + C
   825  	ADCXQ R10, R9
   826  	MULXQ q<>+64(SB), AX, R10
   827  	ADOXQ AX, R9
   828  
   829  	// (C,t[8]) := t[9] + m*q[9] + C
   830  	ADCXQ R11, R10
   831  	MULXQ q<>+72(SB), AX, R11
   832  	ADOXQ AX, R10
   833  
   834  	// (C,t[9]) := t[10] + m*q[10] + C
   835  	ADCXQ R12, R11
   836  	MULXQ q<>+80(SB), AX, R12
   837  	ADOXQ AX, R11
   838  
   839  	// (C,t[10]) := t[11] + m*q[11] + C
   840  	ADCXQ R13, R12
   841  	MULXQ q<>+88(SB), AX, R13
   842  	ADOXQ AX, R12
   843  
   844  	// t[11] = C + A
   845  	MOVQ  $0, AX
   846  	ADCXQ AX, R13
   847  	ADOXQ BP, R13
   848  
   849  	// clear the flags
   850  	XORQ AX, AX
   851  	MOVQ y+16(FP), AX
   852  	MOVQ 40(AX), DX
   853  
   854  	// (A,t[0])  := t[0] + x[0]*y[5] + A
   855  	MULXQ s0-8(SP), AX, BP
   856  	ADOXQ AX, R14
   857  
   858  	// (A,t[1])  := t[1] + x[1]*y[5] + A
   859  	ADCXQ BP, R15
   860  	MULXQ s1-16(SP), AX, BP
   861  	ADOXQ AX, R15
   862  
   863  	// (A,t[2])  := t[2] + x[2]*y[5] + A
   864  	ADCXQ BP, CX
   865  	MULXQ s2-24(SP), AX, BP
   866  	ADOXQ AX, CX
   867  
   868  	// (A,t[3])  := t[3] + x[3]*y[5] + A
   869  	ADCXQ BP, BX
   870  	MULXQ s3-32(SP), AX, BP
   871  	ADOXQ AX, BX
   872  
   873  	// (A,t[4])  := t[4] + x[4]*y[5] + A
   874  	ADCXQ BP, SI
   875  	MULXQ s4-40(SP), AX, BP
   876  	ADOXQ AX, SI
   877  
   878  	// (A,t[5])  := t[5] + x[5]*y[5] + A
   879  	ADCXQ BP, DI
   880  	MULXQ s5-48(SP), AX, BP
   881  	ADOXQ AX, DI
   882  
   883  	// (A,t[6])  := t[6] + x[6]*y[5] + A
   884  	ADCXQ BP, R8
   885  	MULXQ s6-56(SP), AX, BP
   886  	ADOXQ AX, R8
   887  
   888  	// (A,t[7])  := t[7] + x[7]*y[5] + A
   889  	ADCXQ BP, R9
   890  	MULXQ s7-64(SP), AX, BP
   891  	ADOXQ AX, R9
   892  
   893  	// (A,t[8])  := t[8] + x[8]*y[5] + A
   894  	ADCXQ BP, R10
   895  	MULXQ s8-72(SP), AX, BP
   896  	ADOXQ AX, R10
   897  
   898  	// (A,t[9])  := t[9] + x[9]*y[5] + A
   899  	ADCXQ BP, R11
   900  	MULXQ s9-80(SP), AX, BP
   901  	ADOXQ AX, R11
   902  
   903  	// (A,t[10])  := t[10] + x[10]*y[5] + A
   904  	ADCXQ BP, R12
   905  	MULXQ s10-88(SP), AX, BP
   906  	ADOXQ AX, R12
   907  
   908  	// (A,t[11])  := t[11] + x[11]*y[5] + A
   909  	ADCXQ BP, R13
   910  	MULXQ s11-96(SP), AX, BP
   911  	ADOXQ AX, R13
   912  
   913  	// A += carries from ADCXQ and ADOXQ
   914  	MOVQ  $0, AX
   915  	ADCXQ AX, BP
   916  	ADOXQ AX, BP
   917  	PUSHQ BP
   918  
   919  	// m := t[0]*q'[0] mod W
   920  	MOVQ  qInv0<>(SB), DX
   921  	IMULQ R14, DX
   922  
   923  	// clear the flags
   924  	XORQ AX, AX
   925  
   926  	// C,_ := t[0] + m*q[0]
   927  	MULXQ q<>+0(SB), AX, BP
   928  	ADCXQ R14, AX
   929  	MOVQ  BP, R14
   930  	POPQ  BP
   931  
   932  	// (C,t[0]) := t[1] + m*q[1] + C
   933  	ADCXQ R15, R14
   934  	MULXQ q<>+8(SB), AX, R15
   935  	ADOXQ AX, R14
   936  
   937  	// (C,t[1]) := t[2] + m*q[2] + C
   938  	ADCXQ CX, R15
   939  	MULXQ q<>+16(SB), AX, CX
   940  	ADOXQ AX, R15
   941  
   942  	// (C,t[2]) := t[3] + m*q[3] + C
   943  	ADCXQ BX, CX
   944  	MULXQ q<>+24(SB), AX, BX
   945  	ADOXQ AX, CX
   946  
   947  	// (C,t[3]) := t[4] + m*q[4] + C
   948  	ADCXQ SI, BX
   949  	MULXQ q<>+32(SB), AX, SI
   950  	ADOXQ AX, BX
   951  
   952  	// (C,t[4]) := t[5] + m*q[5] + C
   953  	ADCXQ DI, SI
   954  	MULXQ q<>+40(SB), AX, DI
   955  	ADOXQ AX, SI
   956  
   957  	// (C,t[5]) := t[6] + m*q[6] + C
   958  	ADCXQ R8, DI
   959  	MULXQ q<>+48(SB), AX, R8
   960  	ADOXQ AX, DI
   961  
   962  	// (C,t[6]) := t[7] + m*q[7] + C
   963  	ADCXQ R9, R8
   964  	MULXQ q<>+56(SB), AX, R9
   965  	ADOXQ AX, R8
   966  
   967  	// (C,t[7]) := t[8] + m*q[8] + C
   968  	ADCXQ R10, R9
   969  	MULXQ q<>+64(SB), AX, R10
   970  	ADOXQ AX, R9
   971  
   972  	// (C,t[8]) := t[9] + m*q[9] + C
   973  	ADCXQ R11, R10
   974  	MULXQ q<>+72(SB), AX, R11
   975  	ADOXQ AX, R10
   976  
   977  	// (C,t[9]) := t[10] + m*q[10] + C
   978  	ADCXQ R12, R11
   979  	MULXQ q<>+80(SB), AX, R12
   980  	ADOXQ AX, R11
   981  
   982  	// (C,t[10]) := t[11] + m*q[11] + C
   983  	ADCXQ R13, R12
   984  	MULXQ q<>+88(SB), AX, R13
   985  	ADOXQ AX, R12
   986  
   987  	// t[11] = C + A
   988  	MOVQ  $0, AX
   989  	ADCXQ AX, R13
   990  	ADOXQ BP, R13
   991  
   992  	// clear the flags
   993  	XORQ AX, AX
   994  	MOVQ y+16(FP), AX
   995  	MOVQ 48(AX), DX
   996  
   997  	// (A,t[0])  := t[0] + x[0]*y[6] + A
   998  	MULXQ s0-8(SP), AX, BP
   999  	ADOXQ AX, R14
  1000  
  1001  	// (A,t[1])  := t[1] + x[1]*y[6] + A
  1002  	ADCXQ BP, R15
  1003  	MULXQ s1-16(SP), AX, BP
  1004  	ADOXQ AX, R15
  1005  
  1006  	// (A,t[2])  := t[2] + x[2]*y[6] + A
  1007  	ADCXQ BP, CX
  1008  	MULXQ s2-24(SP), AX, BP
  1009  	ADOXQ AX, CX
  1010  
  1011  	// (A,t[3])  := t[3] + x[3]*y[6] + A
  1012  	ADCXQ BP, BX
  1013  	MULXQ s3-32(SP), AX, BP
  1014  	ADOXQ AX, BX
  1015  
  1016  	// (A,t[4])  := t[4] + x[4]*y[6] + A
  1017  	ADCXQ BP, SI
  1018  	MULXQ s4-40(SP), AX, BP
  1019  	ADOXQ AX, SI
  1020  
  1021  	// (A,t[5])  := t[5] + x[5]*y[6] + A
  1022  	ADCXQ BP, DI
  1023  	MULXQ s5-48(SP), AX, BP
  1024  	ADOXQ AX, DI
  1025  
  1026  	// (A,t[6])  := t[6] + x[6]*y[6] + A
  1027  	ADCXQ BP, R8
  1028  	MULXQ s6-56(SP), AX, BP
  1029  	ADOXQ AX, R8
  1030  
  1031  	// (A,t[7])  := t[7] + x[7]*y[6] + A
  1032  	ADCXQ BP, R9
  1033  	MULXQ s7-64(SP), AX, BP
  1034  	ADOXQ AX, R9
  1035  
  1036  	// (A,t[8])  := t[8] + x[8]*y[6] + A
  1037  	ADCXQ BP, R10
  1038  	MULXQ s8-72(SP), AX, BP
  1039  	ADOXQ AX, R10
  1040  
  1041  	// (A,t[9])  := t[9] + x[9]*y[6] + A
  1042  	ADCXQ BP, R11
  1043  	MULXQ s9-80(SP), AX, BP
  1044  	ADOXQ AX, R11
  1045  
  1046  	// (A,t[10])  := t[10] + x[10]*y[6] + A
  1047  	ADCXQ BP, R12
  1048  	MULXQ s10-88(SP), AX, BP
  1049  	ADOXQ AX, R12
  1050  
  1051  	// (A,t[11])  := t[11] + x[11]*y[6] + A
  1052  	ADCXQ BP, R13
  1053  	MULXQ s11-96(SP), AX, BP
  1054  	ADOXQ AX, R13
  1055  
  1056  	// A += carries from ADCXQ and ADOXQ
  1057  	MOVQ  $0, AX
  1058  	ADCXQ AX, BP
  1059  	ADOXQ AX, BP
  1060  	PUSHQ BP
  1061  
  1062  	// m := t[0]*q'[0] mod W
  1063  	MOVQ  qInv0<>(SB), DX
  1064  	IMULQ R14, DX
  1065  
  1066  	// clear the flags
  1067  	XORQ AX, AX
  1068  
  1069  	// C,_ := t[0] + m*q[0]
  1070  	MULXQ q<>+0(SB), AX, BP
  1071  	ADCXQ R14, AX
  1072  	MOVQ  BP, R14
  1073  	POPQ  BP
  1074  
  1075  	// (C,t[0]) := t[1] + m*q[1] + C
  1076  	ADCXQ R15, R14
  1077  	MULXQ q<>+8(SB), AX, R15
  1078  	ADOXQ AX, R14
  1079  
  1080  	// (C,t[1]) := t[2] + m*q[2] + C
  1081  	ADCXQ CX, R15
  1082  	MULXQ q<>+16(SB), AX, CX
  1083  	ADOXQ AX, R15
  1084  
  1085  	// (C,t[2]) := t[3] + m*q[3] + C
  1086  	ADCXQ BX, CX
  1087  	MULXQ q<>+24(SB), AX, BX
  1088  	ADOXQ AX, CX
  1089  
  1090  	// (C,t[3]) := t[4] + m*q[4] + C
  1091  	ADCXQ SI, BX
  1092  	MULXQ q<>+32(SB), AX, SI
  1093  	ADOXQ AX, BX
  1094  
  1095  	// (C,t[4]) := t[5] + m*q[5] + C
  1096  	ADCXQ DI, SI
  1097  	MULXQ q<>+40(SB), AX, DI
  1098  	ADOXQ AX, SI
  1099  
  1100  	// (C,t[5]) := t[6] + m*q[6] + C
  1101  	ADCXQ R8, DI
  1102  	MULXQ q<>+48(SB), AX, R8
  1103  	ADOXQ AX, DI
  1104  
  1105  	// (C,t[6]) := t[7] + m*q[7] + C
  1106  	ADCXQ R9, R8
  1107  	MULXQ q<>+56(SB), AX, R9
  1108  	ADOXQ AX, R8
  1109  
  1110  	// (C,t[7]) := t[8] + m*q[8] + C
  1111  	ADCXQ R10, R9
  1112  	MULXQ q<>+64(SB), AX, R10
  1113  	ADOXQ AX, R9
  1114  
  1115  	// (C,t[8]) := t[9] + m*q[9] + C
  1116  	ADCXQ R11, R10
  1117  	MULXQ q<>+72(SB), AX, R11
  1118  	ADOXQ AX, R10
  1119  
  1120  	// (C,t[9]) := t[10] + m*q[10] + C
  1121  	ADCXQ R12, R11
  1122  	MULXQ q<>+80(SB), AX, R12
  1123  	ADOXQ AX, R11
  1124  
  1125  	// (C,t[10]) := t[11] + m*q[11] + C
  1126  	ADCXQ R13, R12
  1127  	MULXQ q<>+88(SB), AX, R13
  1128  	ADOXQ AX, R12
  1129  
  1130  	// t[11] = C + A
  1131  	MOVQ  $0, AX
  1132  	ADCXQ AX, R13
  1133  	ADOXQ BP, R13
  1134  
  1135  	// clear the flags
  1136  	XORQ AX, AX
  1137  	MOVQ y+16(FP), AX
  1138  	MOVQ 56(AX), DX
  1139  
  1140  	// (A,t[0])  := t[0] + x[0]*y[7] + A
  1141  	MULXQ s0-8(SP), AX, BP
  1142  	ADOXQ AX, R14
  1143  
  1144  	// (A,t[1])  := t[1] + x[1]*y[7] + A
  1145  	ADCXQ BP, R15
  1146  	MULXQ s1-16(SP), AX, BP
  1147  	ADOXQ AX, R15
  1148  
  1149  	// (A,t[2])  := t[2] + x[2]*y[7] + A
  1150  	ADCXQ BP, CX
  1151  	MULXQ s2-24(SP), AX, BP
  1152  	ADOXQ AX, CX
  1153  
  1154  	// (A,t[3])  := t[3] + x[3]*y[7] + A
  1155  	ADCXQ BP, BX
  1156  	MULXQ s3-32(SP), AX, BP
  1157  	ADOXQ AX, BX
  1158  
  1159  	// (A,t[4])  := t[4] + x[4]*y[7] + A
  1160  	ADCXQ BP, SI
  1161  	MULXQ s4-40(SP), AX, BP
  1162  	ADOXQ AX, SI
  1163  
  1164  	// (A,t[5])  := t[5] + x[5]*y[7] + A
  1165  	ADCXQ BP, DI
  1166  	MULXQ s5-48(SP), AX, BP
  1167  	ADOXQ AX, DI
  1168  
  1169  	// (A,t[6])  := t[6] + x[6]*y[7] + A
  1170  	ADCXQ BP, R8
  1171  	MULXQ s6-56(SP), AX, BP
  1172  	ADOXQ AX, R8
  1173  
  1174  	// (A,t[7])  := t[7] + x[7]*y[7] + A
  1175  	ADCXQ BP, R9
  1176  	MULXQ s7-64(SP), AX, BP
  1177  	ADOXQ AX, R9
  1178  
  1179  	// (A,t[8])  := t[8] + x[8]*y[7] + A
  1180  	ADCXQ BP, R10
  1181  	MULXQ s8-72(SP), AX, BP
  1182  	ADOXQ AX, R10
  1183  
  1184  	// (A,t[9])  := t[9] + x[9]*y[7] + A
  1185  	ADCXQ BP, R11
  1186  	MULXQ s9-80(SP), AX, BP
  1187  	ADOXQ AX, R11
  1188  
  1189  	// (A,t[10])  := t[10] + x[10]*y[7] + A
  1190  	ADCXQ BP, R12
  1191  	MULXQ s10-88(SP), AX, BP
  1192  	ADOXQ AX, R12
  1193  
  1194  	// (A,t[11])  := t[11] + x[11]*y[7] + A
  1195  	ADCXQ BP, R13
  1196  	MULXQ s11-96(SP), AX, BP
  1197  	ADOXQ AX, R13
  1198  
  1199  	// A += carries from ADCXQ and ADOXQ
  1200  	MOVQ  $0, AX
  1201  	ADCXQ AX, BP
  1202  	ADOXQ AX, BP
  1203  	PUSHQ BP
  1204  
  1205  	// m := t[0]*q'[0] mod W
  1206  	MOVQ  qInv0<>(SB), DX
  1207  	IMULQ R14, DX
  1208  
  1209  	// clear the flags
  1210  	XORQ AX, AX
  1211  
  1212  	// C,_ := t[0] + m*q[0]
  1213  	MULXQ q<>+0(SB), AX, BP
  1214  	ADCXQ R14, AX
  1215  	MOVQ  BP, R14
  1216  	POPQ  BP
  1217  
  1218  	// (C,t[0]) := t[1] + m*q[1] + C
  1219  	ADCXQ R15, R14
  1220  	MULXQ q<>+8(SB), AX, R15
  1221  	ADOXQ AX, R14
  1222  
  1223  	// (C,t[1]) := t[2] + m*q[2] + C
  1224  	ADCXQ CX, R15
  1225  	MULXQ q<>+16(SB), AX, CX
  1226  	ADOXQ AX, R15
  1227  
  1228  	// (C,t[2]) := t[3] + m*q[3] + C
  1229  	ADCXQ BX, CX
  1230  	MULXQ q<>+24(SB), AX, BX
  1231  	ADOXQ AX, CX
  1232  
  1233  	// (C,t[3]) := t[4] + m*q[4] + C
  1234  	ADCXQ SI, BX
  1235  	MULXQ q<>+32(SB), AX, SI
  1236  	ADOXQ AX, BX
  1237  
  1238  	// (C,t[4]) := t[5] + m*q[5] + C
  1239  	ADCXQ DI, SI
  1240  	MULXQ q<>+40(SB), AX, DI
  1241  	ADOXQ AX, SI
  1242  
  1243  	// (C,t[5]) := t[6] + m*q[6] + C
  1244  	ADCXQ R8, DI
  1245  	MULXQ q<>+48(SB), AX, R8
  1246  	ADOXQ AX, DI
  1247  
  1248  	// (C,t[6]) := t[7] + m*q[7] + C
  1249  	ADCXQ R9, R8
  1250  	MULXQ q<>+56(SB), AX, R9
  1251  	ADOXQ AX, R8
  1252  
  1253  	// (C,t[7]) := t[8] + m*q[8] + C
  1254  	ADCXQ R10, R9
  1255  	MULXQ q<>+64(SB), AX, R10
  1256  	ADOXQ AX, R9
  1257  
  1258  	// (C,t[8]) := t[9] + m*q[9] + C
  1259  	ADCXQ R11, R10
  1260  	MULXQ q<>+72(SB), AX, R11
  1261  	ADOXQ AX, R10
  1262  
  1263  	// (C,t[9]) := t[10] + m*q[10] + C
  1264  	ADCXQ R12, R11
  1265  	MULXQ q<>+80(SB), AX, R12
  1266  	ADOXQ AX, R11
  1267  
  1268  	// (C,t[10]) := t[11] + m*q[11] + C
  1269  	ADCXQ R13, R12
  1270  	MULXQ q<>+88(SB), AX, R13
  1271  	ADOXQ AX, R12
  1272  
  1273  	// t[11] = C + A
  1274  	MOVQ  $0, AX
  1275  	ADCXQ AX, R13
  1276  	ADOXQ BP, R13
  1277  
  1278  	// clear the flags
  1279  	XORQ AX, AX
  1280  	MOVQ y+16(FP), AX
  1281  	MOVQ 64(AX), DX
  1282  
  1283  	// (A,t[0])  := t[0] + x[0]*y[8] + A
  1284  	MULXQ s0-8(SP), AX, BP
  1285  	ADOXQ AX, R14
  1286  
  1287  	// (A,t[1])  := t[1] + x[1]*y[8] + A
  1288  	ADCXQ BP, R15
  1289  	MULXQ s1-16(SP), AX, BP
  1290  	ADOXQ AX, R15
  1291  
  1292  	// (A,t[2])  := t[2] + x[2]*y[8] + A
  1293  	ADCXQ BP, CX
  1294  	MULXQ s2-24(SP), AX, BP
  1295  	ADOXQ AX, CX
  1296  
  1297  	// (A,t[3])  := t[3] + x[3]*y[8] + A
  1298  	ADCXQ BP, BX
  1299  	MULXQ s3-32(SP), AX, BP
  1300  	ADOXQ AX, BX
  1301  
  1302  	// (A,t[4])  := t[4] + x[4]*y[8] + A
  1303  	ADCXQ BP, SI
  1304  	MULXQ s4-40(SP), AX, BP
  1305  	ADOXQ AX, SI
  1306  
  1307  	// (A,t[5])  := t[5] + x[5]*y[8] + A
  1308  	ADCXQ BP, DI
  1309  	MULXQ s5-48(SP), AX, BP
  1310  	ADOXQ AX, DI
  1311  
  1312  	// (A,t[6])  := t[6] + x[6]*y[8] + A
  1313  	ADCXQ BP, R8
  1314  	MULXQ s6-56(SP), AX, BP
  1315  	ADOXQ AX, R8
  1316  
  1317  	// (A,t[7])  := t[7] + x[7]*y[8] + A
  1318  	ADCXQ BP, R9
  1319  	MULXQ s7-64(SP), AX, BP
  1320  	ADOXQ AX, R9
  1321  
  1322  	// (A,t[8])  := t[8] + x[8]*y[8] + A
  1323  	ADCXQ BP, R10
  1324  	MULXQ s8-72(SP), AX, BP
  1325  	ADOXQ AX, R10
  1326  
  1327  	// (A,t[9])  := t[9] + x[9]*y[8] + A
  1328  	ADCXQ BP, R11
  1329  	MULXQ s9-80(SP), AX, BP
  1330  	ADOXQ AX, R11
  1331  
  1332  	// (A,t[10])  := t[10] + x[10]*y[8] + A
  1333  	ADCXQ BP, R12
  1334  	MULXQ s10-88(SP), AX, BP
  1335  	ADOXQ AX, R12
  1336  
  1337  	// (A,t[11])  := t[11] + x[11]*y[8] + A
  1338  	ADCXQ BP, R13
  1339  	MULXQ s11-96(SP), AX, BP
  1340  	ADOXQ AX, R13
  1341  
  1342  	// A += carries from ADCXQ and ADOXQ
  1343  	MOVQ  $0, AX
  1344  	ADCXQ AX, BP
  1345  	ADOXQ AX, BP
  1346  	PUSHQ BP
  1347  
  1348  	// m := t[0]*q'[0] mod W
  1349  	MOVQ  qInv0<>(SB), DX
  1350  	IMULQ R14, DX
  1351  
  1352  	// clear the flags
  1353  	XORQ AX, AX
  1354  
  1355  	// C,_ := t[0] + m*q[0]
  1356  	MULXQ q<>+0(SB), AX, BP
  1357  	ADCXQ R14, AX
  1358  	MOVQ  BP, R14
  1359  	POPQ  BP
  1360  
  1361  	// (C,t[0]) := t[1] + m*q[1] + C
  1362  	ADCXQ R15, R14
  1363  	MULXQ q<>+8(SB), AX, R15
  1364  	ADOXQ AX, R14
  1365  
  1366  	// (C,t[1]) := t[2] + m*q[2] + C
  1367  	ADCXQ CX, R15
  1368  	MULXQ q<>+16(SB), AX, CX
  1369  	ADOXQ AX, R15
  1370  
  1371  	// (C,t[2]) := t[3] + m*q[3] + C
  1372  	ADCXQ BX, CX
  1373  	MULXQ q<>+24(SB), AX, BX
  1374  	ADOXQ AX, CX
  1375  
  1376  	// (C,t[3]) := t[4] + m*q[4] + C
  1377  	ADCXQ SI, BX
  1378  	MULXQ q<>+32(SB), AX, SI
  1379  	ADOXQ AX, BX
  1380  
  1381  	// (C,t[4]) := t[5] + m*q[5] + C
  1382  	ADCXQ DI, SI
  1383  	MULXQ q<>+40(SB), AX, DI
  1384  	ADOXQ AX, SI
  1385  
  1386  	// (C,t[5]) := t[6] + m*q[6] + C
  1387  	ADCXQ R8, DI
  1388  	MULXQ q<>+48(SB), AX, R8
  1389  	ADOXQ AX, DI
  1390  
  1391  	// (C,t[6]) := t[7] + m*q[7] + C
  1392  	ADCXQ R9, R8
  1393  	MULXQ q<>+56(SB), AX, R9
  1394  	ADOXQ AX, R8
  1395  
  1396  	// (C,t[7]) := t[8] + m*q[8] + C
  1397  	ADCXQ R10, R9
  1398  	MULXQ q<>+64(SB), AX, R10
  1399  	ADOXQ AX, R9
  1400  
  1401  	// (C,t[8]) := t[9] + m*q[9] + C
  1402  	ADCXQ R11, R10
  1403  	MULXQ q<>+72(SB), AX, R11
  1404  	ADOXQ AX, R10
  1405  
  1406  	// (C,t[9]) := t[10] + m*q[10] + C
  1407  	ADCXQ R12, R11
  1408  	MULXQ q<>+80(SB), AX, R12
  1409  	ADOXQ AX, R11
  1410  
  1411  	// (C,t[10]) := t[11] + m*q[11] + C
  1412  	ADCXQ R13, R12
  1413  	MULXQ q<>+88(SB), AX, R13
  1414  	ADOXQ AX, R12
  1415  
  1416  	// t[11] = C + A
  1417  	MOVQ  $0, AX
  1418  	ADCXQ AX, R13
  1419  	ADOXQ BP, R13
  1420  
  1421  	// clear the flags
  1422  	XORQ AX, AX
  1423  	MOVQ y+16(FP), AX
  1424  	MOVQ 72(AX), DX
  1425  
  1426  	// (A,t[0])  := t[0] + x[0]*y[9] + A
  1427  	MULXQ s0-8(SP), AX, BP
  1428  	ADOXQ AX, R14
  1429  
  1430  	// (A,t[1])  := t[1] + x[1]*y[9] + A
  1431  	ADCXQ BP, R15
  1432  	MULXQ s1-16(SP), AX, BP
  1433  	ADOXQ AX, R15
  1434  
  1435  	// (A,t[2])  := t[2] + x[2]*y[9] + A
  1436  	ADCXQ BP, CX
  1437  	MULXQ s2-24(SP), AX, BP
  1438  	ADOXQ AX, CX
  1439  
  1440  	// (A,t[3])  := t[3] + x[3]*y[9] + A
  1441  	ADCXQ BP, BX
  1442  	MULXQ s3-32(SP), AX, BP
  1443  	ADOXQ AX, BX
  1444  
  1445  	// (A,t[4])  := t[4] + x[4]*y[9] + A
  1446  	ADCXQ BP, SI
  1447  	MULXQ s4-40(SP), AX, BP
  1448  	ADOXQ AX, SI
  1449  
  1450  	// (A,t[5])  := t[5] + x[5]*y[9] + A
  1451  	ADCXQ BP, DI
  1452  	MULXQ s5-48(SP), AX, BP
  1453  	ADOXQ AX, DI
  1454  
  1455  	// (A,t[6])  := t[6] + x[6]*y[9] + A
  1456  	ADCXQ BP, R8
  1457  	MULXQ s6-56(SP), AX, BP
  1458  	ADOXQ AX, R8
  1459  
  1460  	// (A,t[7])  := t[7] + x[7]*y[9] + A
  1461  	ADCXQ BP, R9
  1462  	MULXQ s7-64(SP), AX, BP
  1463  	ADOXQ AX, R9
  1464  
  1465  	// (A,t[8])  := t[8] + x[8]*y[9] + A
  1466  	ADCXQ BP, R10
  1467  	MULXQ s8-72(SP), AX, BP
  1468  	ADOXQ AX, R10
  1469  
  1470  	// (A,t[9])  := t[9] + x[9]*y[9] + A
  1471  	ADCXQ BP, R11
  1472  	MULXQ s9-80(SP), AX, BP
  1473  	ADOXQ AX, R11
  1474  
  1475  	// (A,t[10])  := t[10] + x[10]*y[9] + A
  1476  	ADCXQ BP, R12
  1477  	MULXQ s10-88(SP), AX, BP
  1478  	ADOXQ AX, R12
  1479  
  1480  	// (A,t[11])  := t[11] + x[11]*y[9] + A
  1481  	ADCXQ BP, R13
  1482  	MULXQ s11-96(SP), AX, BP
  1483  	ADOXQ AX, R13
  1484  
  1485  	// A += carries from ADCXQ and ADOXQ
  1486  	MOVQ  $0, AX
  1487  	ADCXQ AX, BP
  1488  	ADOXQ AX, BP
  1489  	PUSHQ BP
  1490  
  1491  	// m := t[0]*q'[0] mod W
  1492  	MOVQ  qInv0<>(SB), DX
  1493  	IMULQ R14, DX
  1494  
  1495  	// clear the flags
  1496  	XORQ AX, AX
  1497  
  1498  	// C,_ := t[0] + m*q[0]
  1499  	MULXQ q<>+0(SB), AX, BP
  1500  	ADCXQ R14, AX
  1501  	MOVQ  BP, R14
  1502  	POPQ  BP
  1503  
  1504  	// (C,t[0]) := t[1] + m*q[1] + C
  1505  	ADCXQ R15, R14
  1506  	MULXQ q<>+8(SB), AX, R15
  1507  	ADOXQ AX, R14
  1508  
  1509  	// (C,t[1]) := t[2] + m*q[2] + C
  1510  	ADCXQ CX, R15
  1511  	MULXQ q<>+16(SB), AX, CX
  1512  	ADOXQ AX, R15
  1513  
  1514  	// (C,t[2]) := t[3] + m*q[3] + C
  1515  	ADCXQ BX, CX
  1516  	MULXQ q<>+24(SB), AX, BX
  1517  	ADOXQ AX, CX
  1518  
  1519  	// (C,t[3]) := t[4] + m*q[4] + C
  1520  	ADCXQ SI, BX
  1521  	MULXQ q<>+32(SB), AX, SI
  1522  	ADOXQ AX, BX
  1523  
  1524  	// (C,t[4]) := t[5] + m*q[5] + C
  1525  	ADCXQ DI, SI
  1526  	MULXQ q<>+40(SB), AX, DI
  1527  	ADOXQ AX, SI
  1528  
  1529  	// (C,t[5]) := t[6] + m*q[6] + C
  1530  	ADCXQ R8, DI
  1531  	MULXQ q<>+48(SB), AX, R8
  1532  	ADOXQ AX, DI
  1533  
  1534  	// (C,t[6]) := t[7] + m*q[7] + C
  1535  	ADCXQ R9, R8
  1536  	MULXQ q<>+56(SB), AX, R9
  1537  	ADOXQ AX, R8
  1538  
  1539  	// (C,t[7]) := t[8] + m*q[8] + C
  1540  	ADCXQ R10, R9
  1541  	MULXQ q<>+64(SB), AX, R10
  1542  	ADOXQ AX, R9
  1543  
  1544  	// (C,t[8]) := t[9] + m*q[9] + C
  1545  	ADCXQ R11, R10
  1546  	MULXQ q<>+72(SB), AX, R11
  1547  	ADOXQ AX, R10
  1548  
  1549  	// (C,t[9]) := t[10] + m*q[10] + C
  1550  	ADCXQ R12, R11
  1551  	MULXQ q<>+80(SB), AX, R12
  1552  	ADOXQ AX, R11
  1553  
  1554  	// (C,t[10]) := t[11] + m*q[11] + C
  1555  	ADCXQ R13, R12
  1556  	MULXQ q<>+88(SB), AX, R13
  1557  	ADOXQ AX, R12
  1558  
  1559  	// t[11] = C + A
  1560  	MOVQ  $0, AX
  1561  	ADCXQ AX, R13
  1562  	ADOXQ BP, R13
  1563  
  1564  	// clear the flags
  1565  	XORQ AX, AX
  1566  	MOVQ y+16(FP), AX
  1567  	MOVQ 80(AX), DX
  1568  
  1569  	// (A,t[0])  := t[0] + x[0]*y[10] + A
  1570  	MULXQ s0-8(SP), AX, BP
  1571  	ADOXQ AX, R14
  1572  
  1573  	// (A,t[1])  := t[1] + x[1]*y[10] + A
  1574  	ADCXQ BP, R15
  1575  	MULXQ s1-16(SP), AX, BP
  1576  	ADOXQ AX, R15
  1577  
  1578  	// (A,t[2])  := t[2] + x[2]*y[10] + A
  1579  	ADCXQ BP, CX
  1580  	MULXQ s2-24(SP), AX, BP
  1581  	ADOXQ AX, CX
  1582  
  1583  	// (A,t[3])  := t[3] + x[3]*y[10] + A
  1584  	ADCXQ BP, BX
  1585  	MULXQ s3-32(SP), AX, BP
  1586  	ADOXQ AX, BX
  1587  
  1588  	// (A,t[4])  := t[4] + x[4]*y[10] + A
  1589  	ADCXQ BP, SI
  1590  	MULXQ s4-40(SP), AX, BP
  1591  	ADOXQ AX, SI
  1592  
  1593  	// (A,t[5])  := t[5] + x[5]*y[10] + A
  1594  	ADCXQ BP, DI
  1595  	MULXQ s5-48(SP), AX, BP
  1596  	ADOXQ AX, DI
  1597  
  1598  	// (A,t[6])  := t[6] + x[6]*y[10] + A
  1599  	ADCXQ BP, R8
  1600  	MULXQ s6-56(SP), AX, BP
  1601  	ADOXQ AX, R8
  1602  
  1603  	// (A,t[7])  := t[7] + x[7]*y[10] + A
  1604  	ADCXQ BP, R9
  1605  	MULXQ s7-64(SP), AX, BP
  1606  	ADOXQ AX, R9
  1607  
  1608  	// (A,t[8])  := t[8] + x[8]*y[10] + A
  1609  	ADCXQ BP, R10
  1610  	MULXQ s8-72(SP), AX, BP
  1611  	ADOXQ AX, R10
  1612  
  1613  	// (A,t[9])  := t[9] + x[9]*y[10] + A
  1614  	ADCXQ BP, R11
  1615  	MULXQ s9-80(SP), AX, BP
  1616  	ADOXQ AX, R11
  1617  
  1618  	// (A,t[10])  := t[10] + x[10]*y[10] + A
  1619  	ADCXQ BP, R12
  1620  	MULXQ s10-88(SP), AX, BP
  1621  	ADOXQ AX, R12
  1622  
  1623  	// (A,t[11])  := t[11] + x[11]*y[10] + A
  1624  	ADCXQ BP, R13
  1625  	MULXQ s11-96(SP), AX, BP
  1626  	ADOXQ AX, R13
  1627  
  1628  	// A += carries from ADCXQ and ADOXQ
  1629  	MOVQ  $0, AX
  1630  	ADCXQ AX, BP
  1631  	ADOXQ AX, BP
  1632  	PUSHQ BP
  1633  
  1634  	// m := t[0]*q'[0] mod W
  1635  	MOVQ  qInv0<>(SB), DX
  1636  	IMULQ R14, DX
  1637  
  1638  	// clear the flags
  1639  	XORQ AX, AX
  1640  
  1641  	// C,_ := t[0] + m*q[0]
  1642  	MULXQ q<>+0(SB), AX, BP
  1643  	ADCXQ R14, AX
  1644  	MOVQ  BP, R14
  1645  	POPQ  BP
  1646  
  1647  	// (C,t[0]) := t[1] + m*q[1] + C
  1648  	ADCXQ R15, R14
  1649  	MULXQ q<>+8(SB), AX, R15
  1650  	ADOXQ AX, R14
  1651  
  1652  	// (C,t[1]) := t[2] + m*q[2] + C
  1653  	ADCXQ CX, R15
  1654  	MULXQ q<>+16(SB), AX, CX
  1655  	ADOXQ AX, R15
  1656  
  1657  	// (C,t[2]) := t[3] + m*q[3] + C
  1658  	ADCXQ BX, CX
  1659  	MULXQ q<>+24(SB), AX, BX
  1660  	ADOXQ AX, CX
  1661  
  1662  	// (C,t[3]) := t[4] + m*q[4] + C
  1663  	ADCXQ SI, BX
  1664  	MULXQ q<>+32(SB), AX, SI
  1665  	ADOXQ AX, BX
  1666  
  1667  	// (C,t[4]) := t[5] + m*q[5] + C
  1668  	ADCXQ DI, SI
  1669  	MULXQ q<>+40(SB), AX, DI
  1670  	ADOXQ AX, SI
  1671  
  1672  	// (C,t[5]) := t[6] + m*q[6] + C
  1673  	ADCXQ R8, DI
  1674  	MULXQ q<>+48(SB), AX, R8
  1675  	ADOXQ AX, DI
  1676  
  1677  	// (C,t[6]) := t[7] + m*q[7] + C
  1678  	ADCXQ R9, R8
  1679  	MULXQ q<>+56(SB), AX, R9
  1680  	ADOXQ AX, R8
  1681  
  1682  	// (C,t[7]) := t[8] + m*q[8] + C
  1683  	ADCXQ R10, R9
  1684  	MULXQ q<>+64(SB), AX, R10
  1685  	ADOXQ AX, R9
  1686  
  1687  	// (C,t[8]) := t[9] + m*q[9] + C
  1688  	ADCXQ R11, R10
  1689  	MULXQ q<>+72(SB), AX, R11
  1690  	ADOXQ AX, R10
  1691  
  1692  	// (C,t[9]) := t[10] + m*q[10] + C
  1693  	ADCXQ R12, R11
  1694  	MULXQ q<>+80(SB), AX, R12
  1695  	ADOXQ AX, R11
  1696  
  1697  	// (C,t[10]) := t[11] + m*q[11] + C
  1698  	ADCXQ R13, R12
  1699  	MULXQ q<>+88(SB), AX, R13
  1700  	ADOXQ AX, R12
  1701  
  1702  	// t[11] = C + A
  1703  	MOVQ  $0, AX
  1704  	ADCXQ AX, R13
  1705  	ADOXQ BP, R13
  1706  
  1707  	// clear the flags
  1708  	XORQ AX, AX
  1709  	MOVQ y+16(FP), AX
  1710  	MOVQ 88(AX), DX
  1711  
  1712  	// (A,t[0])  := t[0] + x[0]*y[11] + A
  1713  	MULXQ s0-8(SP), AX, BP
  1714  	ADOXQ AX, R14
  1715  
  1716  	// (A,t[1])  := t[1] + x[1]*y[11] + A
  1717  	ADCXQ BP, R15
  1718  	MULXQ s1-16(SP), AX, BP
  1719  	ADOXQ AX, R15
  1720  
  1721  	// (A,t[2])  := t[2] + x[2]*y[11] + A
  1722  	ADCXQ BP, CX
  1723  	MULXQ s2-24(SP), AX, BP
  1724  	ADOXQ AX, CX
  1725  
  1726  	// (A,t[3])  := t[3] + x[3]*y[11] + A
  1727  	ADCXQ BP, BX
  1728  	MULXQ s3-32(SP), AX, BP
  1729  	ADOXQ AX, BX
  1730  
  1731  	// (A,t[4])  := t[4] + x[4]*y[11] + A
  1732  	ADCXQ BP, SI
  1733  	MULXQ s4-40(SP), AX, BP
  1734  	ADOXQ AX, SI
  1735  
  1736  	// (A,t[5])  := t[5] + x[5]*y[11] + A
  1737  	ADCXQ BP, DI
  1738  	MULXQ s5-48(SP), AX, BP
  1739  	ADOXQ AX, DI
  1740  
  1741  	// (A,t[6])  := t[6] + x[6]*y[11] + A
  1742  	ADCXQ BP, R8
  1743  	MULXQ s6-56(SP), AX, BP
  1744  	ADOXQ AX, R8
  1745  
  1746  	// (A,t[7])  := t[7] + x[7]*y[11] + A
  1747  	ADCXQ BP, R9
  1748  	MULXQ s7-64(SP), AX, BP
  1749  	ADOXQ AX, R9
  1750  
  1751  	// (A,t[8])  := t[8] + x[8]*y[11] + A
  1752  	ADCXQ BP, R10
  1753  	MULXQ s8-72(SP), AX, BP
  1754  	ADOXQ AX, R10
  1755  
  1756  	// (A,t[9])  := t[9] + x[9]*y[11] + A
  1757  	ADCXQ BP, R11
  1758  	MULXQ s9-80(SP), AX, BP
  1759  	ADOXQ AX, R11
  1760  
  1761  	// (A,t[10])  := t[10] + x[10]*y[11] + A
  1762  	ADCXQ BP, R12
  1763  	MULXQ s10-88(SP), AX, BP
  1764  	ADOXQ AX, R12
  1765  
  1766  	// (A,t[11])  := t[11] + x[11]*y[11] + A
  1767  	ADCXQ BP, R13
  1768  	MULXQ s11-96(SP), AX, BP
  1769  	ADOXQ AX, R13
  1770  
  1771  	// A += carries from ADCXQ and ADOXQ
  1772  	MOVQ  $0, AX
  1773  	ADCXQ AX, BP
  1774  	ADOXQ AX, BP
  1775  	PUSHQ BP
  1776  
  1777  	// m := t[0]*q'[0] mod W
  1778  	MOVQ  qInv0<>(SB), DX
  1779  	IMULQ R14, DX
  1780  
  1781  	// clear the flags
  1782  	XORQ AX, AX
  1783  
  1784  	// C,_ := t[0] + m*q[0]
  1785  	MULXQ q<>+0(SB), AX, BP
  1786  	ADCXQ R14, AX
  1787  	MOVQ  BP, R14
  1788  	POPQ  BP
  1789  
  1790  	// (C,t[0]) := t[1] + m*q[1] + C
  1791  	ADCXQ R15, R14
  1792  	MULXQ q<>+8(SB), AX, R15
  1793  	ADOXQ AX, R14
  1794  
  1795  	// (C,t[1]) := t[2] + m*q[2] + C
  1796  	ADCXQ CX, R15
  1797  	MULXQ q<>+16(SB), AX, CX
  1798  	ADOXQ AX, R15
  1799  
  1800  	// (C,t[2]) := t[3] + m*q[3] + C
  1801  	ADCXQ BX, CX
  1802  	MULXQ q<>+24(SB), AX, BX
  1803  	ADOXQ AX, CX
  1804  
  1805  	// (C,t[3]) := t[4] + m*q[4] + C
  1806  	ADCXQ SI, BX
  1807  	MULXQ q<>+32(SB), AX, SI
  1808  	ADOXQ AX, BX
  1809  
  1810  	// (C,t[4]) := t[5] + m*q[5] + C
  1811  	ADCXQ DI, SI
  1812  	MULXQ q<>+40(SB), AX, DI
  1813  	ADOXQ AX, SI
  1814  
  1815  	// (C,t[5]) := t[6] + m*q[6] + C
  1816  	ADCXQ R8, DI
  1817  	MULXQ q<>+48(SB), AX, R8
  1818  	ADOXQ AX, DI
  1819  
  1820  	// (C,t[6]) := t[7] + m*q[7] + C
  1821  	ADCXQ R9, R8
  1822  	MULXQ q<>+56(SB), AX, R9
  1823  	ADOXQ AX, R8
  1824  
  1825  	// (C,t[7]) := t[8] + m*q[8] + C
  1826  	ADCXQ R10, R9
  1827  	MULXQ q<>+64(SB), AX, R10
  1828  	ADOXQ AX, R9
  1829  
  1830  	// (C,t[8]) := t[9] + m*q[9] + C
  1831  	ADCXQ R11, R10
  1832  	MULXQ q<>+72(SB), AX, R11
  1833  	ADOXQ AX, R10
  1834  
  1835  	// (C,t[9]) := t[10] + m*q[10] + C
  1836  	ADCXQ R12, R11
  1837  	MULXQ q<>+80(SB), AX, R12
  1838  	ADOXQ AX, R11
  1839  
  1840  	// (C,t[10]) := t[11] + m*q[11] + C
  1841  	ADCXQ R13, R12
  1842  	MULXQ q<>+88(SB), AX, R13
  1843  	ADOXQ AX, R12
  1844  
  1845  	// t[11] = C + A
  1846  	MOVQ  $0, AX
  1847  	ADCXQ AX, R13
  1848  	ADOXQ BP, R13
  1849  
  1850  	// reduce element(R14,R15,CX,BX,SI,DI,R8,R9,R10,R11,R12,R13) using temp registers (s0-8(SP),s1-16(SP),s2-24(SP),s3-32(SP),s4-40(SP),s5-48(SP),s6-56(SP),s7-64(SP),s8-72(SP),s9-80(SP),s10-88(SP),s11-96(SP))
  1851  	REDUCE(R14,R15,CX,BX,SI,DI,R8,R9,R10,R11,R12,R13,s0-8(SP),s1-16(SP),s2-24(SP),s3-32(SP),s4-40(SP),s5-48(SP),s6-56(SP),s7-64(SP),s8-72(SP),s9-80(SP),s10-88(SP),s11-96(SP))
  1852  
  1853  	MOVQ res+0(FP), AX
  1854  	MOVQ R14, 0(AX)
  1855  	MOVQ R15, 8(AX)
  1856  	MOVQ CX, 16(AX)
  1857  	MOVQ BX, 24(AX)
  1858  	MOVQ SI, 32(AX)
  1859  	MOVQ DI, 40(AX)
  1860  	MOVQ R8, 48(AX)
  1861  	MOVQ R9, 56(AX)
  1862  	MOVQ R10, 64(AX)
  1863  	MOVQ R11, 72(AX)
  1864  	MOVQ R12, 80(AX)
  1865  	MOVQ R13, 88(AX)
  1866  	RET
  1867  
  1868  l1:
  1869  	MOVQ res+0(FP), AX
  1870  	MOVQ AX, (SP)
  1871  	MOVQ x+8(FP), AX
  1872  	MOVQ AX, 8(SP)
  1873  	MOVQ y+16(FP), AX
  1874  	MOVQ AX, 16(SP)
  1875  	CALL ·_mulGeneric(SB)
  1876  	RET
  1877  
  1878  TEXT ·fromMont(SB), $96-8
  1879  	NO_LOCAL_POINTERS
  1880  
  1881  	// the algorithm is described here
  1882  	// https://hackmd.io/@gnark/modular_multiplication
  1883  	// when y = 1 we have:
  1884  	// for i=0 to N-1
  1885  	// 		t[i] = x[i]
  1886  	// for i=0 to N-1
  1887  	// 		m := t[0]*q'[0] mod W
  1888  	// 		C,_ := t[0] + m*q[0]
  1889  	// 		for j=1 to N-1
  1890  	// 		    (C,t[j-1]) := t[j] + m*q[j] + C
  1891  	// 		t[N-1] = C
  1892  	CMPB ·supportAdx(SB), $1
  1893  	JNE  l2
  1894  	MOVQ res+0(FP), DX
  1895  	MOVQ 0(DX), R14
  1896  	MOVQ 8(DX), R15
  1897  	MOVQ 16(DX), CX
  1898  	MOVQ 24(DX), BX
  1899  	MOVQ 32(DX), SI
  1900  	MOVQ 40(DX), DI
  1901  	MOVQ 48(DX), R8
  1902  	MOVQ 56(DX), R9
  1903  	MOVQ 64(DX), R10
  1904  	MOVQ 72(DX), R11
  1905  	MOVQ 80(DX), R12
  1906  	MOVQ 88(DX), R13
  1907  	XORQ DX, DX
  1908  
  1909  	// m := t[0]*q'[0] mod W
  1910  	MOVQ  qInv0<>(SB), DX
  1911  	IMULQ R14, DX
  1912  	XORQ  AX, AX
  1913  
  1914  	// C,_ := t[0] + m*q[0]
  1915  	MULXQ q<>+0(SB), AX, BP
  1916  	ADCXQ R14, AX
  1917  	MOVQ  BP, R14
  1918  
  1919  	// (C,t[0]) := t[1] + m*q[1] + C
  1920  	ADCXQ R15, R14
  1921  	MULXQ q<>+8(SB), AX, R15
  1922  	ADOXQ AX, R14
  1923  
  1924  	// (C,t[1]) := t[2] + m*q[2] + C
  1925  	ADCXQ CX, R15
  1926  	MULXQ q<>+16(SB), AX, CX
  1927  	ADOXQ AX, R15
  1928  
  1929  	// (C,t[2]) := t[3] + m*q[3] + C
  1930  	ADCXQ BX, CX
  1931  	MULXQ q<>+24(SB), AX, BX
  1932  	ADOXQ AX, CX
  1933  
  1934  	// (C,t[3]) := t[4] + m*q[4] + C
  1935  	ADCXQ SI, BX
  1936  	MULXQ q<>+32(SB), AX, SI
  1937  	ADOXQ AX, BX
  1938  
  1939  	// (C,t[4]) := t[5] + m*q[5] + C
  1940  	ADCXQ DI, SI
  1941  	MULXQ q<>+40(SB), AX, DI
  1942  	ADOXQ AX, SI
  1943  
  1944  	// (C,t[5]) := t[6] + m*q[6] + C
  1945  	ADCXQ R8, DI
  1946  	MULXQ q<>+48(SB), AX, R8
  1947  	ADOXQ AX, DI
  1948  
  1949  	// (C,t[6]) := t[7] + m*q[7] + C
  1950  	ADCXQ R9, R8
  1951  	MULXQ q<>+56(SB), AX, R9
  1952  	ADOXQ AX, R8
  1953  
  1954  	// (C,t[7]) := t[8] + m*q[8] + C
  1955  	ADCXQ R10, R9
  1956  	MULXQ q<>+64(SB), AX, R10
  1957  	ADOXQ AX, R9
  1958  
  1959  	// (C,t[8]) := t[9] + m*q[9] + C
  1960  	ADCXQ R11, R10
  1961  	MULXQ q<>+72(SB), AX, R11
  1962  	ADOXQ AX, R10
  1963  
  1964  	// (C,t[9]) := t[10] + m*q[10] + C
  1965  	ADCXQ R12, R11
  1966  	MULXQ q<>+80(SB), AX, R12
  1967  	ADOXQ AX, R11
  1968  
  1969  	// (C,t[10]) := t[11] + m*q[11] + C
  1970  	ADCXQ R13, R12
  1971  	MULXQ q<>+88(SB), AX, R13
  1972  	ADOXQ AX, R12
  1973  	MOVQ  $0, AX
  1974  	ADCXQ AX, R13
  1975  	ADOXQ AX, R13
  1976  	XORQ  DX, DX
  1977  
  1978  	// m := t[0]*q'[0] mod W
  1979  	MOVQ  qInv0<>(SB), DX
  1980  	IMULQ R14, DX
  1981  	XORQ  AX, AX
  1982  
  1983  	// C,_ := t[0] + m*q[0]
  1984  	MULXQ q<>+0(SB), AX, BP
  1985  	ADCXQ R14, AX
  1986  	MOVQ  BP, R14
  1987  
  1988  	// (C,t[0]) := t[1] + m*q[1] + C
  1989  	ADCXQ R15, R14
  1990  	MULXQ q<>+8(SB), AX, R15
  1991  	ADOXQ AX, R14
  1992  
  1993  	// (C,t[1]) := t[2] + m*q[2] + C
  1994  	ADCXQ CX, R15
  1995  	MULXQ q<>+16(SB), AX, CX
  1996  	ADOXQ AX, R15
  1997  
  1998  	// (C,t[2]) := t[3] + m*q[3] + C
  1999  	ADCXQ BX, CX
  2000  	MULXQ q<>+24(SB), AX, BX
  2001  	ADOXQ AX, CX
  2002  
  2003  	// (C,t[3]) := t[4] + m*q[4] + C
  2004  	ADCXQ SI, BX
  2005  	MULXQ q<>+32(SB), AX, SI
  2006  	ADOXQ AX, BX
  2007  
  2008  	// (C,t[4]) := t[5] + m*q[5] + C
  2009  	ADCXQ DI, SI
  2010  	MULXQ q<>+40(SB), AX, DI
  2011  	ADOXQ AX, SI
  2012  
  2013  	// (C,t[5]) := t[6] + m*q[6] + C
  2014  	ADCXQ R8, DI
  2015  	MULXQ q<>+48(SB), AX, R8
  2016  	ADOXQ AX, DI
  2017  
  2018  	// (C,t[6]) := t[7] + m*q[7] + C
  2019  	ADCXQ R9, R8
  2020  	MULXQ q<>+56(SB), AX, R9
  2021  	ADOXQ AX, R8
  2022  
  2023  	// (C,t[7]) := t[8] + m*q[8] + C
  2024  	ADCXQ R10, R9
  2025  	MULXQ q<>+64(SB), AX, R10
  2026  	ADOXQ AX, R9
  2027  
  2028  	// (C,t[8]) := t[9] + m*q[9] + C
  2029  	ADCXQ R11, R10
  2030  	MULXQ q<>+72(SB), AX, R11
  2031  	ADOXQ AX, R10
  2032  
  2033  	// (C,t[9]) := t[10] + m*q[10] + C
  2034  	ADCXQ R12, R11
  2035  	MULXQ q<>+80(SB), AX, R12
  2036  	ADOXQ AX, R11
  2037  
  2038  	// (C,t[10]) := t[11] + m*q[11] + C
  2039  	ADCXQ R13, R12
  2040  	MULXQ q<>+88(SB), AX, R13
  2041  	ADOXQ AX, R12
  2042  	MOVQ  $0, AX
  2043  	ADCXQ AX, R13
  2044  	ADOXQ AX, R13
  2045  	XORQ  DX, DX
  2046  
  2047  	// m := t[0]*q'[0] mod W
  2048  	MOVQ  qInv0<>(SB), DX
  2049  	IMULQ R14, DX
  2050  	XORQ  AX, AX
  2051  
  2052  	// C,_ := t[0] + m*q[0]
  2053  	MULXQ q<>+0(SB), AX, BP
  2054  	ADCXQ R14, AX
  2055  	MOVQ  BP, R14
  2056  
  2057  	// (C,t[0]) := t[1] + m*q[1] + C
  2058  	ADCXQ R15, R14
  2059  	MULXQ q<>+8(SB), AX, R15
  2060  	ADOXQ AX, R14
  2061  
  2062  	// (C,t[1]) := t[2] + m*q[2] + C
  2063  	ADCXQ CX, R15
  2064  	MULXQ q<>+16(SB), AX, CX
  2065  	ADOXQ AX, R15
  2066  
  2067  	// (C,t[2]) := t[3] + m*q[3] + C
  2068  	ADCXQ BX, CX
  2069  	MULXQ q<>+24(SB), AX, BX
  2070  	ADOXQ AX, CX
  2071  
  2072  	// (C,t[3]) := t[4] + m*q[4] + C
  2073  	ADCXQ SI, BX
  2074  	MULXQ q<>+32(SB), AX, SI
  2075  	ADOXQ AX, BX
  2076  
  2077  	// (C,t[4]) := t[5] + m*q[5] + C
  2078  	ADCXQ DI, SI
  2079  	MULXQ q<>+40(SB), AX, DI
  2080  	ADOXQ AX, SI
  2081  
  2082  	// (C,t[5]) := t[6] + m*q[6] + C
  2083  	ADCXQ R8, DI
  2084  	MULXQ q<>+48(SB), AX, R8
  2085  	ADOXQ AX, DI
  2086  
  2087  	// (C,t[6]) := t[7] + m*q[7] + C
  2088  	ADCXQ R9, R8
  2089  	MULXQ q<>+56(SB), AX, R9
  2090  	ADOXQ AX, R8
  2091  
  2092  	// (C,t[7]) := t[8] + m*q[8] + C
  2093  	ADCXQ R10, R9
  2094  	MULXQ q<>+64(SB), AX, R10
  2095  	ADOXQ AX, R9
  2096  
  2097  	// (C,t[8]) := t[9] + m*q[9] + C
  2098  	ADCXQ R11, R10
  2099  	MULXQ q<>+72(SB), AX, R11
  2100  	ADOXQ AX, R10
  2101  
  2102  	// (C,t[9]) := t[10] + m*q[10] + C
  2103  	ADCXQ R12, R11
  2104  	MULXQ q<>+80(SB), AX, R12
  2105  	ADOXQ AX, R11
  2106  
  2107  	// (C,t[10]) := t[11] + m*q[11] + C
  2108  	ADCXQ R13, R12
  2109  	MULXQ q<>+88(SB), AX, R13
  2110  	ADOXQ AX, R12
  2111  	MOVQ  $0, AX
  2112  	ADCXQ AX, R13
  2113  	ADOXQ AX, R13
  2114  	XORQ  DX, DX
  2115  
  2116  	// m := t[0]*q'[0] mod W
  2117  	MOVQ  qInv0<>(SB), DX
  2118  	IMULQ R14, DX
  2119  	XORQ  AX, AX
  2120  
  2121  	// C,_ := t[0] + m*q[0]
  2122  	MULXQ q<>+0(SB), AX, BP
  2123  	ADCXQ R14, AX
  2124  	MOVQ  BP, R14
  2125  
  2126  	// (C,t[0]) := t[1] + m*q[1] + C
  2127  	ADCXQ R15, R14
  2128  	MULXQ q<>+8(SB), AX, R15
  2129  	ADOXQ AX, R14
  2130  
  2131  	// (C,t[1]) := t[2] + m*q[2] + C
  2132  	ADCXQ CX, R15
  2133  	MULXQ q<>+16(SB), AX, CX
  2134  	ADOXQ AX, R15
  2135  
  2136  	// (C,t[2]) := t[3] + m*q[3] + C
  2137  	ADCXQ BX, CX
  2138  	MULXQ q<>+24(SB), AX, BX
  2139  	ADOXQ AX, CX
  2140  
  2141  	// (C,t[3]) := t[4] + m*q[4] + C
  2142  	ADCXQ SI, BX
  2143  	MULXQ q<>+32(SB), AX, SI
  2144  	ADOXQ AX, BX
  2145  
  2146  	// (C,t[4]) := t[5] + m*q[5] + C
  2147  	ADCXQ DI, SI
  2148  	MULXQ q<>+40(SB), AX, DI
  2149  	ADOXQ AX, SI
  2150  
  2151  	// (C,t[5]) := t[6] + m*q[6] + C
  2152  	ADCXQ R8, DI
  2153  	MULXQ q<>+48(SB), AX, R8
  2154  	ADOXQ AX, DI
  2155  
  2156  	// (C,t[6]) := t[7] + m*q[7] + C
  2157  	ADCXQ R9, R8
  2158  	MULXQ q<>+56(SB), AX, R9
  2159  	ADOXQ AX, R8
  2160  
  2161  	// (C,t[7]) := t[8] + m*q[8] + C
  2162  	ADCXQ R10, R9
  2163  	MULXQ q<>+64(SB), AX, R10
  2164  	ADOXQ AX, R9
  2165  
  2166  	// (C,t[8]) := t[9] + m*q[9] + C
  2167  	ADCXQ R11, R10
  2168  	MULXQ q<>+72(SB), AX, R11
  2169  	ADOXQ AX, R10
  2170  
  2171  	// (C,t[9]) := t[10] + m*q[10] + C
  2172  	ADCXQ R12, R11
  2173  	MULXQ q<>+80(SB), AX, R12
  2174  	ADOXQ AX, R11
  2175  
  2176  	// (C,t[10]) := t[11] + m*q[11] + C
  2177  	ADCXQ R13, R12
  2178  	MULXQ q<>+88(SB), AX, R13
  2179  	ADOXQ AX, R12
  2180  	MOVQ  $0, AX
  2181  	ADCXQ AX, R13
  2182  	ADOXQ AX, R13
  2183  	XORQ  DX, DX
  2184  
  2185  	// m := t[0]*q'[0] mod W
  2186  	MOVQ  qInv0<>(SB), DX
  2187  	IMULQ R14, DX
  2188  	XORQ  AX, AX
  2189  
  2190  	// C,_ := t[0] + m*q[0]
  2191  	MULXQ q<>+0(SB), AX, BP
  2192  	ADCXQ R14, AX
  2193  	MOVQ  BP, R14
  2194  
  2195  	// (C,t[0]) := t[1] + m*q[1] + C
  2196  	ADCXQ R15, R14
  2197  	MULXQ q<>+8(SB), AX, R15
  2198  	ADOXQ AX, R14
  2199  
  2200  	// (C,t[1]) := t[2] + m*q[2] + C
  2201  	ADCXQ CX, R15
  2202  	MULXQ q<>+16(SB), AX, CX
  2203  	ADOXQ AX, R15
  2204  
  2205  	// (C,t[2]) := t[3] + m*q[3] + C
  2206  	ADCXQ BX, CX
  2207  	MULXQ q<>+24(SB), AX, BX
  2208  	ADOXQ AX, CX
  2209  
  2210  	// (C,t[3]) := t[4] + m*q[4] + C
  2211  	ADCXQ SI, BX
  2212  	MULXQ q<>+32(SB), AX, SI
  2213  	ADOXQ AX, BX
  2214  
  2215  	// (C,t[4]) := t[5] + m*q[5] + C
  2216  	ADCXQ DI, SI
  2217  	MULXQ q<>+40(SB), AX, DI
  2218  	ADOXQ AX, SI
  2219  
  2220  	// (C,t[5]) := t[6] + m*q[6] + C
  2221  	ADCXQ R8, DI
  2222  	MULXQ q<>+48(SB), AX, R8
  2223  	ADOXQ AX, DI
  2224  
  2225  	// (C,t[6]) := t[7] + m*q[7] + C
  2226  	ADCXQ R9, R8
  2227  	MULXQ q<>+56(SB), AX, R9
  2228  	ADOXQ AX, R8
  2229  
  2230  	// (C,t[7]) := t[8] + m*q[8] + C
  2231  	ADCXQ R10, R9
  2232  	MULXQ q<>+64(SB), AX, R10
  2233  	ADOXQ AX, R9
  2234  
  2235  	// (C,t[8]) := t[9] + m*q[9] + C
  2236  	ADCXQ R11, R10
  2237  	MULXQ q<>+72(SB), AX, R11
  2238  	ADOXQ AX, R10
  2239  
  2240  	// (C,t[9]) := t[10] + m*q[10] + C
  2241  	ADCXQ R12, R11
  2242  	MULXQ q<>+80(SB), AX, R12
  2243  	ADOXQ AX, R11
  2244  
  2245  	// (C,t[10]) := t[11] + m*q[11] + C
  2246  	ADCXQ R13, R12
  2247  	MULXQ q<>+88(SB), AX, R13
  2248  	ADOXQ AX, R12
  2249  	MOVQ  $0, AX
  2250  	ADCXQ AX, R13
  2251  	ADOXQ AX, R13
  2252  	XORQ  DX, DX
  2253  
  2254  	// m := t[0]*q'[0] mod W
  2255  	MOVQ  qInv0<>(SB), DX
  2256  	IMULQ R14, DX
  2257  	XORQ  AX, AX
  2258  
  2259  	// C,_ := t[0] + m*q[0]
  2260  	MULXQ q<>+0(SB), AX, BP
  2261  	ADCXQ R14, AX
  2262  	MOVQ  BP, R14
  2263  
  2264  	// (C,t[0]) := t[1] + m*q[1] + C
  2265  	ADCXQ R15, R14
  2266  	MULXQ q<>+8(SB), AX, R15
  2267  	ADOXQ AX, R14
  2268  
  2269  	// (C,t[1]) := t[2] + m*q[2] + C
  2270  	ADCXQ CX, R15
  2271  	MULXQ q<>+16(SB), AX, CX
  2272  	ADOXQ AX, R15
  2273  
  2274  	// (C,t[2]) := t[3] + m*q[3] + C
  2275  	ADCXQ BX, CX
  2276  	MULXQ q<>+24(SB), AX, BX
  2277  	ADOXQ AX, CX
  2278  
  2279  	// (C,t[3]) := t[4] + m*q[4] + C
  2280  	ADCXQ SI, BX
  2281  	MULXQ q<>+32(SB), AX, SI
  2282  	ADOXQ AX, BX
  2283  
  2284  	// (C,t[4]) := t[5] + m*q[5] + C
  2285  	ADCXQ DI, SI
  2286  	MULXQ q<>+40(SB), AX, DI
  2287  	ADOXQ AX, SI
  2288  
  2289  	// (C,t[5]) := t[6] + m*q[6] + C
  2290  	ADCXQ R8, DI
  2291  	MULXQ q<>+48(SB), AX, R8
  2292  	ADOXQ AX, DI
  2293  
  2294  	// (C,t[6]) := t[7] + m*q[7] + C
  2295  	ADCXQ R9, R8
  2296  	MULXQ q<>+56(SB), AX, R9
  2297  	ADOXQ AX, R8
  2298  
  2299  	// (C,t[7]) := t[8] + m*q[8] + C
  2300  	ADCXQ R10, R9
  2301  	MULXQ q<>+64(SB), AX, R10
  2302  	ADOXQ AX, R9
  2303  
  2304  	// (C,t[8]) := t[9] + m*q[9] + C
  2305  	ADCXQ R11, R10
  2306  	MULXQ q<>+72(SB), AX, R11
  2307  	ADOXQ AX, R10
  2308  
  2309  	// (C,t[9]) := t[10] + m*q[10] + C
  2310  	ADCXQ R12, R11
  2311  	MULXQ q<>+80(SB), AX, R12
  2312  	ADOXQ AX, R11
  2313  
  2314  	// (C,t[10]) := t[11] + m*q[11] + C
  2315  	ADCXQ R13, R12
  2316  	MULXQ q<>+88(SB), AX, R13
  2317  	ADOXQ AX, R12
  2318  	MOVQ  $0, AX
  2319  	ADCXQ AX, R13
  2320  	ADOXQ AX, R13
  2321  	XORQ  DX, DX
  2322  
  2323  	// m := t[0]*q'[0] mod W
  2324  	MOVQ  qInv0<>(SB), DX
  2325  	IMULQ R14, DX
  2326  	XORQ  AX, AX
  2327  
  2328  	// C,_ := t[0] + m*q[0]
  2329  	MULXQ q<>+0(SB), AX, BP
  2330  	ADCXQ R14, AX
  2331  	MOVQ  BP, R14
  2332  
  2333  	// (C,t[0]) := t[1] + m*q[1] + C
  2334  	ADCXQ R15, R14
  2335  	MULXQ q<>+8(SB), AX, R15
  2336  	ADOXQ AX, R14
  2337  
  2338  	// (C,t[1]) := t[2] + m*q[2] + C
  2339  	ADCXQ CX, R15
  2340  	MULXQ q<>+16(SB), AX, CX
  2341  	ADOXQ AX, R15
  2342  
  2343  	// (C,t[2]) := t[3] + m*q[3] + C
  2344  	ADCXQ BX, CX
  2345  	MULXQ q<>+24(SB), AX, BX
  2346  	ADOXQ AX, CX
  2347  
  2348  	// (C,t[3]) := t[4] + m*q[4] + C
  2349  	ADCXQ SI, BX
  2350  	MULXQ q<>+32(SB), AX, SI
  2351  	ADOXQ AX, BX
  2352  
  2353  	// (C,t[4]) := t[5] + m*q[5] + C
  2354  	ADCXQ DI, SI
  2355  	MULXQ q<>+40(SB), AX, DI
  2356  	ADOXQ AX, SI
  2357  
  2358  	// (C,t[5]) := t[6] + m*q[6] + C
  2359  	ADCXQ R8, DI
  2360  	MULXQ q<>+48(SB), AX, R8
  2361  	ADOXQ AX, DI
  2362  
  2363  	// (C,t[6]) := t[7] + m*q[7] + C
  2364  	ADCXQ R9, R8
  2365  	MULXQ q<>+56(SB), AX, R9
  2366  	ADOXQ AX, R8
  2367  
  2368  	// (C,t[7]) := t[8] + m*q[8] + C
  2369  	ADCXQ R10, R9
  2370  	MULXQ q<>+64(SB), AX, R10
  2371  	ADOXQ AX, R9
  2372  
  2373  	// (C,t[8]) := t[9] + m*q[9] + C
  2374  	ADCXQ R11, R10
  2375  	MULXQ q<>+72(SB), AX, R11
  2376  	ADOXQ AX, R10
  2377  
  2378  	// (C,t[9]) := t[10] + m*q[10] + C
  2379  	ADCXQ R12, R11
  2380  	MULXQ q<>+80(SB), AX, R12
  2381  	ADOXQ AX, R11
  2382  
  2383  	// (C,t[10]) := t[11] + m*q[11] + C
  2384  	ADCXQ R13, R12
  2385  	MULXQ q<>+88(SB), AX, R13
  2386  	ADOXQ AX, R12
  2387  	MOVQ  $0, AX
  2388  	ADCXQ AX, R13
  2389  	ADOXQ AX, R13
  2390  	XORQ  DX, DX
  2391  
  2392  	// m := t[0]*q'[0] mod W
  2393  	MOVQ  qInv0<>(SB), DX
  2394  	IMULQ R14, DX
  2395  	XORQ  AX, AX
  2396  
  2397  	// C,_ := t[0] + m*q[0]
  2398  	MULXQ q<>+0(SB), AX, BP
  2399  	ADCXQ R14, AX
  2400  	MOVQ  BP, R14
  2401  
  2402  	// (C,t[0]) := t[1] + m*q[1] + C
  2403  	ADCXQ R15, R14
  2404  	MULXQ q<>+8(SB), AX, R15
  2405  	ADOXQ AX, R14
  2406  
  2407  	// (C,t[1]) := t[2] + m*q[2] + C
  2408  	ADCXQ CX, R15
  2409  	MULXQ q<>+16(SB), AX, CX
  2410  	ADOXQ AX, R15
  2411  
  2412  	// (C,t[2]) := t[3] + m*q[3] + C
  2413  	ADCXQ BX, CX
  2414  	MULXQ q<>+24(SB), AX, BX
  2415  	ADOXQ AX, CX
  2416  
  2417  	// (C,t[3]) := t[4] + m*q[4] + C
  2418  	ADCXQ SI, BX
  2419  	MULXQ q<>+32(SB), AX, SI
  2420  	ADOXQ AX, BX
  2421  
  2422  	// (C,t[4]) := t[5] + m*q[5] + C
  2423  	ADCXQ DI, SI
  2424  	MULXQ q<>+40(SB), AX, DI
  2425  	ADOXQ AX, SI
  2426  
  2427  	// (C,t[5]) := t[6] + m*q[6] + C
  2428  	ADCXQ R8, DI
  2429  	MULXQ q<>+48(SB), AX, R8
  2430  	ADOXQ AX, DI
  2431  
  2432  	// (C,t[6]) := t[7] + m*q[7] + C
  2433  	ADCXQ R9, R8
  2434  	MULXQ q<>+56(SB), AX, R9
  2435  	ADOXQ AX, R8
  2436  
  2437  	// (C,t[7]) := t[8] + m*q[8] + C
  2438  	ADCXQ R10, R9
  2439  	MULXQ q<>+64(SB), AX, R10
  2440  	ADOXQ AX, R9
  2441  
  2442  	// (C,t[8]) := t[9] + m*q[9] + C
  2443  	ADCXQ R11, R10
  2444  	MULXQ q<>+72(SB), AX, R11
  2445  	ADOXQ AX, R10
  2446  
  2447  	// (C,t[9]) := t[10] + m*q[10] + C
  2448  	ADCXQ R12, R11
  2449  	MULXQ q<>+80(SB), AX, R12
  2450  	ADOXQ AX, R11
  2451  
  2452  	// (C,t[10]) := t[11] + m*q[11] + C
  2453  	ADCXQ R13, R12
  2454  	MULXQ q<>+88(SB), AX, R13
  2455  	ADOXQ AX, R12
  2456  	MOVQ  $0, AX
  2457  	ADCXQ AX, R13
  2458  	ADOXQ AX, R13
  2459  	XORQ  DX, DX
  2460  
  2461  	// m := t[0]*q'[0] mod W
  2462  	MOVQ  qInv0<>(SB), DX
  2463  	IMULQ R14, DX
  2464  	XORQ  AX, AX
  2465  
  2466  	// C,_ := t[0] + m*q[0]
  2467  	MULXQ q<>+0(SB), AX, BP
  2468  	ADCXQ R14, AX
  2469  	MOVQ  BP, R14
  2470  
  2471  	// (C,t[0]) := t[1] + m*q[1] + C
  2472  	ADCXQ R15, R14
  2473  	MULXQ q<>+8(SB), AX, R15
  2474  	ADOXQ AX, R14
  2475  
  2476  	// (C,t[1]) := t[2] + m*q[2] + C
  2477  	ADCXQ CX, R15
  2478  	MULXQ q<>+16(SB), AX, CX
  2479  	ADOXQ AX, R15
  2480  
  2481  	// (C,t[2]) := t[3] + m*q[3] + C
  2482  	ADCXQ BX, CX
  2483  	MULXQ q<>+24(SB), AX, BX
  2484  	ADOXQ AX, CX
  2485  
  2486  	// (C,t[3]) := t[4] + m*q[4] + C
  2487  	ADCXQ SI, BX
  2488  	MULXQ q<>+32(SB), AX, SI
  2489  	ADOXQ AX, BX
  2490  
  2491  	// (C,t[4]) := t[5] + m*q[5] + C
  2492  	ADCXQ DI, SI
  2493  	MULXQ q<>+40(SB), AX, DI
  2494  	ADOXQ AX, SI
  2495  
  2496  	// (C,t[5]) := t[6] + m*q[6] + C
  2497  	ADCXQ R8, DI
  2498  	MULXQ q<>+48(SB), AX, R8
  2499  	ADOXQ AX, DI
  2500  
  2501  	// (C,t[6]) := t[7] + m*q[7] + C
  2502  	ADCXQ R9, R8
  2503  	MULXQ q<>+56(SB), AX, R9
  2504  	ADOXQ AX, R8
  2505  
  2506  	// (C,t[7]) := t[8] + m*q[8] + C
  2507  	ADCXQ R10, R9
  2508  	MULXQ q<>+64(SB), AX, R10
  2509  	ADOXQ AX, R9
  2510  
  2511  	// (C,t[8]) := t[9] + m*q[9] + C
  2512  	ADCXQ R11, R10
  2513  	MULXQ q<>+72(SB), AX, R11
  2514  	ADOXQ AX, R10
  2515  
  2516  	// (C,t[9]) := t[10] + m*q[10] + C
  2517  	ADCXQ R12, R11
  2518  	MULXQ q<>+80(SB), AX, R12
  2519  	ADOXQ AX, R11
  2520  
  2521  	// (C,t[10]) := t[11] + m*q[11] + C
  2522  	ADCXQ R13, R12
  2523  	MULXQ q<>+88(SB), AX, R13
  2524  	ADOXQ AX, R12
  2525  	MOVQ  $0, AX
  2526  	ADCXQ AX, R13
  2527  	ADOXQ AX, R13
  2528  	XORQ  DX, DX
  2529  
  2530  	// m := t[0]*q'[0] mod W
  2531  	MOVQ  qInv0<>(SB), DX
  2532  	IMULQ R14, DX
  2533  	XORQ  AX, AX
  2534  
  2535  	// C,_ := t[0] + m*q[0]
  2536  	MULXQ q<>+0(SB), AX, BP
  2537  	ADCXQ R14, AX
  2538  	MOVQ  BP, R14
  2539  
  2540  	// (C,t[0]) := t[1] + m*q[1] + C
  2541  	ADCXQ R15, R14
  2542  	MULXQ q<>+8(SB), AX, R15
  2543  	ADOXQ AX, R14
  2544  
  2545  	// (C,t[1]) := t[2] + m*q[2] + C
  2546  	ADCXQ CX, R15
  2547  	MULXQ q<>+16(SB), AX, CX
  2548  	ADOXQ AX, R15
  2549  
  2550  	// (C,t[2]) := t[3] + m*q[3] + C
  2551  	ADCXQ BX, CX
  2552  	MULXQ q<>+24(SB), AX, BX
  2553  	ADOXQ AX, CX
  2554  
  2555  	// (C,t[3]) := t[4] + m*q[4] + C
  2556  	ADCXQ SI, BX
  2557  	MULXQ q<>+32(SB), AX, SI
  2558  	ADOXQ AX, BX
  2559  
  2560  	// (C,t[4]) := t[5] + m*q[5] + C
  2561  	ADCXQ DI, SI
  2562  	MULXQ q<>+40(SB), AX, DI
  2563  	ADOXQ AX, SI
  2564  
  2565  	// (C,t[5]) := t[6] + m*q[6] + C
  2566  	ADCXQ R8, DI
  2567  	MULXQ q<>+48(SB), AX, R8
  2568  	ADOXQ AX, DI
  2569  
  2570  	// (C,t[6]) := t[7] + m*q[7] + C
  2571  	ADCXQ R9, R8
  2572  	MULXQ q<>+56(SB), AX, R9
  2573  	ADOXQ AX, R8
  2574  
  2575  	// (C,t[7]) := t[8] + m*q[8] + C
  2576  	ADCXQ R10, R9
  2577  	MULXQ q<>+64(SB), AX, R10
  2578  	ADOXQ AX, R9
  2579  
  2580  	// (C,t[8]) := t[9] + m*q[9] + C
  2581  	ADCXQ R11, R10
  2582  	MULXQ q<>+72(SB), AX, R11
  2583  	ADOXQ AX, R10
  2584  
  2585  	// (C,t[9]) := t[10] + m*q[10] + C
  2586  	ADCXQ R12, R11
  2587  	MULXQ q<>+80(SB), AX, R12
  2588  	ADOXQ AX, R11
  2589  
  2590  	// (C,t[10]) := t[11] + m*q[11] + C
  2591  	ADCXQ R13, R12
  2592  	MULXQ q<>+88(SB), AX, R13
  2593  	ADOXQ AX, R12
  2594  	MOVQ  $0, AX
  2595  	ADCXQ AX, R13
  2596  	ADOXQ AX, R13
  2597  	XORQ  DX, DX
  2598  
  2599  	// m := t[0]*q'[0] mod W
  2600  	MOVQ  qInv0<>(SB), DX
  2601  	IMULQ R14, DX
  2602  	XORQ  AX, AX
  2603  
  2604  	// C,_ := t[0] + m*q[0]
  2605  	MULXQ q<>+0(SB), AX, BP
  2606  	ADCXQ R14, AX
  2607  	MOVQ  BP, R14
  2608  
  2609  	// (C,t[0]) := t[1] + m*q[1] + C
  2610  	ADCXQ R15, R14
  2611  	MULXQ q<>+8(SB), AX, R15
  2612  	ADOXQ AX, R14
  2613  
  2614  	// (C,t[1]) := t[2] + m*q[2] + C
  2615  	ADCXQ CX, R15
  2616  	MULXQ q<>+16(SB), AX, CX
  2617  	ADOXQ AX, R15
  2618  
  2619  	// (C,t[2]) := t[3] + m*q[3] + C
  2620  	ADCXQ BX, CX
  2621  	MULXQ q<>+24(SB), AX, BX
  2622  	ADOXQ AX, CX
  2623  
  2624  	// (C,t[3]) := t[4] + m*q[4] + C
  2625  	ADCXQ SI, BX
  2626  	MULXQ q<>+32(SB), AX, SI
  2627  	ADOXQ AX, BX
  2628  
  2629  	// (C,t[4]) := t[5] + m*q[5] + C
  2630  	ADCXQ DI, SI
  2631  	MULXQ q<>+40(SB), AX, DI
  2632  	ADOXQ AX, SI
  2633  
  2634  	// (C,t[5]) := t[6] + m*q[6] + C
  2635  	ADCXQ R8, DI
  2636  	MULXQ q<>+48(SB), AX, R8
  2637  	ADOXQ AX, DI
  2638  
  2639  	// (C,t[6]) := t[7] + m*q[7] + C
  2640  	ADCXQ R9, R8
  2641  	MULXQ q<>+56(SB), AX, R9
  2642  	ADOXQ AX, R8
  2643  
  2644  	// (C,t[7]) := t[8] + m*q[8] + C
  2645  	ADCXQ R10, R9
  2646  	MULXQ q<>+64(SB), AX, R10
  2647  	ADOXQ AX, R9
  2648  
  2649  	// (C,t[8]) := t[9] + m*q[9] + C
  2650  	ADCXQ R11, R10
  2651  	MULXQ q<>+72(SB), AX, R11
  2652  	ADOXQ AX, R10
  2653  
  2654  	// (C,t[9]) := t[10] + m*q[10] + C
  2655  	ADCXQ R12, R11
  2656  	MULXQ q<>+80(SB), AX, R12
  2657  	ADOXQ AX, R11
  2658  
  2659  	// (C,t[10]) := t[11] + m*q[11] + C
  2660  	ADCXQ R13, R12
  2661  	MULXQ q<>+88(SB), AX, R13
  2662  	ADOXQ AX, R12
  2663  	MOVQ  $0, AX
  2664  	ADCXQ AX, R13
  2665  	ADOXQ AX, R13
  2666  	XORQ  DX, DX
  2667  
  2668  	// m := t[0]*q'[0] mod W
  2669  	MOVQ  qInv0<>(SB), DX
  2670  	IMULQ R14, DX
  2671  	XORQ  AX, AX
  2672  
  2673  	// C,_ := t[0] + m*q[0]
  2674  	MULXQ q<>+0(SB), AX, BP
  2675  	ADCXQ R14, AX
  2676  	MOVQ  BP, R14
  2677  
  2678  	// (C,t[0]) := t[1] + m*q[1] + C
  2679  	ADCXQ R15, R14
  2680  	MULXQ q<>+8(SB), AX, R15
  2681  	ADOXQ AX, R14
  2682  
  2683  	// (C,t[1]) := t[2] + m*q[2] + C
  2684  	ADCXQ CX, R15
  2685  	MULXQ q<>+16(SB), AX, CX
  2686  	ADOXQ AX, R15
  2687  
  2688  	// (C,t[2]) := t[3] + m*q[3] + C
  2689  	ADCXQ BX, CX
  2690  	MULXQ q<>+24(SB), AX, BX
  2691  	ADOXQ AX, CX
  2692  
  2693  	// (C,t[3]) := t[4] + m*q[4] + C
  2694  	ADCXQ SI, BX
  2695  	MULXQ q<>+32(SB), AX, SI
  2696  	ADOXQ AX, BX
  2697  
  2698  	// (C,t[4]) := t[5] + m*q[5] + C
  2699  	ADCXQ DI, SI
  2700  	MULXQ q<>+40(SB), AX, DI
  2701  	ADOXQ AX, SI
  2702  
  2703  	// (C,t[5]) := t[6] + m*q[6] + C
  2704  	ADCXQ R8, DI
  2705  	MULXQ q<>+48(SB), AX, R8
  2706  	ADOXQ AX, DI
  2707  
  2708  	// (C,t[6]) := t[7] + m*q[7] + C
  2709  	ADCXQ R9, R8
  2710  	MULXQ q<>+56(SB), AX, R9
  2711  	ADOXQ AX, R8
  2712  
  2713  	// (C,t[7]) := t[8] + m*q[8] + C
  2714  	ADCXQ R10, R9
  2715  	MULXQ q<>+64(SB), AX, R10
  2716  	ADOXQ AX, R9
  2717  
  2718  	// (C,t[8]) := t[9] + m*q[9] + C
  2719  	ADCXQ R11, R10
  2720  	MULXQ q<>+72(SB), AX, R11
  2721  	ADOXQ AX, R10
  2722  
  2723  	// (C,t[9]) := t[10] + m*q[10] + C
  2724  	ADCXQ R12, R11
  2725  	MULXQ q<>+80(SB), AX, R12
  2726  	ADOXQ AX, R11
  2727  
  2728  	// (C,t[10]) := t[11] + m*q[11] + C
  2729  	ADCXQ R13, R12
  2730  	MULXQ q<>+88(SB), AX, R13
  2731  	ADOXQ AX, R12
  2732  	MOVQ  $0, AX
  2733  	ADCXQ AX, R13
  2734  	ADOXQ AX, R13
  2735  
  2736  	// reduce element(R14,R15,CX,BX,SI,DI,R8,R9,R10,R11,R12,R13) using temp registers (s0-8(SP),s1-16(SP),s2-24(SP),s3-32(SP),s4-40(SP),s5-48(SP),s6-56(SP),s7-64(SP),s8-72(SP),s9-80(SP),s10-88(SP),s11-96(SP))
  2737  	REDUCE(R14,R15,CX,BX,SI,DI,R8,R9,R10,R11,R12,R13,s0-8(SP),s1-16(SP),s2-24(SP),s3-32(SP),s4-40(SP),s5-48(SP),s6-56(SP),s7-64(SP),s8-72(SP),s9-80(SP),s10-88(SP),s11-96(SP))
  2738  
  2739  	MOVQ res+0(FP), AX
  2740  	MOVQ R14, 0(AX)
  2741  	MOVQ R15, 8(AX)
  2742  	MOVQ CX, 16(AX)
  2743  	MOVQ BX, 24(AX)
  2744  	MOVQ SI, 32(AX)
  2745  	MOVQ DI, 40(AX)
  2746  	MOVQ R8, 48(AX)
  2747  	MOVQ R9, 56(AX)
  2748  	MOVQ R10, 64(AX)
  2749  	MOVQ R11, 72(AX)
  2750  	MOVQ R12, 80(AX)
  2751  	MOVQ R13, 88(AX)
  2752  	RET
  2753  
  2754  l2:
  2755  	MOVQ res+0(FP), AX
  2756  	MOVQ AX, (SP)
  2757  	CALL ·_fromMontGeneric(SB)
  2758  	RET