1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/security/nss/lib/freebl/mpi/mp_comba.c Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,1298 @@
1.4 +/*
1.5 + * The below file is derived from TFM v0.03.
1.6 + * It contains code from fp_mul_comba.c and
1.7 + * fp_sqr_comba.c, which contained the following license.
1.8 + *
1.9 + * Right now, the assembly in this file limits
1.10 + * this code to AMD 64.
1.11 + *
1.12 + * This file is public domain.
1.13 + */
1.14 +
1.15 +/* TomsFastMath, a fast ISO C bignum library.
1.16 + *
1.17 + * This project is meant to fill in where LibTomMath
1.18 + * falls short. That is speed ;-)
1.19 + *
1.20 + * This project is public domain and free for all purposes.
1.21 + *
1.22 + * Tom St Denis, tomstdenis@iahu.ca
1.23 + */
1.24 +
1.25 +
1.26 +#include "mpi-priv.h"
1.27 +
1.28 +
1.29 +
1.30 +/* clamp digits */
1.31 +#define mp_clamp(a) { while ((a)->used && (a)->dp[(a)->used-1] == 0) --((a)->used); (a)->sign = (a)->used ? (a)->sign : ZPOS; }
1.32 +
1.33 +/* anything you need at the start */
1.34 +#define COMBA_START
1.35 +
1.36 +/* clear the chaining variables */
1.37 +#define COMBA_CLEAR \
1.38 + c0 = c1 = c2 = 0;
1.39 +
1.40 +/* forward the carry to the next digit */
1.41 +#define COMBA_FORWARD \
1.42 + do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1.43 +
1.44 +/* anything you need at the end */
1.45 +#define COMBA_FINI
1.46 +
1.47 +/* this should multiply i and j */
1.48 +#define MULADD(i, j) \
1.49 +__asm__ ( \
1.50 + "movq %6,%%rax \n\t" \
1.51 + "mulq %7 \n\t" \
1.52 + "addq %%rax,%0 \n\t" \
1.53 + "adcq %%rdx,%1 \n\t" \
1.54 + "adcq $0,%2 \n\t" \
1.55 + :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j) :"%rax","%rdx","cc");
1.56 +
1.57 +
1.58 +
1.59 +
1.60 +/* sqr macros only */
1.61 +#define CLEAR_CARRY \
1.62 + c0 = c1 = c2 = 0;
1.63 +
1.64 +#define COMBA_STORE(x) \
1.65 + x = c0;
1.66 +
1.67 +#define COMBA_STORE2(x) \
1.68 + x = c1;
1.69 +
1.70 +#define CARRY_FORWARD \
1.71 + do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1.72 +
1.73 +#define COMBA_FINI
1.74 +
1.75 +#define SQRADD(i, j) \
1.76 +__asm__ ( \
1.77 + "movq %6,%%rax \n\t" \
1.78 + "mulq %%rax \n\t" \
1.79 + "addq %%rax,%0 \n\t" \
1.80 + "adcq %%rdx,%1 \n\t" \
1.81 + "adcq $0,%2 \n\t" \
1.82 + :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i) :"%rax","%rdx","cc");
1.83 +
1.84 +#define SQRADD2(i, j) \
1.85 +__asm__ ( \
1.86 + "movq %6,%%rax \n\t" \
1.87 + "mulq %7 \n\t" \
1.88 + "addq %%rax,%0 \n\t" \
1.89 + "adcq %%rdx,%1 \n\t" \
1.90 + "adcq $0,%2 \n\t" \
1.91 + "addq %%rax,%0 \n\t" \
1.92 + "adcq %%rdx,%1 \n\t" \
1.93 + "adcq $0,%2 \n\t" \
1.94 + :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j) :"%rax","%rdx","cc");
1.95 +
1.96 +#define SQRADDSC(i, j) \
1.97 +__asm__ ( \
1.98 + "movq %3,%%rax \n\t" \
1.99 + "mulq %4 \n\t" \
1.100 + "movq %%rax,%0 \n\t" \
1.101 + "movq %%rdx,%1 \n\t" \
1.102 + "xorq %2,%2 \n\t" \
1.103 + :"=r"(sc0), "=r"(sc1), "=r"(sc2): "g"(i), "g"(j) :"%rax","%rdx","cc");
1.104 +
1.105 +#define SQRADDAC(i, j) \
1.106 +__asm__ ( \
1.107 + "movq %6,%%rax \n\t" \
1.108 + "mulq %7 \n\t" \
1.109 + "addq %%rax,%0 \n\t" \
1.110 + "adcq %%rdx,%1 \n\t" \
1.111 + "adcq $0,%2 \n\t" \
1.112 + :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%rax","%rdx","cc");
1.113 +
1.114 +#define SQRADDDB \
1.115 +__asm__ ( \
1.116 + "addq %6,%0 \n\t" \
1.117 + "adcq %7,%1 \n\t" \
1.118 + "adcq %8,%2 \n\t" \
1.119 + "addq %6,%0 \n\t" \
1.120 + "adcq %7,%1 \n\t" \
1.121 + "adcq %8,%2 \n\t" \
1.122 + :"=&r"(c0), "=&r"(c1), "=&r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "cc");
1.123 +
1.124 +
1.125 +
1.126 +
1.127 +
1.128 +void s_mp_mul_comba_4(const mp_int *A, const mp_int *B, mp_int *C)
1.129 +{
1.130 + mp_digit c0, c1, c2, at[8];
1.131 +
1.132 + memcpy(at, A->dp, 4 * sizeof(mp_digit));
1.133 + memcpy(at+4, B->dp, 4 * sizeof(mp_digit));
1.134 + COMBA_START;
1.135 +
1.136 + COMBA_CLEAR;
1.137 + /* 0 */
1.138 + MULADD(at[0], at[4]);
1.139 + COMBA_STORE(C->dp[0]);
1.140 + /* 1 */
1.141 + COMBA_FORWARD;
1.142 + MULADD(at[0], at[5]); MULADD(at[1], at[4]);
1.143 + COMBA_STORE(C->dp[1]);
1.144 + /* 2 */
1.145 + COMBA_FORWARD;
1.146 + MULADD(at[0], at[6]); MULADD(at[1], at[5]); MULADD(at[2], at[4]);
1.147 + COMBA_STORE(C->dp[2]);
1.148 + /* 3 */
1.149 + COMBA_FORWARD;
1.150 + MULADD(at[0], at[7]); MULADD(at[1], at[6]); MULADD(at[2], at[5]); MULADD(at[3], at[4]);
1.151 + COMBA_STORE(C->dp[3]);
1.152 + /* 4 */
1.153 + COMBA_FORWARD;
1.154 + MULADD(at[1], at[7]); MULADD(at[2], at[6]); MULADD(at[3], at[5]);
1.155 + COMBA_STORE(C->dp[4]);
1.156 + /* 5 */
1.157 + COMBA_FORWARD;
1.158 + MULADD(at[2], at[7]); MULADD(at[3], at[6]);
1.159 + COMBA_STORE(C->dp[5]);
1.160 + /* 6 */
1.161 + COMBA_FORWARD;
1.162 + MULADD(at[3], at[7]);
1.163 + COMBA_STORE(C->dp[6]);
1.164 + COMBA_STORE2(C->dp[7]);
1.165 + C->used = 8;
1.166 + C->sign = A->sign ^ B->sign;
1.167 + mp_clamp(C);
1.168 + COMBA_FINI;
1.169 +}
1.170 +
1.171 +void s_mp_mul_comba_8(const mp_int *A, const mp_int *B, mp_int *C)
1.172 +{
1.173 + mp_digit c0, c1, c2, at[16];
1.174 +
1.175 + memcpy(at, A->dp, 8 * sizeof(mp_digit));
1.176 + memcpy(at+8, B->dp, 8 * sizeof(mp_digit));
1.177 + COMBA_START;
1.178 +
1.179 + COMBA_CLEAR;
1.180 + /* 0 */
1.181 + MULADD(at[0], at[8]);
1.182 + COMBA_STORE(C->dp[0]);
1.183 + /* 1 */
1.184 + COMBA_FORWARD;
1.185 + MULADD(at[0], at[9]); MULADD(at[1], at[8]);
1.186 + COMBA_STORE(C->dp[1]);
1.187 + /* 2 */
1.188 + COMBA_FORWARD;
1.189 + MULADD(at[0], at[10]); MULADD(at[1], at[9]); MULADD(at[2], at[8]);
1.190 + COMBA_STORE(C->dp[2]);
1.191 + /* 3 */
1.192 + COMBA_FORWARD;
1.193 + MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); MULADD(at[3], at[8]);
1.194 + COMBA_STORE(C->dp[3]);
1.195 + /* 4 */
1.196 + COMBA_FORWARD;
1.197 + 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]);
1.198 + COMBA_STORE(C->dp[4]);
1.199 + /* 5 */
1.200 + COMBA_FORWARD;
1.201 + 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]);
1.202 + COMBA_STORE(C->dp[5]);
1.203 + /* 6 */
1.204 + COMBA_FORWARD;
1.205 + 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]);
1.206 + COMBA_STORE(C->dp[6]);
1.207 + /* 7 */
1.208 + COMBA_FORWARD;
1.209 + 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]);
1.210 + COMBA_STORE(C->dp[7]);
1.211 + /* 8 */
1.212 + COMBA_FORWARD;
1.213 + 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]);
1.214 + COMBA_STORE(C->dp[8]);
1.215 + /* 9 */
1.216 + COMBA_FORWARD;
1.217 + 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]);
1.218 + COMBA_STORE(C->dp[9]);
1.219 + /* 10 */
1.220 + COMBA_FORWARD;
1.221 + 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]);
1.222 + COMBA_STORE(C->dp[10]);
1.223 + /* 11 */
1.224 + COMBA_FORWARD;
1.225 + MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]);
1.226 + COMBA_STORE(C->dp[11]);
1.227 + /* 12 */
1.228 + COMBA_FORWARD;
1.229 + MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]);
1.230 + COMBA_STORE(C->dp[12]);
1.231 + /* 13 */
1.232 + COMBA_FORWARD;
1.233 + MULADD(at[6], at[15]); MULADD(at[7], at[14]);
1.234 + COMBA_STORE(C->dp[13]);
1.235 + /* 14 */
1.236 + COMBA_FORWARD;
1.237 + MULADD(at[7], at[15]);
1.238 + COMBA_STORE(C->dp[14]);
1.239 + COMBA_STORE2(C->dp[15]);
1.240 + C->used = 16;
1.241 + C->sign = A->sign ^ B->sign;
1.242 + mp_clamp(C);
1.243 + COMBA_FINI;
1.244 +}
1.245 +
1.246 +void s_mp_mul_comba_16(const mp_int *A, const mp_int *B, mp_int *C)
1.247 +{
1.248 + mp_digit c0, c1, c2, at[32];
1.249 +
1.250 + memcpy(at, A->dp, 16 * sizeof(mp_digit));
1.251 + memcpy(at+16, B->dp, 16 * sizeof(mp_digit));
1.252 + COMBA_START;
1.253 +
1.254 + COMBA_CLEAR;
1.255 + /* 0 */
1.256 + MULADD(at[0], at[16]);
1.257 + COMBA_STORE(C->dp[0]);
1.258 + /* 1 */
1.259 + COMBA_FORWARD;
1.260 + MULADD(at[0], at[17]); MULADD(at[1], at[16]);
1.261 + COMBA_STORE(C->dp[1]);
1.262 + /* 2 */
1.263 + COMBA_FORWARD;
1.264 + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]);
1.265 + COMBA_STORE(C->dp[2]);
1.266 + /* 3 */
1.267 + COMBA_FORWARD;
1.268 + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]);
1.269 + COMBA_STORE(C->dp[3]);
1.270 + /* 4 */
1.271 + COMBA_FORWARD;
1.272 + 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]);
1.273 + COMBA_STORE(C->dp[4]);
1.274 + /* 5 */
1.275 + COMBA_FORWARD;
1.276 + 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]);
1.277 + COMBA_STORE(C->dp[5]);
1.278 + /* 6 */
1.279 + COMBA_FORWARD;
1.280 + 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]);
1.281 + COMBA_STORE(C->dp[6]);
1.282 + /* 7 */
1.283 + COMBA_FORWARD;
1.284 + 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]);
1.285 + COMBA_STORE(C->dp[7]);
1.286 + /* 8 */
1.287 + COMBA_FORWARD;
1.288 + 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]);
1.289 + COMBA_STORE(C->dp[8]);
1.290 + /* 9 */
1.291 + COMBA_FORWARD;
1.292 + 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]);
1.293 + COMBA_STORE(C->dp[9]);
1.294 + /* 10 */
1.295 + COMBA_FORWARD;
1.296 + 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]);
1.297 + COMBA_STORE(C->dp[10]);
1.298 + /* 11 */
1.299 + COMBA_FORWARD;
1.300 + 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]);
1.301 + COMBA_STORE(C->dp[11]);
1.302 + /* 12 */
1.303 + COMBA_FORWARD;
1.304 + 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]);
1.305 + COMBA_STORE(C->dp[12]);
1.306 + /* 13 */
1.307 + COMBA_FORWARD;
1.308 + 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]);
1.309 + COMBA_STORE(C->dp[13]);
1.310 + /* 14 */
1.311 + COMBA_FORWARD;
1.312 + 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]);
1.313 + COMBA_STORE(C->dp[14]);
1.314 + /* 15 */
1.315 + COMBA_FORWARD;
1.316 + 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]);
1.317 + COMBA_STORE(C->dp[15]);
1.318 + /* 16 */
1.319 + COMBA_FORWARD;
1.320 + 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]);
1.321 + COMBA_STORE(C->dp[16]);
1.322 + /* 17 */
1.323 + COMBA_FORWARD;
1.324 + 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]);
1.325 + COMBA_STORE(C->dp[17]);
1.326 + /* 18 */
1.327 + COMBA_FORWARD;
1.328 + 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]);
1.329 + COMBA_STORE(C->dp[18]);
1.330 + /* 19 */
1.331 + COMBA_FORWARD;
1.332 + 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]);
1.333 + COMBA_STORE(C->dp[19]);
1.334 + /* 20 */
1.335 + COMBA_FORWARD;
1.336 + 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]);
1.337 + COMBA_STORE(C->dp[20]);
1.338 + /* 21 */
1.339 + COMBA_FORWARD;
1.340 + 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]);
1.341 + COMBA_STORE(C->dp[21]);
1.342 + /* 22 */
1.343 + COMBA_FORWARD;
1.344 + 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]);
1.345 + COMBA_STORE(C->dp[22]);
1.346 + /* 23 */
1.347 + COMBA_FORWARD;
1.348 + 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]);
1.349 + COMBA_STORE(C->dp[23]);
1.350 + /* 24 */
1.351 + COMBA_FORWARD;
1.352 + 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]);
1.353 + COMBA_STORE(C->dp[24]);
1.354 + /* 25 */
1.355 + COMBA_FORWARD;
1.356 + 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]);
1.357 + COMBA_STORE(C->dp[25]);
1.358 + /* 26 */
1.359 + COMBA_FORWARD;
1.360 + 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]);
1.361 + COMBA_STORE(C->dp[26]);
1.362 + /* 27 */
1.363 + COMBA_FORWARD;
1.364 + MULADD(at[12], at[31]); MULADD(at[13], at[30]); MULADD(at[14], at[29]); MULADD(at[15], at[28]);
1.365 + COMBA_STORE(C->dp[27]);
1.366 + /* 28 */
1.367 + COMBA_FORWARD;
1.368 + MULADD(at[13], at[31]); MULADD(at[14], at[30]); MULADD(at[15], at[29]);
1.369 + COMBA_STORE(C->dp[28]);
1.370 + /* 29 */
1.371 + COMBA_FORWARD;
1.372 + MULADD(at[14], at[31]); MULADD(at[15], at[30]);
1.373 + COMBA_STORE(C->dp[29]);
1.374 + /* 30 */
1.375 + COMBA_FORWARD;
1.376 + MULADD(at[15], at[31]);
1.377 + COMBA_STORE(C->dp[30]);
1.378 + COMBA_STORE2(C->dp[31]);
1.379 + C->used = 32;
1.380 + C->sign = A->sign ^ B->sign;
1.381 + mp_clamp(C);
1.382 + COMBA_FINI;
1.383 +}
1.384 +
1.385 +void s_mp_mul_comba_32(const mp_int *A, const mp_int *B, mp_int *C)
1.386 +{
1.387 + mp_digit c0, c1, c2, at[64];
1.388 +
1.389 + memcpy(at, A->dp, 32 * sizeof(mp_digit));
1.390 + memcpy(at+32, B->dp, 32 * sizeof(mp_digit));
1.391 + COMBA_START;
1.392 +
1.393 + COMBA_CLEAR;
1.394 + /* 0 */
1.395 + MULADD(at[0], at[32]);
1.396 + COMBA_STORE(C->dp[0]);
1.397 + /* 1 */
1.398 + COMBA_FORWARD;
1.399 + MULADD(at[0], at[33]); MULADD(at[1], at[32]);
1.400 + COMBA_STORE(C->dp[1]);
1.401 + /* 2 */
1.402 + COMBA_FORWARD;
1.403 + MULADD(at[0], at[34]); MULADD(at[1], at[33]); MULADD(at[2], at[32]);
1.404 + COMBA_STORE(C->dp[2]);
1.405 + /* 3 */
1.406 + COMBA_FORWARD;
1.407 + MULADD(at[0], at[35]); MULADD(at[1], at[34]); MULADD(at[2], at[33]); MULADD(at[3], at[32]);
1.408 + COMBA_STORE(C->dp[3]);
1.409 + /* 4 */
1.410 + COMBA_FORWARD;
1.411 + 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]);
1.412 + COMBA_STORE(C->dp[4]);
1.413 + /* 5 */
1.414 + COMBA_FORWARD;
1.415 + 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]);
1.416 + COMBA_STORE(C->dp[5]);
1.417 + /* 6 */
1.418 + COMBA_FORWARD;
1.419 + 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]);
1.420 + COMBA_STORE(C->dp[6]);
1.421 + /* 7 */
1.422 + COMBA_FORWARD;
1.423 + 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]);
1.424 + COMBA_STORE(C->dp[7]);
1.425 + /* 8 */
1.426 + COMBA_FORWARD;
1.427 + 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]);
1.428 + COMBA_STORE(C->dp[8]);
1.429 + /* 9 */
1.430 + COMBA_FORWARD;
1.431 + 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]);
1.432 + COMBA_STORE(C->dp[9]);
1.433 + /* 10 */
1.434 + COMBA_FORWARD;
1.435 + 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]);
1.436 + COMBA_STORE(C->dp[10]);
1.437 + /* 11 */
1.438 + COMBA_FORWARD;
1.439 + 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]);
1.440 + COMBA_STORE(C->dp[11]);
1.441 + /* 12 */
1.442 + COMBA_FORWARD;
1.443 + 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]);
1.444 + COMBA_STORE(C->dp[12]);
1.445 + /* 13 */
1.446 + COMBA_FORWARD;
1.447 + 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]);
1.448 + COMBA_STORE(C->dp[13]);
1.449 + /* 14 */
1.450 + COMBA_FORWARD;
1.451 + 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]);
1.452 + COMBA_STORE(C->dp[14]);
1.453 + /* 15 */
1.454 + COMBA_FORWARD;
1.455 + 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]);
1.456 + COMBA_STORE(C->dp[15]);
1.457 + /* 16 */
1.458 + COMBA_FORWARD;
1.459 + 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]);
1.460 + COMBA_STORE(C->dp[16]);
1.461 + /* 17 */
1.462 + COMBA_FORWARD;
1.463 + 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]);
1.464 + COMBA_STORE(C->dp[17]);
1.465 + /* 18 */
1.466 + COMBA_FORWARD;
1.467 + 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]);
1.468 + COMBA_STORE(C->dp[18]);
1.469 + /* 19 */
1.470 + COMBA_FORWARD;
1.471 + 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]);
1.472 + COMBA_STORE(C->dp[19]);
1.473 + /* 20 */
1.474 + COMBA_FORWARD;
1.475 + 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]);
1.476 + COMBA_STORE(C->dp[20]);
1.477 + /* 21 */
1.478 + COMBA_FORWARD;
1.479 + 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]);
1.480 + COMBA_STORE(C->dp[21]);
1.481 + /* 22 */
1.482 + COMBA_FORWARD;
1.483 + 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]);
1.484 + COMBA_STORE(C->dp[22]);
1.485 + /* 23 */
1.486 + COMBA_FORWARD;
1.487 + 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]);
1.488 + COMBA_STORE(C->dp[23]);
1.489 + /* 24 */
1.490 + COMBA_FORWARD;
1.491 + 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]);
1.492 + COMBA_STORE(C->dp[24]);
1.493 + /* 25 */
1.494 + COMBA_FORWARD;
1.495 + 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]);
1.496 + COMBA_STORE(C->dp[25]);
1.497 + /* 26 */
1.498 + COMBA_FORWARD;
1.499 + 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]);
1.500 + COMBA_STORE(C->dp[26]);
1.501 + /* 27 */
1.502 + COMBA_FORWARD;
1.503 + 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]);
1.504 + COMBA_STORE(C->dp[27]);
1.505 + /* 28 */
1.506 + COMBA_FORWARD;
1.507 + 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]);
1.508 + COMBA_STORE(C->dp[28]);
1.509 + /* 29 */
1.510 + COMBA_FORWARD;
1.511 + 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]);
1.512 + COMBA_STORE(C->dp[29]);
1.513 + /* 30 */
1.514 + COMBA_FORWARD;
1.515 + 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]);
1.516 + COMBA_STORE(C->dp[30]);
1.517 + /* 31 */
1.518 + COMBA_FORWARD;
1.519 + 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]);
1.520 + COMBA_STORE(C->dp[31]);
1.521 + /* 32 */
1.522 + COMBA_FORWARD;
1.523 + 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]);
1.524 + COMBA_STORE(C->dp[32]);
1.525 + /* 33 */
1.526 + COMBA_FORWARD;
1.527 + 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]);
1.528 + COMBA_STORE(C->dp[33]);
1.529 + /* 34 */
1.530 + COMBA_FORWARD;
1.531 + 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]);
1.532 + COMBA_STORE(C->dp[34]);
1.533 + /* 35 */
1.534 + COMBA_FORWARD;
1.535 + 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]);
1.536 + COMBA_STORE(C->dp[35]);
1.537 + /* 36 */
1.538 + COMBA_FORWARD;
1.539 + 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]);
1.540 + COMBA_STORE(C->dp[36]);
1.541 + /* 37 */
1.542 + COMBA_FORWARD;
1.543 + 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]);
1.544 + COMBA_STORE(C->dp[37]);
1.545 + /* 38 */
1.546 + COMBA_FORWARD;
1.547 + 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]);
1.548 + COMBA_STORE(C->dp[38]);
1.549 + /* 39 */
1.550 + COMBA_FORWARD;
1.551 + 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]);
1.552 + COMBA_STORE(C->dp[39]);
1.553 + /* 40 */
1.554 + COMBA_FORWARD;
1.555 + 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]);
1.556 + COMBA_STORE(C->dp[40]);
1.557 + /* 41 */
1.558 + COMBA_FORWARD;
1.559 + 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]);
1.560 + COMBA_STORE(C->dp[41]);
1.561 + /* 42 */
1.562 + COMBA_FORWARD;
1.563 + 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]);
1.564 + COMBA_STORE(C->dp[42]);
1.565 + /* 43 */
1.566 + COMBA_FORWARD;
1.567 + 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]);
1.568 + COMBA_STORE(C->dp[43]);
1.569 + /* 44 */
1.570 + COMBA_FORWARD;
1.571 + 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]);
1.572 + COMBA_STORE(C->dp[44]);
1.573 + /* 45 */
1.574 + COMBA_FORWARD;
1.575 + 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]);
1.576 + COMBA_STORE(C->dp[45]);
1.577 + /* 46 */
1.578 + COMBA_FORWARD;
1.579 + 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]);
1.580 + COMBA_STORE(C->dp[46]);
1.581 + /* 47 */
1.582 + COMBA_FORWARD;
1.583 + 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]);
1.584 + COMBA_STORE(C->dp[47]);
1.585 + /* 48 */
1.586 + COMBA_FORWARD;
1.587 + 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]);
1.588 + COMBA_STORE(C->dp[48]);
1.589 + /* 49 */
1.590 + COMBA_FORWARD;
1.591 + 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]);
1.592 + COMBA_STORE(C->dp[49]);
1.593 + /* 50 */
1.594 + COMBA_FORWARD;
1.595 + 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]);
1.596 + COMBA_STORE(C->dp[50]);
1.597 + /* 51 */
1.598 + COMBA_FORWARD;
1.599 + 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]);
1.600 + COMBA_STORE(C->dp[51]);
1.601 + /* 52 */
1.602 + COMBA_FORWARD;
1.603 + 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]);
1.604 + COMBA_STORE(C->dp[52]);
1.605 + /* 53 */
1.606 + COMBA_FORWARD;
1.607 + 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]);
1.608 + COMBA_STORE(C->dp[53]);
1.609 + /* 54 */
1.610 + COMBA_FORWARD;
1.611 + 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]);
1.612 + COMBA_STORE(C->dp[54]);
1.613 + /* 55 */
1.614 + COMBA_FORWARD;
1.615 + 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]);
1.616 + COMBA_STORE(C->dp[55]);
1.617 + /* 56 */
1.618 + COMBA_FORWARD;
1.619 + 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]);
1.620 + COMBA_STORE(C->dp[56]);
1.621 + /* 57 */
1.622 + COMBA_FORWARD;
1.623 + 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]);
1.624 + COMBA_STORE(C->dp[57]);
1.625 + /* 58 */
1.626 + COMBA_FORWARD;
1.627 + 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]);
1.628 + COMBA_STORE(C->dp[58]);
1.629 + /* 59 */
1.630 + COMBA_FORWARD;
1.631 + MULADD(at[28], at[63]); MULADD(at[29], at[62]); MULADD(at[30], at[61]); MULADD(at[31], at[60]);
1.632 + COMBA_STORE(C->dp[59]);
1.633 + /* 60 */
1.634 + COMBA_FORWARD;
1.635 + MULADD(at[29], at[63]); MULADD(at[30], at[62]); MULADD(at[31], at[61]);
1.636 + COMBA_STORE(C->dp[60]);
1.637 + /* 61 */
1.638 + COMBA_FORWARD;
1.639 + MULADD(at[30], at[63]); MULADD(at[31], at[62]);
1.640 + COMBA_STORE(C->dp[61]);
1.641 + /* 62 */
1.642 + COMBA_FORWARD;
1.643 + MULADD(at[31], at[63]);
1.644 + COMBA_STORE(C->dp[62]);
1.645 + COMBA_STORE2(C->dp[63]);
1.646 + C->used = 64;
1.647 + C->sign = A->sign ^ B->sign;
1.648 + mp_clamp(C);
1.649 + COMBA_FINI;
1.650 +}
1.651 +
1.652 +
1.653 +
1.654 +void s_mp_sqr_comba_4(const mp_int *A, mp_int *B)
1.655 +{
1.656 + mp_digit *a, b[8], c0, c1, c2;
1.657 +
1.658 + a = A->dp;
1.659 + COMBA_START;
1.660 +
1.661 + /* clear carries */
1.662 + CLEAR_CARRY;
1.663 +
1.664 + /* output 0 */
1.665 + SQRADD(a[0],a[0]);
1.666 + COMBA_STORE(b[0]);
1.667 +
1.668 + /* output 1 */
1.669 + CARRY_FORWARD;
1.670 + SQRADD2(a[0], a[1]);
1.671 + COMBA_STORE(b[1]);
1.672 +
1.673 + /* output 2 */
1.674 + CARRY_FORWARD;
1.675 + SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
1.676 + COMBA_STORE(b[2]);
1.677 +
1.678 + /* output 3 */
1.679 + CARRY_FORWARD;
1.680 + SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
1.681 + COMBA_STORE(b[3]);
1.682 +
1.683 + /* output 4 */
1.684 + CARRY_FORWARD;
1.685 + SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
1.686 + COMBA_STORE(b[4]);
1.687 +
1.688 + /* output 5 */
1.689 + CARRY_FORWARD;
1.690 + SQRADD2(a[2], a[3]);
1.691 + COMBA_STORE(b[5]);
1.692 +
1.693 + /* output 6 */
1.694 + CARRY_FORWARD;
1.695 + SQRADD(a[3], a[3]);
1.696 + COMBA_STORE(b[6]);
1.697 + COMBA_STORE2(b[7]);
1.698 + COMBA_FINI;
1.699 +
1.700 + B->used = 8;
1.701 + B->sign = ZPOS;
1.702 + memcpy(B->dp, b, 8 * sizeof(mp_digit));
1.703 + mp_clamp(B);
1.704 +}
1.705 +
1.706 +void s_mp_sqr_comba_8(const mp_int *A, mp_int *B)
1.707 +{
1.708 + mp_digit *a, b[16], c0, c1, c2, sc0, sc1, sc2;
1.709 +
1.710 + a = A->dp;
1.711 + COMBA_START;
1.712 +
1.713 + /* clear carries */
1.714 + CLEAR_CARRY;
1.715 +
1.716 + /* output 0 */
1.717 + SQRADD(a[0],a[0]);
1.718 + COMBA_STORE(b[0]);
1.719 +
1.720 + /* output 1 */
1.721 + CARRY_FORWARD;
1.722 + SQRADD2(a[0], a[1]);
1.723 + COMBA_STORE(b[1]);
1.724 +
1.725 + /* output 2 */
1.726 + CARRY_FORWARD;
1.727 + SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
1.728 + COMBA_STORE(b[2]);
1.729 +
1.730 + /* output 3 */
1.731 + CARRY_FORWARD;
1.732 + SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
1.733 + COMBA_STORE(b[3]);
1.734 +
1.735 + /* output 4 */
1.736 + CARRY_FORWARD;
1.737 + SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
1.738 + COMBA_STORE(b[4]);
1.739 +
1.740 + /* output 5 */
1.741 + CARRY_FORWARD;
1.742 + SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB;
1.743 + COMBA_STORE(b[5]);
1.744 +
1.745 + /* output 6 */
1.746 + CARRY_FORWARD;
1.747 + SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]);
1.748 + COMBA_STORE(b[6]);
1.749 +
1.750 + /* output 7 */
1.751 + CARRY_FORWARD;
1.752 + SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB;
1.753 + COMBA_STORE(b[7]);
1.754 +
1.755 + /* output 8 */
1.756 + CARRY_FORWARD;
1.757 + SQRADDSC(a[1], a[7]); SQRADDAC(a[2], a[6]); SQRADDAC(a[3], a[5]); SQRADDDB; SQRADD(a[4], a[4]);
1.758 + COMBA_STORE(b[8]);
1.759 +
1.760 + /* output 9 */
1.761 + CARRY_FORWARD;
1.762 + SQRADDSC(a[2], a[7]); SQRADDAC(a[3], a[6]); SQRADDAC(a[4], a[5]); SQRADDDB;
1.763 + COMBA_STORE(b[9]);
1.764 +
1.765 + /* output 10 */
1.766 + CARRY_FORWARD;
1.767 + SQRADD2(a[3], a[7]); SQRADD2(a[4], a[6]); SQRADD(a[5], a[5]);
1.768 + COMBA_STORE(b[10]);
1.769 +
1.770 + /* output 11 */
1.771 + CARRY_FORWARD;
1.772 + SQRADD2(a[4], a[7]); SQRADD2(a[5], a[6]);
1.773 + COMBA_STORE(b[11]);
1.774 +
1.775 + /* output 12 */
1.776 + CARRY_FORWARD;
1.777 + SQRADD2(a[5], a[7]); SQRADD(a[6], a[6]);
1.778 + COMBA_STORE(b[12]);
1.779 +
1.780 + /* output 13 */
1.781 + CARRY_FORWARD;
1.782 + SQRADD2(a[6], a[7]);
1.783 + COMBA_STORE(b[13]);
1.784 +
1.785 + /* output 14 */
1.786 + CARRY_FORWARD;
1.787 + SQRADD(a[7], a[7]);
1.788 + COMBA_STORE(b[14]);
1.789 + COMBA_STORE2(b[15]);
1.790 + COMBA_FINI;
1.791 +
1.792 + B->used = 16;
1.793 + B->sign = ZPOS;
1.794 + memcpy(B->dp, b, 16 * sizeof(mp_digit));
1.795 + mp_clamp(B);
1.796 +}
1.797 +
1.798 +void s_mp_sqr_comba_16(const mp_int *A, mp_int *B)
1.799 +{
1.800 + mp_digit *a, b[32], c0, c1, c2, sc0, sc1, sc2;
1.801 +
1.802 + a = A->dp;
1.803 + COMBA_START;
1.804 +
1.805 + /* clear carries */
1.806 + CLEAR_CARRY;
1.807 +
1.808 + /* output 0 */
1.809 + SQRADD(a[0],a[0]);
1.810 + COMBA_STORE(b[0]);
1.811 +
1.812 + /* output 1 */
1.813 + CARRY_FORWARD;
1.814 + SQRADD2(a[0], a[1]);
1.815 + COMBA_STORE(b[1]);
1.816 +
1.817 + /* output 2 */
1.818 + CARRY_FORWARD;
1.819 + SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
1.820 + COMBA_STORE(b[2]);
1.821 +
1.822 + /* output 3 */
1.823 + CARRY_FORWARD;
1.824 + SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
1.825 + COMBA_STORE(b[3]);
1.826 +
1.827 + /* output 4 */
1.828 + CARRY_FORWARD;
1.829 + SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
1.830 + COMBA_STORE(b[4]);
1.831 +
1.832 + /* output 5 */
1.833 + CARRY_FORWARD;
1.834 + SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB;
1.835 + COMBA_STORE(b[5]);
1.836 +
1.837 + /* output 6 */
1.838 + CARRY_FORWARD;
1.839 + SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]);
1.840 + COMBA_STORE(b[6]);
1.841 +
1.842 + /* output 7 */
1.843 + CARRY_FORWARD;
1.844 + SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB;
1.845 + COMBA_STORE(b[7]);
1.846 +
1.847 + /* output 8 */
1.848 + CARRY_FORWARD;
1.849 + 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]);
1.850 + COMBA_STORE(b[8]);
1.851 +
1.852 + /* output 9 */
1.853 + CARRY_FORWARD;
1.854 + 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;
1.855 + COMBA_STORE(b[9]);
1.856 +
1.857 + /* output 10 */
1.858 + CARRY_FORWARD;
1.859 + 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]);
1.860 + COMBA_STORE(b[10]);
1.861 +
1.862 + /* output 11 */
1.863 + CARRY_FORWARD;
1.864 + 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;
1.865 + COMBA_STORE(b[11]);
1.866 +
1.867 + /* output 12 */
1.868 + CARRY_FORWARD;
1.869 + 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]);
1.870 + COMBA_STORE(b[12]);
1.871 +
1.872 + /* output 13 */
1.873 + CARRY_FORWARD;
1.874 + 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;
1.875 + COMBA_STORE(b[13]);
1.876 +
1.877 + /* output 14 */
1.878 + CARRY_FORWARD;
1.879 + 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]);
1.880 + COMBA_STORE(b[14]);
1.881 +
1.882 + /* output 15 */
1.883 + CARRY_FORWARD;
1.884 + 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;
1.885 + COMBA_STORE(b[15]);
1.886 +
1.887 + /* output 16 */
1.888 + CARRY_FORWARD;
1.889 + 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]);
1.890 + COMBA_STORE(b[16]);
1.891 +
1.892 + /* output 17 */
1.893 + CARRY_FORWARD;
1.894 + 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;
1.895 + COMBA_STORE(b[17]);
1.896 +
1.897 + /* output 18 */
1.898 + CARRY_FORWARD;
1.899 + 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]);
1.900 + COMBA_STORE(b[18]);
1.901 +
1.902 + /* output 19 */
1.903 + CARRY_FORWARD;
1.904 + 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;
1.905 + COMBA_STORE(b[19]);
1.906 +
1.907 + /* output 20 */
1.908 + CARRY_FORWARD;
1.909 + 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]);
1.910 + COMBA_STORE(b[20]);
1.911 +
1.912 + /* output 21 */
1.913 + CARRY_FORWARD;
1.914 + 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;
1.915 + COMBA_STORE(b[21]);
1.916 +
1.917 + /* output 22 */
1.918 + CARRY_FORWARD;
1.919 + 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]);
1.920 + COMBA_STORE(b[22]);
1.921 +
1.922 + /* output 23 */
1.923 + CARRY_FORWARD;
1.924 + SQRADDSC(a[8], a[15]); SQRADDAC(a[9], a[14]); SQRADDAC(a[10], a[13]); SQRADDAC(a[11], a[12]); SQRADDDB;
1.925 + COMBA_STORE(b[23]);
1.926 +
1.927 + /* output 24 */
1.928 + CARRY_FORWARD;
1.929 + SQRADDSC(a[9], a[15]); SQRADDAC(a[10], a[14]); SQRADDAC(a[11], a[13]); SQRADDDB; SQRADD(a[12], a[12]);
1.930 + COMBA_STORE(b[24]);
1.931 +
1.932 + /* output 25 */
1.933 + CARRY_FORWARD;
1.934 + SQRADDSC(a[10], a[15]); SQRADDAC(a[11], a[14]); SQRADDAC(a[12], a[13]); SQRADDDB;
1.935 + COMBA_STORE(b[25]);
1.936 +
1.937 + /* output 26 */
1.938 + CARRY_FORWARD;
1.939 + SQRADD2(a[11], a[15]); SQRADD2(a[12], a[14]); SQRADD(a[13], a[13]);
1.940 + COMBA_STORE(b[26]);
1.941 +
1.942 + /* output 27 */
1.943 + CARRY_FORWARD;
1.944 + SQRADD2(a[12], a[15]); SQRADD2(a[13], a[14]);
1.945 + COMBA_STORE(b[27]);
1.946 +
1.947 + /* output 28 */
1.948 + CARRY_FORWARD;
1.949 + SQRADD2(a[13], a[15]); SQRADD(a[14], a[14]);
1.950 + COMBA_STORE(b[28]);
1.951 +
1.952 + /* output 29 */
1.953 + CARRY_FORWARD;
1.954 + SQRADD2(a[14], a[15]);
1.955 + COMBA_STORE(b[29]);
1.956 +
1.957 + /* output 30 */
1.958 + CARRY_FORWARD;
1.959 + SQRADD(a[15], a[15]);
1.960 + COMBA_STORE(b[30]);
1.961 + COMBA_STORE2(b[31]);
1.962 + COMBA_FINI;
1.963 +
1.964 + B->used = 32;
1.965 + B->sign = ZPOS;
1.966 + memcpy(B->dp, b, 32 * sizeof(mp_digit));
1.967 + mp_clamp(B);
1.968 +}
1.969 +
1.970 +
1.971 +void s_mp_sqr_comba_32(const mp_int *A, mp_int *B)
1.972 +{
1.973 + mp_digit *a, b[64], c0, c1, c2, sc0, sc1, sc2;
1.974 +
1.975 + a = A->dp;
1.976 + COMBA_START;
1.977 +
1.978 + /* clear carries */
1.979 + CLEAR_CARRY;
1.980 +
1.981 + /* output 0 */
1.982 + SQRADD(a[0],a[0]);
1.983 + COMBA_STORE(b[0]);
1.984 +
1.985 + /* output 1 */
1.986 + CARRY_FORWARD;
1.987 + SQRADD2(a[0], a[1]);
1.988 + COMBA_STORE(b[1]);
1.989 +
1.990 + /* output 2 */
1.991 + CARRY_FORWARD;
1.992 + SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
1.993 + COMBA_STORE(b[2]);
1.994 +
1.995 + /* output 3 */
1.996 + CARRY_FORWARD;
1.997 + SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
1.998 + COMBA_STORE(b[3]);
1.999 +
1.1000 + /* output 4 */
1.1001 + CARRY_FORWARD;
1.1002 + SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
1.1003 + COMBA_STORE(b[4]);
1.1004 +
1.1005 + /* output 5 */
1.1006 + CARRY_FORWARD;
1.1007 + SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB;
1.1008 + COMBA_STORE(b[5]);
1.1009 +
1.1010 + /* output 6 */
1.1011 + CARRY_FORWARD;
1.1012 + SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]);
1.1013 + COMBA_STORE(b[6]);
1.1014 +
1.1015 + /* output 7 */
1.1016 + CARRY_FORWARD;
1.1017 + SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB;
1.1018 + COMBA_STORE(b[7]);
1.1019 +
1.1020 + /* output 8 */
1.1021 + CARRY_FORWARD;
1.1022 + 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]);
1.1023 + COMBA_STORE(b[8]);
1.1024 +
1.1025 + /* output 9 */
1.1026 + CARRY_FORWARD;
1.1027 + 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;
1.1028 + COMBA_STORE(b[9]);
1.1029 +
1.1030 + /* output 10 */
1.1031 + CARRY_FORWARD;
1.1032 + 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]);
1.1033 + COMBA_STORE(b[10]);
1.1034 +
1.1035 + /* output 11 */
1.1036 + CARRY_FORWARD;
1.1037 + 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;
1.1038 + COMBA_STORE(b[11]);
1.1039 +
1.1040 + /* output 12 */
1.1041 + CARRY_FORWARD;
1.1042 + 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]);
1.1043 + COMBA_STORE(b[12]);
1.1044 +
1.1045 + /* output 13 */
1.1046 + CARRY_FORWARD;
1.1047 + 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;
1.1048 + COMBA_STORE(b[13]);
1.1049 +
1.1050 + /* output 14 */
1.1051 + CARRY_FORWARD;
1.1052 + 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]);
1.1053 + COMBA_STORE(b[14]);
1.1054 +
1.1055 + /* output 15 */
1.1056 + CARRY_FORWARD;
1.1057 + 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;
1.1058 + COMBA_STORE(b[15]);
1.1059 +
1.1060 + /* output 16 */
1.1061 + CARRY_FORWARD;
1.1062 + 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]);
1.1063 + COMBA_STORE(b[16]);
1.1064 +
1.1065 + /* output 17 */
1.1066 + CARRY_FORWARD;
1.1067 + 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;
1.1068 + COMBA_STORE(b[17]);
1.1069 +
1.1070 + /* output 18 */
1.1071 + CARRY_FORWARD;
1.1072 + 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]);
1.1073 + COMBA_STORE(b[18]);
1.1074 +
1.1075 + /* output 19 */
1.1076 + CARRY_FORWARD;
1.1077 + 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;
1.1078 + COMBA_STORE(b[19]);
1.1079 +
1.1080 + /* output 20 */
1.1081 + CARRY_FORWARD;
1.1082 + 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]);
1.1083 + COMBA_STORE(b[20]);
1.1084 +
1.1085 + /* output 21 */
1.1086 + CARRY_FORWARD;
1.1087 + 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;
1.1088 + COMBA_STORE(b[21]);
1.1089 +
1.1090 + /* output 22 */
1.1091 + CARRY_FORWARD;
1.1092 + 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]);
1.1093 + COMBA_STORE(b[22]);
1.1094 +
1.1095 + /* output 23 */
1.1096 + CARRY_FORWARD;
1.1097 + 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;
1.1098 + COMBA_STORE(b[23]);
1.1099 +
1.1100 + /* output 24 */
1.1101 + CARRY_FORWARD;
1.1102 + 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]);
1.1103 + COMBA_STORE(b[24]);
1.1104 +
1.1105 + /* output 25 */
1.1106 + CARRY_FORWARD;
1.1107 + 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;
1.1108 + COMBA_STORE(b[25]);
1.1109 +
1.1110 + /* output 26 */
1.1111 + CARRY_FORWARD;
1.1112 + 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]);
1.1113 + COMBA_STORE(b[26]);
1.1114 +
1.1115 + /* output 27 */
1.1116 + CARRY_FORWARD;
1.1117 + 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;
1.1118 + COMBA_STORE(b[27]);
1.1119 +
1.1120 + /* output 28 */
1.1121 + CARRY_FORWARD;
1.1122 + 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]);
1.1123 + COMBA_STORE(b[28]);
1.1124 +
1.1125 + /* output 29 */
1.1126 + CARRY_FORWARD;
1.1127 + 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;
1.1128 + COMBA_STORE(b[29]);
1.1129 +
1.1130 + /* output 30 */
1.1131 + CARRY_FORWARD;
1.1132 + 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]);
1.1133 + COMBA_STORE(b[30]);
1.1134 +
1.1135 + /* output 31 */
1.1136 + CARRY_FORWARD;
1.1137 + 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;
1.1138 + COMBA_STORE(b[31]);
1.1139 +
1.1140 + /* output 32 */
1.1141 + CARRY_FORWARD;
1.1142 + 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]);
1.1143 + COMBA_STORE(b[32]);
1.1144 +
1.1145 + /* output 33 */
1.1146 + CARRY_FORWARD;
1.1147 + 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;
1.1148 + COMBA_STORE(b[33]);
1.1149 +
1.1150 + /* output 34 */
1.1151 + CARRY_FORWARD;
1.1152 + 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]);
1.1153 + COMBA_STORE(b[34]);
1.1154 +
1.1155 + /* output 35 */
1.1156 + CARRY_FORWARD;
1.1157 + 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;
1.1158 + COMBA_STORE(b[35]);
1.1159 +
1.1160 + /* output 36 */
1.1161 + CARRY_FORWARD;
1.1162 + 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]);
1.1163 + COMBA_STORE(b[36]);
1.1164 +
1.1165 + /* output 37 */
1.1166 + CARRY_FORWARD;
1.1167 + 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;
1.1168 + COMBA_STORE(b[37]);
1.1169 +
1.1170 + /* output 38 */
1.1171 + CARRY_FORWARD;
1.1172 + 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]);
1.1173 + COMBA_STORE(b[38]);
1.1174 +
1.1175 + /* output 39 */
1.1176 + CARRY_FORWARD;
1.1177 + 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;
1.1178 + COMBA_STORE(b[39]);
1.1179 +
1.1180 + /* output 40 */
1.1181 + CARRY_FORWARD;
1.1182 + 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]);
1.1183 + COMBA_STORE(b[40]);
1.1184 +
1.1185 + /* output 41 */
1.1186 + CARRY_FORWARD;
1.1187 + 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;
1.1188 + COMBA_STORE(b[41]);
1.1189 +
1.1190 + /* output 42 */
1.1191 + CARRY_FORWARD;
1.1192 + 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]);
1.1193 + COMBA_STORE(b[42]);
1.1194 +
1.1195 + /* output 43 */
1.1196 + CARRY_FORWARD;
1.1197 + 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;
1.1198 + COMBA_STORE(b[43]);
1.1199 +
1.1200 + /* output 44 */
1.1201 + CARRY_FORWARD;
1.1202 + 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]);
1.1203 + COMBA_STORE(b[44]);
1.1204 +
1.1205 + /* output 45 */
1.1206 + CARRY_FORWARD;
1.1207 + 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;
1.1208 + COMBA_STORE(b[45]);
1.1209 +
1.1210 + /* output 46 */
1.1211 + CARRY_FORWARD;
1.1212 + 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]);
1.1213 + COMBA_STORE(b[46]);
1.1214 +
1.1215 + /* output 47 */
1.1216 + CARRY_FORWARD;
1.1217 + 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;
1.1218 + COMBA_STORE(b[47]);
1.1219 +
1.1220 + /* output 48 */
1.1221 + CARRY_FORWARD;
1.1222 + 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]);
1.1223 + COMBA_STORE(b[48]);
1.1224 +
1.1225 + /* output 49 */
1.1226 + CARRY_FORWARD;
1.1227 + 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;
1.1228 + COMBA_STORE(b[49]);
1.1229 +
1.1230 + /* output 50 */
1.1231 + CARRY_FORWARD;
1.1232 + 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]);
1.1233 + COMBA_STORE(b[50]);
1.1234 +
1.1235 + /* output 51 */
1.1236 + CARRY_FORWARD;
1.1237 + 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;
1.1238 + COMBA_STORE(b[51]);
1.1239 +
1.1240 + /* output 52 */
1.1241 + CARRY_FORWARD;
1.1242 + 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]);
1.1243 + COMBA_STORE(b[52]);
1.1244 +
1.1245 + /* output 53 */
1.1246 + CARRY_FORWARD;
1.1247 + 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;
1.1248 + COMBA_STORE(b[53]);
1.1249 +
1.1250 + /* output 54 */
1.1251 + CARRY_FORWARD;
1.1252 + 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]);
1.1253 + COMBA_STORE(b[54]);
1.1254 +
1.1255 + /* output 55 */
1.1256 + CARRY_FORWARD;
1.1257 + SQRADDSC(a[24], a[31]); SQRADDAC(a[25], a[30]); SQRADDAC(a[26], a[29]); SQRADDAC(a[27], a[28]); SQRADDDB;
1.1258 + COMBA_STORE(b[55]);
1.1259 +
1.1260 + /* output 56 */
1.1261 + CARRY_FORWARD;
1.1262 + SQRADDSC(a[25], a[31]); SQRADDAC(a[26], a[30]); SQRADDAC(a[27], a[29]); SQRADDDB; SQRADD(a[28], a[28]);
1.1263 + COMBA_STORE(b[56]);
1.1264 +
1.1265 + /* output 57 */
1.1266 + CARRY_FORWARD;
1.1267 + SQRADDSC(a[26], a[31]); SQRADDAC(a[27], a[30]); SQRADDAC(a[28], a[29]); SQRADDDB;
1.1268 + COMBA_STORE(b[57]);
1.1269 +
1.1270 + /* output 58 */
1.1271 + CARRY_FORWARD;
1.1272 + SQRADD2(a[27], a[31]); SQRADD2(a[28], a[30]); SQRADD(a[29], a[29]);
1.1273 + COMBA_STORE(b[58]);
1.1274 +
1.1275 + /* output 59 */
1.1276 + CARRY_FORWARD;
1.1277 + SQRADD2(a[28], a[31]); SQRADD2(a[29], a[30]);
1.1278 + COMBA_STORE(b[59]);
1.1279 +
1.1280 + /* output 60 */
1.1281 + CARRY_FORWARD;
1.1282 + SQRADD2(a[29], a[31]); SQRADD(a[30], a[30]);
1.1283 + COMBA_STORE(b[60]);
1.1284 +
1.1285 + /* output 61 */
1.1286 + CARRY_FORWARD;
1.1287 + SQRADD2(a[30], a[31]);
1.1288 + COMBA_STORE(b[61]);
1.1289 +
1.1290 + /* output 62 */
1.1291 + CARRY_FORWARD;
1.1292 + SQRADD(a[31], a[31]);
1.1293 + COMBA_STORE(b[62]);
1.1294 + COMBA_STORE2(b[63]);
1.1295 + COMBA_FINI;
1.1296 +
1.1297 + B->used = 64;
1.1298 + B->sign = ZPOS;
1.1299 + memcpy(B->dp, b, 64 * sizeof(mp_digit));
1.1300 + mp_clamp(B);
1.1301 +}
