Quelle  mp_comba.c

/*
 * 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);
}