Back to index

lightning-sunbird  0.9+nobinonly
mp_comba.c
Go to the documentation of this file.
00001 /*
00002  * The below file is derived from TFM v0.03.
00003  * It contains code from fp_mul_comba.c and
00004  * fp_sqr_comba.c, which contained the following license.
00005  *
00006  * Right now, the assembly in this file limits
00007  * this code to AMD 64.
00008  *
00009  * This file is public domain.
00010  */
00011 
00012 /* TomsFastMath, a fast ISO C bignum library.
00013  * 
00014  * This project is meant to fill in where LibTomMath
00015  * falls short.  That is speed ;-)
00016  *
00017  * This project is public domain and free for all purposes.
00018  * 
00019  * Tom St Denis, tomstdenis@iahu.ca
00020  */
00021 
00022 
00023 #include "mpi-priv.h"
00024 
00025 
00026 
00027 /* clamp digits */
00028 #define mp_clamp(a)   { while ((a)->used && (a)->dp[(a)->used-1] == 0) --((a)->used); (a)->sign = (a)->used ? (a)->sign : ZPOS; }
00029 
00030 /* anything you need at the start */
00031 #define COMBA_START
00032 
00033 /* clear the chaining variables */
00034 #define COMBA_CLEAR \
00035    c0 = c1 = c2 = 0;
00036 
00037 /* forward the carry to the next digit */
00038 #define COMBA_FORWARD \
00039    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
00040 
00041 /* anything you need at the end */
00042 #define COMBA_FINI
00043 
00044 /* this should multiply i and j  */
00045 #define MULADD(i, j)                                      \
00046 __asm__  (                                                    \
00047      "movq  %6,%%rax     \n\t"                            \
00048      "mulq  %7           \n\t"                            \
00049      "addq  %%rax,%0     \n\t"                            \
00050      "adcq  %%rdx,%1     \n\t"                            \
00051      "adcq  $0,%2        \n\t"                            \
00052      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j)  :"%rax","%rdx","%cc");
00053 
00054 
00055 
00056 
00057 /* sqr macros only */
00058 #define CLEAR_CARRY \
00059    c0 = c1 = c2 = 0;
00060 
00061 #define COMBA_STORE(x) \
00062    x = c0;
00063 
00064 #define COMBA_STORE2(x) \
00065    x = c1;
00066 
00067 #define CARRY_FORWARD \
00068    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
00069 
00070 #define COMBA_FINI
00071 
00072 #define SQRADD(i, j)                                      \
00073 __asm__ (                                                     \
00074      "movq  %6,%%rax     \n\t"                            \
00075      "mulq  %%rax        \n\t"                            \
00076      "addq  %%rax,%0     \n\t"                            \
00077      "adcq  %%rdx,%1     \n\t"                            \
00078      "adcq  $0,%2        \n\t"                            \
00079      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i) :"%rax","%rdx","%cc");
00080 
00081 #define SQRADD2(i, j)                                     \
00082 __asm__ (                                                     \
00083      "movq  %6,%%rax     \n\t"                            \
00084      "mulq  %7           \n\t"                            \
00085      "addq  %%rax,%0     \n\t"                            \
00086      "adcq  %%rdx,%1     \n\t"                            \
00087      "adcq  $0,%2        \n\t"                            \
00088      "addq  %%rax,%0     \n\t"                            \
00089      "adcq  %%rdx,%1     \n\t"                            \
00090      "adcq  $0,%2        \n\t"                            \
00091      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j)  :"%rax","%rdx","%cc");
00092 
00093 #define SQRADDSC(i, j)                                    \
00094 __asm__ (                                                     \
00095      "movq  %6,%%rax     \n\t"                            \
00096      "mulq  %7           \n\t"                            \
00097      "movq  %%rax,%0     \n\t"                            \
00098      "movq  %%rdx,%1     \n\t"                            \
00099      "xorq  %2,%2        \n\t"                            \
00100      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%rax","%rdx","%cc");
00101 
00102 #define SQRADDAC(i, j)                                                         \
00103 __asm__ (                                                     \
00104      "movq  %6,%%rax     \n\t"                            \
00105      "mulq  %7           \n\t"                            \
00106      "addq  %%rax,%0     \n\t"                            \
00107      "adcq  %%rdx,%1     \n\t"                            \
00108      "adcq  $0,%2        \n\t"                            \
00109      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%rax","%rdx","%cc");
00110 
00111 #define SQRADDDB                                                               \
00112 __asm__ (                                                     \
00113      "addq %3,%0         \n\t"                            \
00114      "adcq %4,%1         \n\t"                            \
00115      "adcq %5,%2         \n\t"                            \
00116      "addq %3,%0         \n\t"                            \
00117      "adcq %4,%1         \n\t"                            \
00118      "adcq %5,%2         \n\t"                            \
00119      :"=r"(c0), "=r"(c1), "=r"(c2), "=r"(sc0), "=r"(sc1), "=r"(sc2) : "0"(c0), "1"(c1), "2"(c2), "3"(sc0), "4"(sc1), "5"(sc2) : "%cc");
00120 
00121 
00122 
00123 
00124 
00125 void s_mp_mul_comba_4(const mp_int *A, const mp_int *B, mp_int *C)
00126 {
00127    mp_digit c0, c1, c2, at[8];
00128 
00129    memcpy(at, A->dp, 4 * sizeof(mp_digit));
00130    memcpy(at+4, B->dp, 4 * sizeof(mp_digit));
00131    COMBA_START;
00132    
00133    COMBA_CLEAR;
00134    /* 0 */
00135    MULADD(at[0], at[4]); 
00136    COMBA_STORE(C->dp[0]);
00137    /* 1 */
00138    COMBA_FORWARD;
00139    MULADD(at[0], at[5]);       MULADD(at[1], at[4]); 
00140    COMBA_STORE(C->dp[1]);
00141    /* 2 */
00142    COMBA_FORWARD;
00143    MULADD(at[0], at[6]);       MULADD(at[1], at[5]);       MULADD(at[2], at[4]); 
00144    COMBA_STORE(C->dp[2]);
00145    /* 3 */
00146    COMBA_FORWARD;
00147    MULADD(at[0], at[7]);       MULADD(at[1], at[6]);       MULADD(at[2], at[5]);       MULADD(at[3], at[4]); 
00148    COMBA_STORE(C->dp[3]);
00149    /* 4 */
00150    COMBA_FORWARD;
00151    MULADD(at[1], at[7]);       MULADD(at[2], at[6]);       MULADD(at[3], at[5]); 
00152    COMBA_STORE(C->dp[4]);
00153    /* 5 */
00154    COMBA_FORWARD;
00155    MULADD(at[2], at[7]);       MULADD(at[3], at[6]); 
00156    COMBA_STORE(C->dp[5]);
00157    /* 6 */
00158    COMBA_FORWARD;
00159    MULADD(at[3], at[7]); 
00160    COMBA_STORE(C->dp[6]);
00161    COMBA_STORE2(C->dp[7]);
00162    C->used = 8;
00163    C->sign = A->sign ^ B->sign;
00164    mp_clamp(C);
00165    COMBA_FINI;
00166 }
00167 
00168 void s_mp_mul_comba_8(const mp_int *A, const mp_int *B, mp_int *C)
00169 {
00170    mp_digit c0, c1, c2, at[16];
00171 
00172    memcpy(at, A->dp, 8 * sizeof(mp_digit));
00173    memcpy(at+8, B->dp, 8 * sizeof(mp_digit));
00174    COMBA_START;
00175 
00176    COMBA_CLEAR;
00177    /* 0 */
00178    MULADD(at[0], at[8]); 
00179    COMBA_STORE(C->dp[0]);
00180    /* 1 */
00181    COMBA_FORWARD;
00182    MULADD(at[0], at[9]);       MULADD(at[1], at[8]); 
00183    COMBA_STORE(C->dp[1]);
00184    /* 2 */
00185    COMBA_FORWARD;
00186    MULADD(at[0], at[10]);       MULADD(at[1], at[9]);       MULADD(at[2], at[8]); 
00187    COMBA_STORE(C->dp[2]);
00188    /* 3 */
00189    COMBA_FORWARD;
00190    MULADD(at[0], at[11]);       MULADD(at[1], at[10]);       MULADD(at[2], at[9]);       MULADD(at[3], at[8]); 
00191    COMBA_STORE(C->dp[3]);
00192    /* 4 */
00193    COMBA_FORWARD;
00194    MULADD(at[0], at[12]);       MULADD(at[1], at[11]);       MULADD(at[2], at[10]);       MULADD(at[3], at[9]);       MULADD(at[4], at[8]); 
00195    COMBA_STORE(C->dp[4]);
00196    /* 5 */
00197    COMBA_FORWARD;
00198    MULADD(at[0], at[13]);       MULADD(at[1], at[12]);       MULADD(at[2], at[11]);       MULADD(at[3], at[10]);       MULADD(at[4], at[9]);       MULADD(at[5], at[8]); 
00199    COMBA_STORE(C->dp[5]);
00200    /* 6 */
00201    COMBA_FORWARD;
00202    MULADD(at[0], at[14]);       MULADD(at[1], at[13]);       MULADD(at[2], at[12]);       MULADD(at[3], at[11]);       MULADD(at[4], at[10]);       MULADD(at[5], at[9]);       MULADD(at[6], at[8]); 
00203    COMBA_STORE(C->dp[6]);
00204    /* 7 */
00205    COMBA_FORWARD;
00206    MULADD(at[0], at[15]);       MULADD(at[1], at[14]);       MULADD(at[2], at[13]);       MULADD(at[3], at[12]);       MULADD(at[4], at[11]);       MULADD(at[5], at[10]);       MULADD(at[6], at[9]);       MULADD(at[7], at[8]); 
00207    COMBA_STORE(C->dp[7]);
00208    /* 8 */
00209    COMBA_FORWARD;
00210    MULADD(at[1], at[15]);       MULADD(at[2], at[14]);       MULADD(at[3], at[13]);       MULADD(at[4], at[12]);       MULADD(at[5], at[11]);       MULADD(at[6], at[10]);       MULADD(at[7], at[9]); 
00211    COMBA_STORE(C->dp[8]);
00212    /* 9 */
00213    COMBA_FORWARD;
00214    MULADD(at[2], at[15]);       MULADD(at[3], at[14]);       MULADD(at[4], at[13]);       MULADD(at[5], at[12]);       MULADD(at[6], at[11]);       MULADD(at[7], at[10]); 
00215    COMBA_STORE(C->dp[9]);
00216    /* 10 */
00217    COMBA_FORWARD;
00218    MULADD(at[3], at[15]);       MULADD(at[4], at[14]);       MULADD(at[5], at[13]);       MULADD(at[6], at[12]);       MULADD(at[7], at[11]); 
00219    COMBA_STORE(C->dp[10]);
00220    /* 11 */
00221    COMBA_FORWARD;
00222    MULADD(at[4], at[15]);       MULADD(at[5], at[14]);       MULADD(at[6], at[13]);       MULADD(at[7], at[12]); 
00223    COMBA_STORE(C->dp[11]);
00224    /* 12 */
00225    COMBA_FORWARD;
00226    MULADD(at[5], at[15]);       MULADD(at[6], at[14]);       MULADD(at[7], at[13]); 
00227    COMBA_STORE(C->dp[12]);
00228    /* 13 */
00229    COMBA_FORWARD;
00230    MULADD(at[6], at[15]);       MULADD(at[7], at[14]); 
00231    COMBA_STORE(C->dp[13]);
00232    /* 14 */
00233    COMBA_FORWARD;
00234    MULADD(at[7], at[15]); 
00235    COMBA_STORE(C->dp[14]);
00236    COMBA_STORE2(C->dp[15]);
00237    C->used = 16;
00238    C->sign = A->sign ^ B->sign;
00239    mp_clamp(C);
00240    COMBA_FINI;
00241 }
00242 
00243 void s_mp_mul_comba_16(const mp_int *A, const mp_int *B, mp_int *C)
00244 {
00245    mp_digit c0, c1, c2, at[32];
00246 
00247    memcpy(at, A->dp, 16 * sizeof(mp_digit));
00248    memcpy(at+16, B->dp, 16 * sizeof(mp_digit));
00249    COMBA_START;
00250 
00251    COMBA_CLEAR;
00252    /* 0 */
00253    MULADD(at[0], at[16]); 
00254    COMBA_STORE(C->dp[0]);
00255    /* 1 */
00256    COMBA_FORWARD;
00257    MULADD(at[0], at[17]);       MULADD(at[1], at[16]); 
00258    COMBA_STORE(C->dp[1]);
00259    /* 2 */
00260    COMBA_FORWARD;
00261    MULADD(at[0], at[18]);       MULADD(at[1], at[17]);       MULADD(at[2], at[16]); 
00262    COMBA_STORE(C->dp[2]);
00263    /* 3 */
00264    COMBA_FORWARD;
00265    MULADD(at[0], at[19]);       MULADD(at[1], at[18]);       MULADD(at[2], at[17]);       MULADD(at[3], at[16]); 
00266    COMBA_STORE(C->dp[3]);
00267    /* 4 */
00268    COMBA_FORWARD;
00269    MULADD(at[0], at[20]);       MULADD(at[1], at[19]);       MULADD(at[2], at[18]);       MULADD(at[3], at[17]);       MULADD(at[4], at[16]); 
00270    COMBA_STORE(C->dp[4]);
00271    /* 5 */
00272    COMBA_FORWARD;
00273    MULADD(at[0], at[21]);       MULADD(at[1], at[20]);       MULADD(at[2], at[19]);       MULADD(at[3], at[18]);       MULADD(at[4], at[17]);       MULADD(at[5], at[16]); 
00274    COMBA_STORE(C->dp[5]);
00275    /* 6 */
00276    COMBA_FORWARD;
00277    MULADD(at[0], at[22]);       MULADD(at[1], at[21]);       MULADD(at[2], at[20]);       MULADD(at[3], at[19]);       MULADD(at[4], at[18]);       MULADD(at[5], at[17]);       MULADD(at[6], at[16]); 
00278    COMBA_STORE(C->dp[6]);
00279    /* 7 */
00280    COMBA_FORWARD;
00281    MULADD(at[0], at[23]);       MULADD(at[1], at[22]);       MULADD(at[2], at[21]);       MULADD(at[3], at[20]);       MULADD(at[4], at[19]);       MULADD(at[5], at[18]);       MULADD(at[6], at[17]);       MULADD(at[7], at[16]); 
00282    COMBA_STORE(C->dp[7]);
00283    /* 8 */
00284    COMBA_FORWARD;
00285    MULADD(at[0], at[24]);       MULADD(at[1], at[23]);       MULADD(at[2], at[22]);       MULADD(at[3], at[21]);       MULADD(at[4], at[20]);       MULADD(at[5], at[19]);       MULADD(at[6], at[18]);       MULADD(at[7], at[17]);       MULADD(at[8], at[16]); 
00286    COMBA_STORE(C->dp[8]);
00287    /* 9 */
00288    COMBA_FORWARD;
00289    MULADD(at[0], at[25]);       MULADD(at[1], at[24]);       MULADD(at[2], at[23]);       MULADD(at[3], at[22]);       MULADD(at[4], at[21]);       MULADD(at[5], at[20]);       MULADD(at[6], at[19]);       MULADD(at[7], at[18]);       MULADD(at[8], at[17]);       MULADD(at[9], at[16]); 
00290    COMBA_STORE(C->dp[9]);
00291    /* 10 */
00292    COMBA_FORWARD;
00293    MULADD(at[0], at[26]);       MULADD(at[1], at[25]);       MULADD(at[2], at[24]);       MULADD(at[3], at[23]);       MULADD(at[4], at[22]);       MULADD(at[5], at[21]);       MULADD(at[6], at[20]);       MULADD(at[7], at[19]);       MULADD(at[8], at[18]);       MULADD(at[9], at[17]);       MULADD(at[10], at[16]); 
00294    COMBA_STORE(C->dp[10]);
00295    /* 11 */
00296    COMBA_FORWARD;
00297    MULADD(at[0], at[27]);       MULADD(at[1], at[26]);       MULADD(at[2], at[25]);       MULADD(at[3], at[24]);       MULADD(at[4], at[23]);       MULADD(at[5], at[22]);       MULADD(at[6], at[21]);       MULADD(at[7], at[20]);       MULADD(at[8], at[19]);       MULADD(at[9], at[18]);       MULADD(at[10], at[17]);       MULADD(at[11], at[16]); 
00298    COMBA_STORE(C->dp[11]);
00299    /* 12 */
00300    COMBA_FORWARD;
00301    MULADD(at[0], at[28]);       MULADD(at[1], at[27]);       MULADD(at[2], at[26]);       MULADD(at[3], at[25]);       MULADD(at[4], at[24]);       MULADD(at[5], at[23]);       MULADD(at[6], at[22]);       MULADD(at[7], at[21]);       MULADD(at[8], at[20]);       MULADD(at[9], at[19]);       MULADD(at[10], at[18]);       MULADD(at[11], at[17]);       MULADD(at[12], at[16]); 
00302    COMBA_STORE(C->dp[12]);
00303    /* 13 */
00304    COMBA_FORWARD;
00305    MULADD(at[0], at[29]);       MULADD(at[1], at[28]);       MULADD(at[2], at[27]);       MULADD(at[3], at[26]);       MULADD(at[4], at[25]);       MULADD(at[5], at[24]);       MULADD(at[6], at[23]);       MULADD(at[7], at[22]);       MULADD(at[8], at[21]);       MULADD(at[9], at[20]);       MULADD(at[10], at[19]);       MULADD(at[11], at[18]);       MULADD(at[12], at[17]);       MULADD(at[13], at[16]); 
00306    COMBA_STORE(C->dp[13]);
00307    /* 14 */
00308    COMBA_FORWARD;
00309    MULADD(at[0], at[30]);       MULADD(at[1], at[29]);       MULADD(at[2], at[28]);       MULADD(at[3], at[27]);       MULADD(at[4], at[26]);       MULADD(at[5], at[25]);       MULADD(at[6], at[24]);       MULADD(at[7], at[23]);       MULADD(at[8], at[22]);       MULADD(at[9], at[21]);       MULADD(at[10], at[20]);       MULADD(at[11], at[19]);       MULADD(at[12], at[18]);       MULADD(at[13], at[17]);       MULADD(at[14], at[16]); 
00310    COMBA_STORE(C->dp[14]);
00311    /* 15 */
00312    COMBA_FORWARD;
00313    MULADD(at[0], at[31]);       MULADD(at[1], at[30]);       MULADD(at[2], at[29]);       MULADD(at[3], at[28]);       MULADD(at[4], at[27]);       MULADD(at[5], at[26]);       MULADD(at[6], at[25]);       MULADD(at[7], at[24]);       MULADD(at[8], at[23]);       MULADD(at[9], at[22]);       MULADD(at[10], at[21]);       MULADD(at[11], at[20]);       MULADD(at[12], at[19]);       MULADD(at[13], at[18]);       MULADD(at[14], at[17]);       MULADD(at[15], at[16]); 
00314    COMBA_STORE(C->dp[15]);
00315    /* 16 */
00316    COMBA_FORWARD;
00317    MULADD(at[1], at[31]);       MULADD(at[2], at[30]);       MULADD(at[3], at[29]);       MULADD(at[4], at[28]);       MULADD(at[5], at[27]);       MULADD(at[6], at[26]);       MULADD(at[7], at[25]);       MULADD(at[8], at[24]);       MULADD(at[9], at[23]);       MULADD(at[10], at[22]);       MULADD(at[11], at[21]);       MULADD(at[12], at[20]);       MULADD(at[13], at[19]);       MULADD(at[14], at[18]);       MULADD(at[15], at[17]); 
00318    COMBA_STORE(C->dp[16]);
00319    /* 17 */
00320    COMBA_FORWARD;
00321    MULADD(at[2], at[31]);       MULADD(at[3], at[30]);       MULADD(at[4], at[29]);       MULADD(at[5], at[28]);       MULADD(at[6], at[27]);       MULADD(at[7], at[26]);       MULADD(at[8], at[25]);       MULADD(at[9], at[24]);       MULADD(at[10], at[23]);       MULADD(at[11], at[22]);       MULADD(at[12], at[21]);       MULADD(at[13], at[20]);       MULADD(at[14], at[19]);       MULADD(at[15], at[18]); 
00322    COMBA_STORE(C->dp[17]);
00323    /* 18 */
00324    COMBA_FORWARD;
00325    MULADD(at[3], at[31]);       MULADD(at[4], at[30]);       MULADD(at[5], at[29]);       MULADD(at[6], at[28]);       MULADD(at[7], at[27]);       MULADD(at[8], at[26]);       MULADD(at[9], at[25]);       MULADD(at[10], at[24]);       MULADD(at[11], at[23]);       MULADD(at[12], at[22]);       MULADD(at[13], at[21]);       MULADD(at[14], at[20]);       MULADD(at[15], at[19]); 
00326    COMBA_STORE(C->dp[18]);
00327    /* 19 */
00328    COMBA_FORWARD;
00329    MULADD(at[4], at[31]);       MULADD(at[5], at[30]);       MULADD(at[6], at[29]);       MULADD(at[7], at[28]);       MULADD(at[8], at[27]);       MULADD(at[9], at[26]);       MULADD(at[10], at[25]);       MULADD(at[11], at[24]);       MULADD(at[12], at[23]);       MULADD(at[13], at[22]);       MULADD(at[14], at[21]);       MULADD(at[15], at[20]); 
00330    COMBA_STORE(C->dp[19]);
00331    /* 20 */
00332    COMBA_FORWARD;
00333    MULADD(at[5], at[31]);       MULADD(at[6], at[30]);       MULADD(at[7], at[29]);       MULADD(at[8], at[28]);       MULADD(at[9], at[27]);       MULADD(at[10], at[26]);       MULADD(at[11], at[25]);       MULADD(at[12], at[24]);       MULADD(at[13], at[23]);       MULADD(at[14], at[22]);       MULADD(at[15], at[21]); 
00334    COMBA_STORE(C->dp[20]);
00335    /* 21 */
00336    COMBA_FORWARD;
00337    MULADD(at[6], at[31]);       MULADD(at[7], at[30]);       MULADD(at[8], at[29]);       MULADD(at[9], at[28]);       MULADD(at[10], at[27]);       MULADD(at[11], at[26]);       MULADD(at[12], at[25]);       MULADD(at[13], at[24]);       MULADD(at[14], at[23]);       MULADD(at[15], at[22]); 
00338    COMBA_STORE(C->dp[21]);
00339    /* 22 */
00340    COMBA_FORWARD;
00341    MULADD(at[7], at[31]);       MULADD(at[8], at[30]);       MULADD(at[9], at[29]);       MULADD(at[10], at[28]);       MULADD(at[11], at[27]);       MULADD(at[12], at[26]);       MULADD(at[13], at[25]);       MULADD(at[14], at[24]);       MULADD(at[15], at[23]); 
00342    COMBA_STORE(C->dp[22]);
00343    /* 23 */
00344    COMBA_FORWARD;
00345    MULADD(at[8], at[31]);       MULADD(at[9], at[30]);       MULADD(at[10], at[29]);       MULADD(at[11], at[28]);       MULADD(at[12], at[27]);       MULADD(at[13], at[26]);       MULADD(at[14], at[25]);       MULADD(at[15], at[24]); 
00346    COMBA_STORE(C->dp[23]);
00347    /* 24 */
00348    COMBA_FORWARD;
00349    MULADD(at[9], at[31]);       MULADD(at[10], at[30]);       MULADD(at[11], at[29]);       MULADD(at[12], at[28]);       MULADD(at[13], at[27]);       MULADD(at[14], at[26]);       MULADD(at[15], at[25]); 
00350    COMBA_STORE(C->dp[24]);
00351    /* 25 */
00352    COMBA_FORWARD;
00353    MULADD(at[10], at[31]);       MULADD(at[11], at[30]);       MULADD(at[12], at[29]);       MULADD(at[13], at[28]);       MULADD(at[14], at[27]);       MULADD(at[15], at[26]); 
00354    COMBA_STORE(C->dp[25]);
00355    /* 26 */
00356    COMBA_FORWARD;
00357    MULADD(at[11], at[31]);       MULADD(at[12], at[30]);       MULADD(at[13], at[29]);       MULADD(at[14], at[28]);       MULADD(at[15], at[27]); 
00358    COMBA_STORE(C->dp[26]);
00359    /* 27 */
00360    COMBA_FORWARD;
00361    MULADD(at[12], at[31]);       MULADD(at[13], at[30]);       MULADD(at[14], at[29]);       MULADD(at[15], at[28]); 
00362    COMBA_STORE(C->dp[27]);
00363    /* 28 */
00364    COMBA_FORWARD;
00365    MULADD(at[13], at[31]);       MULADD(at[14], at[30]);       MULADD(at[15], at[29]); 
00366    COMBA_STORE(C->dp[28]);
00367    /* 29 */
00368    COMBA_FORWARD;
00369    MULADD(at[14], at[31]);       MULADD(at[15], at[30]); 
00370    COMBA_STORE(C->dp[29]);
00371    /* 30 */
00372    COMBA_FORWARD;
00373    MULADD(at[15], at[31]); 
00374    COMBA_STORE(C->dp[30]);
00375    COMBA_STORE2(C->dp[31]);
00376    C->used = 32;
00377    C->sign = A->sign ^ B->sign;
00378    mp_clamp(C);
00379    COMBA_FINI;
00380 }
00381 
00382 void s_mp_mul_comba_32(const mp_int *A, const mp_int *B, mp_int *C)
00383 {
00384    mp_digit c0, c1, c2, at[64];
00385 
00386    memcpy(at, A->dp, 32 * sizeof(mp_digit));
00387    memcpy(at+32, B->dp, 32 * sizeof(mp_digit));
00388    COMBA_START;
00389 
00390    COMBA_CLEAR;
00391    /* 0 */
00392    MULADD(at[0], at[32]); 
00393    COMBA_STORE(C->dp[0]);
00394    /* 1 */
00395    COMBA_FORWARD;
00396    MULADD(at[0], at[33]);    MULADD(at[1], at[32]); 
00397    COMBA_STORE(C->dp[1]);
00398    /* 2 */
00399    COMBA_FORWARD;
00400    MULADD(at[0], at[34]);    MULADD(at[1], at[33]);    MULADD(at[2], at[32]); 
00401    COMBA_STORE(C->dp[2]);
00402    /* 3 */
00403    COMBA_FORWARD;
00404    MULADD(at[0], at[35]);    MULADD(at[1], at[34]);    MULADD(at[2], at[33]);    MULADD(at[3], at[32]); 
00405    COMBA_STORE(C->dp[3]);
00406    /* 4 */
00407    COMBA_FORWARD;
00408    MULADD(at[0], at[36]);    MULADD(at[1], at[35]);    MULADD(at[2], at[34]);    MULADD(at[3], at[33]);    MULADD(at[4], at[32]); 
00409    COMBA_STORE(C->dp[4]);
00410    /* 5 */
00411    COMBA_FORWARD;
00412    MULADD(at[0], at[37]);    MULADD(at[1], at[36]);    MULADD(at[2], at[35]);    MULADD(at[3], at[34]);    MULADD(at[4], at[33]);    MULADD(at[5], at[32]); 
00413    COMBA_STORE(C->dp[5]);
00414    /* 6 */
00415    COMBA_FORWARD;
00416    MULADD(at[0], at[38]);    MULADD(at[1], at[37]);    MULADD(at[2], at[36]);    MULADD(at[3], at[35]);    MULADD(at[4], at[34]);    MULADD(at[5], at[33]);    MULADD(at[6], at[32]); 
00417    COMBA_STORE(C->dp[6]);
00418    /* 7 */
00419    COMBA_FORWARD;
00420    MULADD(at[0], at[39]);    MULADD(at[1], at[38]);    MULADD(at[2], at[37]);    MULADD(at[3], at[36]);    MULADD(at[4], at[35]);    MULADD(at[5], at[34]);    MULADD(at[6], at[33]);    MULADD(at[7], at[32]); 
00421    COMBA_STORE(C->dp[7]);
00422    /* 8 */
00423    COMBA_FORWARD;
00424    MULADD(at[0], at[40]);    MULADD(at[1], at[39]);    MULADD(at[2], at[38]);    MULADD(at[3], at[37]);    MULADD(at[4], at[36]);    MULADD(at[5], at[35]);    MULADD(at[6], at[34]);    MULADD(at[7], at[33]);    MULADD(at[8], at[32]); 
00425    COMBA_STORE(C->dp[8]);
00426    /* 9 */
00427    COMBA_FORWARD;
00428    MULADD(at[0], at[41]);    MULADD(at[1], at[40]);    MULADD(at[2], at[39]);    MULADD(at[3], at[38]);    MULADD(at[4], at[37]);    MULADD(at[5], at[36]);    MULADD(at[6], at[35]);    MULADD(at[7], at[34]);    MULADD(at[8], at[33]);    MULADD(at[9], at[32]); 
00429    COMBA_STORE(C->dp[9]);
00430    /* 10 */
00431    COMBA_FORWARD;
00432    MULADD(at[0], at[42]);    MULADD(at[1], at[41]);    MULADD(at[2], at[40]);    MULADD(at[3], at[39]);    MULADD(at[4], at[38]);    MULADD(at[5], at[37]);    MULADD(at[6], at[36]);    MULADD(at[7], at[35]);    MULADD(at[8], at[34]);    MULADD(at[9], at[33]);    MULADD(at[10], at[32]); 
00433    COMBA_STORE(C->dp[10]);
00434    /* 11 */
00435    COMBA_FORWARD;
00436    MULADD(at[0], at[43]);    MULADD(at[1], at[42]);    MULADD(at[2], at[41]);    MULADD(at[3], at[40]);    MULADD(at[4], at[39]);    MULADD(at[5], at[38]);    MULADD(at[6], at[37]);    MULADD(at[7], at[36]);    MULADD(at[8], at[35]);    MULADD(at[9], at[34]);    MULADD(at[10], at[33]);    MULADD(at[11], at[32]); 
00437    COMBA_STORE(C->dp[11]);
00438    /* 12 */
00439    COMBA_FORWARD;
00440    MULADD(at[0], at[44]);    MULADD(at[1], at[43]);    MULADD(at[2], at[42]);    MULADD(at[3], at[41]);    MULADD(at[4], at[40]);    MULADD(at[5], at[39]);    MULADD(at[6], at[38]);    MULADD(at[7], at[37]);    MULADD(at[8], at[36]);    MULADD(at[9], at[35]);    MULADD(at[10], at[34]);    MULADD(at[11], at[33]);    MULADD(at[12], at[32]); 
00441    COMBA_STORE(C->dp[12]);
00442    /* 13 */
00443    COMBA_FORWARD;
00444    MULADD(at[0], at[45]);    MULADD(at[1], at[44]);    MULADD(at[2], at[43]);    MULADD(at[3], at[42]);    MULADD(at[4], at[41]);    MULADD(at[5], at[40]);    MULADD(at[6], at[39]);    MULADD(at[7], at[38]);    MULADD(at[8], at[37]);    MULADD(at[9], at[36]);    MULADD(at[10], at[35]);    MULADD(at[11], at[34]);    MULADD(at[12], at[33]);    MULADD(at[13], at[32]); 
00445    COMBA_STORE(C->dp[13]);
00446    /* 14 */
00447    COMBA_FORWARD;
00448    MULADD(at[0], at[46]);    MULADD(at[1], at[45]);    MULADD(at[2], at[44]);    MULADD(at[3], at[43]);    MULADD(at[4], at[42]);    MULADD(at[5], at[41]);    MULADD(at[6], at[40]);    MULADD(at[7], at[39]);    MULADD(at[8], at[38]);    MULADD(at[9], at[37]);    MULADD(at[10], at[36]);    MULADD(at[11], at[35]);    MULADD(at[12], at[34]);    MULADD(at[13], at[33]);    MULADD(at[14], at[32]); 
00449    COMBA_STORE(C->dp[14]);
00450    /* 15 */
00451    COMBA_FORWARD;
00452    MULADD(at[0], at[47]);    MULADD(at[1], at[46]);    MULADD(at[2], at[45]);    MULADD(at[3], at[44]);    MULADD(at[4], at[43]);    MULADD(at[5], at[42]);    MULADD(at[6], at[41]);    MULADD(at[7], at[40]);    MULADD(at[8], at[39]);    MULADD(at[9], at[38]);    MULADD(at[10], at[37]);    MULADD(at[11], at[36]);    MULADD(at[12], at[35]);    MULADD(at[13], at[34]);    MULADD(at[14], at[33]);    MULADD(at[15], at[32]); 
00453    COMBA_STORE(C->dp[15]);
00454    /* 16 */
00455    COMBA_FORWARD;
00456    MULADD(at[0], at[48]);    MULADD(at[1], at[47]);    MULADD(at[2], at[46]);    MULADD(at[3], at[45]);    MULADD(at[4], at[44]);    MULADD(at[5], at[43]);    MULADD(at[6], at[42]);    MULADD(at[7], at[41]);    MULADD(at[8], at[40]);    MULADD(at[9], at[39]);    MULADD(at[10], at[38]);    MULADD(at[11], at[37]);    MULADD(at[12], at[36]);    MULADD(at[13], at[35]);    MULADD(at[14], at[34]);    MULADD(at[15], at[33]);    MULADD(at[16], at[32]); 
00457    COMBA_STORE(C->dp[16]);
00458    /* 17 */
00459    COMBA_FORWARD;
00460    MULADD(at[0], at[49]);    MULADD(at[1], at[48]);    MULADD(at[2], at[47]);    MULADD(at[3], at[46]);    MULADD(at[4], at[45]);    MULADD(at[5], at[44]);    MULADD(at[6], at[43]);    MULADD(at[7], at[42]);    MULADD(at[8], at[41]);    MULADD(at[9], at[40]);    MULADD(at[10], at[39]);    MULADD(at[11], at[38]);    MULADD(at[12], at[37]);    MULADD(at[13], at[36]);    MULADD(at[14], at[35]);    MULADD(at[15], at[34]);    MULADD(at[16], at[33]);    MULADD(at[17], at[32]); 
00461    COMBA_STORE(C->dp[17]);
00462    /* 18 */
00463    COMBA_FORWARD;
00464    MULADD(at[0], at[50]);    MULADD(at[1], at[49]);    MULADD(at[2], at[48]);    MULADD(at[3], at[47]);    MULADD(at[4], at[46]);    MULADD(at[5], at[45]);    MULADD(at[6], at[44]);    MULADD(at[7], at[43]);    MULADD(at[8], at[42]);    MULADD(at[9], at[41]);    MULADD(at[10], at[40]);    MULADD(at[11], at[39]);    MULADD(at[12], at[38]);    MULADD(at[13], at[37]);    MULADD(at[14], at[36]);    MULADD(at[15], at[35]);    MULADD(at[16], at[34]);    MULADD(at[17], at[33]);    MULADD(at[18], at[32]); 
00465    COMBA_STORE(C->dp[18]);
00466    /* 19 */
00467    COMBA_FORWARD;
00468    MULADD(at[0], at[51]);    MULADD(at[1], at[50]);    MULADD(at[2], at[49]);    MULADD(at[3], at[48]);    MULADD(at[4], at[47]);    MULADD(at[5], at[46]);    MULADD(at[6], at[45]);    MULADD(at[7], at[44]);    MULADD(at[8], at[43]);    MULADD(at[9], at[42]);    MULADD(at[10], at[41]);    MULADD(at[11], at[40]);    MULADD(at[12], at[39]);    MULADD(at[13], at[38]);    MULADD(at[14], at[37]);    MULADD(at[15], at[36]);    MULADD(at[16], at[35]);    MULADD(at[17], at[34]);    MULADD(at[18], at[33]);    MULADD(at[19], at[32]); 
00469    COMBA_STORE(C->dp[19]);
00470    /* 20 */
00471    COMBA_FORWARD;
00472    MULADD(at[0], at[52]);    MULADD(at[1], at[51]);    MULADD(at[2], at[50]);    MULADD(at[3], at[49]);    MULADD(at[4], at[48]);    MULADD(at[5], at[47]);    MULADD(at[6], at[46]);    MULADD(at[7], at[45]);    MULADD(at[8], at[44]);    MULADD(at[9], at[43]);    MULADD(at[10], at[42]);    MULADD(at[11], at[41]);    MULADD(at[12], at[40]);    MULADD(at[13], at[39]);    MULADD(at[14], at[38]);    MULADD(at[15], at[37]);    MULADD(at[16], at[36]);    MULADD(at[17], at[35]);    MULADD(at[18], at[34]);    MULADD(at[19], at[33]);    MULADD(at[20], at[32]); 
00473    COMBA_STORE(C->dp[20]);
00474    /* 21 */
00475    COMBA_FORWARD;
00476    MULADD(at[0], at[53]);    MULADD(at[1], at[52]);    MULADD(at[2], at[51]);    MULADD(at[3], at[50]);    MULADD(at[4], at[49]);    MULADD(at[5], at[48]);    MULADD(at[6], at[47]);    MULADD(at[7], at[46]);    MULADD(at[8], at[45]);    MULADD(at[9], at[44]);    MULADD(at[10], at[43]);    MULADD(at[11], at[42]);    MULADD(at[12], at[41]);    MULADD(at[13], at[40]);    MULADD(at[14], at[39]);    MULADD(at[15], at[38]);    MULADD(at[16], at[37]);    MULADD(at[17], at[36]);    MULADD(at[18], at[35]);    MULADD(at[19], at[34]);    MULADD(at[20], at[33]);    MULADD(at[21], at[32]); 
00477    COMBA_STORE(C->dp[21]);
00478    /* 22 */
00479    COMBA_FORWARD;
00480    MULADD(at[0], at[54]);    MULADD(at[1], at[53]);    MULADD(at[2], at[52]);    MULADD(at[3], at[51]);    MULADD(at[4], at[50]);    MULADD(at[5], at[49]);    MULADD(at[6], at[48]);    MULADD(at[7], at[47]);    MULADD(at[8], at[46]);    MULADD(at[9], at[45]);    MULADD(at[10], at[44]);    MULADD(at[11], at[43]);    MULADD(at[12], at[42]);    MULADD(at[13], at[41]);    MULADD(at[14], at[40]);    MULADD(at[15], at[39]);    MULADD(at[16], at[38]);    MULADD(at[17], at[37]);    MULADD(at[18], at[36]);    MULADD(at[19], at[35]);    MULADD(at[20], at[34]);    MULADD(at[21], at[33]);    MULADD(at[22], at[32]); 
00481    COMBA_STORE(C->dp[22]);
00482    /* 23 */
00483    COMBA_FORWARD;
00484    MULADD(at[0], at[55]);    MULADD(at[1], at[54]);    MULADD(at[2], at[53]);    MULADD(at[3], at[52]);    MULADD(at[4], at[51]);    MULADD(at[5], at[50]);    MULADD(at[6], at[49]);    MULADD(at[7], at[48]);    MULADD(at[8], at[47]);    MULADD(at[9], at[46]);    MULADD(at[10], at[45]);    MULADD(at[11], at[44]);    MULADD(at[12], at[43]);    MULADD(at[13], at[42]);    MULADD(at[14], at[41]);    MULADD(at[15], at[40]);    MULADD(at[16], at[39]);    MULADD(at[17], at[38]);    MULADD(at[18], at[37]);    MULADD(at[19], at[36]);    MULADD(at[20], at[35]);    MULADD(at[21], at[34]);    MULADD(at[22], at[33]);    MULADD(at[23], at[32]); 
00485    COMBA_STORE(C->dp[23]);
00486    /* 24 */
00487    COMBA_FORWARD;
00488    MULADD(at[0], at[56]);    MULADD(at[1], at[55]);    MULADD(at[2], at[54]);    MULADD(at[3], at[53]);    MULADD(at[4], at[52]);    MULADD(at[5], at[51]);    MULADD(at[6], at[50]);    MULADD(at[7], at[49]);    MULADD(at[8], at[48]);    MULADD(at[9], at[47]);    MULADD(at[10], at[46]);    MULADD(at[11], at[45]);    MULADD(at[12], at[44]);    MULADD(at[13], at[43]);    MULADD(at[14], at[42]);    MULADD(at[15], at[41]);    MULADD(at[16], at[40]);    MULADD(at[17], at[39]);    MULADD(at[18], at[38]);    MULADD(at[19], at[37]);    MULADD(at[20], at[36]);    MULADD(at[21], at[35]);    MULADD(at[22], at[34]);    MULADD(at[23], at[33]);    MULADD(at[24], at[32]); 
00489    COMBA_STORE(C->dp[24]);
00490    /* 25 */
00491    COMBA_FORWARD;
00492    MULADD(at[0], at[57]);    MULADD(at[1], at[56]);    MULADD(at[2], at[55]);    MULADD(at[3], at[54]);    MULADD(at[4], at[53]);    MULADD(at[5], at[52]);    MULADD(at[6], at[51]);    MULADD(at[7], at[50]);    MULADD(at[8], at[49]);    MULADD(at[9], at[48]);    MULADD(at[10], at[47]);    MULADD(at[11], at[46]);    MULADD(at[12], at[45]);    MULADD(at[13], at[44]);    MULADD(at[14], at[43]);    MULADD(at[15], at[42]);    MULADD(at[16], at[41]);    MULADD(at[17], at[40]);    MULADD(at[18], at[39]);    MULADD(at[19], at[38]);    MULADD(at[20], at[37]);    MULADD(at[21], at[36]);    MULADD(at[22], at[35]);    MULADD(at[23], at[34]);    MULADD(at[24], at[33]);    MULADD(at[25], at[32]); 
00493    COMBA_STORE(C->dp[25]);
00494    /* 26 */
00495    COMBA_FORWARD;
00496    MULADD(at[0], at[58]);    MULADD(at[1], at[57]);    MULADD(at[2], at[56]);    MULADD(at[3], at[55]);    MULADD(at[4], at[54]);    MULADD(at[5], at[53]);    MULADD(at[6], at[52]);    MULADD(at[7], at[51]);    MULADD(at[8], at[50]);    MULADD(at[9], at[49]);    MULADD(at[10], at[48]);    MULADD(at[11], at[47]);    MULADD(at[12], at[46]);    MULADD(at[13], at[45]);    MULADD(at[14], at[44]);    MULADD(at[15], at[43]);    MULADD(at[16], at[42]);    MULADD(at[17], at[41]);    MULADD(at[18], at[40]);    MULADD(at[19], at[39]);    MULADD(at[20], at[38]);    MULADD(at[21], at[37]);    MULADD(at[22], at[36]);    MULADD(at[23], at[35]);    MULADD(at[24], at[34]);    MULADD(at[25], at[33]);    MULADD(at[26], at[32]); 
00497    COMBA_STORE(C->dp[26]);
00498    /* 27 */
00499    COMBA_FORWARD;
00500    MULADD(at[0], at[59]);    MULADD(at[1], at[58]);    MULADD(at[2], at[57]);    MULADD(at[3], at[56]);    MULADD(at[4], at[55]);    MULADD(at[5], at[54]);    MULADD(at[6], at[53]);    MULADD(at[7], at[52]);    MULADD(at[8], at[51]);    MULADD(at[9], at[50]);    MULADD(at[10], at[49]);    MULADD(at[11], at[48]);    MULADD(at[12], at[47]);    MULADD(at[13], at[46]);    MULADD(at[14], at[45]);    MULADD(at[15], at[44]);    MULADD(at[16], at[43]);    MULADD(at[17], at[42]);    MULADD(at[18], at[41]);    MULADD(at[19], at[40]);    MULADD(at[20], at[39]);    MULADD(at[21], at[38]);    MULADD(at[22], at[37]);    MULADD(at[23], at[36]);    MULADD(at[24], at[35]);    MULADD(at[25], at[34]);    MULADD(at[26], at[33]);    MULADD(at[27], at[32]); 
00501    COMBA_STORE(C->dp[27]);
00502    /* 28 */
00503    COMBA_FORWARD;
00504    MULADD(at[0], at[60]);    MULADD(at[1], at[59]);    MULADD(at[2], at[58]);    MULADD(at[3], at[57]);    MULADD(at[4], at[56]);    MULADD(at[5], at[55]);    MULADD(at[6], at[54]);    MULADD(at[7], at[53]);    MULADD(at[8], at[52]);    MULADD(at[9], at[51]);    MULADD(at[10], at[50]);    MULADD(at[11], at[49]);    MULADD(at[12], at[48]);    MULADD(at[13], at[47]);    MULADD(at[14], at[46]);    MULADD(at[15], at[45]);    MULADD(at[16], at[44]);    MULADD(at[17], at[43]);    MULADD(at[18], at[42]);    MULADD(at[19], at[41]);    MULADD(at[20], at[40]);    MULADD(at[21], at[39]);    MULADD(at[22], at[38]);    MULADD(at[23], at[37]);    MULADD(at[24], at[36]);    MULADD(at[25], at[35]);    MULADD(at[26], at[34]);    MULADD(at[27], at[33]);    MULADD(at[28], at[32]); 
00505    COMBA_STORE(C->dp[28]);
00506    /* 29 */
00507    COMBA_FORWARD;
00508    MULADD(at[0], at[61]);    MULADD(at[1], at[60]);    MULADD(at[2], at[59]);    MULADD(at[3], at[58]);    MULADD(at[4], at[57]);    MULADD(at[5], at[56]);    MULADD(at[6], at[55]);    MULADD(at[7], at[54]);    MULADD(at[8], at[53]);    MULADD(at[9], at[52]);    MULADD(at[10], at[51]);    MULADD(at[11], at[50]);    MULADD(at[12], at[49]);    MULADD(at[13], at[48]);    MULADD(at[14], at[47]);    MULADD(at[15], at[46]);    MULADD(at[16], at[45]);    MULADD(at[17], at[44]);    MULADD(at[18], at[43]);    MULADD(at[19], at[42]);    MULADD(at[20], at[41]);    MULADD(at[21], at[40]);    MULADD(at[22], at[39]);    MULADD(at[23], at[38]);    MULADD(at[24], at[37]);    MULADD(at[25], at[36]);    MULADD(at[26], at[35]);    MULADD(at[27], at[34]);    MULADD(at[28], at[33]);    MULADD(at[29], at[32]); 
00509    COMBA_STORE(C->dp[29]);
00510    /* 30 */
00511    COMBA_FORWARD;
00512    MULADD(at[0], at[62]);    MULADD(at[1], at[61]);    MULADD(at[2], at[60]);    MULADD(at[3], at[59]);    MULADD(at[4], at[58]);    MULADD(at[5], at[57]);    MULADD(at[6], at[56]);    MULADD(at[7], at[55]);    MULADD(at[8], at[54]);    MULADD(at[9], at[53]);    MULADD(at[10], at[52]);    MULADD(at[11], at[51]);    MULADD(at[12], at[50]);    MULADD(at[13], at[49]);    MULADD(at[14], at[48]);    MULADD(at[15], at[47]);    MULADD(at[16], at[46]);    MULADD(at[17], at[45]);    MULADD(at[18], at[44]);    MULADD(at[19], at[43]);    MULADD(at[20], at[42]);    MULADD(at[21], at[41]);    MULADD(at[22], at[40]);    MULADD(at[23], at[39]);    MULADD(at[24], at[38]);    MULADD(at[25], at[37]);    MULADD(at[26], at[36]);    MULADD(at[27], at[35]);    MULADD(at[28], at[34]);    MULADD(at[29], at[33]);    MULADD(at[30], at[32]); 
00513    COMBA_STORE(C->dp[30]);
00514    /* 31 */
00515    COMBA_FORWARD;
00516    MULADD(at[0], at[63]);    MULADD(at[1], at[62]);    MULADD(at[2], at[61]);    MULADD(at[3], at[60]);    MULADD(at[4], at[59]);    MULADD(at[5], at[58]);    MULADD(at[6], at[57]);    MULADD(at[7], at[56]);    MULADD(at[8], at[55]);    MULADD(at[9], at[54]);    MULADD(at[10], at[53]);    MULADD(at[11], at[52]);    MULADD(at[12], at[51]);    MULADD(at[13], at[50]);    MULADD(at[14], at[49]);    MULADD(at[15], at[48]);    MULADD(at[16], at[47]);    MULADD(at[17], at[46]);    MULADD(at[18], at[45]);    MULADD(at[19], at[44]);    MULADD(at[20], at[43]);    MULADD(at[21], at[42]);    MULADD(at[22], at[41]);    MULADD(at[23], at[40]);    MULADD(at[24], at[39]);    MULADD(at[25], at[38]);    MULADD(at[26], at[37]);    MULADD(at[27], at[36]);    MULADD(at[28], at[35]);    MULADD(at[29], at[34]);    MULADD(at[30], at[33]);    MULADD(at[31], at[32]); 
00517    COMBA_STORE(C->dp[31]);
00518    /* 32 */
00519    COMBA_FORWARD;
00520    MULADD(at[1], at[63]);    MULADD(at[2], at[62]);    MULADD(at[3], at[61]);    MULADD(at[4], at[60]);    MULADD(at[5], at[59]);    MULADD(at[6], at[58]);    MULADD(at[7], at[57]);    MULADD(at[8], at[56]);    MULADD(at[9], at[55]);    MULADD(at[10], at[54]);    MULADD(at[11], at[53]);    MULADD(at[12], at[52]);    MULADD(at[13], at[51]);    MULADD(at[14], at[50]);    MULADD(at[15], at[49]);    MULADD(at[16], at[48]);    MULADD(at[17], at[47]);    MULADD(at[18], at[46]);    MULADD(at[19], at[45]);    MULADD(at[20], at[44]);    MULADD(at[21], at[43]);    MULADD(at[22], at[42]);    MULADD(at[23], at[41]);    MULADD(at[24], at[40]);    MULADD(at[25], at[39]);    MULADD(at[26], at[38]);    MULADD(at[27], at[37]);    MULADD(at[28], at[36]);    MULADD(at[29], at[35]);    MULADD(at[30], at[34]);    MULADD(at[31], at[33]); 
00521    COMBA_STORE(C->dp[32]);
00522    /* 33 */
00523    COMBA_FORWARD;
00524    MULADD(at[2], at[63]);    MULADD(at[3], at[62]);    MULADD(at[4], at[61]);    MULADD(at[5], at[60]);    MULADD(at[6], at[59]);    MULADD(at[7], at[58]);    MULADD(at[8], at[57]);    MULADD(at[9], at[56]);    MULADD(at[10], at[55]);    MULADD(at[11], at[54]);    MULADD(at[12], at[53]);    MULADD(at[13], at[52]);    MULADD(at[14], at[51]);    MULADD(at[15], at[50]);    MULADD(at[16], at[49]);    MULADD(at[17], at[48]);    MULADD(at[18], at[47]);    MULADD(at[19], at[46]);    MULADD(at[20], at[45]);    MULADD(at[21], at[44]);    MULADD(at[22], at[43]);    MULADD(at[23], at[42]);    MULADD(at[24], at[41]);    MULADD(at[25], at[40]);    MULADD(at[26], at[39]);    MULADD(at[27], at[38]);    MULADD(at[28], at[37]);    MULADD(at[29], at[36]);    MULADD(at[30], at[35]);    MULADD(at[31], at[34]); 
00525    COMBA_STORE(C->dp[33]);
00526    /* 34 */
00527    COMBA_FORWARD;
00528    MULADD(at[3], at[63]);    MULADD(at[4], at[62]);    MULADD(at[5], at[61]);    MULADD(at[6], at[60]);    MULADD(at[7], at[59]);    MULADD(at[8], at[58]);    MULADD(at[9], at[57]);    MULADD(at[10], at[56]);    MULADD(at[11], at[55]);    MULADD(at[12], at[54]);    MULADD(at[13], at[53]);    MULADD(at[14], at[52]);    MULADD(at[15], at[51]);    MULADD(at[16], at[50]);    MULADD(at[17], at[49]);    MULADD(at[18], at[48]);    MULADD(at[19], at[47]);    MULADD(at[20], at[46]);    MULADD(at[21], at[45]);    MULADD(at[22], at[44]);    MULADD(at[23], at[43]);    MULADD(at[24], at[42]);    MULADD(at[25], at[41]);    MULADD(at[26], at[40]);    MULADD(at[27], at[39]);    MULADD(at[28], at[38]);    MULADD(at[29], at[37]);    MULADD(at[30], at[36]);    MULADD(at[31], at[35]); 
00529    COMBA_STORE(C->dp[34]);
00530    /* 35 */
00531    COMBA_FORWARD;
00532    MULADD(at[4], at[63]);    MULADD(at[5], at[62]);    MULADD(at[6], at[61]);    MULADD(at[7], at[60]);    MULADD(at[8], at[59]);    MULADD(at[9], at[58]);    MULADD(at[10], at[57]);    MULADD(at[11], at[56]);    MULADD(at[12], at[55]);    MULADD(at[13], at[54]);    MULADD(at[14], at[53]);    MULADD(at[15], at[52]);    MULADD(at[16], at[51]);    MULADD(at[17], at[50]);    MULADD(at[18], at[49]);    MULADD(at[19], at[48]);    MULADD(at[20], at[47]);    MULADD(at[21], at[46]);    MULADD(at[22], at[45]);    MULADD(at[23], at[44]);    MULADD(at[24], at[43]);    MULADD(at[25], at[42]);    MULADD(at[26], at[41]);    MULADD(at[27], at[40]);    MULADD(at[28], at[39]);    MULADD(at[29], at[38]);    MULADD(at[30], at[37]);    MULADD(at[31], at[36]); 
00533    COMBA_STORE(C->dp[35]);
00534    /* 36 */
00535    COMBA_FORWARD;
00536    MULADD(at[5], at[63]);    MULADD(at[6], at[62]);    MULADD(at[7], at[61]);    MULADD(at[8], at[60]);    MULADD(at[9], at[59]);    MULADD(at[10], at[58]);    MULADD(at[11], at[57]);    MULADD(at[12], at[56]);    MULADD(at[13], at[55]);    MULADD(at[14], at[54]);    MULADD(at[15], at[53]);    MULADD(at[16], at[52]);    MULADD(at[17], at[51]);    MULADD(at[18], at[50]);    MULADD(at[19], at[49]);    MULADD(at[20], at[48]);    MULADD(at[21], at[47]);    MULADD(at[22], at[46]);    MULADD(at[23], at[45]);    MULADD(at[24], at[44]);    MULADD(at[25], at[43]);    MULADD(at[26], at[42]);    MULADD(at[27], at[41]);    MULADD(at[28], at[40]);    MULADD(at[29], at[39]);    MULADD(at[30], at[38]);    MULADD(at[31], at[37]); 
00537    COMBA_STORE(C->dp[36]);
00538    /* 37 */
00539    COMBA_FORWARD;
00540    MULADD(at[6], at[63]);    MULADD(at[7], at[62]);    MULADD(at[8], at[61]);    MULADD(at[9], at[60]);    MULADD(at[10], at[59]);    MULADD(at[11], at[58]);    MULADD(at[12], at[57]);    MULADD(at[13], at[56]);    MULADD(at[14], at[55]);    MULADD(at[15], at[54]);    MULADD(at[16], at[53]);    MULADD(at[17], at[52]);    MULADD(at[18], at[51]);    MULADD(at[19], at[50]);    MULADD(at[20], at[49]);    MULADD(at[21], at[48]);    MULADD(at[22], at[47]);    MULADD(at[23], at[46]);    MULADD(at[24], at[45]);    MULADD(at[25], at[44]);    MULADD(at[26], at[43]);    MULADD(at[27], at[42]);    MULADD(at[28], at[41]);    MULADD(at[29], at[40]);    MULADD(at[30], at[39]);    MULADD(at[31], at[38]); 
00541    COMBA_STORE(C->dp[37]);
00542    /* 38 */
00543    COMBA_FORWARD;
00544    MULADD(at[7], at[63]);    MULADD(at[8], at[62]);    MULADD(at[9], at[61]);    MULADD(at[10], at[60]);    MULADD(at[11], at[59]);    MULADD(at[12], at[58]);    MULADD(at[13], at[57]);    MULADD(at[14], at[56]);    MULADD(at[15], at[55]);    MULADD(at[16], at[54]);    MULADD(at[17], at[53]);    MULADD(at[18], at[52]);    MULADD(at[19], at[51]);    MULADD(at[20], at[50]);    MULADD(at[21], at[49]);    MULADD(at[22], at[48]);    MULADD(at[23], at[47]);    MULADD(at[24], at[46]);    MULADD(at[25], at[45]);    MULADD(at[26], at[44]);    MULADD(at[27], at[43]);    MULADD(at[28], at[42]);    MULADD(at[29], at[41]);    MULADD(at[30], at[40]);    MULADD(at[31], at[39]); 
00545    COMBA_STORE(C->dp[38]);
00546    /* 39 */
00547    COMBA_FORWARD;
00548    MULADD(at[8], at[63]);    MULADD(at[9], at[62]);    MULADD(at[10], at[61]);    MULADD(at[11], at[60]);    MULADD(at[12], at[59]);    MULADD(at[13], at[58]);    MULADD(at[14], at[57]);    MULADD(at[15], at[56]);    MULADD(at[16], at[55]);    MULADD(at[17], at[54]);    MULADD(at[18], at[53]);    MULADD(at[19], at[52]);    MULADD(at[20], at[51]);    MULADD(at[21], at[50]);    MULADD(at[22], at[49]);    MULADD(at[23], at[48]);    MULADD(at[24], at[47]);    MULADD(at[25], at[46]);    MULADD(at[26], at[45]);    MULADD(at[27], at[44]);    MULADD(at[28], at[43]);    MULADD(at[29], at[42]);    MULADD(at[30], at[41]);    MULADD(at[31], at[40]); 
00549    COMBA_STORE(C->dp[39]);
00550    /* 40 */
00551    COMBA_FORWARD;
00552    MULADD(at[9], at[63]);    MULADD(at[10], at[62]);    MULADD(at[11], at[61]);    MULADD(at[12], at[60]);    MULADD(at[13], at[59]);    MULADD(at[14], at[58]);    MULADD(at[15], at[57]);    MULADD(at[16], at[56]);    MULADD(at[17], at[55]);    MULADD(at[18], at[54]);    MULADD(at[19], at[53]);    MULADD(at[20], at[52]);    MULADD(at[21], at[51]);    MULADD(at[22], at[50]);    MULADD(at[23], at[49]);    MULADD(at[24], at[48]);    MULADD(at[25], at[47]);    MULADD(at[26], at[46]);    MULADD(at[27], at[45]);    MULADD(at[28], at[44]);    MULADD(at[29], at[43]);    MULADD(at[30], at[42]);    MULADD(at[31], at[41]); 
00553    COMBA_STORE(C->dp[40]);
00554    /* 41 */
00555    COMBA_FORWARD;
00556    MULADD(at[10], at[63]);    MULADD(at[11], at[62]);    MULADD(at[12], at[61]);    MULADD(at[13], at[60]);    MULADD(at[14], at[59]);    MULADD(at[15], at[58]);    MULADD(at[16], at[57]);    MULADD(at[17], at[56]);    MULADD(at[18], at[55]);    MULADD(at[19], at[54]);    MULADD(at[20], at[53]);    MULADD(at[21], at[52]);    MULADD(at[22], at[51]);    MULADD(at[23], at[50]);    MULADD(at[24], at[49]);    MULADD(at[25], at[48]);    MULADD(at[26], at[47]);    MULADD(at[27], at[46]);    MULADD(at[28], at[45]);    MULADD(at[29], at[44]);    MULADD(at[30], at[43]);    MULADD(at[31], at[42]); 
00557    COMBA_STORE(C->dp[41]);
00558    /* 42 */
00559    COMBA_FORWARD;
00560    MULADD(at[11], at[63]);    MULADD(at[12], at[62]);    MULADD(at[13], at[61]);    MULADD(at[14], at[60]);    MULADD(at[15], at[59]);    MULADD(at[16], at[58]);    MULADD(at[17], at[57]);    MULADD(at[18], at[56]);    MULADD(at[19], at[55]);    MULADD(at[20], at[54]);    MULADD(at[21], at[53]);    MULADD(at[22], at[52]);    MULADD(at[23], at[51]);    MULADD(at[24], at[50]);    MULADD(at[25], at[49]);    MULADD(at[26], at[48]);    MULADD(at[27], at[47]);    MULADD(at[28], at[46]);    MULADD(at[29], at[45]);    MULADD(at[30], at[44]);    MULADD(at[31], at[43]); 
00561    COMBA_STORE(C->dp[42]);
00562    /* 43 */
00563    COMBA_FORWARD;
00564    MULADD(at[12], at[63]);    MULADD(at[13], at[62]);    MULADD(at[14], at[61]);    MULADD(at[15], at[60]);    MULADD(at[16], at[59]);    MULADD(at[17], at[58]);    MULADD(at[18], at[57]);    MULADD(at[19], at[56]);    MULADD(at[20], at[55]);    MULADD(at[21], at[54]);    MULADD(at[22], at[53]);    MULADD(at[23], at[52]);    MULADD(at[24], at[51]);    MULADD(at[25], at[50]);    MULADD(at[26], at[49]);    MULADD(at[27], at[48]);    MULADD(at[28], at[47]);    MULADD(at[29], at[46]);    MULADD(at[30], at[45]);    MULADD(at[31], at[44]); 
00565    COMBA_STORE(C->dp[43]);
00566    /* 44 */
00567    COMBA_FORWARD;
00568    MULADD(at[13], at[63]);    MULADD(at[14], at[62]);    MULADD(at[15], at[61]);    MULADD(at[16], at[60]);    MULADD(at[17], at[59]);    MULADD(at[18], at[58]);    MULADD(at[19], at[57]);    MULADD(at[20], at[56]);    MULADD(at[21], at[55]);    MULADD(at[22], at[54]);    MULADD(at[23], at[53]);    MULADD(at[24], at[52]);    MULADD(at[25], at[51]);    MULADD(at[26], at[50]);    MULADD(at[27], at[49]);    MULADD(at[28], at[48]);    MULADD(at[29], at[47]);    MULADD(at[30], at[46]);    MULADD(at[31], at[45]); 
00569    COMBA_STORE(C->dp[44]);
00570    /* 45 */
00571    COMBA_FORWARD;
00572    MULADD(at[14], at[63]);    MULADD(at[15], at[62]);    MULADD(at[16], at[61]);    MULADD(at[17], at[60]);    MULADD(at[18], at[59]);    MULADD(at[19], at[58]);    MULADD(at[20], at[57]);    MULADD(at[21], at[56]);    MULADD(at[22], at[55]);    MULADD(at[23], at[54]);    MULADD(at[24], at[53]);    MULADD(at[25], at[52]);    MULADD(at[26], at[51]);    MULADD(at[27], at[50]);    MULADD(at[28], at[49]);    MULADD(at[29], at[48]);    MULADD(at[30], at[47]);    MULADD(at[31], at[46]); 
00573    COMBA_STORE(C->dp[45]);
00574    /* 46 */
00575    COMBA_FORWARD;
00576    MULADD(at[15], at[63]);    MULADD(at[16], at[62]);    MULADD(at[17], at[61]);    MULADD(at[18], at[60]);    MULADD(at[19], at[59]);    MULADD(at[20], at[58]);    MULADD(at[21], at[57]);    MULADD(at[22], at[56]);    MULADD(at[23], at[55]);    MULADD(at[24], at[54]);    MULADD(at[25], at[53]);    MULADD(at[26], at[52]);    MULADD(at[27], at[51]);    MULADD(at[28], at[50]);    MULADD(at[29], at[49]);    MULADD(at[30], at[48]);    MULADD(at[31], at[47]); 
00577    COMBA_STORE(C->dp[46]);
00578    /* 47 */
00579    COMBA_FORWARD;
00580    MULADD(at[16], at[63]);    MULADD(at[17], at[62]);    MULADD(at[18], at[61]);    MULADD(at[19], at[60]);    MULADD(at[20], at[59]);    MULADD(at[21], at[58]);    MULADD(at[22], at[57]);    MULADD(at[23], at[56]);    MULADD(at[24], at[55]);    MULADD(at[25], at[54]);    MULADD(at[26], at[53]);    MULADD(at[27], at[52]);    MULADD(at[28], at[51]);    MULADD(at[29], at[50]);    MULADD(at[30], at[49]);    MULADD(at[31], at[48]); 
00581    COMBA_STORE(C->dp[47]);
00582    /* 48 */
00583    COMBA_FORWARD;
00584    MULADD(at[17], at[63]);    MULADD(at[18], at[62]);    MULADD(at[19], at[61]);    MULADD(at[20], at[60]);    MULADD(at[21], at[59]);    MULADD(at[22], at[58]);    MULADD(at[23], at[57]);    MULADD(at[24], at[56]);    MULADD(at[25], at[55]);    MULADD(at[26], at[54]);    MULADD(at[27], at[53]);    MULADD(at[28], at[52]);    MULADD(at[29], at[51]);    MULADD(at[30], at[50]);    MULADD(at[31], at[49]); 
00585    COMBA_STORE(C->dp[48]);
00586    /* 49 */
00587    COMBA_FORWARD;
00588    MULADD(at[18], at[63]);    MULADD(at[19], at[62]);    MULADD(at[20], at[61]);    MULADD(at[21], at[60]);    MULADD(at[22], at[59]);    MULADD(at[23], at[58]);    MULADD(at[24], at[57]);    MULADD(at[25], at[56]);    MULADD(at[26], at[55]);    MULADD(at[27], at[54]);    MULADD(at[28], at[53]);    MULADD(at[29], at[52]);    MULADD(at[30], at[51]);    MULADD(at[31], at[50]); 
00589    COMBA_STORE(C->dp[49]);
00590    /* 50 */
00591    COMBA_FORWARD;
00592    MULADD(at[19], at[63]);    MULADD(at[20], at[62]);    MULADD(at[21], at[61]);    MULADD(at[22], at[60]);    MULADD(at[23], at[59]);    MULADD(at[24], at[58]);    MULADD(at[25], at[57]);    MULADD(at[26], at[56]);    MULADD(at[27], at[55]);    MULADD(at[28], at[54]);    MULADD(at[29], at[53]);    MULADD(at[30], at[52]);    MULADD(at[31], at[51]); 
00593    COMBA_STORE(C->dp[50]);
00594    /* 51 */
00595    COMBA_FORWARD;
00596    MULADD(at[20], at[63]);    MULADD(at[21], at[62]);    MULADD(at[22], at[61]);    MULADD(at[23], at[60]);    MULADD(at[24], at[59]);    MULADD(at[25], at[58]);    MULADD(at[26], at[57]);    MULADD(at[27], at[56]);    MULADD(at[28], at[55]);    MULADD(at[29], at[54]);    MULADD(at[30], at[53]);    MULADD(at[31], at[52]); 
00597    COMBA_STORE(C->dp[51]);
00598    /* 52 */
00599    COMBA_FORWARD;
00600    MULADD(at[21], at[63]);    MULADD(at[22], at[62]);    MULADD(at[23], at[61]);    MULADD(at[24], at[60]);    MULADD(at[25], at[59]);    MULADD(at[26], at[58]);    MULADD(at[27], at[57]);    MULADD(at[28], at[56]);    MULADD(at[29], at[55]);    MULADD(at[30], at[54]);    MULADD(at[31], at[53]); 
00601    COMBA_STORE(C->dp[52]);
00602    /* 53 */
00603    COMBA_FORWARD;
00604    MULADD(at[22], at[63]);    MULADD(at[23], at[62]);    MULADD(at[24], at[61]);    MULADD(at[25], at[60]);    MULADD(at[26], at[59]);    MULADD(at[27], at[58]);    MULADD(at[28], at[57]);    MULADD(at[29], at[56]);    MULADD(at[30], at[55]);    MULADD(at[31], at[54]); 
00605    COMBA_STORE(C->dp[53]);
00606    /* 54 */
00607    COMBA_FORWARD;
00608    MULADD(at[23], at[63]);    MULADD(at[24], at[62]);    MULADD(at[25], at[61]);    MULADD(at[26], at[60]);    MULADD(at[27], at[59]);    MULADD(at[28], at[58]);    MULADD(at[29], at[57]);    MULADD(at[30], at[56]);    MULADD(at[31], at[55]); 
00609    COMBA_STORE(C->dp[54]);
00610    /* 55 */
00611    COMBA_FORWARD;
00612    MULADD(at[24], at[63]);    MULADD(at[25], at[62]);    MULADD(at[26], at[61]);    MULADD(at[27], at[60]);    MULADD(at[28], at[59]);    MULADD(at[29], at[58]);    MULADD(at[30], at[57]);    MULADD(at[31], at[56]); 
00613    COMBA_STORE(C->dp[55]);
00614    /* 56 */
00615    COMBA_FORWARD;
00616    MULADD(at[25], at[63]);    MULADD(at[26], at[62]);    MULADD(at[27], at[61]);    MULADD(at[28], at[60]);    MULADD(at[29], at[59]);    MULADD(at[30], at[58]);    MULADD(at[31], at[57]); 
00617    COMBA_STORE(C->dp[56]);
00618    /* 57 */
00619    COMBA_FORWARD;
00620    MULADD(at[26], at[63]);    MULADD(at[27], at[62]);    MULADD(at[28], at[61]);    MULADD(at[29], at[60]);    MULADD(at[30], at[59]);    MULADD(at[31], at[58]); 
00621    COMBA_STORE(C->dp[57]);
00622    /* 58 */
00623    COMBA_FORWARD;
00624    MULADD(at[27], at[63]);    MULADD(at[28], at[62]);    MULADD(at[29], at[61]);    MULADD(at[30], at[60]);    MULADD(at[31], at[59]); 
00625    COMBA_STORE(C->dp[58]);
00626    /* 59 */
00627    COMBA_FORWARD;
00628    MULADD(at[28], at[63]);    MULADD(at[29], at[62]);    MULADD(at[30], at[61]);    MULADD(at[31], at[60]); 
00629    COMBA_STORE(C->dp[59]);
00630    /* 60 */
00631    COMBA_FORWARD;
00632    MULADD(at[29], at[63]);    MULADD(at[30], at[62]);    MULADD(at[31], at[61]); 
00633    COMBA_STORE(C->dp[60]);
00634    /* 61 */
00635    COMBA_FORWARD;
00636    MULADD(at[30], at[63]);    MULADD(at[31], at[62]); 
00637    COMBA_STORE(C->dp[61]);
00638    /* 62 */
00639    COMBA_FORWARD;
00640    MULADD(at[31], at[63]); 
00641    COMBA_STORE(C->dp[62]);
00642    COMBA_STORE2(C->dp[63]);
00643    C->used = 64;
00644    C->sign = A->sign ^ B->sign;
00645    mp_clamp(C);
00646    COMBA_FINI;
00647 }
00648 
00649 
00650 
00651 void s_mp_sqr_comba_4(const mp_int *A, mp_int *B)
00652 {
00653    mp_digit *a, b[8], c0, c1, c2, sc0, sc1, sc2;
00654    /* get rid of some compiler warnings */
00655    sc0 = 0; sc1 = 0; sc2 = 0;
00656 
00657    a = A->dp;
00658    COMBA_START; 
00659 
00660    /* clear carries */
00661    CLEAR_CARRY;
00662 
00663    /* output 0 */
00664    SQRADD(a[0],a[0]);
00665    COMBA_STORE(b[0]);
00666 
00667    /* output 1 */
00668    CARRY_FORWARD;
00669    SQRADD2(a[0], a[1]); 
00670    COMBA_STORE(b[1]);
00671 
00672    /* output 2 */
00673    CARRY_FORWARD;
00674    SQRADD2(a[0], a[2]);    SQRADD(a[1], a[1]); 
00675    COMBA_STORE(b[2]);
00676 
00677    /* output 3 */
00678    CARRY_FORWARD;
00679    SQRADD2(a[0], a[3]);    SQRADD2(a[1], a[2]); 
00680    COMBA_STORE(b[3]);
00681 
00682    /* output 4 */
00683    CARRY_FORWARD;
00684    SQRADD2(a[1], a[3]);    SQRADD(a[2], a[2]); 
00685    COMBA_STORE(b[4]);
00686 
00687    /* output 5 */
00688    CARRY_FORWARD;
00689    SQRADD2(a[2], a[3]); 
00690    COMBA_STORE(b[5]);
00691 
00692    /* output 6 */
00693    CARRY_FORWARD;
00694    SQRADD(a[3], a[3]); 
00695    COMBA_STORE(b[6]);
00696    COMBA_STORE2(b[7]);
00697    COMBA_FINI;
00698 
00699    B->used = 8;
00700    B->sign = ZPOS;
00701    memcpy(B->dp, b, 8 * sizeof(mp_digit));
00702    mp_clamp(B);
00703 }
00704 
00705 void s_mp_sqr_comba_8(const mp_int *A, mp_int *B)
00706 {
00707    mp_digit *a, b[16], c0, c1, c2, sc0, sc1, sc2;
00708    /* get rid of some compiler warnings */
00709    sc0 = 0; sc1 = 0; sc2 = 0;
00710 
00711    a = A->dp;
00712    COMBA_START; 
00713 
00714    /* clear carries */
00715    CLEAR_CARRY;
00716 
00717    /* output 0 */
00718    SQRADD(a[0],a[0]);
00719    COMBA_STORE(b[0]);
00720 
00721    /* output 1 */
00722    CARRY_FORWARD;
00723    SQRADD2(a[0], a[1]); 
00724    COMBA_STORE(b[1]);
00725 
00726    /* output 2 */
00727    CARRY_FORWARD;
00728    SQRADD2(a[0], a[2]);    SQRADD(a[1], a[1]); 
00729    COMBA_STORE(b[2]);
00730 
00731    /* output 3 */
00732    CARRY_FORWARD;
00733    SQRADD2(a[0], a[3]);    SQRADD2(a[1], a[2]); 
00734    COMBA_STORE(b[3]);
00735 
00736    /* output 4 */
00737    CARRY_FORWARD;
00738    SQRADD2(a[0], a[4]);    SQRADD2(a[1], a[3]);    SQRADD(a[2], a[2]); 
00739    COMBA_STORE(b[4]);
00740 
00741    /* output 5 */
00742    CARRY_FORWARD;
00743    SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB; 
00744    COMBA_STORE(b[5]);
00745 
00746    /* output 6 */
00747    CARRY_FORWARD;
00748    SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]); 
00749    COMBA_STORE(b[6]);
00750 
00751    /* output 7 */
00752    CARRY_FORWARD;
00753    SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB; 
00754    COMBA_STORE(b[7]);
00755 
00756    /* output 8 */
00757    CARRY_FORWARD;
00758    SQRADDSC(a[1], a[7]); SQRADDAC(a[2], a[6]); SQRADDAC(a[3], a[5]); SQRADDDB; SQRADD(a[4], a[4]); 
00759    COMBA_STORE(b[8]);
00760 
00761    /* output 9 */
00762    CARRY_FORWARD;
00763    SQRADDSC(a[2], a[7]); SQRADDAC(a[3], a[6]); SQRADDAC(a[4], a[5]); SQRADDDB; 
00764    COMBA_STORE(b[9]);
00765 
00766    /* output 10 */
00767    CARRY_FORWARD;
00768    SQRADD2(a[3], a[7]);    SQRADD2(a[4], a[6]);    SQRADD(a[5], a[5]); 
00769    COMBA_STORE(b[10]);
00770 
00771    /* output 11 */
00772    CARRY_FORWARD;
00773    SQRADD2(a[4], a[7]);    SQRADD2(a[5], a[6]); 
00774    COMBA_STORE(b[11]);
00775 
00776    /* output 12 */
00777    CARRY_FORWARD;
00778    SQRADD2(a[5], a[7]);    SQRADD(a[6], a[6]); 
00779    COMBA_STORE(b[12]);
00780 
00781    /* output 13 */
00782    CARRY_FORWARD;
00783    SQRADD2(a[6], a[7]); 
00784    COMBA_STORE(b[13]);
00785 
00786    /* output 14 */
00787    CARRY_FORWARD;
00788    SQRADD(a[7], a[7]); 
00789    COMBA_STORE(b[14]);
00790    COMBA_STORE2(b[15]);
00791    COMBA_FINI;
00792 
00793    B->used = 16;
00794    B->sign = ZPOS;
00795    memcpy(B->dp, b, 16 * sizeof(mp_digit));
00796    mp_clamp(B);
00797 }
00798 
00799 void s_mp_sqr_comba_16(const mp_int *A, mp_int *B)
00800 {
00801    mp_digit *a, b[32], c0, c1, c2, sc0, sc1, sc2;
00802    /* get rid of some compiler warnings */
00803    sc0 = 0; sc1 = 0; sc2 = 0;
00804 
00805    a = A->dp;
00806    COMBA_START; 
00807 
00808    /* clear carries */
00809    CLEAR_CARRY;
00810 
00811    /* output 0 */
00812    SQRADD(a[0],a[0]);
00813    COMBA_STORE(b[0]);
00814 
00815    /* output 1 */
00816    CARRY_FORWARD;
00817    SQRADD2(a[0], a[1]); 
00818    COMBA_STORE(b[1]);
00819 
00820    /* output 2 */
00821    CARRY_FORWARD;
00822    SQRADD2(a[0], a[2]);    SQRADD(a[1], a[1]); 
00823    COMBA_STORE(b[2]);
00824 
00825    /* output 3 */
00826    CARRY_FORWARD;
00827    SQRADD2(a[0], a[3]);    SQRADD2(a[1], a[2]); 
00828    COMBA_STORE(b[3]);
00829 
00830    /* output 4 */
00831    CARRY_FORWARD;
00832    SQRADD2(a[0], a[4]);    SQRADD2(a[1], a[3]);    SQRADD(a[2], a[2]); 
00833    COMBA_STORE(b[4]);
00834 
00835    /* output 5 */
00836    CARRY_FORWARD;
00837    SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB; 
00838    COMBA_STORE(b[5]);
00839 
00840    /* output 6 */
00841    CARRY_FORWARD;
00842    SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]); 
00843    COMBA_STORE(b[6]);
00844 
00845    /* output 7 */
00846    CARRY_FORWARD;
00847    SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB; 
00848    COMBA_STORE(b[7]);
00849 
00850    /* output 8 */
00851    CARRY_FORWARD;
00852    SQRADDSC(a[0], a[8]); SQRADDAC(a[1], a[7]); SQRADDAC(a[2], a[6]); SQRADDAC(a[3], a[5]); SQRADDDB; SQRADD(a[4], a[4]); 
00853    COMBA_STORE(b[8]);
00854 
00855    /* output 9 */
00856    CARRY_FORWARD;
00857    SQRADDSC(a[0], a[9]); SQRADDAC(a[1], a[8]); SQRADDAC(a[2], a[7]); SQRADDAC(a[3], a[6]); SQRADDAC(a[4], a[5]); SQRADDDB; 
00858    COMBA_STORE(b[9]);
00859 
00860    /* output 10 */
00861    CARRY_FORWARD;
00862    SQRADDSC(a[0], a[10]); SQRADDAC(a[1], a[9]); SQRADDAC(a[2], a[8]); SQRADDAC(a[3], a[7]); SQRADDAC(a[4], a[6]); SQRADDDB; SQRADD(a[5], a[5]); 
00863    COMBA_STORE(b[10]);
00864 
00865    /* output 11 */
00866    CARRY_FORWARD;
00867    SQRADDSC(a[0], a[11]); SQRADDAC(a[1], a[10]); SQRADDAC(a[2], a[9]); SQRADDAC(a[3], a[8]); SQRADDAC(a[4], a[7]); SQRADDAC(a[5], a[6]); SQRADDDB; 
00868    COMBA_STORE(b[11]);
00869 
00870    /* output 12 */
00871    CARRY_FORWARD;
00872    SQRADDSC(a[0], a[12]); SQRADDAC(a[1], a[11]); SQRADDAC(a[2], a[10]); SQRADDAC(a[3], a[9]); SQRADDAC(a[4], a[8]); SQRADDAC(a[5], a[7]); SQRADDDB; SQRADD(a[6], a[6]); 
00873    COMBA_STORE(b[12]);
00874 
00875    /* output 13 */
00876    CARRY_FORWARD;
00877    SQRADDSC(a[0], a[13]); SQRADDAC(a[1], a[12]); SQRADDAC(a[2], a[11]); SQRADDAC(a[3], a[10]); SQRADDAC(a[4], a[9]); SQRADDAC(a[5], a[8]); SQRADDAC(a[6], a[7]); SQRADDDB; 
00878    COMBA_STORE(b[13]);
00879 
00880    /* output 14 */
00881    CARRY_FORWARD;
00882    SQRADDSC(a[0], a[14]); SQRADDAC(a[1], a[13]); SQRADDAC(a[2], a[12]); SQRADDAC(a[3], a[11]); SQRADDAC(a[4], a[10]); SQRADDAC(a[5], a[9]); SQRADDAC(a[6], a[8]); SQRADDDB; SQRADD(a[7], a[7]); 
00883    COMBA_STORE(b[14]);
00884 
00885    /* output 15 */
00886    CARRY_FORWARD;
00887    SQRADDSC(a[0], a[15]); SQRADDAC(a[1], a[14]); SQRADDAC(a[2], a[13]); SQRADDAC(a[3], a[12]); SQRADDAC(a[4], a[11]); SQRADDAC(a[5], a[10]); SQRADDAC(a[6], a[9]); SQRADDAC(a[7], a[8]); SQRADDDB; 
00888    COMBA_STORE(b[15]);
00889 
00890    /* output 16 */
00891    CARRY_FORWARD;
00892    SQRADDSC(a[1], a[15]); SQRADDAC(a[2], a[14]); SQRADDAC(a[3], a[13]); SQRADDAC(a[4], a[12]); SQRADDAC(a[5], a[11]); SQRADDAC(a[6], a[10]); SQRADDAC(a[7], a[9]); SQRADDDB; SQRADD(a[8], a[8]); 
00893    COMBA_STORE(b[16]);
00894 
00895    /* output 17 */
00896    CARRY_FORWARD;
00897    SQRADDSC(a[2], a[15]); SQRADDAC(a[3], a[14]); SQRADDAC(a[4], a[13]); SQRADDAC(a[5], a[12]); SQRADDAC(a[6], a[11]); SQRADDAC(a[7], a[10]); SQRADDAC(a[8], a[9]); SQRADDDB; 
00898    COMBA_STORE(b[17]);
00899 
00900    /* output 18 */
00901    CARRY_FORWARD;
00902    SQRADDSC(a[3], a[15]); SQRADDAC(a[4], a[14]); SQRADDAC(a[5], a[13]); SQRADDAC(a[6], a[12]); SQRADDAC(a[7], a[11]); SQRADDAC(a[8], a[10]); SQRADDDB; SQRADD(a[9], a[9]); 
00903    COMBA_STORE(b[18]);
00904 
00905    /* output 19 */
00906    CARRY_FORWARD;
00907    SQRADDSC(a[4], a[15]); SQRADDAC(a[5], a[14]); SQRADDAC(a[6], a[13]); SQRADDAC(a[7], a[12]); SQRADDAC(a[8], a[11]); SQRADDAC(a[9], a[10]); SQRADDDB; 
00908    COMBA_STORE(b[19]);
00909 
00910    /* output 20 */
00911    CARRY_FORWARD;
00912    SQRADDSC(a[5], a[15]); SQRADDAC(a[6], a[14]); SQRADDAC(a[7], a[13]); SQRADDAC(a[8], a[12]); SQRADDAC(a[9], a[11]); SQRADDDB; SQRADD(a[10], a[10]); 
00913    COMBA_STORE(b[20]);
00914 
00915    /* output 21 */
00916    CARRY_FORWARD;
00917    SQRADDSC(a[6], a[15]); SQRADDAC(a[7], a[14]); SQRADDAC(a[8], a[13]); SQRADDAC(a[9], a[12]); SQRADDAC(a[10], a[11]); SQRADDDB; 
00918    COMBA_STORE(b[21]);
00919 
00920    /* output 22 */
00921    CARRY_FORWARD;
00922    SQRADDSC(a[7], a[15]); SQRADDAC(a[8], a[14]); SQRADDAC(a[9], a[13]); SQRADDAC(a[10], a[12]); SQRADDDB; SQRADD(a[11], a[11]); 
00923    COMBA_STORE(b[22]);
00924 
00925    /* output 23 */
00926    CARRY_FORWARD;
00927    SQRADDSC(a[8], a[15]); SQRADDAC(a[9], a[14]); SQRADDAC(a[10], a[13]); SQRADDAC(a[11], a[12]); SQRADDDB; 
00928    COMBA_STORE(b[23]);
00929 
00930    /* output 24 */
00931    CARRY_FORWARD;
00932    SQRADDSC(a[9], a[15]); SQRADDAC(a[10], a[14]); SQRADDAC(a[11], a[13]); SQRADDDB; SQRADD(a[12], a[12]); 
00933    COMBA_STORE(b[24]);
00934 
00935    /* output 25 */
00936    CARRY_FORWARD;
00937    SQRADDSC(a[10], a[15]); SQRADDAC(a[11], a[14]); SQRADDAC(a[12], a[13]); SQRADDDB; 
00938    COMBA_STORE(b[25]);
00939 
00940    /* output 26 */
00941    CARRY_FORWARD;
00942    SQRADD2(a[11], a[15]);    SQRADD2(a[12], a[14]);    SQRADD(a[13], a[13]); 
00943    COMBA_STORE(b[26]);
00944 
00945    /* output 27 */
00946    CARRY_FORWARD;
00947    SQRADD2(a[12], a[15]);    SQRADD2(a[13], a[14]); 
00948    COMBA_STORE(b[27]);
00949 
00950    /* output 28 */
00951    CARRY_FORWARD;
00952    SQRADD2(a[13], a[15]);    SQRADD(a[14], a[14]); 
00953    COMBA_STORE(b[28]);
00954 
00955    /* output 29 */
00956    CARRY_FORWARD;
00957    SQRADD2(a[14], a[15]); 
00958    COMBA_STORE(b[29]);
00959 
00960    /* output 30 */
00961    CARRY_FORWARD;
00962    SQRADD(a[15], a[15]); 
00963    COMBA_STORE(b[30]);
00964    COMBA_STORE2(b[31]);
00965    COMBA_FINI;
00966 
00967    B->used = 32;
00968    B->sign = ZPOS;
00969    memcpy(B->dp, b, 32 * sizeof(mp_digit));
00970    mp_clamp(B);
00971 }
00972 
00973 
00974 void s_mp_sqr_comba_32(const mp_int *A, mp_int *B)
00975 {
00976    mp_digit *a, b[64], c0, c1, c2, sc0, sc1, sc2;
00977    /* get rid of some compiler warnings */
00978    sc0 = 0; sc1 = 0; sc2 = 0;
00979 
00980    a = A->dp;
00981    COMBA_START; 
00982 
00983    /* clear carries */
00984    CLEAR_CARRY;
00985 
00986    /* output 0 */
00987    SQRADD(a[0],a[0]);
00988    COMBA_STORE(b[0]);
00989 
00990    /* output 1 */
00991    CARRY_FORWARD;
00992    SQRADD2(a[0], a[1]); 
00993    COMBA_STORE(b[1]);
00994 
00995    /* output 2 */
00996    CARRY_FORWARD;
00997    SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]); 
00998    COMBA_STORE(b[2]);
00999 
01000    /* output 3 */
01001    CARRY_FORWARD;
01002    SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]); 
01003    COMBA_STORE(b[3]);
01004 
01005    /* output 4 */
01006    CARRY_FORWARD;
01007    SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]); 
01008    COMBA_STORE(b[4]);
01009 
01010    /* output 5 */
01011    CARRY_FORWARD;
01012    SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB; 
01013    COMBA_STORE(b[5]);
01014 
01015    /* output 6 */
01016    CARRY_FORWARD;
01017    SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]); 
01018    COMBA_STORE(b[6]);
01019 
01020    /* output 7 */
01021    CARRY_FORWARD;
01022    SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB; 
01023    COMBA_STORE(b[7]);
01024 
01025    /* output 8 */
01026    CARRY_FORWARD;
01027    SQRADDSC(a[0], a[8]); SQRADDAC(a[1], a[7]); SQRADDAC(a[2], a[6]); SQRADDAC(a[3], a[5]); SQRADDDB; SQRADD(a[4], a[4]); 
01028    COMBA_STORE(b[8]);
01029 
01030    /* output 9 */
01031    CARRY_FORWARD;
01032    SQRADDSC(a[0], a[9]); SQRADDAC(a[1], a[8]); SQRADDAC(a[2], a[7]); SQRADDAC(a[3], a[6]); SQRADDAC(a[4], a[5]); SQRADDDB; 
01033    COMBA_STORE(b[9]);
01034 
01035    /* output 10 */
01036    CARRY_FORWARD;
01037    SQRADDSC(a[0], a[10]); SQRADDAC(a[1], a[9]); SQRADDAC(a[2], a[8]); SQRADDAC(a[3], a[7]); SQRADDAC(a[4], a[6]); SQRADDDB; SQRADD(a[5], a[5]); 
01038    COMBA_STORE(b[10]);
01039 
01040    /* output 11 */
01041    CARRY_FORWARD;
01042    SQRADDSC(a[0], a[11]); SQRADDAC(a[1], a[10]); SQRADDAC(a[2], a[9]); SQRADDAC(a[3], a[8]); SQRADDAC(a[4], a[7]); SQRADDAC(a[5], a[6]); SQRADDDB; 
01043    COMBA_STORE(b[11]);
01044 
01045    /* output 12 */
01046    CARRY_FORWARD;
01047    SQRADDSC(a[0], a[12]); SQRADDAC(a[1], a[11]); SQRADDAC(a[2], a[10]); SQRADDAC(a[3], a[9]); SQRADDAC(a[4], a[8]); SQRADDAC(a[5], a[7]); SQRADDDB; SQRADD(a[6], a[6]); 
01048    COMBA_STORE(b[12]);
01049 
01050    /* output 13 */
01051    CARRY_FORWARD;
01052    SQRADDSC(a[0], a[13]); SQRADDAC(a[1], a[12]); SQRADDAC(a[2], a[11]); SQRADDAC(a[3], a[10]); SQRADDAC(a[4], a[9]); SQRADDAC(a[5], a[8]); SQRADDAC(a[6], a[7]); SQRADDDB; 
01053    COMBA_STORE(b[13]);
01054 
01055    /* output 14 */
01056    CARRY_FORWARD;
01057    SQRADDSC(a[0], a[14]); SQRADDAC(a[1], a[13]); SQRADDAC(a[2], a[12]); SQRADDAC(a[3], a[11]); SQRADDAC(a[4], a[10]); SQRADDAC(a[5], a[9]); SQRADDAC(a[6], a[8]); SQRADDDB; SQRADD(a[7], a[7]); 
01058    COMBA_STORE(b[14]);
01059 
01060    /* output 15 */
01061    CARRY_FORWARD;
01062    SQRADDSC(a[0], a[15]); SQRADDAC(a[1], a[14]); SQRADDAC(a[2], a[13]); SQRADDAC(a[3], a[12]); SQRADDAC(a[4], a[11]); SQRADDAC(a[5], a[10]); SQRADDAC(a[6], a[9]); SQRADDAC(a[7], a[8]); SQRADDDB; 
01063    COMBA_STORE(b[15]);
01064 
01065    /* output 16 */
01066    CARRY_FORWARD;
01067    SQRADDSC(a[0], a[16]); SQRADDAC(a[1], a[15]); SQRADDAC(a[2], a[14]); SQRADDAC(a[3], a[13]); SQRADDAC(a[4], a[12]); SQRADDAC(a[5], a[11]); SQRADDAC(a[6], a[10]); SQRADDAC(a[7], a[9]); SQRADDDB; SQRADD(a[8], a[8]); 
01068    COMBA_STORE(b[16]);
01069 
01070    /* output 17 */
01071    CARRY_FORWARD;
01072    SQRADDSC(a[0], a[17]); SQRADDAC(a[1], a[16]); SQRADDAC(a[2], a[15]); SQRADDAC(a[3], a[14]); SQRADDAC(a[4], a[13]); SQRADDAC(a[5], a[12]); SQRADDAC(a[6], a[11]); SQRADDAC(a[7], a[10]); SQRADDAC(a[8], a[9]); SQRADDDB; 
01073    COMBA_STORE(b[17]);
01074 
01075    /* output 18 */
01076    CARRY_FORWARD;
01077    SQRADDSC(a[0], a[18]); SQRADDAC(a[1], a[17]); SQRADDAC(a[2], a[16]); SQRADDAC(a[3], a[15]); SQRADDAC(a[4], a[14]); SQRADDAC(a[5], a[13]); SQRADDAC(a[6], a[12]); SQRADDAC(a[7], a[11]); SQRADDAC(a[8], a[10]); SQRADDDB; SQRADD(a[9], a[9]); 
01078    COMBA_STORE(b[18]);
01079 
01080    /* output 19 */
01081    CARRY_FORWARD;
01082    SQRADDSC(a[0], a[19]); SQRADDAC(a[1], a[18]); SQRADDAC(a[2], a[17]); SQRADDAC(a[3], a[16]); SQRADDAC(a[4], a[15]); SQRADDAC(a[5], a[14]); SQRADDAC(a[6], a[13]); SQRADDAC(a[7], a[12]); SQRADDAC(a[8], a[11]); SQRADDAC(a[9], a[10]); SQRADDDB; 
01083    COMBA_STORE(b[19]);
01084 
01085    /* output 20 */
01086    CARRY_FORWARD;
01087    SQRADDSC(a[0], a[20]); SQRADDAC(a[1], a[19]); SQRADDAC(a[2], a[18]); SQRADDAC(a[3], a[17]); SQRADDAC(a[4], a[16]); SQRADDAC(a[5], a[15]); SQRADDAC(a[6], a[14]); SQRADDAC(a[7], a[13]); SQRADDAC(a[8], a[12]); SQRADDAC(a[9], a[11]); SQRADDDB; SQRADD(a[10], a[10]); 
01088    COMBA_STORE(b[20]);
01089 
01090    /* output 21 */
01091    CARRY_FORWARD;
01092    SQRADDSC(a[0], a[21]); SQRADDAC(a[1], a[20]); SQRADDAC(a[2], a[19]); SQRADDAC(a[3], a[18]); SQRADDAC(a[4], a[17]); SQRADDAC(a[5], a[16]); SQRADDAC(a[6], a[15]); SQRADDAC(a[7], a[14]); SQRADDAC(a[8], a[13]); SQRADDAC(a[9], a[12]); SQRADDAC(a[10], a[11]); SQRADDDB; 
01093    COMBA_STORE(b[21]);
01094 
01095    /* output 22 */
01096    CARRY_FORWARD;
01097    SQRADDSC(a[0], a[22]); SQRADDAC(a[1], a[21]); SQRADDAC(a[2], a[20]); SQRADDAC(a[3], a[19]); SQRADDAC(a[4], a[18]); SQRADDAC(a[5], a[17]); SQRADDAC(a[6], a[16]); SQRADDAC(a[7], a[15]); SQRADDAC(a[8], a[14]); SQRADDAC(a[9], a[13]); SQRADDAC(a[10], a[12]); SQRADDDB; SQRADD(a[11], a[11]); 
01098    COMBA_STORE(b[22]);
01099 
01100    /* output 23 */
01101    CARRY_FORWARD;
01102    SQRADDSC(a[0], a[23]); SQRADDAC(a[1], a[22]); SQRADDAC(a[2], a[21]); SQRADDAC(a[3], a[20]); SQRADDAC(a[4], a[19]); SQRADDAC(a[5], a[18]); SQRADDAC(a[6], a[17]); SQRADDAC(a[7], a[16]); SQRADDAC(a[8], a[15]); SQRADDAC(a[9], a[14]); SQRADDAC(a[10], a[13]); SQRADDAC(a[11], a[12]); SQRADDDB; 
01103    COMBA_STORE(b[23]);
01104 
01105    /* output 24 */
01106    CARRY_FORWARD;
01107    SQRADDSC(a[0], a[24]); SQRADDAC(a[1], a[23]); SQRADDAC(a[2], a[22]); SQRADDAC(a[3], a[21]); SQRADDAC(a[4], a[20]); SQRADDAC(a[5], a[19]); SQRADDAC(a[6], a[18]); SQRADDAC(a[7], a[17]); SQRADDAC(a[8], a[16]); SQRADDAC(a[9], a[15]); SQRADDAC(a[10], a[14]); SQRADDAC(a[11], a[13]); SQRADDDB; SQRADD(a[12], a[12]); 
01108    COMBA_STORE(b[24]);
01109 
01110    /* output 25 */
01111    CARRY_FORWARD;
01112    SQRADDSC(a[0], a[25]); SQRADDAC(a[1], a[24]); SQRADDAC(a[2], a[23]); SQRADDAC(a[3], a[22]); SQRADDAC(a[4], a[21]); SQRADDAC(a[5], a[20]); SQRADDAC(a[6], a[19]); SQRADDAC(a[7], a[18]); SQRADDAC(a[8], a[17]); SQRADDAC(a[9], a[16]); SQRADDAC(a[10], a[15]); SQRADDAC(a[11], a[14]); SQRADDAC(a[12], a[13]); SQRADDDB; 
01113    COMBA_STORE(b[25]);
01114 
01115    /* output 26 */
01116    CARRY_FORWARD;
01117    SQRADDSC(a[0], a[26]); SQRADDAC(a[1], a[25]); SQRADDAC(a[2], a[24]); SQRADDAC(a[3], a[23]); SQRADDAC(a[4], a[22]); SQRADDAC(a[5], a[21]); SQRADDAC(a[6], a[20]); SQRADDAC(a[7], a[19]); SQRADDAC(a[8], a[18]); SQRADDAC(a[9], a[17]); SQRADDAC(a[10], a[16]); SQRADDAC(a[11], a[15]); SQRADDAC(a[12], a[14]); SQRADDDB; SQRADD(a[13], a[13]); 
01118    COMBA_STORE(b[26]);
01119 
01120    /* output 27 */
01121    CARRY_FORWARD;
01122    SQRADDSC(a[0], a[27]); SQRADDAC(a[1], a[26]); SQRADDAC(a[2], a[25]); SQRADDAC(a[3], a[24]); SQRADDAC(a[4], a[23]); SQRADDAC(a[5], a[22]); SQRADDAC(a[6], a[21]); SQRADDAC(a[7], a[20]); SQRADDAC(a[8], a[19]); SQRADDAC(a[9], a[18]); SQRADDAC(a[10], a[17]); SQRADDAC(a[11], a[16]); SQRADDAC(a[12], a[15]); SQRADDAC(a[13], a[14]); SQRADDDB; 
01123    COMBA_STORE(b[27]);
01124 
01125    /* output 28 */
01126    CARRY_FORWARD;
01127    SQRADDSC(a[0], a[28]); SQRADDAC(a[1], a[27]); SQRADDAC(a[2], a[26]); SQRADDAC(a[3], a[25]); SQRADDAC(a[4], a[24]); SQRADDAC(a[5], a[23]); SQRADDAC(a[6], a[22]); SQRADDAC(a[7], a[21]); SQRADDAC(a[8], a[20]); SQRADDAC(a[9], a[19]); SQRADDAC(a[10], a[18]); SQRADDAC(a[11], a[17]); SQRADDAC(a[12], a[16]); SQRADDAC(a[13], a[15]); SQRADDDB; SQRADD(a[14], a[14]); 
01128    COMBA_STORE(b[28]);
01129 
01130    /* output 29 */
01131    CARRY_FORWARD;
01132    SQRADDSC(a[0], a[29]); SQRADDAC(a[1], a[28]); SQRADDAC(a[2], a[27]); SQRADDAC(a[3], a[26]); SQRADDAC(a[4], a[25]); SQRADDAC(a[5], a[24]); SQRADDAC(a[6], a[23]); SQRADDAC(a[7], a[22]); SQRADDAC(a[8], a[21]); SQRADDAC(a[9], a[20]); SQRADDAC(a[10], a[19]); SQRADDAC(a[11], a[18]); SQRADDAC(a[12], a[17]); SQRADDAC(a[13], a[16]); SQRADDAC(a[14], a[15]); SQRADDDB; 
01133    COMBA_STORE(b[29]);
01134 
01135    /* output 30 */
01136    CARRY_FORWARD;
01137    SQRADDSC(a[0], a[30]); SQRADDAC(a[1], a[29]); SQRADDAC(a[2], a[28]); SQRADDAC(a[3], a[27]); SQRADDAC(a[4], a[26]); SQRADDAC(a[5], a[25]); SQRADDAC(a[6], a[24]); SQRADDAC(a[7], a[23]); SQRADDAC(a[8], a[22]); SQRADDAC(a[9], a[21]); SQRADDAC(a[10], a[20]); SQRADDAC(a[11], a[19]); SQRADDAC(a[12], a[18]); SQRADDAC(a[13], a[17]); SQRADDAC(a[14], a[16]); SQRADDDB; SQRADD(a[15], a[15]); 
01138    COMBA_STORE(b[30]);
01139 
01140    /* output 31 */
01141    CARRY_FORWARD;
01142    SQRADDSC(a[0], a[31]); SQRADDAC(a[1], a[30]); SQRADDAC(a[2], a[29]); SQRADDAC(a[3], a[28]); SQRADDAC(a[4], a[27]); SQRADDAC(a[5], a[26]); SQRADDAC(a[6], a[25]); SQRADDAC(a[7], a[24]); SQRADDAC(a[8], a[23]); SQRADDAC(a[9], a[22]); SQRADDAC(a[10], a[21]); SQRADDAC(a[11], a[20]); SQRADDAC(a[12], a[19]); SQRADDAC(a[13], a[18]); SQRADDAC(a[14], a[17]); SQRADDAC(a[15], a[16]); SQRADDDB; 
01143    COMBA_STORE(b[31]);
01144 
01145    /* output 32 */
01146    CARRY_FORWARD;
01147    SQRADDSC(a[1], a[31]); SQRADDAC(a[2], a[30]); SQRADDAC(a[3], a[29]); SQRADDAC(a[4], a[28]); SQRADDAC(a[5], a[27]); SQRADDAC(a[6], a[26]); SQRADDAC(a[7], a[25]); SQRADDAC(a[8], a[24]); SQRADDAC(a[9], a[23]); SQRADDAC(a[10], a[22]); SQRADDAC(a[11], a[21]); SQRADDAC(a[12], a[20]); SQRADDAC(a[13], a[19]); SQRADDAC(a[14], a[18]); SQRADDAC(a[15], a[17]); SQRADDDB; SQRADD(a[16], a[16]); 
01148    COMBA_STORE(b[32]);
01149 
01150    /* output 33 */
01151    CARRY_FORWARD;
01152    SQRADDSC(a[2], a[31]); SQRADDAC(a[3], a[30]); SQRADDAC(a[4], a[29]); SQRADDAC(a[5], a[28]); SQRADDAC(a[6], a[27]); SQRADDAC(a[7], a[26]); SQRADDAC(a[8], a[25]); SQRADDAC(a[9], a[24]); SQRADDAC(a[10], a[23]); SQRADDAC(a[11], a[22]); SQRADDAC(a[12], a[21]); SQRADDAC(a[13], a[20]); SQRADDAC(a[14], a[19]); SQRADDAC(a[15], a[18]); SQRADDAC(a[16], a[17]); SQRADDDB; 
01153    COMBA_STORE(b[33]);
01154 
01155    /* output 34 */
01156    CARRY_FORWARD;
01157    SQRADDSC(a[3], a[31]); SQRADDAC(a[4], a[30]); SQRADDAC(a[5], a[29]); SQRADDAC(a[6], a[28]); SQRADDAC(a[7], a[27]); SQRADDAC(a[8], a[26]); SQRADDAC(a[9], a[25]); SQRADDAC(a[10], a[24]); SQRADDAC(a[11], a[23]); SQRADDAC(a[12], a[22]); SQRADDAC(a[13], a[21]); SQRADDAC(a[14], a[20]); SQRADDAC(a[15], a[19]); SQRADDAC(a[16], a[18]); SQRADDDB; SQRADD(a[17], a[17]); 
01158    COMBA_STORE(b[34]);
01159 
01160    /* output 35 */
01161    CARRY_FORWARD;
01162    SQRADDSC(a[4], a[31]); SQRADDAC(a[5], a[30]); SQRADDAC(a[6], a[29]); SQRADDAC(a[7], a[28]); SQRADDAC(a[8], a[27]); SQRADDAC(a[9], a[26]); SQRADDAC(a[10], a[25]); SQRADDAC(a[11], a[24]); SQRADDAC(a[12], a[23]); SQRADDAC(a[13], a[22]); SQRADDAC(a[14], a[21]); SQRADDAC(a[15], a[20]); SQRADDAC(a[16], a[19]); SQRADDAC(a[17], a[18]); SQRADDDB; 
01163    COMBA_STORE(b[35]);
01164 
01165    /* output 36 */
01166    CARRY_FORWARD;
01167    SQRADDSC(a[5], a[31]); SQRADDAC(a[6], a[30]); SQRADDAC(a[7], a[29]); SQRADDAC(a[8], a[28]); SQRADDAC(a[9], a[27]); SQRADDAC(a[10], a[26]); SQRADDAC(a[11], a[25]); SQRADDAC(a[12], a[24]); SQRADDAC(a[13], a[23]); SQRADDAC(a[14], a[22]); SQRADDAC(a[15], a[21]); SQRADDAC(a[16], a[20]); SQRADDAC(a[17], a[19]); SQRADDDB; SQRADD(a[18], a[18]); 
01168    COMBA_STORE(b[36]);
01169 
01170    /* output 37 */
01171    CARRY_FORWARD;
01172    SQRADDSC(a[6], a[31]); SQRADDAC(a[7], a[30]); SQRADDAC(a[8], a[29]); SQRADDAC(a[9], a[28]); SQRADDAC(a[10], a[27]); SQRADDAC(a[11], a[26]); SQRADDAC(a[12], a[25]); SQRADDAC(a[13], a[24]); SQRADDAC(a[14], a[23]); SQRADDAC(a[15], a[22]); SQRADDAC(a[16], a[21]); SQRADDAC(a[17], a[20]); SQRADDAC(a[18], a[19]); SQRADDDB; 
01173    COMBA_STORE(b[37]);
01174 
01175    /* output 38 */
01176    CARRY_FORWARD;
01177    SQRADDSC(a[7], a[31]); SQRADDAC(a[8], a[30]); SQRADDAC(a[9], a[29]); SQRADDAC(a[10], a[28]); SQRADDAC(a[11], a[27]); SQRADDAC(a[12], a[26]); SQRADDAC(a[13], a[25]); SQRADDAC(a[14], a[24]); SQRADDAC(a[15], a[23]); SQRADDAC(a[16], a[22]); SQRADDAC(a[17], a[21]); SQRADDAC(a[18], a[20]); SQRADDDB; SQRADD(a[19], a[19]); 
01178    COMBA_STORE(b[38]);
01179 
01180    /* output 39 */
01181    CARRY_FORWARD;
01182    SQRADDSC(a[8], a[31]); SQRADDAC(a[9], a[30]); SQRADDAC(a[10], a[29]); SQRADDAC(a[11], a[28]); SQRADDAC(a[12], a[27]); SQRADDAC(a[13], a[26]); SQRADDAC(a[14], a[25]); SQRADDAC(a[15], a[24]); SQRADDAC(a[16], a[23]); SQRADDAC(a[17], a[22]); SQRADDAC(a[18], a[21]); SQRADDAC(a[19], a[20]); SQRADDDB; 
01183    COMBA_STORE(b[39]);
01184 
01185    /* output 40 */
01186    CARRY_FORWARD;
01187    SQRADDSC(a[9], a[31]); SQRADDAC(a[10], a[30]); SQRADDAC(a[11], a[29]); SQRADDAC(a[12], a[28]); SQRADDAC(a[13], a[27]); SQRADDAC(a[14], a[26]); SQRADDAC(a[15], a[25]); SQRADDAC(a[16], a[24]); SQRADDAC(a[17], a[23]); SQRADDAC(a[18], a[22]); SQRADDAC(a[19], a[21]); SQRADDDB; SQRADD(a[20], a[20]); 
01188    COMBA_STORE(b[40]);
01189 
01190    /* output 41 */
01191    CARRY_FORWARD;
01192    SQRADDSC(a[10], a[31]); SQRADDAC(a[11], a[30]); SQRADDAC(a[12], a[29]); SQRADDAC(a[13], a[28]); SQRADDAC(a[14], a[27]); SQRADDAC(a[15], a[26]); SQRADDAC(a[16], a[25]); SQRADDAC(a[17], a[24]); SQRADDAC(a[18], a[23]); SQRADDAC(a[19], a[22]); SQRADDAC(a[20], a[21]); SQRADDDB; 
01193    COMBA_STORE(b[41]);
01194 
01195    /* output 42 */
01196    CARRY_FORWARD;
01197    SQRADDSC(a[11], a[31]); SQRADDAC(a[12], a[30]); SQRADDAC(a[13], a[29]); SQRADDAC(a[14], a[28]); SQRADDAC(a[15], a[27]); SQRADDAC(a[16], a[26]); SQRADDAC(a[17], a[25]); SQRADDAC(a[18], a[24]); SQRADDAC(a[19], a[23]); SQRADDAC(a[20], a[22]); SQRADDDB; SQRADD(a[21], a[21]); 
01198    COMBA_STORE(b[42]);
01199 
01200    /* output 43 */
01201    CARRY_FORWARD;
01202    SQRADDSC(a[12], a[31]); SQRADDAC(a[13], a[30]); SQRADDAC(a[14], a[29]); SQRADDAC(a[15], a[28]); SQRADDAC(a[16], a[27]); SQRADDAC(a[17], a[26]); SQRADDAC(a[18], a[25]); SQRADDAC(a[19], a[24]); SQRADDAC(a[20], a[23]); SQRADDAC(a[21], a[22]); SQRADDDB; 
01203    COMBA_STORE(b[43]);
01204 
01205    /* output 44 */
01206    CARRY_FORWARD;
01207    SQRADDSC(a[13], a[31]); SQRADDAC(a[14], a[30]); SQRADDAC(a[15], a[29]); SQRADDAC(a[16], a[28]); SQRADDAC(a[17], a[27]); SQRADDAC(a[18], a[26]); SQRADDAC(a[19], a[25]); SQRADDAC(a[20], a[24]); SQRADDAC(a[21], a[23]); SQRADDDB; SQRADD(a[22], a[22]); 
01208    COMBA_STORE(b[44]);
01209 
01210    /* output 45 */
01211    CARRY_FORWARD;
01212    SQRADDSC(a[14], a[31]); SQRADDAC(a[15], a[30]); SQRADDAC(a[16], a[29]); SQRADDAC(a[17], a[28]); SQRADDAC(a[18], a[27]); SQRADDAC(a[19], a[26]); SQRADDAC(a[20], a[25]); SQRADDAC(a[21], a[24]); SQRADDAC(a[22], a[23]); SQRADDDB; 
01213    COMBA_STORE(b[45]);
01214 
01215    /* output 46 */
01216    CARRY_FORWARD;
01217    SQRADDSC(a[15], a[31]); SQRADDAC(a[16], a[30]); SQRADDAC(a[17], a[29]); SQRADDAC(a[18], a[28]); SQRADDAC(a[19], a[27]); SQRADDAC(a[20], a[26]); SQRADDAC(a[21], a[25]); SQRADDAC(a[22], a[24]); SQRADDDB; SQRADD(a[23], a[23]); 
01218    COMBA_STORE(b[46]);
01219 
01220    /* output 47 */
01221    CARRY_FORWARD;
01222    SQRADDSC(a[16], a[31]); SQRADDAC(a[17], a[30]); SQRADDAC(a[18], a[29]); SQRADDAC(a[19], a[28]); SQRADDAC(a[20], a[27]); SQRADDAC(a[21], a[26]); SQRADDAC(a[22], a[25]); SQRADDAC(a[23], a[24]); SQRADDDB; 
01223    COMBA_STORE(b[47]);
01224 
01225    /* output 48 */
01226    CARRY_FORWARD;
01227    SQRADDSC(a[17], a[31]); SQRADDAC(a[18], a[30]); SQRADDAC(a[19], a[29]); SQRADDAC(a[20], a[28]); SQRADDAC(a[21], a[27]); SQRADDAC(a[22], a[26]); SQRADDAC(a[23], a[25]); SQRADDDB; SQRADD(a[24], a[24]); 
01228    COMBA_STORE(b[48]);
01229 
01230    /* output 49 */
01231    CARRY_FORWARD;
01232    SQRADDSC(a[18], a[31]); SQRADDAC(a[19], a[30]); SQRADDAC(a[20], a[29]); SQRADDAC(a[21], a[28]); SQRADDAC(a[22], a[27]); SQRADDAC(a[23], a[26]); SQRADDAC(a[24], a[25]); SQRADDDB; 
01233    COMBA_STORE(b[49]);
01234 
01235    /* output 50 */
01236    CARRY_FORWARD;
01237    SQRADDSC(a[19], a[31]); SQRADDAC(a[20], a[30]); SQRADDAC(a[21], a[29]); SQRADDAC(a[22], a[28]); SQRADDAC(a[23], a[27]); SQRADDAC(a[24], a[26]); SQRADDDB; SQRADD(a[25], a[25]); 
01238    COMBA_STORE(b[50]);
01239 
01240    /* output 51 */
01241    CARRY_FORWARD;
01242    SQRADDSC(a[20], a[31]); SQRADDAC(a[21], a[30]); SQRADDAC(a[22], a[29]); SQRADDAC(a[23], a[28]); SQRADDAC(a[24], a[27]); SQRADDAC(a[25], a[26]); SQRADDDB; 
01243    COMBA_STORE(b[51]);
01244 
01245    /* output 52 */
01246    CARRY_FORWARD;
01247    SQRADDSC(a[21], a[31]); SQRADDAC(a[22], a[30]); SQRADDAC(a[23], a[29]); SQRADDAC(a[24], a[28]); SQRADDAC(a[25], a[27]); SQRADDDB; SQRADD(a[26], a[26]); 
01248    COMBA_STORE(b[52]);
01249 
01250    /* output 53 */
01251    CARRY_FORWARD;
01252    SQRADDSC(a[22], a[31]); SQRADDAC(a[23], a[30]); SQRADDAC(a[24], a[29]); SQRADDAC(a[25], a[28]); SQRADDAC(a[26], a[27]); SQRADDDB; 
01253    COMBA_STORE(b[53]);
01254 
01255    /* output 54 */
01256    CARRY_FORWARD;
01257    SQRADDSC(a[23], a[31]); SQRADDAC(a[24], a[30]); SQRADDAC(a[25], a[29]); SQRADDAC(a[26], a[28]); SQRADDDB; SQRADD(a[27], a[27]); 
01258    COMBA_STORE(b[54]);
01259 
01260    /* output 55 */
01261    CARRY_FORWARD;
01262    SQRADDSC(a[24], a[31]); SQRADDAC(a[25], a[30]); SQRADDAC(a[26], a[29]); SQRADDAC(a[27], a[28]); SQRADDDB; 
01263    COMBA_STORE(b[55]);
01264 
01265    /* output 56 */
01266    CARRY_FORWARD;
01267    SQRADDSC(a[25], a[31]); SQRADDAC(a[26], a[30]); SQRADDAC(a[27], a[29]); SQRADDDB; SQRADD(a[28], a[28]); 
01268    COMBA_STORE(b[56]);
01269 
01270    /* output 57 */
01271    CARRY_FORWARD;
01272    SQRADDSC(a[26], a[31]); SQRADDAC(a[27], a[30]); SQRADDAC(a[28], a[29]); SQRADDDB; 
01273    COMBA_STORE(b[57]);
01274 
01275    /* output 58 */
01276    CARRY_FORWARD;
01277    SQRADD2(a[27], a[31]); SQRADD2(a[28], a[30]); SQRADD(a[29], a[29]); 
01278    COMBA_STORE(b[58]);
01279 
01280    /* output 59 */
01281    CARRY_FORWARD;
01282    SQRADD2(a[28], a[31]); SQRADD2(a[29], a[30]); 
01283    COMBA_STORE(b[59]);
01284 
01285    /* output 60 */
01286    CARRY_FORWARD;
01287    SQRADD2(a[29], a[31]); SQRADD(a[30], a[30]); 
01288    COMBA_STORE(b[60]);
01289 
01290    /* output 61 */
01291    CARRY_FORWARD;
01292    SQRADD2(a[30], a[31]); 
01293    COMBA_STORE(b[61]);
01294 
01295    /* output 62 */
01296    CARRY_FORWARD;
01297    SQRADD(a[31], a[31]); 
01298    COMBA_STORE(b[62]);
01299    COMBA_STORE2(b[63]);
01300    COMBA_FINI;
01301 
01302    B->used = 64;
01303    B->sign = ZPOS;
01304    memcpy(B->dp, b, 64 * sizeof(mp_digit));
01305    mp_clamp(B);
01306 }