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