Source code
Revision control
Copy as Markdown
Other Tools
/*
* The below file is derived from TFM v0.03.
* It contains code from fp_mul_comba.c and
* fp_sqr_comba.c, which contained the following license.
*
* Right now, the assembly in this file limits
* this code to AMD 64.
*
* This file is public domain.
*/
/* TomsFastMath, a fast ISO C bignum library.
*
* This project is meant to fill in where LibTomMath
* falls short. That is speed ;-)
*
* This project is public domain and free for all purposes.
*
* Tom St Denis, tomstdenis@iahu.ca
*/
#include "mpi-priv.h"
/* clamp digits */
#define mp_clamp(a) \
{ \
while ((a)->used && (a)->dp[(a)->used - 1] == 0) \
--((a)->used); \
(a)->sign = (a)->used ? (a)->sign : ZPOS; \
}
/* anything you need at the start */
#define COMBA_START
/* clear the chaining variables */
#define COMBA_CLEAR \
c0 = c1 = c2 = 0;
/* forward the carry to the next digit */
#define COMBA_FORWARD \
do { \
c0 = c1; \
c1 = c2; \
c2 = 0; \
} while (0);
/* anything you need at the end */
#define COMBA_FINI
/* this should multiply i and j */
#define MULADD(i, j) \
__asm__( \
"movq %6,%%rax \n\t" \
"mulq %7 \n\t" \
"addq %%rax,%0 \n\t" \
"adcq %%rdx,%1 \n\t" \
"adcq $0,%2 \n\t" \
: "=r"(c0), "=r"(c1), "=r"(c2) \
: "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j) \
: "%rax", "%rdx", "cc");
/* sqr macros only */
#define CLEAR_CARRY \
c0 = c1 = c2 = 0;
#define COMBA_STORE(x) \
x = c0;
#define COMBA_STORE2(x) \
x = c1;
#define CARRY_FORWARD \
do { \
c0 = c1; \
c1 = c2; \
c2 = 0; \
} while (0);
#define COMBA_FINI
#define SQRADD(i, j) \
__asm__( \
"movq %6,%%rax \n\t" \
"mulq %%rax \n\t" \
"addq %%rax,%0 \n\t" \
"adcq %%rdx,%1 \n\t" \
"adcq $0,%2 \n\t" \
: "=r"(c0), "=r"(c1), "=r"(c2) \
: "0"(c0), "1"(c1), "2"(c2), "g"(i) \
: "%rax", "%rdx", "cc");
#define SQRADD2(i, j) \
__asm__( \
"movq %6,%%rax \n\t" \
"mulq %7 \n\t" \
"addq %%rax,%0 \n\t" \
"adcq %%rdx,%1 \n\t" \
"adcq $0,%2 \n\t" \
"addq %%rax,%0 \n\t" \
"adcq %%rdx,%1 \n\t" \
"adcq $0,%2 \n\t" \
: "=r"(c0), "=r"(c1), "=r"(c2) \
: "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j) \
: "%rax", "%rdx", "cc");
#define SQRADDSC(i, j) \
__asm__( \
"movq %3,%%rax \n\t" \
"mulq %4 \n\t" \
"movq %%rax,%0 \n\t" \
"movq %%rdx,%1 \n\t" \
"xorq %2,%2 \n\t" \
: "=r"(sc0), "=r"(sc1), "=r"(sc2) \
: "g"(i), "g"(j) \
: "%rax", "%rdx", "cc");
#define SQRADDAC(i, j) \
__asm__( \
"movq %6,%%rax \n\t" \
"mulq %7 \n\t" \
"addq %%rax,%0 \n\t" \
"adcq %%rdx,%1 \n\t" \
"adcq $0,%2 \n\t" \
: "=r"(sc0), "=r"(sc1), "=r"(sc2) \
: "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) \
: "%rax", "%rdx", "cc");
#define SQRADDDB \
__asm__( \
"addq %6,%0 \n\t" \
"adcq %7,%1 \n\t" \
"adcq %8,%2 \n\t" \
"addq %6,%0 \n\t" \
"adcq %7,%1 \n\t" \
"adcq %8,%2 \n\t" \
: "=&r"(c0), "=&r"(c1), "=&r"(c2) \
: "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) \
: "cc");
void
s_mp_mul_comba_4(const mp_int *A, const mp_int *B, mp_int *C)
{
mp_digit c0, c1, c2, at[8];
memcpy(at, A->dp, 4 * sizeof(mp_digit));
memcpy(at + 4, B->dp, 4 * sizeof(mp_digit));
COMBA_START;
COMBA_CLEAR;
/* 0 */
MULADD(at[0], at[4]);
COMBA_STORE(C->dp[0]);
/* 1 */
COMBA_FORWARD;
MULADD(at[0], at[5]);
MULADD(at[1], at[4]);
COMBA_STORE(C->dp[1]);
/* 2 */
COMBA_FORWARD;
MULADD(at[0], at[6]);
MULADD(at[1], at[5]);
MULADD(at[2], at[4]);
COMBA_STORE(C->dp[2]);
/* 3 */
COMBA_FORWARD;
MULADD(at[0], at[7]);
MULADD(at[1], at[6]);
MULADD(at[2], at[5]);
MULADD(at[3], at[4]);
COMBA_STORE(C->dp[3]);
/* 4 */
COMBA_FORWARD;
MULADD(at[1], at[7]);
MULADD(at[2], at[6]);
MULADD(at[3], at[5]);
COMBA_STORE(C->dp[4]);
/* 5 */
COMBA_FORWARD;
MULADD(at[2], at[7]);
MULADD(at[3], at[6]);
COMBA_STORE(C->dp[5]);
/* 6 */
COMBA_FORWARD;
MULADD(at[3], at[7]);
COMBA_STORE(C->dp[6]);
COMBA_STORE2(C->dp[7]);
C->used = 8;
C->sign = A->sign ^ B->sign;
mp_clamp(C);
COMBA_FINI;
}
void
s_mp_mul_comba_8(const mp_int *A, const mp_int *B, mp_int *C)
{
mp_digit c0, c1, c2, at[16];
memcpy(at, A->dp, 8 * sizeof(mp_digit));
memcpy(at + 8, B->dp, 8 * sizeof(mp_digit));
COMBA_START;
COMBA_CLEAR;
/* 0 */
MULADD(at[0], at[8]);
COMBA_STORE(C->dp[0]);
/* 1 */
COMBA_FORWARD;
MULADD(at[0], at[9]);
MULADD(at[1], at[8]);
COMBA_STORE(C->dp[1]);
/* 2 */
COMBA_FORWARD;
MULADD(at[0], at[10]);
MULADD(at[1], at[9]);
MULADD(at[2], at[8]);
COMBA_STORE(C->dp[2]);
/* 3 */
COMBA_FORWARD;
MULADD(at[0], at[11]);
MULADD(at[1], at[10]);
MULADD(at[2], at[9]);
MULADD(at[3], at[8]);
COMBA_STORE(C->dp[3]);
/* 4 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[4]);
/* 5 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[5]);
/* 6 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[6]);
/* 7 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[7]);
/* 8 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[8]);
/* 9 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[9]);
/* 10 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[10]);
/* 11 */
COMBA_FORWARD;
MULADD(at[4], at[15]);
MULADD(at[5], at[14]);
MULADD(at[6], at[13]);
MULADD(at[7], at[12]);
COMBA_STORE(C->dp[11]);
/* 12 */
COMBA_FORWARD;
MULADD(at[5], at[15]);
MULADD(at[6], at[14]);
MULADD(at[7], at[13]);
COMBA_STORE(C->dp[12]);
/* 13 */
COMBA_FORWARD;
MULADD(at[6], at[15]);
MULADD(at[7], at[14]);
COMBA_STORE(C->dp[13]);
/* 14 */
COMBA_FORWARD;
MULADD(at[7], at[15]);
COMBA_STORE(C->dp[14]);
COMBA_STORE2(C->dp[15]);
C->used = 16;
C->sign = A->sign ^ B->sign;
mp_clamp(C);
COMBA_FINI;
}
void
s_mp_mul_comba_16(const mp_int *A, const mp_int *B, mp_int *C)
{
mp_digit c0, c1, c2, at[32];
memcpy(at, A->dp, 16 * sizeof(mp_digit));
memcpy(at + 16, B->dp, 16 * sizeof(mp_digit));
COMBA_START;
COMBA_CLEAR;
/* 0 */
MULADD(at[0], at[16]);
COMBA_STORE(C->dp[0]);
/* 1 */
COMBA_FORWARD;
MULADD(at[0], at[17]);
MULADD(at[1], at[16]);
COMBA_STORE(C->dp[1]);
/* 2 */
COMBA_FORWARD;
MULADD(at[0], at[18]);
MULADD(at[1], at[17]);
MULADD(at[2], at[16]);
COMBA_STORE(C->dp[2]);
/* 3 */
COMBA_FORWARD;
MULADD(at[0], at[19]);
MULADD(at[1], at[18]);
MULADD(at[2], at[17]);
MULADD(at[3], at[16]);
COMBA_STORE(C->dp[3]);
/* 4 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[4]);
/* 5 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[5]);
/* 6 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[6]);
/* 7 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[7]);
/* 8 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[8]);
/* 9 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[9]);
/* 10 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[10]);
/* 11 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[11]);
/* 12 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[12]);
/* 13 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[13]);
/* 14 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[14]);
/* 15 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[15]);
/* 16 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[16]);
/* 17 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[17]);
/* 18 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[18]);
/* 19 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[19]);
/* 20 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[20]);
/* 21 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[21]);
/* 22 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[22]);
/* 23 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[23]);
/* 24 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[24]);
/* 25 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[25]);
/* 26 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[26]);
/* 27 */
COMBA_FORWARD;
MULADD(at[12], at[31]);
MULADD(at[13], at[30]);
MULADD(at[14], at[29]);
MULADD(at[15], at[28]);
COMBA_STORE(C->dp[27]);
/* 28 */
COMBA_FORWARD;
MULADD(at[13], at[31]);
MULADD(at[14], at[30]);
MULADD(at[15], at[29]);
COMBA_STORE(C->dp[28]);
/* 29 */
COMBA_FORWARD;
MULADD(at[14], at[31]);
MULADD(at[15], at[30]);
COMBA_STORE(C->dp[29]);
/* 30 */
COMBA_FORWARD;
MULADD(at[15], at[31]);
COMBA_STORE(C->dp[30]);
COMBA_STORE2(C->dp[31]);
C->used = 32;
C->sign = A->sign ^ B->sign;
mp_clamp(C);
COMBA_FINI;
}
void
s_mp_mul_comba_32(const mp_int *A, const mp_int *B, mp_int *C)
{
mp_digit c0, c1, c2, at[64];
memcpy(at, A->dp, 32 * sizeof(mp_digit));
memcpy(at + 32, B->dp, 32 * sizeof(mp_digit));
COMBA_START;
COMBA_CLEAR;
/* 0 */
MULADD(at[0], at[32]);
COMBA_STORE(C->dp[0]);
/* 1 */
COMBA_FORWARD;
MULADD(at[0], at[33]);
MULADD(at[1], at[32]);
COMBA_STORE(C->dp[1]);
/* 2 */
COMBA_FORWARD;
MULADD(at[0], at[34]);
MULADD(at[1], at[33]);
MULADD(at[2], at[32]);
COMBA_STORE(C->dp[2]);
/* 3 */
COMBA_FORWARD;
MULADD(at[0], at[35]);
MULADD(at[1], at[34]);
MULADD(at[2], at[33]);
MULADD(at[3], at[32]);
COMBA_STORE(C->dp[3]);
/* 4 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[4]);
/* 5 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[5]);
/* 6 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[6]);
/* 7 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[7]);
/* 8 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[8]);
/* 9 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[9]);
/* 10 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[10]);
/* 11 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[11]);
/* 12 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[12]);
/* 13 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[13]);
/* 14 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[14]);
/* 15 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[15]);
/* 16 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[16]);
/* 17 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[17]);
/* 18 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[18]);
/* 19 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[19]);
/* 20 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[20]);
/* 21 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[21]);
/* 22 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[22]);
/* 23 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[23]);
/* 24 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[24]);
/* 25 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[25]);
/* 26 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[26]);
/* 27 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[27]);
/* 28 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[28]);
/* 29 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[29]);
/* 30 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[30]);
/* 31 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[31]);
/* 32 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[32]);
/* 33 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[33]);
/* 34 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[34]);
/* 35 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[35]);
/* 36 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[36]);
/* 37 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[37]);
/* 38 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[38]);
/* 39 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[39]);
/* 40 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[40]);
/* 41 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[41]);
/* 42 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[42]);
/* 43 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[43]);
/* 44 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[44]);
/* 45 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[45]);
/* 46 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[46]);
/* 47 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[47]);
/* 48 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[48]);
/* 49 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[49]);
/* 50 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[50]);
/* 51 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[51]);
/* 52 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[52]);
/* 53 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[53]);
/* 54 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[54]);
/* 55 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[55]);
/* 56 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[56]);
/* 57 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[57]);
/* 58 */
COMBA_FORWARD;
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]);
COMBA_STORE(C->dp[58]);
/* 59 */
COMBA_FORWARD;
MULADD(at[28], at[63]);
MULADD(at[29], at[62]);
MULADD(at[30], at[61]);
MULADD(at[31], at[60]);
COMBA_STORE(C->dp[59]);
/* 60 */
COMBA_FORWARD;
MULADD(at[29], at[63]);
MULADD(at[30], at[62]);
MULADD(at[31], at[61]);
COMBA_STORE(C->dp[60]);
/* 61 */
COMBA_FORWARD;
MULADD(at[30], at[63]);
MULADD(at[31], at[62]);
COMBA_STORE(C->dp[61]);
/* 62 */
COMBA_FORWARD;
MULADD(at[31], at[63]);
COMBA_STORE(C->dp[62]);
COMBA_STORE2(C->dp[63]);
C->used = 64;
C->sign = A->sign ^ B->sign;
mp_clamp(C);
COMBA_FINI;
}
void
s_mp_sqr_comba_4(const mp_int *A, mp_int *B)
{
mp_digit *a, b[8], c0, c1, c2;
a = A->dp;
COMBA_START;
/* clear carries */
CLEAR_CARRY;
/* output 0 */
SQRADD(a[0], a[0]);
COMBA_STORE(b[0]);
/* output 1 */
CARRY_FORWARD;
SQRADD2(a[0], a[1]);
COMBA_STORE(b[1]);
/* output 2 */
CARRY_FORWARD;
SQRADD2(a[0], a[2]);
SQRADD(a[1], a[1]);
COMBA_STORE(b[2]);
/* output 3 */
CARRY_FORWARD;
SQRADD2(a[0], a[3]);
SQRADD2(a[1], a[2]);
COMBA_STORE(b[3]);
/* output 4 */
CARRY_FORWARD;
SQRADD2(a[1], a[3]);
SQRADD(a[2], a[2]);
COMBA_STORE(b[4]);
/* output 5 */
CARRY_FORWARD;
SQRADD2(a[2], a[3]);
COMBA_STORE(b[5]);
/* output 6 */
CARRY_FORWARD;
SQRADD(a[3], a[3]);
COMBA_STORE(b[6]);
COMBA_STORE2(b[7]);
COMBA_FINI;
B->used = 8;
B->sign = ZPOS;
memcpy(B->dp, b, 8 * sizeof(mp_digit));
mp_clamp(B);
}
void
s_mp_sqr_comba_8(const mp_int *A, mp_int *B)
{
mp_digit *a, b[16], c0, c1, c2, sc0, sc1, sc2;
a = A->dp;
COMBA_START;
/* clear carries */
CLEAR_CARRY;
/* output 0 */
SQRADD(a[0], a[0]);
COMBA_STORE(b[0]);
/* output 1 */
CARRY_FORWARD;
SQRADD2(a[0], a[1]);
COMBA_STORE(b[1]);
/* output 2 */
CARRY_FORWARD;
SQRADD2(a[0], a[2]);
SQRADD(a[1], a[1]);
COMBA_STORE(b[2]);
/* output 3 */
CARRY_FORWARD;
SQRADD2(a[0], a[3]);
SQRADD2(a[1], a[2]);
COMBA_STORE(b[3]);
/* output 4 */
CARRY_FORWARD;
SQRADD2(a[0], a[4]);
SQRADD2(a[1], a[3]);
SQRADD(a[2], a[2]);
COMBA_STORE(b[4]);
/* output 5 */
CARRY_FORWARD;
SQRADDSC(a[0], a[5]);
SQRADDAC(a[1], a[4]);
SQRADDAC(a[2], a[3]);
SQRADDDB;
COMBA_STORE(b[5]);
/* output 6 */
CARRY_FORWARD;
SQRADDSC(a[0], a[6]);
SQRADDAC(a[1], a[5]);
SQRADDAC(a[2], a[4]);
SQRADDDB;
SQRADD(a[3], a[3]);
COMBA_STORE(b[6]);
/* output 7 */
CARRY_FORWARD;
SQRADDSC(a[0], a[7]);
SQRADDAC(a[1], a[6]);
SQRADDAC(a[2], a[5]);
SQRADDAC(a[3], a[4]);
SQRADDDB;
COMBA_STORE(b[7]);
/* output 8 */
CARRY_FORWARD;
SQRADDSC(a[1], a[7]);
SQRADDAC(a[2], a[6]);
SQRADDAC(a[3], a[5]);
SQRADDDB;
SQRADD(a[4], a[4]);
COMBA_STORE(b[8]);
/* output 9 */
CARRY_FORWARD;
SQRADDSC(a[2], a[7]);
SQRADDAC(a[3], a[6]);
SQRADDAC(a[4], a[5]);
SQRADDDB;
COMBA_STORE(b[9]);
/* output 10 */
CARRY_FORWARD;
SQRADD2(a[3], a[7]);
SQRADD2(a[4], a[6]);
SQRADD(a[5], a[5]);
COMBA_STORE(b[10]);
/* output 11 */
CARRY_FORWARD;
SQRADD2(a[4], a[7]);
SQRADD2(a[5], a[6]);
COMBA_STORE(b[11]);
/* output 12 */
CARRY_FORWARD;
SQRADD2(a[5], a[7]);
SQRADD(a[6], a[6]);
COMBA_STORE(b[12]);
/* output 13 */
CARRY_FORWARD;
SQRADD2(a[6], a[7]);
COMBA_STORE(b[13]);
/* output 14 */
CARRY_FORWARD;
SQRADD(a[7], a[7]);
COMBA_STORE(b[14]);
COMBA_STORE2(b[15]);
COMBA_FINI;
B->used = 16;
B->sign = ZPOS;
memcpy(B->dp, b, 16 * sizeof(mp_digit));
mp_clamp(B);
}
void
s_mp_sqr_comba_16(const mp_int *A, mp_int *B)
{
mp_digit *a, b[32], c0, c1, c2, sc0, sc1, sc2;
a = A->dp;
COMBA_START;
/* clear carries */
CLEAR_CARRY;
/* output 0 */
SQRADD(a[0], a[0]);
COMBA_STORE(b[0]);
/* output 1 */
CARRY_FORWARD;
SQRADD2(a[0], a[1]);
COMBA_STORE(b[1]);
/* output 2 */
CARRY_FORWARD;
SQRADD2(a[0], a[2]);
SQRADD(a[1], a[1]);
COMBA_STORE(b[2]);
/* output 3 */
CARRY_FORWARD;
SQRADD2(a[0], a[3]);
SQRADD2(a[1], a[2]);
COMBA_STORE(b[3]);
/* output 4 */
CARRY_FORWARD;
SQRADD2(a[0], a[4]);
SQRADD2(a[1], a[3]);
SQRADD(a[2], a[2]);
COMBA_STORE(b[4]);
/* output 5 */
CARRY_FORWARD;
SQRADDSC(a[0], a[5]);
SQRADDAC(a[1], a[4]);
SQRADDAC(a[2], a[3]);
SQRADDDB;
COMBA_STORE(b[5]);
/* output 6 */
CARRY_FORWARD;
SQRADDSC(a[0], a[6]);
SQRADDAC(a[1], a[5]);
SQRADDAC(a[2], a[4]);
SQRADDDB;
SQRADD(a[3], a[3]);
COMBA_STORE(b[6]);
/* output 7 */
CARRY_FORWARD;
SQRADDSC(a[0], a[7]);
SQRADDAC(a[1], a[6]);
SQRADDAC(a[2], a[5]);
SQRADDAC(a[3], a[4]);
SQRADDDB;
COMBA_STORE(b[7]);
/* output 8 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[8]);
/* output 9 */
CARRY_FORWARD;
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;
COMBA_STORE(b[9]);
/* output 10 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[10]);
/* output 11 */
CARRY_FORWARD;
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;
COMBA_STORE(b[11]);
/* output 12 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[12]);
/* output 13 */
CARRY_FORWARD;
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;
COMBA_STORE(b[13]);
/* output 14 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[14]);
/* output 15 */
CARRY_FORWARD;
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;
COMBA_STORE(b[15]);
/* output 16 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[16]);
/* output 17 */
CARRY_FORWARD;
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;
COMBA_STORE(b[17]);
/* output 18 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[18]);
/* output 19 */
CARRY_FORWARD;
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;
COMBA_STORE(b[19]);
/* output 20 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[20]);
/* output 21 */
CARRY_FORWARD;
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;
COMBA_STORE(b[21]);
/* output 22 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[22]);
/* output 23 */
CARRY_FORWARD;
SQRADDSC(a[8], a[15]);
SQRADDAC(a[9], a[14]);
SQRADDAC(a[10], a[13]);
SQRADDAC(a[11], a[12]);
SQRADDDB;
COMBA_STORE(b[23]);
/* output 24 */
CARRY_FORWARD;
SQRADDSC(a[9], a[15]);
SQRADDAC(a[10], a[14]);
SQRADDAC(a[11], a[13]);
SQRADDDB;
SQRADD(a[12], a[12]);
COMBA_STORE(b[24]);
/* output 25 */
CARRY_FORWARD;
SQRADDSC(a[10], a[15]);
SQRADDAC(a[11], a[14]);
SQRADDAC(a[12], a[13]);
SQRADDDB;
COMBA_STORE(b[25]);
/* output 26 */
CARRY_FORWARD;
SQRADD2(a[11], a[15]);
SQRADD2(a[12], a[14]);
SQRADD(a[13], a[13]);
COMBA_STORE(b[26]);
/* output 27 */
CARRY_FORWARD;
SQRADD2(a[12], a[15]);
SQRADD2(a[13], a[14]);
COMBA_STORE(b[27]);
/* output 28 */
CARRY_FORWARD;
SQRADD2(a[13], a[15]);
SQRADD(a[14], a[14]);
COMBA_STORE(b[28]);
/* output 29 */
CARRY_FORWARD;
SQRADD2(a[14], a[15]);
COMBA_STORE(b[29]);
/* output 30 */
CARRY_FORWARD;
SQRADD(a[15], a[15]);
COMBA_STORE(b[30]);
COMBA_STORE2(b[31]);
COMBA_FINI;
B->used = 32;
B->sign = ZPOS;
memcpy(B->dp, b, 32 * sizeof(mp_digit));
mp_clamp(B);
}
void
s_mp_sqr_comba_32(const mp_int *A, mp_int *B)
{
mp_digit *a, b[64], c0, c1, c2, sc0, sc1, sc2;
a = A->dp;
COMBA_START;
/* clear carries */
CLEAR_CARRY;
/* output 0 */
SQRADD(a[0], a[0]);
COMBA_STORE(b[0]);
/* output 1 */
CARRY_FORWARD;
SQRADD2(a[0], a[1]);
COMBA_STORE(b[1]);
/* output 2 */
CARRY_FORWARD;
SQRADD2(a[0], a[2]);
SQRADD(a[1], a[1]);
COMBA_STORE(b[2]);
/* output 3 */
CARRY_FORWARD;
SQRADD2(a[0], a[3]);
SQRADD2(a[1], a[2]);
COMBA_STORE(b[3]);
/* output 4 */
CARRY_FORWARD;
SQRADD2(a[0], a[4]);
SQRADD2(a[1], a[3]);
SQRADD(a[2], a[2]);
COMBA_STORE(b[4]);
/* output 5 */
CARRY_FORWARD;
SQRADDSC(a[0], a[5]);
SQRADDAC(a[1], a[4]);
SQRADDAC(a[2], a[3]);
SQRADDDB;
COMBA_STORE(b[5]);
/* output 6 */
CARRY_FORWARD;
SQRADDSC(a[0], a[6]);
SQRADDAC(a[1], a[5]);
SQRADDAC(a[2], a[4]);
SQRADDDB;
SQRADD(a[3], a[3]);
COMBA_STORE(b[6]);
/* output 7 */
CARRY_FORWARD;
SQRADDSC(a[0], a[7]);
SQRADDAC(a[1], a[6]);
SQRADDAC(a[2], a[5]);
SQRADDAC(a[3], a[4]);
SQRADDDB;
COMBA_STORE(b[7]);
/* output 8 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[8]);
/* output 9 */
CARRY_FORWARD;
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;
COMBA_STORE(b[9]);
/* output 10 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[10]);
/* output 11 */
CARRY_FORWARD;
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;
COMBA_STORE(b[11]);
/* output 12 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[12]);
/* output 13 */
CARRY_FORWARD;
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;
COMBA_STORE(b[13]);
/* output 14 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[14]);
/* output 15 */
CARRY_FORWARD;
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;
COMBA_STORE(b[15]);
/* output 16 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[16]);
/* output 17 */
CARRY_FORWARD;
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;
COMBA_STORE(b[17]);
/* output 18 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[18]);
/* output 19 */
CARRY_FORWARD;
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;
COMBA_STORE(b[19]);
/* output 20 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[20]);
/* output 21 */
CARRY_FORWARD;
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;
COMBA_STORE(b[21]);
/* output 22 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[22]);
/* output 23 */
CARRY_FORWARD;
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;
COMBA_STORE(b[23]);
/* output 24 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[24]);
/* output 25 */
CARRY_FORWARD;
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;
COMBA_STORE(b[25]);
/* output 26 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[26]);
/* output 27 */
CARRY_FORWARD;
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;
COMBA_STORE(b[27]);
/* output 28 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[28]);
/* output 29 */
CARRY_FORWARD;
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;
COMBA_STORE(b[29]);
/* output 30 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[30]);
/* output 31 */
CARRY_FORWARD;
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;
COMBA_STORE(b[31]);
/* output 32 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[32]);
/* output 33 */
CARRY_FORWARD;
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;
COMBA_STORE(b[33]);
/* output 34 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[34]);
/* output 35 */
CARRY_FORWARD;
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;
COMBA_STORE(b[35]);
/* output 36 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[36]);
/* output 37 */
CARRY_FORWARD;
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;
COMBA_STORE(b[37]);
/* output 38 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[38]);
/* output 39 */
CARRY_FORWARD;
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;
COMBA_STORE(b[39]);
/* output 40 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[40]);
/* output 41 */
CARRY_FORWARD;
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;
COMBA_STORE(b[41]);
/* output 42 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[42]);
/* output 43 */
CARRY_FORWARD;
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;
COMBA_STORE(b[43]);
/* output 44 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[44]);
/* output 45 */
CARRY_FORWARD;
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;
COMBA_STORE(b[45]);
/* output 46 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[46]);
/* output 47 */
CARRY_FORWARD;
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;
COMBA_STORE(b[47]);
/* output 48 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[48]);
/* output 49 */
CARRY_FORWARD;
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;
COMBA_STORE(b[49]);
/* output 50 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[50]);
/* output 51 */
CARRY_FORWARD;
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;
COMBA_STORE(b[51]);
/* output 52 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[52]);
/* output 53 */
CARRY_FORWARD;
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;
COMBA_STORE(b[53]);
/* output 54 */
CARRY_FORWARD;
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]);
COMBA_STORE(b[54]);
/* output 55 */
CARRY_FORWARD;
SQRADDSC(a[24], a[31]);
SQRADDAC(a[25], a[30]);
SQRADDAC(a[26], a[29]);
SQRADDAC(a[27], a[28]);
SQRADDDB;
COMBA_STORE(b[55]);
/* output 56 */
CARRY_FORWARD;
SQRADDSC(a[25], a[31]);
SQRADDAC(a[26], a[30]);
SQRADDAC(a[27], a[29]);
SQRADDDB;
SQRADD(a[28], a[28]);
COMBA_STORE(b[56]);
/* output 57 */
CARRY_FORWARD;
SQRADDSC(a[26], a[31]);
SQRADDAC(a[27], a[30]);
SQRADDAC(a[28], a[29]);
SQRADDDB;
COMBA_STORE(b[57]);
/* output 58 */
CARRY_FORWARD;
SQRADD2(a[27], a[31]);
SQRADD2(a[28], a[30]);
SQRADD(a[29], a[29]);
COMBA_STORE(b[58]);
/* output 59 */
CARRY_FORWARD;
SQRADD2(a[28], a[31]);
SQRADD2(a[29], a[30]);
COMBA_STORE(b[59]);
/* output 60 */
CARRY_FORWARD;
SQRADD2(a[29], a[31]);
SQRADD(a[30], a[30]);
COMBA_STORE(b[60]);
/* output 61 */
CARRY_FORWARD;
SQRADD2(a[30], a[31]);
COMBA_STORE(b[61]);
/* output 62 */
CARRY_FORWARD;
SQRADD(a[31], a[31]);
COMBA_STORE(b[62]);
COMBA_STORE2(b[63]);
COMBA_FINI;
B->used = 64;
B->sign = ZPOS;
memcpy(B->dp, b, 64 * sizeof(mp_digit));
mp_clamp(B);
}