The Tor Browser / file comparison

comparison: security/nss/lib/freebl/mpi/mp_comba.c

security/nss/lib/freebl/mpi/mp_comba.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:f4eeefc18e4b
1 /*
2 * The below file is derived from TFM v0.03.
3 * It contains code from fp_mul_comba.c and
4 * fp_sqr_comba.c, which contained the following license.
5 *
6 * Right now, the assembly in this file limits
7 * this code to AMD 64.
8 *
9 * This file is public domain.
10 */
11
12 /* TomsFastMath, a fast ISO C bignum library.
13 *
14 * This project is meant to fill in where LibTomMath
15 * falls short. That is speed ;-)
16 *
17 * This project is public domain and free for all purposes.
18 *
19 * Tom St Denis, tomstdenis@iahu.ca
20 */
21
22
23 #include "mpi-priv.h"
24
25
26
27 /* clamp digits */
28 #define mp_clamp(a) { while ((a)->used && (a)->dp[(a)->used-1] == 0) --((a)->used); (a)->sign = (a)->used ? (a)->sign : ZPOS; }
29
30 /* anything you need at the start */
31 #define COMBA_START
32
33 /* clear the chaining variables */
34 #define COMBA_CLEAR \
35 c0 = c1 = c2 = 0;
36
37 /* forward the carry to the next digit */
38 #define COMBA_FORWARD \
39 do { c0 = c1; c1 = c2; c2 = 0; } while (0);
40
41 /* anything you need at the end */
42 #define COMBA_FINI
43
44 /* this should multiply i and j */
45 #define MULADD(i, j) \
46 __asm__ ( \
47 "movq %6,%%rax \n\t" \
48 "mulq %7 \n\t" \
49 "addq %%rax,%0 \n\t" \
50 "adcq %%rdx,%1 \n\t" \
51 "adcq $0,%2 \n\t" \
52 :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j) :"%rax","%rdx","cc");
53
54
55
56
57 /* sqr macros only */
58 #define CLEAR_CARRY \
59 c0 = c1 = c2 = 0;
60
61 #define COMBA_STORE(x) \
62 x = c0;
63
64 #define COMBA_STORE2(x) \
65 x = c1;
66
67 #define CARRY_FORWARD \
68 do { c0 = c1; c1 = c2; c2 = 0; } while (0);
69
70 #define COMBA_FINI
71
72 #define SQRADD(i, j) \
73 __asm__ ( \
74 "movq %6,%%rax \n\t" \
75 "mulq %%rax \n\t" \
76 "addq %%rax,%0 \n\t" \
77 "adcq %%rdx,%1 \n\t" \
78 "adcq $0,%2 \n\t" \
79 :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i) :"%rax","%rdx","cc");
80
81 #define SQRADD2(i, j) \
82 __asm__ ( \
83 "movq %6,%%rax \n\t" \
84 "mulq %7 \n\t" \
85 "addq %%rax,%0 \n\t" \
86 "adcq %%rdx,%1 \n\t" \
87 "adcq $0,%2 \n\t" \
88 "addq %%rax,%0 \n\t" \
89 "adcq %%rdx,%1 \n\t" \
90 "adcq $0,%2 \n\t" \
91 :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j) :"%rax","%rdx","cc");
92
93 #define SQRADDSC(i, j) \
94 __asm__ ( \
95 "movq %3,%%rax \n\t" \
96 "mulq %4 \n\t" \
97 "movq %%rax,%0 \n\t" \
98 "movq %%rdx,%1 \n\t" \
99 "xorq %2,%2 \n\t" \
100 :"=r"(sc0), "=r"(sc1), "=r"(sc2): "g"(i), "g"(j) :"%rax","%rdx","cc");
101
102 #define SQRADDAC(i, j) \
103 __asm__ ( \
104 "movq %6,%%rax \n\t" \
105 "mulq %7 \n\t" \
106 "addq %%rax,%0 \n\t" \
107 "adcq %%rdx,%1 \n\t" \
108 "adcq $0,%2 \n\t" \
109 :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%rax","%rdx","cc");
110
111 #define SQRADDDB \
112 __asm__ ( \
113 "addq %6,%0 \n\t" \
114 "adcq %7,%1 \n\t" \
115 "adcq %8,%2 \n\t" \
116 "addq %6,%0 \n\t" \
117 "adcq %7,%1 \n\t" \
118 "adcq %8,%2 \n\t" \
119 :"=&r"(c0), "=&r"(c1), "=&r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "cc");
120
121
122
123
124
125 void s_mp_mul_comba_4(const mp_int *A, const mp_int *B, mp_int *C)
126 {
127 mp_digit c0, c1, c2, at[8];
128
129 memcpy(at, A->dp, 4 * sizeof(mp_digit));
130 memcpy(at+4, B->dp, 4 * sizeof(mp_digit));
131 COMBA_START;
132
133 COMBA_CLEAR;
134 /* 0 */
135 MULADD(at[0], at[4]);
136 COMBA_STORE(C->dp[0]);
137 /* 1 */
138 COMBA_FORWARD;
139 MULADD(at[0], at[5]); MULADD(at[1], at[4]);
140 COMBA_STORE(C->dp[1]);
141 /* 2 */
142 COMBA_FORWARD;
143 MULADD(at[0], at[6]); MULADD(at[1], at[5]); MULADD(at[2], at[4]);
144 COMBA_STORE(C->dp[2]);
145 /* 3 */
146 COMBA_FORWARD;
147 MULADD(at[0], at[7]); MULADD(at[1], at[6]); MULADD(at[2], at[5]); MULADD(at[3], at[4]);
148 COMBA_STORE(C->dp[3]);
149 /* 4 */
150 COMBA_FORWARD;
151 MULADD(at[1], at[7]); MULADD(at[2], at[6]); MULADD(at[3], at[5]);
152 COMBA_STORE(C->dp[4]);
153 /* 5 */
154 COMBA_FORWARD;
155 MULADD(at[2], at[7]); MULADD(at[3], at[6]);
156 COMBA_STORE(C->dp[5]);
157 /* 6 */
158 COMBA_FORWARD;
159 MULADD(at[3], at[7]);
160 COMBA_STORE(C->dp[6]);
161 COMBA_STORE2(C->dp[7]);
162 C->used = 8;
163 C->sign = A->sign ^ B->sign;
164 mp_clamp(C);
165 COMBA_FINI;
166 }
167
168 void s_mp_mul_comba_8(const mp_int *A, const mp_int *B, mp_int *C)
169 {
170 mp_digit c0, c1, c2, at[16];
171
172 memcpy(at, A->dp, 8 * sizeof(mp_digit));
173 memcpy(at+8, B->dp, 8 * sizeof(mp_digit));
174 COMBA_START;
175
176 COMBA_CLEAR;
177 /* 0 */
178 MULADD(at[0], at[8]);
179 COMBA_STORE(C->dp[0]);
180 /* 1 */
181 COMBA_FORWARD;
182 MULADD(at[0], at[9]); MULADD(at[1], at[8]);
183 COMBA_STORE(C->dp[1]);
184 /* 2 */
185 COMBA_FORWARD;
186 MULADD(at[0], at[10]); MULADD(at[1], at[9]); MULADD(at[2], at[8]);
187 COMBA_STORE(C->dp[2]);
188 /* 3 */
189 COMBA_FORWARD;
190 MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); MULADD(at[3], at[8]);
191 COMBA_STORE(C->dp[3]);
192 /* 4 */
193 COMBA_FORWARD;
194 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]);
195 COMBA_STORE(C->dp[4]);
196 /* 5 */
197 COMBA_FORWARD;
198 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]);
199 COMBA_STORE(C->dp[5]);
200 /* 6 */
201 COMBA_FORWARD;
202 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]);
203 COMBA_STORE(C->dp[6]);
204 /* 7 */
205 COMBA_FORWARD;
206 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]);
207 COMBA_STORE(C->dp[7]);
208 /* 8 */
209 COMBA_FORWARD;
210 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]);
211 COMBA_STORE(C->dp[8]);
212 /* 9 */
213 COMBA_FORWARD;
214 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]);
215 COMBA_STORE(C->dp[9]);
216 /* 10 */
217 COMBA_FORWARD;
218 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]);
219 COMBA_STORE(C->dp[10]);
220 /* 11 */
221 COMBA_FORWARD;
222 MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]);
223 COMBA_STORE(C->dp[11]);
224 /* 12 */
225 COMBA_FORWARD;
226 MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]);
227 COMBA_STORE(C->dp[12]);
228 /* 13 */
229 COMBA_FORWARD;
230 MULADD(at[6], at[15]); MULADD(at[7], at[14]);
231 COMBA_STORE(C->dp[13]);
232 /* 14 */
233 COMBA_FORWARD;
234 MULADD(at[7], at[15]);
235 COMBA_STORE(C->dp[14]);
236 COMBA_STORE2(C->dp[15]);
237 C->used = 16;
238 C->sign = A->sign ^ B->sign;
239 mp_clamp(C);
240 COMBA_FINI;
241 }
242
243 void s_mp_mul_comba_16(const mp_int *A, const mp_int *B, mp_int *C)
244 {
245 mp_digit c0, c1, c2, at[32];
246
247 memcpy(at, A->dp, 16 * sizeof(mp_digit));
248 memcpy(at+16, B->dp, 16 * sizeof(mp_digit));
249 COMBA_START;
250
251 COMBA_CLEAR;
252 /* 0 */
253 MULADD(at[0], at[16]);
254 COMBA_STORE(C->dp[0]);
255 /* 1 */
256 COMBA_FORWARD;
257 MULADD(at[0], at[17]); MULADD(at[1], at[16]);
258 COMBA_STORE(C->dp[1]);
259 /* 2 */
260 COMBA_FORWARD;
261 MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]);
262 COMBA_STORE(C->dp[2]);
263 /* 3 */
264 COMBA_FORWARD;
265 MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]);
266 COMBA_STORE(C->dp[3]);
267 /* 4 */
268 COMBA_FORWARD;
269 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]);
270 COMBA_STORE(C->dp[4]);
271 /* 5 */
272 COMBA_FORWARD;
273 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]);
274 COMBA_STORE(C->dp[5]);
275 /* 6 */
276 COMBA_FORWARD;
277 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]);
278 COMBA_STORE(C->dp[6]);
279 /* 7 */
280 COMBA_FORWARD;
281 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]);
282 COMBA_STORE(C->dp[7]);
283 /* 8 */
284 COMBA_FORWARD;
285 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]);
286 COMBA_STORE(C->dp[8]);
287 /* 9 */
288 COMBA_FORWARD;
289 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]);
290 COMBA_STORE(C->dp[9]);
291 /* 10 */
292 COMBA_FORWARD;
293 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]);
294 COMBA_STORE(C->dp[10]);
295 /* 11 */
296 COMBA_FORWARD;
297 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]);
298 COMBA_STORE(C->dp[11]);
299 /* 12 */
300 COMBA_FORWARD;
301 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]);
302 COMBA_STORE(C->dp[12]);
303 /* 13 */
304 COMBA_FORWARD;
305 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]);
306 COMBA_STORE(C->dp[13]);
307 /* 14 */
308 COMBA_FORWARD;
309 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]);
310 COMBA_STORE(C->dp[14]);
311 /* 15 */
312 COMBA_FORWARD;
313 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]);
314 COMBA_STORE(C->dp[15]);
315 /* 16 */
316 COMBA_FORWARD;
317 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]);
318 COMBA_STORE(C->dp[16]);
319 /* 17 */
320 COMBA_FORWARD;
321 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]);
322 COMBA_STORE(C->dp[17]);
323 /* 18 */
324 COMBA_FORWARD;
325 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]);
326 COMBA_STORE(C->dp[18]);
327 /* 19 */
328 COMBA_FORWARD;
329 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]);
330 COMBA_STORE(C->dp[19]);
331 /* 20 */
332 COMBA_FORWARD;
333 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]);
334 COMBA_STORE(C->dp[20]);
335 /* 21 */
336 COMBA_FORWARD;
337 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]);
338 COMBA_STORE(C->dp[21]);
339 /* 22 */
340 COMBA_FORWARD;
341 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]);
342 COMBA_STORE(C->dp[22]);
343 /* 23 */
344 COMBA_FORWARD;
345 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]);
346 COMBA_STORE(C->dp[23]);
347 /* 24 */
348 COMBA_FORWARD;
349 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]);
350 COMBA_STORE(C->dp[24]);
351 /* 25 */
352 COMBA_FORWARD;
353 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]);
354 COMBA_STORE(C->dp[25]);
355 /* 26 */
356 COMBA_FORWARD;
357 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]);
358 COMBA_STORE(C->dp[26]);
359 /* 27 */
360 COMBA_FORWARD;
361 MULADD(at[12], at[31]); MULADD(at[13], at[30]); MULADD(at[14], at[29]); MULADD(at[15], at[28]);
362 COMBA_STORE(C->dp[27]);
363 /* 28 */
364 COMBA_FORWARD;
365 MULADD(at[13], at[31]); MULADD(at[14], at[30]); MULADD(at[15], at[29]);
366 COMBA_STORE(C->dp[28]);
367 /* 29 */
368 COMBA_FORWARD;
369 MULADD(at[14], at[31]); MULADD(at[15], at[30]);
370 COMBA_STORE(C->dp[29]);
371 /* 30 */
372 COMBA_FORWARD;
373 MULADD(at[15], at[31]);
374 COMBA_STORE(C->dp[30]);
375 COMBA_STORE2(C->dp[31]);
376 C->used = 32;
377 C->sign = A->sign ^ B->sign;
378 mp_clamp(C);
379 COMBA_FINI;
380 }
381
382 void s_mp_mul_comba_32(const mp_int *A, const mp_int *B, mp_int *C)
383 {
384 mp_digit c0, c1, c2, at[64];
385
386 memcpy(at, A->dp, 32 * sizeof(mp_digit));
387 memcpy(at+32, B->dp, 32 * sizeof(mp_digit));
388 COMBA_START;
389
390 COMBA_CLEAR;
391 /* 0 */
392 MULADD(at[0], at[32]);
393 COMBA_STORE(C->dp[0]);
394 /* 1 */
395 COMBA_FORWARD;
396 MULADD(at[0], at[33]); MULADD(at[1], at[32]);
397 COMBA_STORE(C->dp[1]);
398 /* 2 */
399 COMBA_FORWARD;
400 MULADD(at[0], at[34]); MULADD(at[1], at[33]); MULADD(at[2], at[32]);
401 COMBA_STORE(C->dp[2]);
402 /* 3 */
403 COMBA_FORWARD;
404 MULADD(at[0], at[35]); MULADD(at[1], at[34]); MULADD(at[2], at[33]); MULADD(at[3], at[32]);
405 COMBA_STORE(C->dp[3]);
406 /* 4 */
407 COMBA_FORWARD;
408 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]);
409 COMBA_STORE(C->dp[4]);
410 /* 5 */
411 COMBA_FORWARD;
412 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]);
413 COMBA_STORE(C->dp[5]);
414 /* 6 */
415 COMBA_FORWARD;
416 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]);
417 COMBA_STORE(C->dp[6]);
418 /* 7 */
419 COMBA_FORWARD;
420 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]);
421 COMBA_STORE(C->dp[7]);
422 /* 8 */
423 COMBA_FORWARD;
424 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]);
425 COMBA_STORE(C->dp[8]);
426 /* 9 */
427 COMBA_FORWARD;
428 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]);
429 COMBA_STORE(C->dp[9]);
430 /* 10 */
431 COMBA_FORWARD;
432 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]);
433 COMBA_STORE(C->dp[10]);
434 /* 11 */
435 COMBA_FORWARD;
436 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]);
437 COMBA_STORE(C->dp[11]);
438 /* 12 */
439 COMBA_FORWARD;
440 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]);
441 COMBA_STORE(C->dp[12]);
442 /* 13 */
443 COMBA_FORWARD;
444 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]);
445 COMBA_STORE(C->dp[13]);
446 /* 14 */
447 COMBA_FORWARD;
448 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]);
449 COMBA_STORE(C->dp[14]);
450 /* 15 */
451 COMBA_FORWARD;
452 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]);
453 COMBA_STORE(C->dp[15]);
454 /* 16 */
455 COMBA_FORWARD;
456 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]);
457 COMBA_STORE(C->dp[16]);
458 /* 17 */
459 COMBA_FORWARD;
460 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]);
461 COMBA_STORE(C->dp[17]);
462 /* 18 */
463 COMBA_FORWARD;
464 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]);
465 COMBA_STORE(C->dp[18]);
466 /* 19 */
467 COMBA_FORWARD;
468 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]);
469 COMBA_STORE(C->dp[19]);
470 /* 20 */
471 COMBA_FORWARD;
472 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]);
473 COMBA_STORE(C->dp[20]);
474 /* 21 */
475 COMBA_FORWARD;
476 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]);
477 COMBA_STORE(C->dp[21]);
478 /* 22 */
479 COMBA_FORWARD;
480 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]);
481 COMBA_STORE(C->dp[22]);
482 /* 23 */
483 COMBA_FORWARD;
484 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]);
485 COMBA_STORE(C->dp[23]);
486 /* 24 */
487 COMBA_FORWARD;
488 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]);
489 COMBA_STORE(C->dp[24]);
490 /* 25 */
491 COMBA_FORWARD;
492 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]);
493 COMBA_STORE(C->dp[25]);
494 /* 26 */
495 COMBA_FORWARD;
496 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]);
497 COMBA_STORE(C->dp[26]);
498 /* 27 */
499 COMBA_FORWARD;
500 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]);
501 COMBA_STORE(C->dp[27]);
502 /* 28 */
503 COMBA_FORWARD;
504 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]);
505 COMBA_STORE(C->dp[28]);
506 /* 29 */
507 COMBA_FORWARD;
508 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]);
509 COMBA_STORE(C->dp[29]);
510 /* 30 */
511 COMBA_FORWARD;
512 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]);
513 COMBA_STORE(C->dp[30]);
514 /* 31 */
515 COMBA_FORWARD;
516 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]);
517 COMBA_STORE(C->dp[31]);
518 /* 32 */
519 COMBA_FORWARD;
520 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]);
521 COMBA_STORE(C->dp[32]);
522 /* 33 */
523 COMBA_FORWARD;
524 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]);
525 COMBA_STORE(C->dp[33]);
526 /* 34 */
527 COMBA_FORWARD;
528 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]);
529 COMBA_STORE(C->dp[34]);
530 /* 35 */
531 COMBA_FORWARD;
532 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]);
533 COMBA_STORE(C->dp[35]);
534 /* 36 */
535 COMBA_FORWARD;
536 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]);
537 COMBA_STORE(C->dp[36]);
538 /* 37 */
539 COMBA_FORWARD;
540 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]);
541 COMBA_STORE(C->dp[37]);
542 /* 38 */
543 COMBA_FORWARD;
544 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]);
545 COMBA_STORE(C->dp[38]);
546 /* 39 */
547 COMBA_FORWARD;
548 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]);
549 COMBA_STORE(C->dp[39]);
550 /* 40 */
551 COMBA_FORWARD;
552 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]);
553 COMBA_STORE(C->dp[40]);
554 /* 41 */
555 COMBA_FORWARD;
556 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]);
557 COMBA_STORE(C->dp[41]);
558 /* 42 */
559 COMBA_FORWARD;
560 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]);
561 COMBA_STORE(C->dp[42]);
562 /* 43 */
563 COMBA_FORWARD;
564 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]);
565 COMBA_STORE(C->dp[43]);
566 /* 44 */
567 COMBA_FORWARD;
568 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]);
569 COMBA_STORE(C->dp[44]);
570 /* 45 */
571 COMBA_FORWARD;
572 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]);
573 COMBA_STORE(C->dp[45]);
574 /* 46 */
575 COMBA_FORWARD;
576 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]);
577 COMBA_STORE(C->dp[46]);
578 /* 47 */
579 COMBA_FORWARD;
580 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]);
581 COMBA_STORE(C->dp[47]);
582 /* 48 */
583 COMBA_FORWARD;
584 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]);
585 COMBA_STORE(C->dp[48]);
586 /* 49 */
587 COMBA_FORWARD;
588 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]);
589 COMBA_STORE(C->dp[49]);
590 /* 50 */
591 COMBA_FORWARD;
592 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]);
593 COMBA_STORE(C->dp[50]);
594 /* 51 */
595 COMBA_FORWARD;
596 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]);
597 COMBA_STORE(C->dp[51]);
598 /* 52 */
599 COMBA_FORWARD;
600 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]);
601 COMBA_STORE(C->dp[52]);
602 /* 53 */
603 COMBA_FORWARD;
604 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]);
605 COMBA_STORE(C->dp[53]);
606 /* 54 */
607 COMBA_FORWARD;
608 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]);
609 COMBA_STORE(C->dp[54]);
610 /* 55 */
611 COMBA_FORWARD;
612 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]);
613 COMBA_STORE(C->dp[55]);
614 /* 56 */
615 COMBA_FORWARD;
616 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]);
617 COMBA_STORE(C->dp[56]);
618 /* 57 */
619 COMBA_FORWARD;
620 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]);
621 COMBA_STORE(C->dp[57]);
622 /* 58 */
623 COMBA_FORWARD;
624 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]);
625 COMBA_STORE(C->dp[58]);
626 /* 59 */
627 COMBA_FORWARD;
628 MULADD(at[28], at[63]); MULADD(at[29], at[62]); MULADD(at[30], at[61]); MULADD(at[31], at[60]);
629 COMBA_STORE(C->dp[59]);
630 /* 60 */
631 COMBA_FORWARD;
632 MULADD(at[29], at[63]); MULADD(at[30], at[62]); MULADD(at[31], at[61]);
633 COMBA_STORE(C->dp[60]);
634 /* 61 */
635 COMBA_FORWARD;
636 MULADD(at[30], at[63]); MULADD(at[31], at[62]);
637 COMBA_STORE(C->dp[61]);
638 /* 62 */
639 COMBA_FORWARD;
640 MULADD(at[31], at[63]);
641 COMBA_STORE(C->dp[62]);
642 COMBA_STORE2(C->dp[63]);
643 C->used = 64;
644 C->sign = A->sign ^ B->sign;
645 mp_clamp(C);
646 COMBA_FINI;
647 }
648
649
650
651 void s_mp_sqr_comba_4(const mp_int *A, mp_int *B)
652 {
653 mp_digit *a, b[8], c0, c1, c2;
654
655 a = A->dp;
656 COMBA_START;
657
658 /* clear carries */
659 CLEAR_CARRY;
660
661 /* output 0 */
662 SQRADD(a[0],a[0]);
663 COMBA_STORE(b[0]);
664
665 /* output 1 */
666 CARRY_FORWARD;
667 SQRADD2(a[0], a[1]);
668 COMBA_STORE(b[1]);
669
670 /* output 2 */
671 CARRY_FORWARD;
672 SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
673 COMBA_STORE(b[2]);
674
675 /* output 3 */
676 CARRY_FORWARD;
677 SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
678 COMBA_STORE(b[3]);
679
680 /* output 4 */
681 CARRY_FORWARD;
682 SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
683 COMBA_STORE(b[4]);
684
685 /* output 5 */
686 CARRY_FORWARD;
687 SQRADD2(a[2], a[3]);
688 COMBA_STORE(b[5]);
689
690 /* output 6 */
691 CARRY_FORWARD;
692 SQRADD(a[3], a[3]);
693 COMBA_STORE(b[6]);
694 COMBA_STORE2(b[7]);
695 COMBA_FINI;
696
697 B->used = 8;
698 B->sign = ZPOS;
699 memcpy(B->dp, b, 8 * sizeof(mp_digit));
700 mp_clamp(B);
701 }
702
703 void s_mp_sqr_comba_8(const mp_int *A, mp_int *B)
704 {
705 mp_digit *a, b[16], c0, c1, c2, sc0, sc1, sc2;
706
707 a = A->dp;
708 COMBA_START;
709
710 /* clear carries */
711 CLEAR_CARRY;
712
713 /* output 0 */
714 SQRADD(a[0],a[0]);
715 COMBA_STORE(b[0]);
716
717 /* output 1 */
718 CARRY_FORWARD;
719 SQRADD2(a[0], a[1]);
720 COMBA_STORE(b[1]);
721
722 /* output 2 */
723 CARRY_FORWARD;
724 SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
725 COMBA_STORE(b[2]);
726
727 /* output 3 */
728 CARRY_FORWARD;
729 SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
730 COMBA_STORE(b[3]);
731
732 /* output 4 */
733 CARRY_FORWARD;
734 SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
735 COMBA_STORE(b[4]);
736
737 /* output 5 */
738 CARRY_FORWARD;
739 SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB;
740 COMBA_STORE(b[5]);
741
742 /* output 6 */
743 CARRY_FORWARD;
744 SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]);
745 COMBA_STORE(b[6]);
746
747 /* output 7 */
748 CARRY_FORWARD;
749 SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB;
750 COMBA_STORE(b[7]);
751
752 /* output 8 */
753 CARRY_FORWARD;
754 SQRADDSC(a[1], a[7]); SQRADDAC(a[2], a[6]); SQRADDAC(a[3], a[5]); SQRADDDB; SQRADD(a[4], a[4]);
755 COMBA_STORE(b[8]);
756
757 /* output 9 */
758 CARRY_FORWARD;
759 SQRADDSC(a[2], a[7]); SQRADDAC(a[3], a[6]); SQRADDAC(a[4], a[5]); SQRADDDB;
760 COMBA_STORE(b[9]);
761
762 /* output 10 */
763 CARRY_FORWARD;
764 SQRADD2(a[3], a[7]); SQRADD2(a[4], a[6]); SQRADD(a[5], a[5]);
765 COMBA_STORE(b[10]);
766
767 /* output 11 */
768 CARRY_FORWARD;
769 SQRADD2(a[4], a[7]); SQRADD2(a[5], a[6]);
770 COMBA_STORE(b[11]);
771
772 /* output 12 */
773 CARRY_FORWARD;
774 SQRADD2(a[5], a[7]); SQRADD(a[6], a[6]);
775 COMBA_STORE(b[12]);
776
777 /* output 13 */
778 CARRY_FORWARD;
779 SQRADD2(a[6], a[7]);
780 COMBA_STORE(b[13]);
781
782 /* output 14 */
783 CARRY_FORWARD;
784 SQRADD(a[7], a[7]);
785 COMBA_STORE(b[14]);
786 COMBA_STORE2(b[15]);
787 COMBA_FINI;
788
789 B->used = 16;
790 B->sign = ZPOS;
791 memcpy(B->dp, b, 16 * sizeof(mp_digit));
792 mp_clamp(B);
793 }
794
795 void s_mp_sqr_comba_16(const mp_int *A, mp_int *B)
796 {
797 mp_digit *a, b[32], c0, c1, c2, sc0, sc1, sc2;
798
799 a = A->dp;
800 COMBA_START;
801
802 /* clear carries */
803 CLEAR_CARRY;
804
805 /* output 0 */
806 SQRADD(a[0],a[0]);
807 COMBA_STORE(b[0]);
808
809 /* output 1 */
810 CARRY_FORWARD;
811 SQRADD2(a[0], a[1]);
812 COMBA_STORE(b[1]);
813
814 /* output 2 */
815 CARRY_FORWARD;
816 SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
817 COMBA_STORE(b[2]);
818
819 /* output 3 */
820 CARRY_FORWARD;
821 SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
822 COMBA_STORE(b[3]);
823
824 /* output 4 */
825 CARRY_FORWARD;
826 SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
827 COMBA_STORE(b[4]);
828
829 /* output 5 */
830 CARRY_FORWARD;
831 SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB;
832 COMBA_STORE(b[5]);
833
834 /* output 6 */
835 CARRY_FORWARD;
836 SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]);
837 COMBA_STORE(b[6]);
838
839 /* output 7 */
840 CARRY_FORWARD;
841 SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB;
842 COMBA_STORE(b[7]);
843
844 /* output 8 */
845 CARRY_FORWARD;
846 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]);
847 COMBA_STORE(b[8]);
848
849 /* output 9 */
850 CARRY_FORWARD;
851 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;
852 COMBA_STORE(b[9]);
853
854 /* output 10 */
855 CARRY_FORWARD;
856 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]);
857 COMBA_STORE(b[10]);
858
859 /* output 11 */
860 CARRY_FORWARD;
861 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;
862 COMBA_STORE(b[11]);
863
864 /* output 12 */
865 CARRY_FORWARD;
866 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]);
867 COMBA_STORE(b[12]);
868
869 /* output 13 */
870 CARRY_FORWARD;
871 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;
872 COMBA_STORE(b[13]);
873
874 /* output 14 */
875 CARRY_FORWARD;
876 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]);
877 COMBA_STORE(b[14]);
878
879 /* output 15 */
880 CARRY_FORWARD;
881 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;
882 COMBA_STORE(b[15]);
883
884 /* output 16 */
885 CARRY_FORWARD;
886 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]);
887 COMBA_STORE(b[16]);
888
889 /* output 17 */
890 CARRY_FORWARD;
891 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;
892 COMBA_STORE(b[17]);
893
894 /* output 18 */
895 CARRY_FORWARD;
896 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]);
897 COMBA_STORE(b[18]);
898
899 /* output 19 */
900 CARRY_FORWARD;
901 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;
902 COMBA_STORE(b[19]);
903
904 /* output 20 */
905 CARRY_FORWARD;
906 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]);
907 COMBA_STORE(b[20]);
908
909 /* output 21 */
910 CARRY_FORWARD;
911 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;
912 COMBA_STORE(b[21]);
913
914 /* output 22 */
915 CARRY_FORWARD;
916 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]);
917 COMBA_STORE(b[22]);
918
919 /* output 23 */
920 CARRY_FORWARD;
921 SQRADDSC(a[8], a[15]); SQRADDAC(a[9], a[14]); SQRADDAC(a[10], a[13]); SQRADDAC(a[11], a[12]); SQRADDDB;
922 COMBA_STORE(b[23]);
923
924 /* output 24 */
925 CARRY_FORWARD;
926 SQRADDSC(a[9], a[15]); SQRADDAC(a[10], a[14]); SQRADDAC(a[11], a[13]); SQRADDDB; SQRADD(a[12], a[12]);
927 COMBA_STORE(b[24]);
928
929 /* output 25 */
930 CARRY_FORWARD;
931 SQRADDSC(a[10], a[15]); SQRADDAC(a[11], a[14]); SQRADDAC(a[12], a[13]); SQRADDDB;
932 COMBA_STORE(b[25]);
933
934 /* output 26 */
935 CARRY_FORWARD;
936 SQRADD2(a[11], a[15]); SQRADD2(a[12], a[14]); SQRADD(a[13], a[13]);
937 COMBA_STORE(b[26]);
938
939 /* output 27 */
940 CARRY_FORWARD;
941 SQRADD2(a[12], a[15]); SQRADD2(a[13], a[14]);
942 COMBA_STORE(b[27]);
943
944 /* output 28 */
945 CARRY_FORWARD;
946 SQRADD2(a[13], a[15]); SQRADD(a[14], a[14]);
947 COMBA_STORE(b[28]);
948
949 /* output 29 */
950 CARRY_FORWARD;
951 SQRADD2(a[14], a[15]);
952 COMBA_STORE(b[29]);
953
954 /* output 30 */
955 CARRY_FORWARD;
956 SQRADD(a[15], a[15]);
957 COMBA_STORE(b[30]);
958 COMBA_STORE2(b[31]);
959 COMBA_FINI;
960
961 B->used = 32;
962 B->sign = ZPOS;
963 memcpy(B->dp, b, 32 * sizeof(mp_digit));
964 mp_clamp(B);
965 }
966
967
968 void s_mp_sqr_comba_32(const mp_int *A, mp_int *B)
969 {
970 mp_digit *a, b[64], c0, c1, c2, sc0, sc1, sc2;
971
972 a = A->dp;
973 COMBA_START;
974
975 /* clear carries */
976 CLEAR_CARRY;
977
978 /* output 0 */
979 SQRADD(a[0],a[0]);
980 COMBA_STORE(b[0]);
981
982 /* output 1 */
983 CARRY_FORWARD;
984 SQRADD2(a[0], a[1]);
985 COMBA_STORE(b[1]);
986
987 /* output 2 */
988 CARRY_FORWARD;
989 SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]);
990 COMBA_STORE(b[2]);
991
992 /* output 3 */
993 CARRY_FORWARD;
994 SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]);
995 COMBA_STORE(b[3]);
996
997 /* output 4 */
998 CARRY_FORWARD;
999 SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]);
1000 COMBA_STORE(b[4]);
1001
1002 /* output 5 */
1003 CARRY_FORWARD;
1004 SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB;
1005 COMBA_STORE(b[5]);
1006
1007 /* output 6 */
1008 CARRY_FORWARD;
1009 SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]);
1010 COMBA_STORE(b[6]);
1011
1012 /* output 7 */
1013 CARRY_FORWARD;
1014 SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB;
1015 COMBA_STORE(b[7]);
1016
1017 /* output 8 */
1018 CARRY_FORWARD;
1019 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]);
1020 COMBA_STORE(b[8]);
1021
1022 /* output 9 */
1023 CARRY_FORWARD;
1024 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;
1025 COMBA_STORE(b[9]);
1026
1027 /* output 10 */
1028 CARRY_FORWARD;
1029 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]);
1030 COMBA_STORE(b[10]);
1031
1032 /* output 11 */
1033 CARRY_FORWARD;
1034 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;
1035 COMBA_STORE(b[11]);
1036
1037 /* output 12 */
1038 CARRY_FORWARD;
1039 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]);
1040 COMBA_STORE(b[12]);
1041
1042 /* output 13 */
1043 CARRY_FORWARD;
1044 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;
1045 COMBA_STORE(b[13]);
1046
1047 /* output 14 */
1048 CARRY_FORWARD;
1049 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]);
1050 COMBA_STORE(b[14]);
1051
1052 /* output 15 */
1053 CARRY_FORWARD;
1054 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;
1055 COMBA_STORE(b[15]);
1056
1057 /* output 16 */
1058 CARRY_FORWARD;
1059 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]);
1060 COMBA_STORE(b[16]);
1061
1062 /* output 17 */
1063 CARRY_FORWARD;
1064 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;
1065 COMBA_STORE(b[17]);
1066
1067 /* output 18 */
1068 CARRY_FORWARD;
1069 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]);
1070 COMBA_STORE(b[18]);
1071
1072 /* output 19 */
1073 CARRY_FORWARD;
1074 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;
1075 COMBA_STORE(b[19]);
1076
1077 /* output 20 */
1078 CARRY_FORWARD;
1079 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]);
1080 COMBA_STORE(b[20]);
1081
1082 /* output 21 */
1083 CARRY_FORWARD;
1084 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;
1085 COMBA_STORE(b[21]);
1086
1087 /* output 22 */
1088 CARRY_FORWARD;
1089 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]);
1090 COMBA_STORE(b[22]);
1091
1092 /* output 23 */
1093 CARRY_FORWARD;
1094 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;
1095 COMBA_STORE(b[23]);
1096
1097 /* output 24 */
1098 CARRY_FORWARD;
1099 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]);
1100 COMBA_STORE(b[24]);
1101
1102 /* output 25 */
1103 CARRY_FORWARD;
1104 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;
1105 COMBA_STORE(b[25]);
1106
1107 /* output 26 */
1108 CARRY_FORWARD;
1109 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]);
1110 COMBA_STORE(b[26]);
1111
1112 /* output 27 */
1113 CARRY_FORWARD;
1114 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;
1115 COMBA_STORE(b[27]);
1116
1117 /* output 28 */
1118 CARRY_FORWARD;
1119 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]);
1120 COMBA_STORE(b[28]);
1121
1122 /* output 29 */
1123 CARRY_FORWARD;
1124 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;
1125 COMBA_STORE(b[29]);
1126
1127 /* output 30 */
1128 CARRY_FORWARD;
1129 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]);
1130 COMBA_STORE(b[30]);
1131
1132 /* output 31 */
1133 CARRY_FORWARD;
1134 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;
1135 COMBA_STORE(b[31]);
1136
1137 /* output 32 */
1138 CARRY_FORWARD;
1139 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]);
1140 COMBA_STORE(b[32]);
1141
1142 /* output 33 */
1143 CARRY_FORWARD;
1144 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;
1145 COMBA_STORE(b[33]);
1146
1147 /* output 34 */
1148 CARRY_FORWARD;
1149 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]);
1150 COMBA_STORE(b[34]);
1151
1152 /* output 35 */
1153 CARRY_FORWARD;
1154 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;
1155 COMBA_STORE(b[35]);
1156
1157 /* output 36 */
1158 CARRY_FORWARD;
1159 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]);
1160 COMBA_STORE(b[36]);
1161
1162 /* output 37 */
1163 CARRY_FORWARD;
1164 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;
1165 COMBA_STORE(b[37]);
1166
1167 /* output 38 */
1168 CARRY_FORWARD;
1169 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]);
1170 COMBA_STORE(b[38]);
1171
1172 /* output 39 */
1173 CARRY_FORWARD;
1174 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;
1175 COMBA_STORE(b[39]);
1176
1177 /* output 40 */
1178 CARRY_FORWARD;
1179 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]);
1180 COMBA_STORE(b[40]);
1181
1182 /* output 41 */
1183 CARRY_FORWARD;
1184 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;
1185 COMBA_STORE(b[41]);
1186
1187 /* output 42 */
1188 CARRY_FORWARD;
1189 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]);
1190 COMBA_STORE(b[42]);
1191
1192 /* output 43 */
1193 CARRY_FORWARD;
1194 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;
1195 COMBA_STORE(b[43]);
1196
1197 /* output 44 */
1198 CARRY_FORWARD;
1199 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]);
1200 COMBA_STORE(b[44]);
1201
1202 /* output 45 */
1203 CARRY_FORWARD;
1204 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;
1205 COMBA_STORE(b[45]);
1206
1207 /* output 46 */
1208 CARRY_FORWARD;
1209 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]);
1210 COMBA_STORE(b[46]);
1211
1212 /* output 47 */
1213 CARRY_FORWARD;
1214 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;
1215 COMBA_STORE(b[47]);
1216
1217 /* output 48 */
1218 CARRY_FORWARD;
1219 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]);
1220 COMBA_STORE(b[48]);
1221
1222 /* output 49 */
1223 CARRY_FORWARD;
1224 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;
1225 COMBA_STORE(b[49]);
1226
1227 /* output 50 */
1228 CARRY_FORWARD;
1229 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]);
1230 COMBA_STORE(b[50]);
1231
1232 /* output 51 */
1233 CARRY_FORWARD;
1234 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;
1235 COMBA_STORE(b[51]);
1236
1237 /* output 52 */
1238 CARRY_FORWARD;
1239 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]);
1240 COMBA_STORE(b[52]);
1241
1242 /* output 53 */
1243 CARRY_FORWARD;
1244 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;
1245 COMBA_STORE(b[53]);
1246
1247 /* output 54 */
1248 CARRY_FORWARD;
1249 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]);
1250 COMBA_STORE(b[54]);
1251
1252 /* output 55 */
1253 CARRY_FORWARD;
1254 SQRADDSC(a[24], a[31]); SQRADDAC(a[25], a[30]); SQRADDAC(a[26], a[29]); SQRADDAC(a[27], a[28]); SQRADDDB;
1255 COMBA_STORE(b[55]);
1256
1257 /* output 56 */
1258 CARRY_FORWARD;
1259 SQRADDSC(a[25], a[31]); SQRADDAC(a[26], a[30]); SQRADDAC(a[27], a[29]); SQRADDDB; SQRADD(a[28], a[28]);
1260 COMBA_STORE(b[56]);
1261
1262 /* output 57 */
1263 CARRY_FORWARD;
1264 SQRADDSC(a[26], a[31]); SQRADDAC(a[27], a[30]); SQRADDAC(a[28], a[29]); SQRADDDB;
1265 COMBA_STORE(b[57]);
1266
1267 /* output 58 */
1268 CARRY_FORWARD;
1269 SQRADD2(a[27], a[31]); SQRADD2(a[28], a[30]); SQRADD(a[29], a[29]);
1270 COMBA_STORE(b[58]);
1271
1272 /* output 59 */
1273 CARRY_FORWARD;
1274 SQRADD2(a[28], a[31]); SQRADD2(a[29], a[30]);
1275 COMBA_STORE(b[59]);
1276
1277 /* output 60 */
1278 CARRY_FORWARD;
1279 SQRADD2(a[29], a[31]); SQRADD(a[30], a[30]);
1280 COMBA_STORE(b[60]);
1281
1282 /* output 61 */
1283 CARRY_FORWARD;
1284 SQRADD2(a[30], a[31]);
1285 COMBA_STORE(b[61]);
1286
1287 /* output 62 */
1288 CARRY_FORWARD;
1289 SQRADD(a[31], a[31]);
1290 COMBA_STORE(b[62]);
1291 COMBA_STORE2(b[63]);
1292 COMBA_FINI;
1293
1294 B->used = 64;
1295 B->sign = ZPOS;
1296 memcpy(B->dp, b, 64 * sizeof(mp_digit));
1297 mp_clamp(B);
1298 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial